n8n 2.20.6 → 2.21.0

package/dist/modules/instance-ai/instance-ai.service.js

@@ -47,15 +47,18 @@ const api_types_1 = require("@n8n/api-types");
 const backend_common_1 = require("@n8n/backend-common");
 const config_1 = require("@n8n/config");
 const n8n_core_1 = require("n8n-core");
-const constants_1 = require("@n8n/constants");
+const ssrf_protection_service_1 = require("../../services/ssrf/ssrf-protection.service");
 const db_1 = require("@n8n/db");
 const di_1 = require("@n8n/di");
+const permissions_1 = require("@n8n/permissions");
 const url_service_1 = require("../../services/url.service");
 const instance_ai_1 = require("@n8n/instance-ai");
 const workflow_sdk_1 = require("@n8n/workflow-sdk");
 const nanoid_1 = require("nanoid");
+const n8n_workflow_1 = require("n8n-workflow");
 const uuid_1 = require("uuid");
-const constants_2 = require("../../constants");
+const constants_1 = require("../../constants");
+const event_service_1 = require("../../events/event.service");
 const source_control_preferences_service_ee_1 = require("../../modules/source-control.ee/source-control-preferences.service.ee");
 const ai_service_1 = require("../../services/ai.service");
 const push_1 = require("../../push");
@@ -69,16 +72,80 @@ const typeorm_composite_store_1 = require("./storage/typeorm-composite-store");
 const db_snapshot_storage_1 = require("./storage/db-snapshot-storage");
 const db_iteration_log_storage_1 = require("./storage/db-iteration-log-storage");
 const compaction_service_1 = require("./compaction.service");
-const proxy_token_manager_1 = require("./proxy-token-manager");
+const proxy_token_manager_1 = require("../../services/proxy-token-manager");
 const instance_ai_thread_repository_1 = require("./repositories/instance-ai-thread.repository");
 const trace_replay_state_1 = require("./trace-replay-state");
+const liveness_1 = require("./liveness");
 function getErrorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
+const ORCHESTRATOR_AGENT_ID = 'agent-001';
+function getUserFacingErrorMessage(error) {
+    if (error instanceof n8n_workflow_1.UserError) {
+        return error.message;
+    }
+    if (error instanceof n8n_workflow_1.OperationalError) {
+        return 'I hit an operational error before I could finish that response. Please try again.';
+    }
+    if (error instanceof n8n_workflow_1.UnexpectedError) {
+        return 'Something went wrong before I could finish that response. Please try again.';
+    }
+    return 'Something went wrong before I could finish that response. Please try again.';
+}
+function getBackgroundOutcomeResponseId(outcome) {
+    return `background-outcome:${outcome.id}`;
+}
+function createTerminalOutcomeAgentTree(outcome, responseId) {
+    return {
+        agentId: ORCHESTRATOR_AGENT_ID,
+        role: 'orchestrator',
+        status: outcome.status === 'cancelled'
+            ? 'cancelled'
+            : outcome.status === 'failed'
+                ? 'error'
+                : 'completed',
+        textContent: outcome.userFacingMessage,
+        reasoning: '',
+        toolCalls: [],
+        children: [],
+        timeline: [{ type: 'text', content: outcome.userFacingMessage, responseId }],
+    };
+}
+function appendTerminalOutcomeToAgentTree(tree, outcome, responseId) {
+    const text = outcome.userFacingMessage.trim();
+    if (!text)
+        return { tree, appended: false };
+    const alreadyInTimeline = tree.timeline.some((entry) => entry.type === 'text' && entry.responseId === responseId);
+    if (alreadyInTimeline) {
+        return { tree, appended: false };
+    }
+    return {
+        appended: true,
+        tree: {
+            ...tree,
+            textContent: tree.textContent ? `${tree.textContent}\n\n${outcome.userFacingMessage}` : text,
+            timeline: [
+                ...tree.timeline,
+                { type: 'text', content: outcome.userFacingMessage, responseId },
+            ],
+        },
+    };
+}
 function createInertAbortSignal() {
     return new AbortController().signal;
 }
-const ORCHESTRATOR_AGENT_ID = 'agent-001';
+function getAbortReason(signal) {
+    const reason = signal.reason;
+    if (typeof reason === 'object' &&
+        reason !== null &&
+        'name' in reason &&
+        reason.name === 'AbortError') {
+        return 'user_cancelled';
+    }
+    if (reason instanceof Error)
+        return reason.message;
+    return typeof reason === 'string' ? reason : 'user_cancelled';
+}
 const INSTANCE_AI_FEEDBACK_NAMESPACE = 'c5be4c87-5b6e-49ed-afe1-9c5c1f99a5c0';
 const MAX_CONCURRENT_BACKGROUND_TASKS_PER_THREAD = 5;
 function estimateTokens(text) {
@@ -176,7 +243,7 @@ function toConfirmationData(request) {
     }
 }
 let InstanceAiService = class InstanceAiService {
-    constructor(logger, globalConfig, adapterService, eventBus, settingsService, compositeStore, compactionService, aiService, push, threadRepo, urlService, dbSnapshotStorage, dbIterationLogStorage, sourceControlPreferencesService, telemetry, userRepository, aiBuilderTemporaryWorkflowRepository, errorReporter) {
+    constructor(logger, globalConfig, adapterService, eventBus, settingsService, compositeStore, compactionService, aiService, push, threadRepo, urlService, dbSnapshotStorage, dbIterationLogStorage, sourceControlPreferencesService, telemetry, userRepository, aiBuilderTemporaryWorkflowRepository, errorReporter, ssrfProtectionConfig, ssrfProtectionService, eventService) {
         this.adapterService = adapterService;
         this.eventBus = eventBus;
         this.settingsService = settingsService;
@@ -193,7 +260,7 @@ let InstanceAiService = class InstanceAiService {
         this.userRepository = userRepository;
         this.aiBuilderTemporaryWorkflowRepository = aiBuilderTemporaryWorkflowRepository;
         this.errorReporter = errorReporter;
-        this.mcpClientManager = new instance_ai_1.McpClientManager();
+        this.eventService = eventService;
         this.runState = new instance_ai_1.RunStateRegistry();
         this.backgroundTasks = new instance_ai_1.BackgroundTaskManager(MAX_CONCURRENT_BACKGROUND_TASKS_PER_THREAD);
         this.traceContextsByRunId = new Map();
@@ -203,35 +270,42 @@ let InstanceAiService = class InstanceAiService {
         this.threadPushRef = new Map();
         this.schedulerLocks = new Map();
         this.pendingCheckpointReentries = new Map();
+        this.pendingTerminalOutcomes = new Map();
         this.creditedThreads = new Set();
         this.traceReplay = new trace_replay_state_1.TraceReplayState();
         this.logger = logger.scoped('instance-ai');
         this.instanceAiConfig = globalConfig.instanceAi;
+        const livenessPolicyConfig = (0, instance_ai_1.createInstanceAiLivenessPolicyConfig)({
+            confirmationTimeoutMs: this.instanceAiConfig.confirmationTimeout,
+        });
+        this.liveness = new liveness_1.InstanceAiLivenessService({
+            policy: new instance_ai_1.InstanceAiLivenessPolicy(livenessPolicyConfig),
+            backgroundTaskIdleTimeoutMs: livenessPolicyConfig.backgroundTaskIdleTimeoutMs,
+            runState: this.runState,
+            backgroundTasks: this.backgroundTasks,
+            eventBus: this.eventBus,
+            logger: this.logger,
+            finalizeCancelledSuspendedRun: (suspended, reason) => {
+                void this.finalizeCancelledSuspendedRun(suspended, reason);
+            },
+        });
         this.builderSandboxSessions = new instance_ai_1.BuilderSandboxSessionRegistry(this.instanceAiConfig.builderSandboxTtlMs);
         this.defaultTimeZone = globalConfig.generic.timezone;
-        const editorBaseUrl = globalConfig.editorBaseUrl || `http://localhost:${globalConfig.port}`;
         const restEndpoint = globalConfig.endpoints.rest;
-        this.oauth2CallbackUrl = `${editorBaseUrl.replace(/\/$/, '')}/${restEndpoint}/oauth2-credential/callback`;
+        this.oauth2CallbackUrl = `${this.urlService.getInstanceBaseUrl()}/${restEndpoint}/oauth2-credential/callback`;
         this.webhookBaseUrl = `${this.urlService.getWebhookBaseUrl()}${globalConfig.endpoints.webhook}`;
-        this.startConfirmationTimeoutSweep();
-    }
-    startConfirmationTimeoutSweep() {
-        const timeoutMs = this.instanceAiConfig.confirmationTimeout;
-        if (timeoutMs <= 0)
-            return;
-        this.confirmationTimeoutInterval = setInterval(() => {
-            const { suspendedThreadIds, confirmationRequestIds } = this.runState.sweepTimedOut(timeoutMs);
-            for (const threadId of suspendedThreadIds) {
-                this.logger.debug('Auto-rejecting timed-out suspended run', { threadId });
-                this.cancelRun(threadId);
-            }
-            for (const reqId of confirmationRequestIds) {
-                this.logger.debug('Auto-rejecting timed-out sub-agent confirmation', {
-                    requestId: reqId,
+        this.formBaseUrl = `${this.urlService.getWebhookBaseUrl()}${globalConfig.endpoints.form}`;
+        this.mcpClientManager = new instance_ai_1.McpClientManager(ssrfProtectionConfig.enabled ? ssrfProtectionService : undefined);
+        this.eventService.on('instance-ai-settings-updated', ({ mcpSettingsChanged }) => {
+            if (!mcpSettingsChanged)
+                return;
+            this.mcpClientManager.disconnect().catch((error) => {
+                this.logger.warn('Failed to disconnect MCP clients after settings change', {
+                    error: getErrorMessage(error),
                 });
-                this.runState.rejectPendingConfirmation(reqId);
-            }
-        }, constants_1.Time.minutes.toMilliseconds);
+            });
+        });
+        this.liveness.start();
     }
     getSandboxConfigFromEnv() {
         const { sandboxEnabled, sandboxProvider, daytonaApiUrl, daytonaApiKey, n8nSandboxServiceUrl, n8nSandboxServiceApiKey, sandboxImage, sandboxTimeout, } = this.instanceAiConfig;
@@ -253,7 +327,7 @@ let InstanceAiService = class InstanceAiService {
                 daytonaApiUrl: daytonaApiUrl || undefined,
                 daytonaApiKey: daytonaApiKey || undefined,
                 image: sandboxImage || undefined,
-                n8nVersion: constants_2.N8N_VERSION || undefined,
+                n8nVersion: constants_1.N8N_VERSION || undefined,
                 timeout: sandboxTimeout,
             };
         }
@@ -382,7 +456,7 @@ let InstanceAiService = class InstanceAiService {
                 for (const [k, v] of Object.entries(auth)) {
                     headers.set(k, v);
                 }
-                for (const [k, v] of Object.entries((0, api_types_1.buildProxyHeaders)({ feature: 'instance-ai', n8nVersion: constants_2.N8N_VERSION }))) {
+                for (const [k, v] of Object.entries((0, api_types_1.buildProxyHeaders)({ feature: 'instance-ai', n8nVersion: constants_1.N8N_VERSION }))) {
                     headers.set(k, v);
                 }
                 return await globalThis.fetch(input, { ...init, headers });
@@ -682,6 +756,7 @@ let InstanceAiService = class InstanceAiService {
         }
     }
     startRun(user, threadId, message, researchMode, attachments, timeZone, pushRef) {
+        this.liveness.clearThreadState(threadId);
         const { runId, abortController, messageGroupId } = this.runState.startRun({
             threadId,
             user,
@@ -708,7 +783,7 @@ let InstanceAiService = class InstanceAiService {
     getActiveRunId(threadId) {
         return this.runState.getActiveRunId(threadId);
     }
-    cancelRun(threadId) {
+    cancelRun(threadId, reason = 'user_cancelled') {
         const cancelledTasks = this.backgroundTasks.cancelThread(threadId);
         const user = this.runState.getThreadUser(threadId);
         for (const task of cancelledTasks) {
@@ -717,9 +792,15 @@ let InstanceAiService = class InstanceAiService {
                 type: 'agent-completed',
                 runId: task.runId,
                 agentId: task.agentId,
-                payload: { role: task.role, result: '', error: 'Cancelled by user' },
+                payload: {
+                    role: task.role,
+                    result: '',
+                    error: reason === liveness_1.INSTANCE_AI_RUN_TIMEOUT_REASON ? 'Timed out' : 'Cancelled by user',
+                },
+            });
+            void this.recordBackgroundTerminalOutcome(task).finally(() => {
+                void this.saveAgentTreeSnapshot(threadId, task.runId, this.dbSnapshotStorage, true, task.messageGroupId);
             });
-            void this.saveAgentTreeSnapshot(threadId, task.runId, this.dbSnapshotStorage, true, task.messageGroupId);
             if (user) {
                 void this.handlePlannedTaskSettlement(user, task, 'cancelled');
             }
@@ -727,12 +808,16 @@ let InstanceAiService = class InstanceAiService {
         void this.cancelAwaitingApprovalPlan(threadId);
         const { active, suspended } = this.runState.cancelThread(threadId);
         if (active) {
+            if (reason === liveness_1.INSTANCE_AI_RUN_TIMEOUT_REASON)
+                this.liveness.markRunTimedOut(active.runId);
             active.abortController.abort();
             return;
         }
         if (suspended) {
+            if (reason === liveness_1.INSTANCE_AI_RUN_TIMEOUT_REASON)
+                this.liveness.markRunTimedOut(suspended.runId);
             suspended.abortController.abort();
-            void this.finalizeCancelledSuspendedRun(suspended);
+            void this.finalizeCancelledSuspendedRun(suspended, reason);
         }
     }
     sendCorrectionToTask(threadId, taskId, correction) {
@@ -749,12 +834,34 @@ let InstanceAiService = class InstanceAiService {
             agentId: task.agentId,
             payload: { role: task.role, result: '', error: 'Cancelled by user' },
         });
-        void this.saveAgentTreeSnapshot(threadId, task.runId, this.dbSnapshotStorage, true, task.messageGroupId);
+        void this.recordBackgroundTerminalOutcome(task).finally(() => {
+            void this.saveAgentTreeSnapshot(threadId, task.runId, this.dbSnapshotStorage, true, task.messageGroupId);
+        });
         const user = this.runState.getThreadUser(threadId);
         if (user) {
             void this.handlePlannedTaskSettlement(user, task, 'cancelled');
         }
     }
+    async revalidateActiveUser(userId) {
+        try {
+            const user = await this.userRepository.findOne({
+                where: { id: userId },
+                relations: ['role'],
+            });
+            if (!user || user.disabled)
+                return null;
+            if (!(0, permissions_1.hasGlobalScope)(user, 'instanceAi:message'))
+                return null;
+            return user;
+        }
+        catch (error) {
+            this.logger.warn('Failed to revalidate user', {
+                userId,
+                error: getErrorMessage(error),
+            });
+            return null;
+        }
+    }
     cancelAllBackgroundTasks() {
         const cancelled = this.backgroundTasks.cancelAll();
         for (const task of cancelled) {
@@ -762,6 +869,111 @@ let InstanceAiService = class InstanceAiService {
         }
         return cancelled.length;
     }
+    async startStuckBackgroundTaskForTest(user, threadId) {
+        const messageId = `msg_${(0, nanoid_1.nanoid)()}`;
+        const messageText = 'I started a background workflow-builder task.';
+        const { runId, messageGroupId } = this.runState.startRun({ threadId, user });
+        if (!messageGroupId) {
+            throw new n8n_workflow_1.UnexpectedError('Failed to create message group for timeout simulation');
+        }
+        const taskId = `task_${(0, nanoid_1.nanoid)()}`;
+        const agentId = `agent_${(0, nanoid_1.nanoid)()}`;
+        this.eventBus.publish(threadId, {
+            type: 'run-start',
+            runId,
+            agentId: ORCHESTRATOR_AGENT_ID,
+            userId: user.id,
+            payload: { messageId, messageGroupId },
+        });
+        this.eventBus.publish(threadId, {
+            type: 'text-delta',
+            runId,
+            agentId: ORCHESTRATOR_AGENT_ID,
+            responseId: `test-background-start:${runId}`,
+            payload: { text: messageText },
+        });
+        this.eventBus.publish(threadId, {
+            type: 'agent-spawned',
+            runId,
+            agentId,
+            payload: {
+                parentId: ORCHESTRATOR_AGENT_ID,
+                role: 'workflow-builder',
+                tools: [],
+                taskId,
+                kind: 'builder',
+                title: 'Building workflow',
+                subtitle: 'Timeout simulation',
+                goal: 'Simulate a stuck background task timeout',
+            },
+        });
+        const memoryStorage = this.compositeStore.stores.memory;
+        await memoryStorage.saveMessages({
+            messages: [
+                {
+                    id: messageId,
+                    threadId,
+                    resourceId: user.id,
+                    role: 'assistant',
+                    content: {
+                        format: 2,
+                        parts: [{ type: 'text', text: messageText }],
+                        content: messageText,
+                    },
+                    createdAt: new Date(),
+                },
+            ],
+        });
+        const outcome = this.backgroundTasks.spawn({
+            taskId,
+            threadId,
+            runId,
+            role: 'workflow-builder',
+            agentId,
+            messageGroupId,
+            run: async (signal) => await new Promise((resolve) => {
+                signal.addEventListener('abort', () => resolve('aborted'), { once: true });
+            }),
+            onFailed: (task) => {
+                this.eventBus.publish(threadId, {
+                    type: 'agent-completed',
+                    runId,
+                    agentId,
+                    payload: {
+                        role: task.role,
+                        result: '',
+                        error: task.error ?? 'Unknown error',
+                    },
+                });
+            },
+            onSettled: async (task) => {
+                await this.recordBackgroundTerminalOutcome(task);
+                await this.saveAgentTreeSnapshot(threadId, runId, this.dbSnapshotStorage, true, messageGroupId);
+            },
+        });
+        if (outcome.status !== 'started') {
+            throw new n8n_workflow_1.UnexpectedError('Failed to start stuck background task simulation');
+        }
+        this.runState.clearActiveRun(threadId);
+        this.eventBus.publish(threadId, {
+            type: 'run-finish',
+            runId,
+            agentId: ORCHESTRATOR_AGENT_ID,
+            userId: user.id,
+            payload: { status: 'completed' },
+        });
+        return {
+            threadId,
+            runId,
+            messageGroupId,
+            taskId,
+            agentId,
+            timeoutAt: outcome.task.lastActivityAt + this.liveness.backgroundTaskIdleTimeoutMs + 1,
+        };
+    }
+    async runLivenessSweepForTest(now) {
+        await this.liveness.sweepTimedOutWork(now);
+    }
     loadTraceEvents(slug, events) {
         this.traceReplay.loadEvents(slug, events);
     }
@@ -780,6 +992,9 @@ let InstanceAiService = class InstanceAiService {
     generatePairingToken(userId) {
         return this.gatewayRegistry.generatePairingToken(userId);
     }
+    getGatewayApiKeyExpiresAt(userId, key) {
+        return this.gatewayRegistry.getApiKeyExpiresAt(userId, key);
+    }
     getPairingToken(userId) {
         return this.gatewayRegistry.getPairingToken(userId);
     }
@@ -852,6 +1067,7 @@ let InstanceAiService = class InstanceAiService {
         });
         this.creditedThreads.delete(threadId);
         this.schedulerLocks.delete(threadId);
+        this.liveness.clearThreadState(threadId);
         this.domainAccessTrackersByThread.delete(threadId);
         this.threadPushRef.delete(threadId);
         this.deleteTraceContextsForThread(threadId);
@@ -861,10 +1077,7 @@ let InstanceAiService = class InstanceAiService {
         this.eventBus.clearThread(threadId);
     }
     async shutdown() {
-        if (this.confirmationTimeoutInterval) {
-            clearInterval(this.confirmationTimeoutInterval);
-            this.confirmationTimeoutInterval = undefined;
-        }
+        this.liveness.shutdown();
         const { activeRuns, suspendedRuns } = this.runState.shutdown();
         for (const run of activeRuns) {
             run.abortController.abort();
@@ -990,6 +1203,290 @@ let InstanceAiService = class InstanceAiService {
         const plannedTaskService = new instance_ai_1.PlannedTaskCoordinator(plannedTaskStorage);
         return { memory, taskStorage, plannedTaskService };
     }
+    evaluateTerminalResponse(threadId, runId, status, options = {}) {
+        const guard = new instance_ai_1.InstanceAiTerminalResponseGuard({
+            runId,
+            rootAgentId: ORCHESTRATOR_AGENT_ID,
+            messageGroupId: options.messageGroupId,
+            correlationId: options.correlationId,
+        });
+        const decision = guard.evaluateTerminal(this.getTerminalGuardEvents(threadId, runId, options.messageGroupId), status, {
+            workSummary: options.workSummary,
+            errorMessage: options.errorMessage,
+        });
+        this.handleTerminalResponseDecision(threadId, runId, decision, options.messageGroupId);
+        return decision;
+    }
+    evaluateWaitingResponse(threadId, runId, confirmationEvent, options = {}) {
+        const guard = new instance_ai_1.InstanceAiTerminalResponseGuard({
+            runId,
+            rootAgentId: ORCHESTRATOR_AGENT_ID,
+            messageGroupId: options.messageGroupId,
+            correlationId: options.correlationId,
+        });
+        const decision = guard.evaluateWaiting(this.getTerminalGuardEvents(threadId, runId, options.messageGroupId), confirmationEvent);
+        this.handleTerminalResponseDecision(threadId, runId, decision, options.messageGroupId);
+        return decision;
+    }
+    getTerminalGuardEvents(threadId, runId, messageGroupId) {
+        if (!messageGroupId)
+            return this.eventBus.getEventsForRun(threadId, runId);
+        const groupRunIds = this.getRunIdsForMessageGroup(messageGroupId);
+        return groupRunIds.length > 0
+            ? this.eventBus.getEventsForRuns(threadId, groupRunIds)
+            : this.eventBus.getEventsForRun(threadId, runId);
+    }
+    handleTerminalResponseDecision(threadId, runId, decision, messageGroupId) {
+        this.telemetry.track('instance_ai_terminal_response_decision', {
+            thread_id: threadId,
+            run_id: runId,
+            message_group_id: messageGroupId,
+            source: 'terminal_guard',
+            status: decision.status,
+            action: decision.action,
+            reason: decision.reason,
+            visibility_source: decision.visibilitySource,
+        });
+        if (decision.reason === 'completed-after-error') {
+            this.logger.warn('completed_after_error_event', {
+                threadId,
+                runId,
+                messageGroupId,
+            });
+        }
+        if (decision.reason === 'confirmation-invalid') {
+            this.logger.warn('invalid_confirmation_payload', {
+                threadId,
+                runId,
+                messageGroupId,
+            });
+        }
+        if (decision.action === 'emit' && decision.event) {
+            this.eventBus.publish(threadId, decision.event);
+        }
+    }
+    createTerminalOutcomeStorage() {
+        this.terminalOutcomeStorage ??= new instance_ai_1.TerminalOutcomeStorage((0, instance_ai_1.createMemory)(this.createMemoryConfig()));
+        return this.terminalOutcomeStorage;
+    }
+    async finishInvalidConfirmationRun(args) {
+        this.runState.cancelThread(args.threadId);
+        args.abortController.abort();
+        await this.finalizeRunTracing(args.runId, args.tracing, {
+            status: 'error',
+            reason: 'invalid_confirmation_payload',
+        });
+        this.publishRunFinish(args.threadId, args.runId, 'errored', 'I need your input to continue, but I could not display the prompt. Please try again.');
+        await this.saveAgentTreeSnapshot(args.threadId, args.runId, args.snapshotStorage);
+        return {
+            status: 'error',
+            reason: 'invalid_confirmation_payload',
+            metadata: { completion_source: 'orchestrator' },
+        };
+    }
+    buildBackgroundTerminalOutcome(task) {
+        const status = task.status === 'failed' ? 'failed' : task.status === 'cancelled' ? 'cancelled' : 'completed';
+        const userFacingMessage = status === 'completed'
+            ? `The background ${task.role} task finished.`
+            : status === 'cancelled'
+                ? `The background ${task.role} task was cancelled.`
+                : `The background ${task.role} task failed before I could complete that part.`;
+        return {
+            id: `${task.messageGroupId ?? task.runId}:${task.taskId}:${status}`,
+            threadId: task.threadId,
+            runId: task.runId,
+            messageGroupId: task.messageGroupId,
+            correlationId: task.messageGroupId,
+            taskId: task.taskId,
+            agentId: task.agentId,
+            status,
+            userFacingMessage,
+            createdAt: new Date().toISOString(),
+        };
+    }
+    async replayUndeliveredTerminalOutcomes(threadId, options = {}) {
+        const storage = this.createTerminalOutcomeStorage();
+        const persistedOutcomes = await storage.getUndelivered(threadId).catch((error) => {
+            this.logger.warn('Failed to load undelivered Instance AI terminal outcomes', {
+                threadId,
+                error: getErrorMessage(error),
+            });
+            return [];
+        });
+        const inMemoryOutcomes = [...this.pendingTerminalOutcomes.values()].filter((outcome) => outcome.threadId === threadId);
+        const outcomes = new Map();
+        for (const outcome of [...persistedOutcomes, ...inMemoryOutcomes]) {
+            outcomes.set(outcome.id, outcome);
+        }
+        const persistedOutcomeIds = new Set(persistedOutcomes.map((outcome) => outcome.id));
+        const delivery = options.delivery ?? 'snapshot';
+        for (const outcome of outcomes.values()) {
+            const responseId = getBackgroundOutcomeResponseId(outcome);
+            let snapshotDelivered = false;
+            try {
+                snapshotDelivered = await this.persistTerminalOutcomeLineToSnapshot(outcome, responseId);
+            }
+            catch (error) {
+                this.logger.warn('Failed to replay Instance AI terminal outcome', {
+                    threadId,
+                    runId: outcome.runId,
+                    taskId: outcome.taskId,
+                    error: getErrorMessage(error),
+                });
+                if (delivery === 'event') {
+                    const published = this.publishTerminalOutcomeLine(outcome, responseId);
+                    this.telemetry.track('instance_ai_terminal_response_decision', {
+                        thread_id: threadId,
+                        run_id: outcome.runId,
+                        message_group_id: outcome.messageGroupId,
+                        task_id: outcome.taskId,
+                        source: 'terminal_outcome_replay',
+                        status: outcome.status,
+                        action: published ? 'replay_event' : 'already-emitted',
+                        visibility_source: 'background-outcome',
+                    });
+                }
+                continue;
+            }
+            if (!snapshotDelivered)
+                continue;
+            let action = 'replay_snapshot';
+            if (delivery === 'event') {
+                const published = this.publishTerminalOutcomeLine(outcome, responseId);
+                action = published ? 'replay_event' : 'already-emitted';
+            }
+            if (persistedOutcomeIds.has(outcome.id)) {
+                await storage
+                    .markDelivered(threadId, outcome.id, new Date().toISOString())
+                    .catch((error) => {
+                    this.logger.warn('Failed to mark Instance AI terminal outcome as delivered', {
+                        threadId,
+                        runId: outcome.runId,
+                        taskId: outcome.taskId,
+                        error: getErrorMessage(error),
+                    });
+                });
+            }
+            this.pendingTerminalOutcomes.delete(outcome.id);
+            this.telemetry.track('instance_ai_terminal_response_decision', {
+                thread_id: threadId,
+                run_id: outcome.runId,
+                message_group_id: outcome.messageGroupId,
+                task_id: outcome.taskId,
+                source: 'terminal_outcome_replay',
+                status: outcome.status,
+                action,
+                visibility_source: 'background-outcome',
+            });
+        }
+    }
+    async persistTerminalOutcomeLineToSnapshot(outcome, responseId) {
+        const snapshot = await this.dbSnapshotStorage.getLatest(outcome.threadId, {
+            messageGroupId: outcome.messageGroupId,
+            runId: outcome.runId,
+        });
+        if (!snapshot) {
+            await this.dbSnapshotStorage.save(outcome.threadId, createTerminalOutcomeAgentTree(outcome, responseId), outcome.runId, {
+                messageGroupId: outcome.messageGroupId,
+                runIds: [outcome.runId],
+            });
+            return true;
+        }
+        const { tree } = appendTerminalOutcomeToAgentTree(snapshot.tree, outcome, responseId);
+        const runIds = new Set(snapshot.runIds ?? [snapshot.runId]);
+        runIds.add(outcome.runId);
+        await this.dbSnapshotStorage.updateLast(outcome.threadId, tree, snapshot.runId, {
+            messageGroupId: snapshot.messageGroupId ?? outcome.messageGroupId,
+            runIds: [...runIds],
+            langsmithRunId: snapshot.langsmithRunId,
+            langsmithTraceId: snapshot.langsmithTraceId,
+        });
+        return true;
+    }
+    publishTerminalOutcomeLine(outcome, responseId) {
+        const alreadyPublished = this.eventBus
+            .getEventsForRun(outcome.threadId, outcome.runId)
+            .some((event) => event.responseId === responseId);
+        if (alreadyPublished)
+            return false;
+        this.eventBus.publish(outcome.threadId, {
+            type: 'text-delta',
+            runId: outcome.runId,
+            agentId: ORCHESTRATOR_AGENT_ID,
+            responseId,
+            payload: { text: outcome.userFacingMessage },
+        });
+        return true;
+    }
+    async recordBackgroundTerminalOutcome(task) {
+        const outcome = this.buildBackgroundTerminalOutcome(task);
+        let persisted = false;
+        try {
+            await this.createTerminalOutcomeStorage().upsert(task.threadId, outcome);
+            persisted = true;
+        }
+        catch (error) {
+            this.pendingTerminalOutcomes.set(outcome.id, outcome);
+            this.logger.warn('Failed to persist Instance AI terminal outcome', {
+                threadId: task.threadId,
+                runId: task.runId,
+                taskId: task.taskId,
+                error: getErrorMessage(error),
+            });
+            this.telemetry.track('instance_ai_terminal_outcome_persistence_failure', {
+                thread_id: task.threadId,
+                run_id: task.runId,
+                task_id: task.taskId,
+                status: outcome.status,
+                phase: 'metadata',
+            });
+        }
+        const responseId = getBackgroundOutcomeResponseId(outcome);
+        const published = this.publishTerminalOutcomeLine(outcome, responseId);
+        this.telemetry.track('instance_ai_terminal_response_decision', {
+            thread_id: task.threadId,
+            run_id: task.runId,
+            message_group_id: task.messageGroupId,
+            task_id: task.taskId,
+            source: 'background_outcome',
+            status: outcome.status,
+            action: published ? 'emit' : 'already-emitted',
+            visibility_source: 'background-outcome',
+        });
+        let snapshotDelivered = false;
+        try {
+            snapshotDelivered = await this.persistTerminalOutcomeLineToSnapshot(outcome, responseId);
+        }
+        catch (error) {
+            this.logger.warn('Failed to persist Instance AI terminal outcome line to snapshot', {
+                threadId: task.threadId,
+                runId: task.runId,
+                taskId: task.taskId,
+                error: getErrorMessage(error),
+            });
+            this.telemetry.track('instance_ai_terminal_outcome_persistence_failure', {
+                thread_id: task.threadId,
+                run_id: task.runId,
+                task_id: task.taskId,
+                status: outcome.status,
+                phase: 'snapshot',
+            });
+        }
+        if (!persisted || !snapshotDelivered)
+            return;
+        try {
+            await this.createTerminalOutcomeStorage().markDelivered(task.threadId, outcome.id, new Date().toISOString());
+            this.pendingTerminalOutcomes.delete(outcome.id);
+        }
+        catch (error) {
+            this.logger.warn('Failed to mark Instance AI terminal outcome as delivered', {
+                threadId: task.threadId,
+                runId: task.runId,
+                taskId: task.taskId,
+                error: getErrorMessage(error),
+            });
+        }
+    }
     async syncPlannedTasksToUi(threadId, graph) {
         const { taskStorage } = await this.createPlannedTaskState();
         const tasks = this.projectPlannedTaskList(graph);
@@ -1024,7 +1521,8 @@ let InstanceAiService = class InstanceAiService {
         }
     }
     async createExecutionEnvironment(user, threadId, runId, abortSignal, researchMode, messageGroupId, pushRef) {
-        const localGatewayDisabled = await this.settingsService.isLocalGatewayDisabledForUser(user.id);
+        const localGatewayDisabledGlobally = this.settingsService.getAdminSettings().localGatewayDisabled;
+        const localGatewayDisabledForUser = await this.settingsService.isLocalGatewayDisabledForUser(user.id);
         const userGateway = this.gatewayRegistry.findGateway(user.id);
         let searchProxyConfig;
         let tracingProxyConfig;
@@ -1039,7 +1537,7 @@ let InstanceAiService = class InstanceAiService {
             tokenManager = manager;
             const featureHeaders = (0, api_types_1.buildProxyHeaders)({
                 feature: 'instance-ai',
-                n8nVersion: constants_2.N8N_VERSION,
+                n8nVersion: constants_1.N8N_VERSION,
             });
             searchProxyConfig = {
                 apiUrl: proxyBaseUrl + '/brave-search',
@@ -1061,7 +1559,7 @@ let InstanceAiService = class InstanceAiService {
             pushRef,
             threadId,
         });
-        if (!localGatewayDisabled && userGateway?.isConnected) {
+        if (!localGatewayDisabledForUser && userGateway?.isConnected) {
             context.localMcpServer = userGateway;
         }
         context.permissions = this.settingsService.getPermissions();
@@ -1076,16 +1574,21 @@ let InstanceAiService = class InstanceAiService {
         }
         context.domainAccessTracker = domainTracker;
         context.runId = runId;
-        if (localGatewayDisabled) {
-            context.localGatewayStatus = { status: 'disabled' };
+        if (localGatewayDisabledGlobally) {
+            context.localGatewayStatus = { status: 'disabledGlobally' };
         }
-        else if (userGateway?.isConnected) {
-            context.localGatewayStatus = { status: 'connected' };
+        else if (!localGatewayDisabledForUser && userGateway?.isConnected) {
+            context.localGatewayStatus = {
+                status: 'connected',
+                capabilities: userGateway
+                    .getStatus()
+                    .toolCategories.filter(({ enabled }) => enabled)
+                    .map(({ name }) => name),
+            };
         }
         else {
             context.localGatewayStatus = {
-                status: 'disconnected',
-                capabilities: ['filesystem', 'browser'],
+                status: localGatewayDisabledForUser ? 'disabled' : 'disconnected',
             };
         }
         const modelId = proxyBaseUrl && tokenManager
@@ -1131,7 +1634,9 @@ let InstanceAiService = class InstanceAiService {
             localMcpServer: context.localMcpServer,
             oauth2CallbackUrl: this.oauth2CallbackUrl,
             webhookBaseUrl: this.webhookBaseUrl,
+            formBaseUrl: this.formBaseUrl,
             waitForConfirmation: async (requestId) => {
+                this.runState.touchActiveRun(threadId);
                 return await new Promise((resolve) => {
                     this.runState.registerPendingConfirmation(requestId, {
                         resolve,
@@ -1146,6 +1651,8 @@ let InstanceAiService = class InstanceAiService {
             },
             cancelBackgroundTask: async (taskId) => this.cancelBackgroundTask(threadId, taskId),
             spawnBackgroundTask: (opts) => this.spawnBackgroundTask(runId, opts, snapshotStorage, messageGroupId),
+            touchRun: () => this.runState.touchActiveRun(threadId),
+            touchBackgroundTask: (taskId) => this.backgroundTasks.touchTask(threadId, taskId),
             plannedTaskService,
             schedulePlannedTasks: async () => await this.schedulePlannedTasks(user, threadId),
             iterationLog,
@@ -1313,6 +1820,16 @@ let InstanceAiService = class InstanceAiService {
         await current;
     }
     async doSchedulePlannedTasks(user, threadId) {
+        const revalidated = await this.revalidateActiveUser(user.id);
+        if (!revalidated) {
+            this.logger.warn('Cancelling run: user no longer authorized for AI Assistant', {
+                userId: user.id,
+                threadId,
+            });
+            this.cancelRun(threadId);
+            return;
+        }
+        const activeUser = revalidated;
         const { plannedTaskService } = await this.createPlannedTaskState();
         const graph = await plannedTaskService.getGraph(threadId);
         if (!graph)
@@ -1325,7 +1842,7 @@ let InstanceAiService = class InstanceAiService {
             return;
         if (action.type === 'replan') {
             await this.syncPlannedTasksToUi(threadId, action.graph);
-            const startedRunId = await this.startInternalFollowUpRun(user, threadId, this.buildPlannedTaskFollowUpMessage('replan', action.graph, {
+            const startedRunId = await this.startInternalFollowUpRun(activeUser, threadId, this.buildPlannedTaskFollowUpMessage('replan', action.graph, {
                 failedTask: action.failedTask,
             }), this.runState.getThreadResearchMode(threadId), action.graph.messageGroupId, true);
             if (!startedRunId) {
@@ -1335,7 +1852,7 @@ let InstanceAiService = class InstanceAiService {
         }
         if (action.type === 'synthesize') {
             await this.syncPlannedTasksToUi(threadId, action.graph);
-            const startedRunId = await this.startInternalFollowUpRun(user, threadId, this.buildPlannedTaskFollowUpMessage('synthesize', action.graph), this.runState.getThreadResearchMode(threadId), action.graph.messageGroupId);
+            const startedRunId = await this.startInternalFollowUpRun(activeUser, threadId, this.buildPlannedTaskFollowUpMessage('synthesize', action.graph), this.runState.getThreadResearchMode(threadId), action.graph.messageGroupId);
             if (!startedRunId) {
                 await plannedTaskService.revertToActive(threadId);
             }
@@ -1352,7 +1869,7 @@ let InstanceAiService = class InstanceAiService {
             const graphAfterMark = (await plannedTaskService.getGraph(threadId)) ?? action.graph;
             await this.syncPlannedTasksToUi(threadId, graphAfterMark);
             const checkpointRecord = graphAfterMark.tasks.find((t) => t.id === checkpoint.id) ?? checkpoint;
-            const startedRunId = await this.startInternalFollowUpRun(user, threadId, this.buildPlannedTaskFollowUpMessage('checkpoint', graphAfterMark, {
+            const startedRunId = await this.startInternalFollowUpRun(activeUser, threadId, this.buildPlannedTaskFollowUpMessage('checkpoint', graphAfterMark, {
                 checkpoint: checkpointRecord,
             }), this.runState.getThreadResearchMode(threadId), action.graph.messageGroupId, false, { isCheckpointFollowUp: true, checkpointTaskId: checkpoint.id });
             if (!startedRunId) {
@@ -1361,12 +1878,12 @@ let InstanceAiService = class InstanceAiService {
             }
             return;
         }
-        const environment = await this.createExecutionEnvironment(user, threadId, action.graph.planRunId, createInertAbortSignal(), this.runState.getThreadResearchMode(threadId), action.graph.messageGroupId);
+        const environment = await this.createExecutionEnvironment(activeUser, threadId, action.graph.planRunId, createInertAbortSignal(), this.runState.getThreadResearchMode(threadId), action.graph.messageGroupId, this.threadPushRef.get(threadId));
         environment.orchestrationContext.tracing = this.getTraceContext(action.graph.planRunId);
         for (const task of action.tasks) {
             await this.dispatchPlannedTask(task, environment.orchestrationContext, action.graph);
         }
-        await this.doSchedulePlannedTasks(user, threadId);
+        await this.doSchedulePlannedTasks(activeUser, threadId);
     }
     async executeRun(user, threadId, runId, message, abortController, researchMode, attachments, messageGroupId, timeZone, isReplanFollowUp = false, checkpoint) {
         const signal = abortController.signal;
@@ -1374,8 +1891,10 @@ let InstanceAiService = class InstanceAiService {
         let tracing;
         let messageTraceFinalization;
         let aiCreatedWorkflowIds;
+        let activeSnapshotStorage;
+        let messageId = '';
         try {
-            const messageId = (0, nanoid_1.nanoid)();
+            messageId = (0, nanoid_1.nanoid)();
             this.eventBus.publish(threadId, {
                 type: 'run-start',
                 runId,
@@ -1384,6 +1903,10 @@ let InstanceAiService = class InstanceAiService {
                 payload: { messageId, messageGroupId },
             });
             if (signal.aborted) {
+                this.evaluateTerminalResponse(threadId, runId, 'cancelled', {
+                    messageGroupId,
+                    correlationId: messageId,
+                });
                 this.eventBus.publish(threadId, {
                     type: 'run-finish',
                     runId,
@@ -1394,7 +1917,9 @@ let InstanceAiService = class InstanceAiService {
             }
             const mcpServers = this.parseMcpServers(this.instanceAiConfig.mcpServers);
             const executionPushRef = this.threadPushRef.get(threadId);
-            const { context, memory, taskStorage, snapshotStorage, modelId, orchestrationContext } = await this.createExecutionEnvironment(user, threadId, runId, signal, researchMode, messageGroupId, executionPushRef);
+            const environment = await this.createExecutionEnvironment(user, threadId, runId, signal, researchMode, messageGroupId, executionPushRef);
+            activeSnapshotStorage = environment.snapshotStorage;
+            const { context, memory, taskStorage, snapshotStorage, modelId, orchestrationContext } = environment;
             aiCreatedWorkflowIds = context.aiCreatedWorkflowIds ??= new Set();
             orchestrationContext.currentUserMessage = message;
             orchestrationContext.isReplanFollowUp = isReplanFollowUp;
@@ -1433,6 +1958,8 @@ let InstanceAiService = class InstanceAiService {
                 userId: user.id,
                 modelId,
                 input: traceInput,
+                n8nVersion: constants_1.N8N_VERSION,
+                workflowSdkVersion: constants_1.WORKFLOW_SDK_VERSION,
                 proxyConfig: orchestrationContext.tracingProxyConfig,
             });
             if (!tracing && process.env.E2E_TESTS === 'true') {
@@ -1466,18 +1993,19 @@ let InstanceAiService = class InstanceAiService {
                 context,
                 orchestrationContext,
                 mcpServers,
+                mcpManager: this.mcpClientManager,
                 memoryConfig,
                 memory,
                 disableDeferredTools: true,
                 timeZone: timeZone ?? this.defaultTimeZone,
             });
             const enrichedMessage = await this.buildMessageWithRunningTasks(threadId, message);
-            let nonStructuredAttachments = [];
+            let multimodalAttachments = [];
             let attachmentManifest = '';
             let hasParseableAttachment = false;
             if (attachments && attachments.length > 0) {
                 const classifiedAttachments = (0, instance_ai_1.classifyAttachments)(attachments);
-                nonStructuredAttachments = attachments.filter((attachment) => !(0, instance_ai_1.isStructuredAttachment)(attachment));
+                multimodalAttachments = attachments.filter((attachment) => !(0, instance_ai_1.isParseableAttachment)(attachment) && attachment.mimeType.startsWith('image/'));
                 hasParseableAttachment = classifiedAttachments.some((attachment) => attachment.parseable);
                 attachmentManifest = (0, instance_ai_1.buildAttachmentManifest)(classifiedAttachments);
             }
@@ -1553,13 +2081,13 @@ let InstanceAiService = class InstanceAiService {
                 const fullMessage = conversationSummary
                     ? `${conversationSummary}\n\n${messageWithoutSummary}`
                     : messageWithoutSummary;
-                if (nonStructuredAttachments.length > 0) {
+                if (multimodalAttachments.length > 0) {
                     streamInput = [
                         {
                             role: 'user',
                             content: [
                                 { type: 'text', text: fullMessage },
-                                ...nonStructuredAttachments.map((attachment) => ({
+                                ...multimodalAttachments.map((attachment) => ({
                                     type: 'file',
                                     data: attachment.data,
                                     mimeType: attachment.mimeType,
@@ -1577,7 +2105,7 @@ let InstanceAiService = class InstanceAiService {
                         : {
                             fullMessage,
                             attachmentCount: attachments?.length ?? 0,
-                            nonStructuredAttachmentCount: nonStructuredAttachments.length,
+                            multimodalAttachmentCount: multimodalAttachments.length,
                         };
                     await tracing.finishRun(promptBuildRun, {
                         outputs: traceOutput,
@@ -1612,6 +2140,7 @@ let InstanceAiService = class InstanceAiService {
                         signal,
                         eventBus: this.eventBus,
                         logger: this.logger,
+                        onActivity: () => this.runState.touchActiveRun(threadId),
                     });
                 })
                 : await (0, instance_ai_1.streamAgentRun)(agent, streamInput, {
@@ -1631,6 +2160,7 @@ let InstanceAiService = class InstanceAiService {
                     signal,
                     eventBus: this.eventBus,
                     logger: this.logger,
+                    onActivity: () => this.runState.touchActiveRun(threadId),
                 });
             mastraRunId = result.mastraRunId;
             if (result.status === 'suspended') {
@@ -1658,6 +2188,20 @@ let InstanceAiService = class InstanceAiService {
                         is_intermediate: true,
                     });
                 }
+                const waitingDecision = this.evaluateWaitingResponse(threadId, runId, result.confirmationEvent, {
+                    messageGroupId,
+                    correlationId: messageId,
+                });
+                if (waitingDecision?.reason === 'confirmation-invalid') {
+                    messageTraceFinalization = await this.finishInvalidConfirmationRun({
+                        threadId,
+                        runId,
+                        abortController,
+                        snapshotStorage,
+                        tracing,
+                    });
+                    return;
+                }
                 if (result.confirmationEvent) {
                     this.trackConfirmationRequest(threadId, result.confirmationEvent);
                     this.eventBus.publish(threadId, result.confirmationEvent);
@@ -1666,6 +2210,11 @@ let InstanceAiService = class InstanceAiService {
                 return;
             }
             const outputText = await (result.text ?? Promise.resolve(''));
+            this.evaluateTerminalResponse(threadId, runId, result.status, {
+                messageGroupId,
+                correlationId: messageId,
+                workSummary: result.workSummary,
+            });
             const finalStatus = result.status === 'errored' ? 'error' : result.status;
             await this.finalizeRunTracing(runId, tracing, {
                 status: finalStatus,
@@ -1697,25 +2246,44 @@ let InstanceAiService = class InstanceAiService {
         }
         catch (error) {
             if (signal.aborted) {
+                const cancellationReason = this.liveness.consumeRunTimedOut(runId)
+                    ? liveness_1.INSTANCE_AI_RUN_TIMEOUT_REASON
+                    : getAbortReason(signal);
+                if (cancellationReason === liveness_1.INSTANCE_AI_RUN_TIMEOUT_REASON) {
+                    this.liveness.publishRunTimeoutNotice(threadId, runId);
+                }
+                this.evaluateTerminalResponse(threadId, runId, 'cancelled', {
+                    messageGroupId,
+                    correlationId: messageId,
+                });
                 await this.finalizeRunTracing(runId, tracing, {
                     status: 'cancelled',
-                    reason: 'user_cancelled',
+                    reason: cancellationReason,
                 });
                 messageTraceFinalization = {
                     status: 'cancelled',
-                    reason: 'user_cancelled',
+                    reason: cancellationReason,
                     metadata: { completion_source: 'orchestrator' },
                 };
                 const archivedWorkflowIds = await this.reapAiTemporaryFromRun(threadId, user, aiCreatedWorkflowIds);
-                this.publishRunFinish(threadId, runId, 'cancelled', 'user_cancelled', archivedWorkflowIds);
+                this.publishRunFinish(threadId, runId, 'cancelled', cancellationReason, archivedWorkflowIds);
+                if (activeSnapshotStorage) {
+                    await this.saveAgentTreeSnapshot(threadId, runId, activeSnapshotStorage);
+                }
                 return;
             }
             const errorMessage = getErrorMessage(error);
+            const userFacingErrorMessage = getUserFacingErrorMessage(error);
             this.logger.error('Instance AI run error', {
                 error: errorMessage,
                 threadId,
                 runId,
             });
+            this.evaluateTerminalResponse(threadId, runId, 'errored', {
+                messageGroupId,
+                correlationId: messageId,
+                errorMessage: userFacingErrorMessage,
+            });
             await this.finalizeRunTracing(runId, tracing, {
                 status: 'error',
                 reason: errorMessage,
@@ -1732,14 +2300,16 @@ let InstanceAiService = class InstanceAiService {
                 agentId: ORCHESTRATOR_AGENT_ID,
                 payload: {
                     status: 'error',
-                    reason: errorMessage,
+                    reason: userFacingErrorMessage,
                     ...(archivedWorkflowIds.length > 0 ? { archivedWorkflowIds } : {}),
                 },
             });
+            if (activeSnapshotStorage) {
+                await this.saveAgentTreeSnapshot(threadId, runId, activeSnapshotStorage);
+            }
         }
         finally {
             this.runState.clearActiveRun(threadId);
-            this.threadPushRef.delete(threadId);
             this.domainAccessTrackersByThread.get(threadId)?.clearRun(runId);
             if (messageTraceFinalization) {
                 await this.maybeFinalizeRunTraceRoot(runId, messageTraceFinalization);
@@ -1866,6 +2436,19 @@ let InstanceAiService = class InstanceAiService {
     }
     async resolveConfirmation(requestingUserId, requestId, request) {
         const data = toConfirmationData(request);
+        const revalidated = await this.revalidateActiveUser(requestingUserId);
+        if (!revalidated) {
+            this.logger.warn('Rejecting confirmation: user no longer authorized for AI Assistant', {
+                userId: requestingUserId,
+                requestId,
+            });
+            this.runState.rejectPendingConfirmation(requestId);
+            const suspended = this.runState.findSuspendedByRequestId(requestId);
+            if (suspended && suspended.user.id === requestingUserId) {
+                this.cancelRun(suspended.threadId);
+            }
+            return false;
+        }
         if (this.runState.resolvePendingConfirmation(requestingUserId, requestId, data)) {
             this.logger.debug('Resolved pending confirmation (sub-agent HITL)', {
                 requestId,
@@ -1891,6 +2474,16 @@ let InstanceAiService = class InstanceAiService {
         const { agent, runId, mastraRunId, threadId, user, toolCallId, abortController, tracing, checkpoint, } = suspended;
         if (user.id !== requestingUserId)
             return false;
+        const revalidated = await this.revalidateActiveUser(user.id);
+        if (!revalidated) {
+            this.logger.warn('Cancelling suspended run: user no longer authorized for AI Assistant', {
+                userId: user.id,
+                threadId,
+                requestId,
+            });
+            this.cancelRun(threadId);
+            return false;
+        }
         this.runState.activateSuspendedRun(threadId);
         const credentialsPayload = data.nodeCredentials ?? data.credentials;
         const resumeData = {
@@ -1908,7 +2501,7 @@ let InstanceAiService = class InstanceAiService {
             runId,
             mastraRunId,
             threadId,
-            user,
+            user: revalidated,
             toolCallId,
             signal: abortController.signal,
             abortController,
@@ -1935,6 +2528,7 @@ let InstanceAiService = class InstanceAiService {
                         eventBus: this.eventBus,
                         logger: this.logger,
                         mastraRunId: opts.mastraRunId,
+                        onActivity: () => this.runState.touchActiveRun(opts.threadId),
                     });
                 })
                 : await (0, instance_ai_1.resumeAgentRun)(agent, resumeData, {
@@ -1949,6 +2543,7 @@ let InstanceAiService = class InstanceAiService {
                     eventBus: this.eventBus,
                     logger: this.logger,
                     mastraRunId: opts.mastraRunId,
+                    onActivity: () => this.runState.touchActiveRun(opts.threadId),
                 });
             if (result.status === 'suspended') {
                 if (result.suspension) {
@@ -1975,6 +2570,18 @@ let InstanceAiService = class InstanceAiService {
                         is_intermediate: true,
                     });
                 }
+                const messageGroupId = this.traceContextsByRunId.get(opts.runId)?.messageGroupId;
+                const waitingDecision = this.evaluateWaitingResponse(opts.threadId, opts.runId, result.confirmationEvent, { messageGroupId });
+                if (waitingDecision?.reason === 'confirmation-invalid') {
+                    messageTraceFinalization = await this.finishInvalidConfirmationRun({
+                        threadId: opts.threadId,
+                        runId: opts.runId,
+                        abortController: opts.abortController,
+                        snapshotStorage: opts.snapshotStorage,
+                        tracing: opts.tracing,
+                    });
+                    return;
+                }
                 if (result.confirmationEvent) {
                     this.trackConfirmationRequest(opts.threadId, result.confirmationEvent);
                     this.eventBus.publish(opts.threadId, result.confirmationEvent);
@@ -1983,6 +2590,11 @@ let InstanceAiService = class InstanceAiService {
                 return;
             }
             const outputText = await (result.text ?? Promise.resolve(''));
+            const messageGroupId = this.traceContextsByRunId.get(opts.runId)?.messageGroupId;
+            this.evaluateTerminalResponse(opts.threadId, opts.runId, result.status, {
+                messageGroupId,
+                workSummary: result.workSummary,
+            });
             const finalStatus = result.status === 'errored' ? 'error' : result.status;
             await this.finalizeRunTracing(opts.runId, opts.tracing, {
                 status: finalStatus,
@@ -2009,6 +2621,10 @@ let InstanceAiService = class InstanceAiService {
         }
         catch (error) {
             if (opts.signal.aborted) {
+                const messageGroupId = this.traceContextsByRunId.get(opts.runId)?.messageGroupId;
+                this.evaluateTerminalResponse(opts.threadId, opts.runId, 'cancelled', {
+                    messageGroupId,
+                });
                 await this.finalizeRunTracing(opts.runId, opts.tracing, {
                     status: 'cancelled',
                     reason: 'user_cancelled',
@@ -2020,14 +2636,21 @@ let InstanceAiService = class InstanceAiService {
                 };
                 const archivedWorkflowIds = await this.reapAiTemporaryFromRun(opts.threadId, opts.user, undefined);
                 this.publishRunFinish(opts.threadId, opts.runId, 'cancelled', 'user_cancelled', archivedWorkflowIds);
+                await this.saveAgentTreeSnapshot(opts.threadId, opts.runId, opts.snapshotStorage);
                 return;
             }
             const errorMessage = getErrorMessage(error);
+            const userFacingErrorMessage = getUserFacingErrorMessage(error);
             this.logger.error('Instance AI resumed run error', {
                 error: errorMessage,
                 threadId: opts.threadId,
                 runId: opts.runId,
             });
+            const messageGroupId = this.traceContextsByRunId.get(opts.runId)?.messageGroupId;
+            this.evaluateTerminalResponse(opts.threadId, opts.runId, 'errored', {
+                messageGroupId,
+                errorMessage: userFacingErrorMessage,
+            });
             await this.finalizeRunTracing(opts.runId, opts.tracing, {
                 status: 'error',
                 reason: errorMessage,
@@ -2044,14 +2667,14 @@ let InstanceAiService = class InstanceAiService {
                 agentId: ORCHESTRATOR_AGENT_ID,
                 payload: {
                     status: 'error',
-                    reason: errorMessage,
+                    reason: userFacingErrorMessage,
                     ...(archivedWorkflowIds.length > 0 ? { archivedWorkflowIds } : {}),
                 },
             });
+            await this.saveAgentTreeSnapshot(opts.threadId, opts.runId, opts.snapshotStorage);
         }
         finally {
             this.runState.clearActiveRun(opts.threadId);
-            this.threadPushRef.delete(opts.threadId);
             if (messageTraceFinalization) {
                 await this.maybeFinalizeRunTraceRoot(opts.runId, messageTraceFinalization);
             }
@@ -2132,6 +2755,7 @@ let InstanceAiService = class InstanceAiService {
                 }
             },
             onSettled: async (task) => {
+                await this.recordBackgroundTerminalOutcome(task);
                 await this.saveAgentTreeSnapshot(opts.threadId, runId, snapshotStorage, true, task.messageGroupId);
                 if (task.plannedTaskId)
                     return;
@@ -2152,6 +2776,13 @@ let InstanceAiService = class InstanceAiService {
                 const hasActiveRun = !!this.runState.getActiveRunId(opts.threadId);
                 const hasSuspendedRun = this.runState.hasSuspendedRun(opts.threadId);
                 if (remaining.length === 0 && !hasActiveRun && !hasSuspendedRun) {
+                    if (this.liveness.hasTimedOutActiveRunThread(opts.threadId)) {
+                        this.logger.debug('Skipping background auto-follow-up after active run timeout', {
+                            threadId: opts.threadId,
+                            taskId: task.taskId,
+                        });
+                        return;
+                    }
                     const user = this.runState.getThreadUser(opts.threadId);
                     if (user) {
                         const payload = JSON.stringify({
@@ -2302,20 +2933,23 @@ let InstanceAiService = class InstanceAiService {
         }
         return archived;
     }
-    async finalizeCancelledSuspendedRun(suspended) {
+    async finalizeCancelledSuspendedRun(suspended, reason = 'user_cancelled') {
+        if (reason === liveness_1.INSTANCE_AI_RUN_TIMEOUT_REASON) {
+            this.liveness.publishRunTimeoutNotice(suspended.threadId, suspended.runId);
+        }
         await this.finalizeRunTracing(suspended.runId, suspended.tracing, {
             status: 'cancelled',
-            reason: 'user_cancelled',
+            reason,
         });
         const archivedWorkflowIds = await this.reapAiTemporaryFromRun(suspended.threadId, suspended.user, undefined);
-        this.publishRunFinish(suspended.threadId, suspended.runId, 'cancelled', 'user_cancelled', archivedWorkflowIds);
+        this.publishRunFinish(suspended.threadId, suspended.runId, 'cancelled', reason, archivedWorkflowIds);
         await this.saveAgentTreeSnapshot(suspended.threadId, suspended.runId, this.dbSnapshotStorage, true);
         if (suspended.mastraRunId) {
             void this.cleanupMastraSnapshots(suspended.mastraRunId);
         }
         await this.maybeFinalizeRunTraceRoot(suspended.runId, {
             status: 'cancelled',
-            reason: 'user_cancelled',
+            reason,
             metadata: { completion_source: 'orchestrator' },
         });
     }
@@ -2391,11 +3025,9 @@ let InstanceAiService = class InstanceAiService {
     }
     async finalizeRun(threadId, runId, status, snapshotStorage, options) {
         this.publishRunFinish(threadId, runId, status, undefined, options?.archivedWorkflowIds);
-        if (status === 'completed') {
-            await this.saveAgentTreeSnapshot(threadId, runId, snapshotStorage);
-            if (options?.userId && options?.modelId) {
-                void this.refineTitleIfNeeded(threadId, options.userId, options.modelId);
-            }
+        await this.saveAgentTreeSnapshot(threadId, runId, snapshotStorage);
+        if (status === 'completed' && options?.userId && options?.modelId) {
+            void this.refineTitleIfNeeded(threadId, options.userId, options.modelId);
         }
     }
     async refineTitleIfNeeded(threadId, userId, modelId) {
@@ -2456,11 +3088,23 @@ let InstanceAiService = class InstanceAiService {
             let groupRunIds;
             if (messageGroupId) {
                 groupRunIds = this.getRunIdsForMessageGroup(messageGroupId);
+                if (groupRunIds.length === 0) {
+                    const snapshot = await snapshotStorage.getLatest(threadId, { messageGroupId, runId });
+                    groupRunIds = snapshot?.runIds?.length ? snapshot.runIds : [runId];
+                }
                 events = this.eventBus.getEventsForRuns(threadId, groupRunIds);
             }
             else {
                 events = this.eventBus.getEventsForRun(threadId, runId);
             }
+            if (isUpdate && events.length === 0) {
+                this.logger.warn('Skipped updating empty Instance AI agent tree snapshot', {
+                    threadId,
+                    runId,
+                    messageGroupId,
+                });
+                return;
+            }
             const agentTree = (0, instance_ai_1.buildAgentTreeFromEvents)(events);
             const tracing = this.traceContextsByRunId.get(runId)?.tracing;
             const saveOptions = {
@@ -2513,6 +3157,9 @@ exports.InstanceAiService = InstanceAiService = __decorate([
         telemetry_1.Telemetry,
         db_1.UserRepository,
         db_1.AiBuilderTemporaryWorkflowRepository,
-        n8n_core_1.ErrorReporter])
+        n8n_core_1.ErrorReporter,
+        config_1.SsrfProtectionConfig,
+        ssrf_protection_service_1.SsrfProtectionService,
+        event_service_1.EventService])
 ], InstanceAiService);
 //# sourceMappingURL=instance-ai.service.js.map