n8n 2.45.6 → 2.46.1

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

@@ -10,17 +10,12 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 };
 var InstanceAiService_1;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.InstanceAiService = exports.QuotaExhaustedStreamError = exports.QUOTA_EXHAUSTED_USER_MESSAGE = void 0;
+exports.InstanceAiService = exports.QUOTA_EXHAUSTED_USER_MESSAGE = exports.QuotaExhaustedStreamError = exports.isAssistantCreditBalanceExhausted = void 0;
 exports.isAttachmentRejectedByProviderError = isAttachmentRejectedByProviderError;
 exports.getUserFacingErrorMessage = getUserFacingErrorMessage;
 exports.isMaskedStreamFailure = isMaskedStreamFailure;
-exports.isAssistantCreditBalanceExhausted = isAssistantCreditBalanceExhausted;
-exports.resolveOperatorPromptVersion = resolveOperatorPromptVersion;
-const agents_1 = require("@n8n/agents");
-const sandbox_1 = require("@n8n/agents/sandbox");
 const api_types_1 = require("@n8n/api-types");
 const backend_common_1 = require("@n8n/backend-common");
-const backend_network_1 = require("@n8n/backend-network");
 const backend_services_1 = require("@n8n/backend-services");
 const config_1 = require("@n8n/config");
 const db_1 = require("@n8n/db");
@@ -32,72 +27,60 @@ const telemetry_1 = require("@n8n/telemetry");
 const get_error_message_1 = require("@n8n/utils/errors/get-error-message");
 const is_record_1 = require("@n8n/utils/is-record");
 const lazy_import_1 = require("@n8n/utils/lazy-import");
-const workflow_sdk_1 = require("@n8n/workflow-sdk");
 const n8n_core_1 = require("n8n-core");
 const n8n_workflow_1 = require("n8n-workflow");
 const nanoid_1 = require("nanoid");
 const constants_1 = require("../../constants");
 const errors_1 = require("@n8n/errors");
-const instance_ai_builder_delegate_adapter_1 = require("../../modules/agents/instance-ai-builder-delegate.adapter");
-const instance_ai_agent_context_adapter_1 = require("../../modules/agents/instance-ai-agent-context.adapter");
-const model_stream_stall_options_1 = require("../../modules/agents/model-stream-stall-options");
-const check_access_1 = require("../../permissions.ee/check-access");
-const push_1 = require("../../push");
+const instance_ai_builder_delegate_adapter_1 = require("./instance-ai-builder-delegate.adapter");
+const model_stream_stall_options_1 = require("../../utils/model-stream-stall-options");
 const publisher_service_1 = require("../../scaling/pubsub/publisher.service");
-const ai_preference_service_1 = require("../../services/ai-preference.service");
-const ai_usage_service_1 = require("../../services/ai-usage.service");
 const ai_service_1 = require("../../services/ai.service");
-const proxy_token_manager_1 = require("../../services/proxy-token-manager");
 const telemetry_2 = require("../../telemetry");
 const utils_1 = require("../../utils");
-const agent_preview_handoff_1 = require("./agent-preview-handoff");
-const agents_access_1 = require("./agents-access");
-const instance_context_service_1 = require("./instance-context.service");
-const composite_local_mcp_server_1 = require("./browser/composite-local-mcp-server");
+const ai_preferences_telemetry_1 = require("./ai-preferences-telemetry");
 const instance_ai_browser_session_service_1 = require("./browser/instance-ai-browser-session.service");
-const computer_use_availability_1 = require("./computer-use-availability");
 const drop_rejected_attachments_1 = require("./drop-rejected-attachments");
 const thread_credential_allowlist_service_1 = require("./eval/thread-credential-allowlist.service");
 const durable_event_log_1 = require("./event-bus/durable-event-log");
 const in_process_event_bus_1 = require("./event-bus/in-process-event-bus");
 const interrupted_run_sweeper_1 = require("./event-bus/interrupted-run-sweeper");
-const instance_ai_conversation_history_service_1 = require("./instance-ai-conversation-history.service");
 const instance_ai_credit_service_1 = require("./instance-ai-credit.service");
 const instance_ai_error_reporter_service_1 = require("./instance-ai-error-reporter.service");
-const instance_ai_gateway_service_1 = require("./instance-ai-gateway.service");
 const instance_ai_memory_service_1 = require("./instance-ai-memory.service");
 const instance_ai_model_service_1 = require("./instance-ai-model.service");
 const instance_ai_run_limit_error_1 = require("./instance-ai-run-limit.error");
 const instance_ai_run_probe_1 = require("./instance-ai-run-probe");
 const instance_ai_settings_service_1 = require("./instance-ai-settings.service");
-const instance_ai_skills_service_1 = require("./instance-ai-skills.service");
 const instance_ai_temporary_workflow_service_1 = require("./instance-ai-temporary-workflow.service");
 const instance_ai_terminal_outcome_service_1 = require("./instance-ai-terminal-outcome.service");
 const instance_ai_thread_tabs_service_1 = require("./instance-ai-thread-tabs.service");
 const instance_ai_adapter_service_1 = require("./instance-ai.adapter.service");
 const internal_messages_1 = require("./internal-messages");
-const onboarding_opening_1 = require("./onboarding-opening");
 const liveness_1 = require("./liveness");
-const mcp_1 = require("./mcp");
 const observability_1 = require("./observability");
-const planned_task_action_runner_1 = require("./planned-task-action-runner");
 const instance_ai_event_log_repository_1 = require("./repositories/instance-ai-event-log.repository");
 const instance_ai_observation_cursor_repository_1 = require("./repositories/instance-ai-observation-cursor.repository");
 const instance_ai_observation_repository_1 = require("./repositories/instance-ai-observation.repository");
 const instance_ai_pending_confirmation_repository_1 = require("./repositories/instance-ai-pending-confirmation.repository");
 const instance_ai_thread_grant_repository_1 = require("./repositories/instance-ai-thread-grant.repository");
-const sandbox_2 = require("./sandbox");
-const db_iteration_log_storage_1 = require("./storage/db-iteration-log-storage");
+const sandbox_1 = require("./sandbox");
+const self_healing_agent_service_1 = require("./self-healing/self-healing-agent.service");
 const typeorm_agent_checkpoint_store_1 = require("./storage/typeorm-agent-checkpoint-store");
 const typeorm_agent_memory_1 = require("./storage/typeorm-agent-memory");
+const assistant_credits_1 = require("./turn-setup/assistant-credits");
+const assistant_agent_factory_1 = require("./turn-setup/assistant-agent.factory");
+const assistant_turn_environment_factory_1 = require("./turn-setup/assistant-turn-environment.factory");
+const assistant_turn_input_builder_1 = require("./turn-setup/assistant-turn-input.builder");
+var assistant_credits_2 = require("./turn-setup/assistant-credits");
+Object.defineProperty(exports, "isAssistantCreditBalanceExhausted", { enumerable: true, get: function () { return assistant_credits_2.isAssistantCreditBalanceExhausted; } });
+Object.defineProperty(exports, "QuotaExhaustedStreamError", { enumerable: true, get: function () { return assistant_credits_2.QuotaExhaustedStreamError; } });
 const stream_transport_error_1 = require("./stream-transport-error");
 const suspended_run_restorer_service_1 = require("./suspended-run-restorer.service");
 const suspended_thread_persistence_service_1 = require("./suspended-thread-persistence.service");
 const tracing_1 = require("./tracing");
 const workflow_verification_obligation_service_1 = require("./workflow-verification-obligation-service");
 const workflow_verification_task_projector_1 = require("./workflow-verification-task-projector");
-const agent_execution_service_1 = require("../agents/agent-execution.service");
-const format_preview_context_1 = require("../agents/builder/format-preview-context");
 function buildSuspensionTraceOutputs(runId, suspension) {
     const rawMessage = suspension?.suspendPayload.message;
     const message = typeof rawMessage === 'string' && rawMessage ? rawMessage : undefined;
@@ -110,42 +93,6 @@ function buildSuspensionTraceOutputs(runId, suspension) {
         ...(message ? { message } : {}),
     };
 }
-function isNamedResourceAttachment(attachment) {
-    return attachment.type !== 'nodes' && Boolean(attachment.name);
-}
-function buildHandoffContextBlock(context) {
-    if (!context || context.source !== 'credential-modal')
-        return '';
-    const { credential } = context;
-    const placeholderTitles = credential.placeholderTitles ?? [];
-    const lines = [
-        `- Credential type: \`${credential.credentialType}\` (${credential.displayName}).`,
-        credential.id ? `- Existing credential id: \`${credential.id}\`.` : '',
-        credential.nodeName ? `- Node name: "${credential.nodeName}".` : '',
-        credential.nodeType ? `- Node type: \`${credential.nodeType}\`.` : '',
-        placeholderTitles.length
-            ? `- The credential form is fully pre-filled from a recipe; the user only pastes: ${placeholderTitles.map((title) => `"${title}"`).join(', ')}.`
-            : '',
-        credential.docsUrl
-            ? `- The provider page where the user creates/copies the secret (verified during recipe research): ${credential.docsUrl}`
-            : '',
-        credential.documentationUrl ? `- n8n documentation URL: ${credential.documentationUrl}` : '',
-        credential.oauthRedirectUrl
-            ? `- OAuth redirect/callback URL shown in the modal: ${credential.oauthRedirectUrl}`
-            : '',
-    ].filter(Boolean);
-    const prose = [
-        'The user opened this conversation from the credential setup modal and is asking for setup guidance.',
-        ...lines,
-        'Use this metadata only as setup context. Never ask the user to paste credential secrets into chat. For credential setup docs, load `n8n-docs-assistant` and use `n8n-docs` with `intent: "credential-setup"`.',
-        placeholderTitles.length
-            ? `Because the form is pre-filled, give step-by-step guidance on where to obtain the listed value(s) on the provider side${credential.docsUrl ? ' — direct the user to the provider page above rather than re-researching' : ' (research the provider if needed)'} — and do NOT suggest editing the auth template, test URL, or any other credential field.`
-            : '',
-    ]
-        .filter(Boolean)
-        .join('\n');
-    return `${internal_messages_1.CREDENTIAL_CONTEXT_OPEN_TAG}\n${JSON.stringify(context)}\n\n${prose}\n${internal_messages_1.CREDENTIAL_CONTEXT_CLOSE_TAG}`;
-}
 function isTelemetryConfigurableAgent(agent) {
     return (typeof agent === 'object' &&
         agent !== null &&
@@ -155,14 +102,6 @@ const WORKFLOW_SETUP_ROUTING_CLAIM_TTL_MS = 15 * 60 * 1000;
 const CONFIRMATION_EXPIRED_MESSAGE = 'This confirmation has expired. Send a new message to continue.';
 const RESUME_REJECTED_MESSAGE = 'I could not apply that confirmation. Send a new message to continue.';
 const INSTANCE_AI_SHUTDOWN_DRAIN_TIMEOUT_MS = 5 * 1000;
-function isTextMessagePart(part) {
-    return (typeof part === 'object' &&
-        part !== null &&
-        'type' in part &&
-        part.type === 'text' &&
-        'text' in part &&
-        typeof part.text === 'string');
-}
 function isSandboxEndpointNotAllowedError(error) {
     return (0, get_error_message_1.getErrorMessage)(error).toLowerCase().includes('endpoint not allowed');
 }
@@ -247,32 +186,14 @@ function failureStageForErrorCode(errorCode) {
         return 'persistence';
     return 'unknown';
 }
-class QuotaExhaustedStreamError extends n8n_workflow_1.UserError {
-    constructor(maskedError) {
-        super(`AI credits exhausted (${maskedError.name}: ${maskedError.message})`, {
-            cause: maskedError,
-        });
-        this.errorCode = 'quota_exhausted';
-    }
-}
-exports.QuotaExhaustedStreamError = QuotaExhaustedStreamError;
-function createInertAbortSignal() {
-    return new AbortController().signal;
-}
-function isAssistantCreditBalanceExhausted(credits) {
-    return credits.creditsQuota >= 0 && credits.creditsClaimed >= credits.creditsQuota;
-}
-function assistantCreditsExhaustedError() {
-    return new QuotaExhaustedStreamError(new Error('Assistant credits exhausted'));
-}
 function asQuotaExhaustedError(error) {
-    if (error instanceof QuotaExhaustedStreamError)
+    if (error instanceof assistant_credits_1.QuotaExhaustedStreamError)
         return error;
     if (!(0, instance_ai_1.isQuotaExhaustedError)(error))
         return undefined;
     if (error instanceof Error)
-        return new QuotaExhaustedStreamError(error);
-    return assistantCreditsExhaustedError();
+        return new assistant_credits_1.QuotaExhaustedStreamError(error);
+    return (0, assistant_credits_1.assistantCreditsExhaustedError)();
 }
 function quotaExhaustedFromSignal(signal) {
     if (!('reason' in signal))
@@ -315,28 +236,14 @@ const MAX_CONCURRENT_BACKGROUND_TASKS_PER_THREAD = 5;
 const UNLIMITED_CONCURRENCY = -1;
 const MAX_CONSECUTIVE_FAILED_INTERNAL_FOLLOW_UPS = 3;
 const TITLE_REFINE_HISTORY_LIMIT = 50;
-function resolveOperatorPromptVersion(configured) {
-    const version = configured?.trim();
-    if (!version)
-        return undefined;
-    (0, instance_ai_1.assertInstanceAiPromptVersion)(version);
-    return version;
-}
 let InstanceAiService = InstanceAiService_1 = class InstanceAiService {
-    get mcpClientManager() {
-        if (!this._mcpClientManager) {
-            this._mcpClientManager = new instance_ai_1.McpClientManager(this._ssrfProtectionConfig.enabled ? this._ssrfProtectionService : undefined, { onToolCallSettled: (event) => this.trackMcpToolCall(event) });
-        }
-        return this._mcpClientManager;
-    }
-    constructor(logger, globalConfig, instanceSettings, adapterService, eventBus, eventLog, interruptedRunSweeper, settingsService, gatewayService, browserSessionService, memoryService, agentMemory, checkpointStore, aiService, threadGrantRepo, pendingConfirmationRepo, observationRepo, observationCursorRepo, urlService, eventLogRepository, dbIterationLogStorage, instanceWriteAccess, telemetry, mcpRegistryService, userRepository, temporaryWorkflowService, errorReporter, ssrfProtectionConfig, ssrfProtectionService, eventService, evalCredentialAllowlists, runProbe, modelService, creditService, publisher, instanceAiErrorReporter, push, conversationHistoryService, instanceContext, aiPreferenceService, aiUsageService, threadTabsService, skillsService) {
+    constructor(logger, globalConfig, instanceSettings, adapterService, eventBus, eventLog, interruptedRunSweeper, settingsService, browserSessionService, memoryService, agentMemory, checkpointStore, aiService, threadGrantRepo, pendingConfirmationRepo, observationRepo, observationCursorRepo, eventLogRepository, telemetry, userRepository, temporaryWorkflowService, errorReporter, eventService, evalCredentialAllowlists, runProbe, modelService, creditService, publisher, instanceAiErrorReporter, threadTabsService, selfHealingAgent, turnEnvironment, turnInput, agentFactory) {
         this.instanceSettings = instanceSettings;
         this.adapterService = adapterService;
         this.eventBus = eventBus;
         this.eventLog = eventLog;
         this.interruptedRunSweeper = interruptedRunSweeper;
         this.settingsService = settingsService;
-        this.gatewayService = gatewayService;
         this.browserSessionService = browserSessionService;
         this.memoryService = memoryService;
         this.agentMemory = agentMemory;
@@ -346,12 +253,8 @@ let InstanceAiService = InstanceAiService_1 = class InstanceAiService {
         this.pendingConfirmationRepo = pendingConfirmationRepo;
         this.observationRepo = observationRepo;
         this.observationCursorRepo = observationCursorRepo;
-        this.urlService = urlService;
         this.eventLogRepository = eventLogRepository;
-        this.dbIterationLogStorage = dbIterationLogStorage;
-        this.instanceWriteAccess = instanceWriteAccess;
         this.telemetry = telemetry;
-        this.mcpRegistryService = mcpRegistryService;
         this.userRepository = userRepository;
         this.temporaryWorkflowService = temporaryWorkflowService;
         this.errorReporter = errorReporter;
@@ -361,20 +264,17 @@ let InstanceAiService = InstanceAiService_1 = class InstanceAiService {
         this.creditService = creditService;
         this.publisher = publisher;
         this.instanceAiErrorReporter = instanceAiErrorReporter;
-        this.push = push;
-        this.conversationHistoryService = conversationHistoryService;
-        this.instanceContext = instanceContext;
-        this.aiPreferenceService = aiPreferenceService;
-        this.aiUsageService = aiUsageService;
         this.threadTabsService = threadTabsService;
-        this.skillsService = skillsService;
+        this.selfHealingAgent = selfHealingAgent;
+        this.turnEnvironment = turnEnvironment;
+        this.turnInput = turnInput;
+        this.agentFactory = agentFactory;
         this.runState = new instance_ai_1.RunStateRegistry((user) => user.id);
+        this.finalizingSelfHealingRuns = new Set();
         this.memoryTaskRegistry = new instance_ai_1.MemoryTaskRegistry();
         this.domainAccessTrackersByThread = new Map();
         this.threadPushRef = new Map();
         this.pendingBrowserCredentialSetups = new Map();
-        this.planRequestsByThread = new Map();
-        this.schedulerLocks = new Map();
         this.failedInternalFollowUpStreaks = new Map();
         this.runDebugBuffer = new instance_ai_1.RunDebugBuffer();
         this.inFlightExecutions = new Set();
@@ -430,7 +330,7 @@ let InstanceAiService = InstanceAiService_1 = class InstanceAiService {
             eventLog: this.eventLogRepository,
             aiService: this.aiService,
         });
-        this.sandboxService = new sandbox_2.InstanceAiSandboxService({
+        this.sandboxService = new sandbox_1.InstanceAiSandboxService({
             config: this.instanceAiConfig,
             logger: this.logger,
             errorReporter: this.errorReporter,
@@ -439,7 +339,7 @@ let InstanceAiService = InstanceAiService_1 = class InstanceAiService {
             settingsService: this.settingsService,
             aiService: this.aiService,
             resolveTracingConfig: async (threadId, userId) => {
-                const ownerId = userId ?? (await this.agentMemory.getThread(threadId))?.resourceId;
+                const ownerId = userId ?? (await this.memoryService.getThreadActorId(threadId));
                 if (!ownerId)
                     return { userId: 'system' };
                 const { tracingProxyConfig } = await this.createProxyRunConfig({ id: ownerId });
@@ -466,19 +366,11 @@ let InstanceAiService = InstanceAiService_1 = class InstanceAiService {
             },
         });
         this.defaultTimeZone = globalConfig.generic.timezone;
-        const restEndpoint = globalConfig.endpoints.rest;
-        this.oauth2CallbackUrl = `${this.urlService.getInstanceBaseUrl()}/${restEndpoint}/oauth2-credential/callback`;
-        this.webhookBaseUrl = `${this.urlService.getWebhookBaseUrl()}${globalConfig.endpoints.webhook}`;
-        this.formBaseUrl = `${this.urlService.getWebhookBaseUrl()}${globalConfig.endpoints.form}`;
-        this._ssrfProtectionConfig = ssrfProtectionConfig;
-        this._ssrfProtectionService = ssrfProtectionService;
         this.eventService.on('instance-ai-settings-updated', ({ mcpSettingsChanged }) => {
             this.sandboxService.invalidateCachedWorkspaces();
             if (!mcpSettingsChanged)
                 return;
-            if (!this._mcpClientManager)
-                return;
-            this._mcpClientManager.disconnect().catch((error) => {
+            this.agentFactory.disconnectMcpClients().catch((error) => {
                 this.logger.warn('Failed to disconnect MCP clients after settings change', {
                     error: (0, get_error_message_1.getErrorMessage)(error),
                 });
@@ -487,35 +379,7 @@ let InstanceAiService = InstanceAiService_1 = class InstanceAiService {
         this.liveness.start();
     }
     async createProxyRunConfig(user) {
-        if (!this.aiService.isProxyEnabled())
-            return {};
-        const client = await this.aiService.getClient();
-        const proxyBaseUrl = client.getApiProxyBaseUrl();
-        const tokenManager = new proxy_token_manager_1.ProxyTokenManager(async () => {
-            return await client.getInstanceAiApiProxyToken({ id: user.id }, { userMessageId: (0, nanoid_1.nanoid)() });
-        });
-        const featureHeaders = (0, api_types_1.buildProxyHeaders)({
-            feature: 'instance-ai',
-            n8nVersion: constants_1.N8N_VERSION,
-        });
-        return {
-            proxyBaseUrl,
-            tokenManager,
-            searchProxyConfig: {
-                apiUrl: proxyBaseUrl + '/brave-search',
-                getAuthHeaders: async () => ({
-                    ...(await tokenManager.getAuthHeaders()),
-                    ...featureHeaders,
-                }),
-            },
-            tracingProxyConfig: {
-                apiUrl: proxyBaseUrl + '/langsmith',
-                getAuthHeaders: async () => ({
-                    ...(await tokenManager.getAuthHeaders()),
-                    ...featureHeaders,
-                }),
-            },
-        };
+        return await this.turnEnvironment.createProxyRunConfig(user);
     }
     async resolveAgentModelConfig(user) {
         return await this.modelService.resolveAgentModelConfig(user);
@@ -572,20 +436,7 @@ let InstanceAiService = InstanceAiService_1 = class InstanceAiService {
         return args.turnHadAttachments && args.producedNoOutput;
     }
     async assertAssistantCreditsAvailable(user) {
-        let credits;
-        try {
-            credits = await this.modelService.getCredits(user);
-        }
-        catch (error) {
-            this.logger.debug('Skipping pre-run credit check; balance read failed', {
-                userId: user.id,
-                error: (0, get_error_message_1.getErrorMessage)(error),
-            });
-            return;
-        }
-        if (!isAssistantCreditBalanceExhausted(credits))
-            return;
-        throw assistantCreditsExhaustedError();
+        await this.turnEnvironment.assertAssistantCreditsAvailable(user);
     }
     async reclassifyMaskedStreamFailure(error, user, context) {
         if (!isMaskedStreamFailure(error))
@@ -606,7 +457,7 @@ let InstanceAiService = InstanceAiService_1 = class InstanceAiService {
             maskedError: (0, get_error_message_1.getErrorMessage)(error),
             ...context,
         });
-        return new QuotaExhaustedStreamError(error);
+        return new assistant_credits_1.QuotaExhaustedStreamError(error);
     }
     isEnabled() {
         return this.settingsService.isAgentEnabled() && !!this.instanceAiConfig.model;
@@ -651,21 +502,6 @@ let InstanceAiService = InstanceAiService_1 = class InstanceAiService {
             this.logger.info(`Observational memory task ${event.type}`, logContext);
         };
     }
-    subscribeToAgentErrors(agent, threadId, runId) {
-        agent.on("error", (event) => {
-            if (event.type !== "error")
-                return;
-            if (!event.source)
-                return;
-            const severity = (0, instance_ai_error_reporter_service_1.getAgentErrorSeverity)(event.source);
-            this.instanceAiErrorReporter.report(event.error, {
-                component: `instance-ai-${event.source}`,
-                ...(severity ? { severity } : {}),
-                threadId,
-                runId,
-            });
-        });
-    }
     isRunDebugEnabled() {
         return this.instanceAiConfig.runDebugEnabled;
     }
@@ -789,7 +625,62 @@ let InstanceAiService = InstanceAiService_1 = class InstanceAiService {
             }
         }
     }
-    startRun(user, threadId, message, attachments, context, timeZone, pushRef, mode, promptVersion, computerUseChannels, threadArtifacts, observerThresholdTokens) {
+    async startSelfHealingRun(input, lifecycle) {
+        this.selfHealingAgent.assertEnabled();
+        this.assertRunAdmissible(input.user);
+        const { threadId } = lifecycle;
+        this.liveness.clearThreadState(threadId);
+        const { runId, abortController, messageGroupId } = this.runState.startRun({
+            threadId,
+            runId: lifecycle.runId,
+            user: input.user,
+        });
+        const execution = this.selfHealingAgent
+            .execute(input, {
+            threadId,
+            runId,
+            messageGroupId,
+            signal: abortController.signal,
+            sandbox: this.sandboxService,
+            tracing: this.tracing,
+            createProxyRunConfig: async () => await this.createProxyRunConfig(input.user),
+            assertCreditsAvailable: async () => await this.assertAssistantCreditsAvailable(input.user),
+            onActivity: () => this.runState.touchActiveRun(threadId),
+            onFinalizing: () => {
+                this.finalizingSelfHealingRuns.add(runId);
+            },
+            onComplete: lifecycle.onComplete,
+            getAbortReason: () => {
+                if (this.liveness.consumeRunTimeout(runId).timedOut)
+                    return liveness_1.INSTANCE_AI_RUN_TIMEOUT_REASON;
+                if (quotaExhaustedFromSignal(abortController.signal))
+                    return 'quota_exhausted';
+                return getAbortReason(abortController.signal);
+            },
+            onFinish: (result, modelId, stream) => {
+                const status = result.status === 'suspended' ? 'errored' : result.status;
+                if (abortController.signal.reason !== 'service_shutdown') {
+                    this.publishRunFinish(threadId, runId, status, result.reason ?? result.finishReason, undefined, input.user.id, {
+                        modelId,
+                        promptVersion: instance_ai_1.SELF_HEALING_PROFILE_VERSION,
+                    });
+                }
+                this.emitRunMetrics(threadId, status, {
+                    modelId,
+                    workSummary: stream?.workSummary,
+                    usage: stream?.usage,
+                });
+            },
+        })
+            .finally(() => {
+            this.finalizingSelfHealingRuns.delete(runId);
+            this.runState.clearActiveRun(threadId);
+            this.liveness.clearThreadState(threadId);
+        });
+        this.trackInFlightExecution(execution);
+        return await execution;
+    }
+    startRun(user, threadId, message, attachments, context, timeZone, pushRef, mode, promptVersion, browserUseAvailable, threadArtifacts, observerThresholdTokens) {
         if (promptVersion !== undefined &&
             (0, instance_ai_1.resolvePromptProfile)({ version: promptVersion }).fallbackFrom) {
             throw new errors_1.BadRequestError(`Unknown Instance AI prompt version "${promptVersion}"`);
@@ -803,14 +694,14 @@ let InstanceAiService = InstanceAiService_1 = class InstanceAiService {
         if (timeZone) {
             this.runState.setTimeZone(threadId, timeZone);
         }
-        this.runState.setComputerUseChannels(threadId, computerUseChannels);
+        this.runState.setBrowserUseAvailable(threadId, browserUseAvailable);
         this.runState.setBuildMode(threadId, mode);
         this.runState.setPromptVersion(threadId, promptVersion);
         this.runState.setObserverThresholdTokens(threadId, observerThresholdTokens);
         if (pushRef !== undefined) {
             this.threadPushRef.set(threadId, pushRef);
         }
-        this.startExecuteRun(user, threadId, runId, message, abortController, attachments, context, messageGroupId, timeZone, false, undefined, undefined, undefined, threadArtifacts);
+        this.startExecuteRun(user, threadId, runId, message, abortController, attachments, context, messageGroupId, timeZone, undefined, threadArtifacts);
         return runId;
     }
     getMessageGroupId(threadId) {
@@ -833,6 +724,9 @@ let InstanceAiService = InstanceAiService_1 = class InstanceAiService {
             }
         }
         for (const threadId of threadIds) {
+            const runId = this.runState.getActiveRunId(threadId);
+            if (runId && this.finalizingSelfHealingRuns.has(runId))
+                continue;
             try {
                 this.cancelRun(threadId, 'quota_exhausted');
             }
@@ -847,9 +741,8 @@ let InstanceAiService = InstanceAiService_1 = class InstanceAiService {
     }
     cancelRun(threadId, reason = 'user_cancelled') {
         const quotaStop = reason === 'quota_exhausted';
-        const abortReason = quotaStop ? assistantCreditsExhaustedError() : undefined;
+        const abortReason = quotaStop ? (0, assistant_credits_1.assistantCreditsExhaustedError)() : undefined;
         const cancelledTasks = this.backgroundTasks.cancelThread(threadId, abortReason);
-        const user = this.runState.getThreadUser(threadId);
         for (const task of cancelledTasks) {
             void this.tracing.finalizeBackgroundTaskTracing(task, 'cancelled');
             if (quotaStop) {
@@ -875,11 +768,7 @@ let InstanceAiService = InstanceAiService_1 = class InstanceAiService {
                 },
             });
             void this.terminalOutcome.recordBackgroundTerminalOutcome(task);
-            if (user) {
-                void this.handlePlannedTaskSettlement(user, task, 'cancelled', { reschedule: false });
-            }
         }
-        void this.cancelAwaitingApprovalPlan(threadId);
         const { active, suspended } = this.runState.cancelThread(threadId);
         if (active) {
             if (reason === liveness_1.INSTANCE_AI_RUN_TIMEOUT_REASON)
@@ -930,10 +819,6 @@ let InstanceAiService = InstanceAiService_1 = class InstanceAiService {
             payload: { role: task.role, result: '', status: 'cancelled' },
         });
         void this.terminalOutcome.recordBackgroundTerminalOutcome(task);
-        const user = this.runState.getThreadUser(threadId);
-        if (user) {
-            void this.handlePlannedTaskSettlement(user, task, 'cancelled');
-        }
     }
     broadcastTaskControl(payload) {
         if (!this.instanceSettings.isMultiMain)
@@ -1163,12 +1048,10 @@ let InstanceAiService = InstanceAiService_1 = class InstanceAiService {
             reason: 'thread_cleared',
             metadata: { completion_source: 'service_cleanup' },
         });
-        this.schedulerLocks.delete(threadId);
         this.failedInternalFollowUpStreaks.delete(threadId);
         this.domainAccessTrackersByThread.delete(threadId);
         this.evalCredentialAllowlists.clearThread(threadId);
         this.threadPushRef.delete(threadId);
-        this.planRequestsByThread.delete(threadId);
         this.memoryTaskRegistry.clearThread(threadId);
         this.tracing.deleteTraceContextsForThread(threadId);
         await this.deleteAgentBuilderSessions(threadId);
@@ -1195,6 +1078,8 @@ let InstanceAiService = InstanceAiService_1 = class InstanceAiService {
         const { activeRuns, suspendedRuns, pendingThreadIds } = this.runState.shutdown();
         const threadsWithPendingHitl = new Set(pendingThreadIds);
         for (const run of activeRuns) {
+            if (run.abortController.signal.aborted)
+                continue;
             if (threadsWithPendingHitl.has(run.threadId)) {
                 await this.tracing.finalizeRunTracing(run.runId, run.tracing, {
                     status: 'cancelled',
@@ -1205,11 +1090,11 @@ let InstanceAiService = InstanceAiService_1 = class InstanceAiService {
                 continue;
             }
             this.publishRunFinish(run.threadId, run.runId, 'cancelled', 'service_shutdown', undefined, undefined, { promptVersion: run.promptVersion });
+            run.abortController.abort('service_shutdown');
             await this.tracing.finalizeRunTracing(run.runId, run.tracing, {
                 status: 'cancelled',
                 reason: 'service_shutdown',
             });
-            run.abortController.abort();
         }
         for (const run of suspendedRuns) {
             await this.tracing.finalizeRunTracing(run.runId, run.tracing, {
@@ -1233,28 +1118,42 @@ let InstanceAiService = InstanceAiService_1 = class InstanceAiService {
                 metadata: { completion_source: 'service_cleanup' },
             });
         }
-        this.gatewayService.disconnectAll();
         await this.browserSessionService.shutdown();
         this.sandboxService.stopSandboxExpiryTimers();
         this.domainAccessTrackersByThread.clear();
         this.tracing.clear();
         await this.eventLog.flushAll();
         this.eventBus.clear();
-        await this._mcpClientManager?.disconnect();
+        await this.agentFactory.disconnectMcpClients();
         await (0, instance_ai_1.shutdownProductTelemetryProviders)();
         this.logger.debug('Instance AI service shut down');
     }
-    trackInFlightExecution(promise) {
-        const tracked = promise.finally(() => {
+    trackInFlightExecution(promise, failureContext) {
+        const clear = () => {
             this.inFlightExecutions.delete(tracked);
+        };
+        const tracked = promise.then(clear, (error) => {
+            try {
+                if (failureContext) {
+                    this.logger.error('Unexpected Instance AI execution failure', {
+                        ...failureContext,
+                        error,
+                    });
+                }
+            }
+            finally {
+                clear();
+            }
         });
         this.inFlightExecutions.add(tracked);
     }
     startExecuteRun(...args) {
-        this.trackInFlightExecution(this.executeRun(...args));
+        const [, threadId, runId] = args;
+        this.trackInFlightExecution(this.executeRun(...args), { threadId, runId });
     }
     startProcessResumedStream(...args) {
-        this.trackInFlightExecution(this.processResumedStream(...args));
+        const { threadId, runId } = args[2];
+        this.trackInFlightExecution(this.processResumedStream(...args), { threadId, runId });
     }
     shouldPreserveHitlOnShutdown(runId) {
         return this.preserveHitlOnShutdown.has(runId);
@@ -1320,71 +1219,6 @@ let InstanceAiService = InstanceAiService_1 = class InstanceAiService {
             });
         }
     }
-    createAgentMemoryOptions(user, threadId, runId, memoryModelId) {
-        return {
-            observationalMemory: {
-                model: memoryModelId,
-                observerThresholdTokens: this.runState.getObserverThresholdTokens(threadId) ??
-                    this.instanceAiConfig.observerMessageTokens,
-                reflectorThresholdTokens: this.instanceAiConfig.reflectorObservationTokens,
-                midRunObservation: this.instanceAiConfig.midRunObservation,
-                onTaskUsage: async (report) => {
-                    try {
-                        const items = (0, instance_ai_1.tokenUsageToBuilderUsageItems)(report.model, report.usage);
-                        if (items.length === 0)
-                            return;
-                        await this.creditService.claimRunUsage(user, threadId, `${runId}:memory:${report.task}:${report.reportId}`, items, 'completed');
-                    }
-                    catch (error) {
-                        this.logger.warn('Failed to claim observational-memory usage', {
-                            threadId,
-                            runId,
-                            task: report.task,
-                            error: (0, get_error_message_1.getErrorMessage)(error),
-                        });
-                    }
-                },
-            },
-        };
-    }
-    createWorkflowTaskServiceWithUiSync(threadId, runId, workflowTasks) {
-        const sync = async () => await this.taskProjector.syncFromWorkflowLoop(threadId, runId);
-        return {
-            reportBuildOutcome: async (outcome) => {
-                const action = await workflowTasks.reportBuildOutcome(outcome);
-                await sync();
-                return action;
-            },
-            reportVerificationVerdict: async (verdict) => {
-                const action = await workflowTasks.reportVerificationVerdict(verdict);
-                await sync();
-                return action;
-            },
-            updateBuildOutcome: async (workItemId, update) => {
-                await workflowTasks.updateBuildOutcome(workItemId, update);
-                await sync();
-            },
-            beginVerification: async (outcome, state, verificationRunId) => {
-                const resumed = await workflowTasks.beginVerification(outcome, state, verificationRunId);
-                if (resumed)
-                    await sync();
-                return resumed;
-            },
-            getBuildOutcome: async (workItemId) => await workflowTasks.getBuildOutcome(workItemId),
-            startVerification: async (workItemId, triggerNodeName) => {
-                const previousProgress = await workflowTasks.startVerification(workItemId, triggerNodeName);
-                await sync();
-                return previousProgress;
-            },
-            recordVerification: async (workItemId, verification, previousProgress) => {
-                const claim = await workflowTasks.recordVerification(workItemId, verification, previousProgress);
-                await sync();
-                return claim;
-            },
-            getLatestBuildOutcomeForWorkflow: async (workflowId) => await workflowTasks.getLatestBuildOutcomeForWorkflow(workflowId),
-            getWorkflowLoopState: async (workItemId) => await workflowTasks.getWorkflowLoopState(workItemId),
-        };
-    }
     trackWorkflowVerificationObligation(obligation, event, extra = {}) {
         try {
             this.telemetry?.track('instance_ai_workflow_verification_obligation', {
@@ -1392,10 +1226,8 @@ let InstanceAiService = InstanceAiService_1 = class InstanceAiService {
                 thread_id: obligation.threadId,
                 run_id: obligation.runId,
                 task_id: obligation.taskId,
-                planned_task_id: obligation.plannedTaskId,
                 work_item_id: obligation.workItemId,
                 workflow_id: obligation.workflowId,
-                source: obligation.source,
                 policy: obligation.policy,
                 status: obligation.status,
                 readiness_status: obligation.readiness?.status,
@@ -1414,589 +1246,83 @@ let InstanceAiService = InstanceAiService_1 = class InstanceAiService {
             });
         }
     }
-    buildPlannedTaskFollowUpMessage(type, graph, options = {}) {
-        const payload = {
-            tasks: graph.tasks.map((task) => ({
-                id: task.id,
-                title: task.title,
-                kind: task.kind,
-                status: task.status,
-                result: task.result,
-                error: task.error,
-                outcome: task.outcome,
-            })),
-        };
-        if (options.failedTask) {
-            payload.failedTask = {
-                id: options.failedTask.id,
-                title: options.failedTask.title,
-                kind: options.failedTask.kind,
-                error: options.failedTask.error,
-                result: options.failedTask.result,
-            };
-        }
-        if (options.checkpoint) {
-            const depOutcomes = graph.tasks
-                .filter((t) => options.checkpoint.deps.includes(t.id))
-                .map((t) => ({
-                id: t.id,
-                title: t.title,
-                kind: t.kind,
-                status: t.status,
-                result: t.result,
-                outcome: t.outcome,
-            }));
-            payload.checkpoint = {
-                id: options.checkpoint.id,
-                title: options.checkpoint.title,
-                instructions: options.checkpoint.spec,
-                dependsOn: depOutcomes,
-            };
-        }
-        if (options.buildTask) {
-            payload.buildTask = {
-                id: options.buildTask.id,
-                title: options.buildTask.title,
-                kind: options.buildTask.kind,
-                spec: options.buildTask.spec,
-                workflowId: options.buildTask.workflowId,
-                isSupportingWorkflow: options.buildTask.isSupportingWorkflow,
-                deps: options.buildTask.deps,
-            };
-        }
-        return `<planned-task-follow-up type="${type}">\n${JSON.stringify(payload, null, 2)}\n</planned-task-follow-up>\n\n${internal_messages_1.AUTO_FOLLOW_UP_MESSAGE}`;
-    }
-    buildWorkflowVerificationFollowUpMessage(input) {
-        const payload = {
-            obligation: input.obligation,
-            outcome: input.outcome,
-            sourceTask: input.sourceTask,
-        };
-        return `<workflow-verification-follow-up>\n${JSON.stringify(payload, null, 2)}\n</workflow-verification-follow-up>\n\n${internal_messages_1.AUTO_FOLLOW_UP_MESSAGE}`;
-    }
-    async createPlannedTaskState() {
-        const memory = this.agentMemory;
-        const taskStorage = new instance_ai_1.ThreadTaskStorage(memory);
-        const plannedTaskStorage = new instance_ai_1.PlannedTaskStorage(memory);
-        const plannedTaskService = new instance_ai_1.PlannedTaskCoordinator(plannedTaskStorage);
-        return { memory, taskStorage, plannedTaskService };
-    }
     async replayUndeliveredTerminalOutcomes(threadId) {
         await this.terminalOutcome.replayUndeliveredTerminalOutcomes(threadId);
     }
-    async syncPlannedTasksToUi(threadId, graph) {
-        const { taskStorage } = await this.createPlannedTaskState();
-        const tasks = await this.taskProjector.projectPlannedTaskList(threadId, graph);
-        await taskStorage.save(threadId, tasks);
-        this.eventBus.publish(threadId, {
-            type: 'tasks-update',
-            runId: graph.planRunId,
-            agentId: (0, instance_ai_1.orchestratorAgentId)(graph.planRunId),
-            payload: { tasks },
-        });
-    }
-    async cancelAwaitingApprovalPlan(threadId) {
-        try {
-            const { plannedTaskService, taskStorage } = await this.createPlannedTaskState();
-            const graph = await plannedTaskService.getGraph(threadId);
-            if (!graph || graph.status !== 'awaiting_approval')
-                return;
-            await plannedTaskService.clear(threadId);
-            await taskStorage.save(threadId, { tasks: [] });
-            this.eventBus.publish(threadId, {
-                type: 'tasks-update',
-                runId: graph.planRunId,
-                agentId: (0, instance_ai_1.orchestratorAgentId)(graph.planRunId),
-                payload: { tasks: { tasks: [] }, planItems: [] },
-            });
-        }
-        catch (error) {
-            this.logger.warn('Failed to clean up awaiting_approval plan on cancel', {
-                threadId,
-                error: error instanceof Error ? error.message : String(error),
-            });
-        }
-    }
     areMcpConnectionsAvailable() {
-        return (di_1.Container.get(backend_common_1.ModuleRegistry).isActive('mcp-registry') &&
-            this.settingsService.isMcpAccessEnabled());
+        return this.turnEnvironment.areMcpConnectionsAvailable();
     }
     async createExecutionEnvironment(user, threadId, runId, abortSignal, messageGroupId, pushRef, proxyRunConfig, instanceContextGates, experimentGates) {
-        const memory = this.agentMemory;
-        const boundProjectId = await memory.getThreadProjectId(threadId);
-        if (!boundProjectId) {
-            throw new n8n_workflow_1.UnexpectedError(`Instance AI thread "${threadId}" has no bound project; it must be created via POST /instance-ai/threads before a run can start`);
-        }
-        const adminSettings = await this.settingsService.getAdminSettings();
-        const localGatewayDisabledGlobally = adminSettings.localGatewayDisabled;
-        const browserUseEnabledGlobally = adminSettings.browserUseEnabled;
-        const mcpConnectionsAvailable = this.areMcpConnectionsAvailable();
-        const localGatewayDisabledForUser = await this.settingsService.isLocalGatewayDisabledForUser(user.id);
-        const userGateway = this.gatewayService.findGateway(user.id);
-        await this.assertAssistantCreditsAvailable(user);
-        const { searchProxyConfig, tokenManager, proxyBaseUrl } = proxyRunConfig ?? (await this.createProxyRunConfig(user));
-        const proxyContext = { runId, threadId };
-        const modelId = proxyBaseUrl && tokenManager
-            ? await this.modelService.resolveProxyModel(user, proxyBaseUrl, tokenManager, proxyContext)
-            : await this.modelService.resolveAgentModelConfig(user, proxyContext);
-        const memoryModelId = await this.modelService.resolveMemoryModelConfig(user, modelId, {
-            proxyBaseUrl,
-            tokenManager,
-            proxyContext,
-        });
-        const gates = experimentGates ?? (await this.adapterService.resolveExperimentGates(user));
-        const { configEvalsEnabled, conversationHistoryEnabled, progressiveBuildingEnabled, conciseStyleEnabled, setupPanelEnabled, setupPanelVariant, folderExplorationEnabled, credentialDescriptionsEnabled, aiPreferencesEnabled, } = gates;
-        this.runState.setSetupPanelEnabled(threadId, setupPanelEnabled);
-        const { instanceContextEnabled, nodeUsageEnabled } = instanceContextGates ?? gates;
-        const conversationHistory = conversationHistoryEnabled
-            ? this.conversationHistoryService.forContext(user.id, boundProjectId, threadId)
-            : undefined;
-        const mode = this.runState.getBuildMode(threadId) ??
-            (progressiveBuildingEnabled ? 'progressive' : 'default');
-        const selectedPrompt = (0, instance_ai_1.resolvePromptProfile)({
-            version: this.runState.getPromptVersion(threadId) ??
-                resolveOperatorPromptVersion(this.instanceAiConfig.promptVersion) ??
-                (conciseStyleEnabled && mode === 'default' ? instance_ai_1.CONCISE_PROMPT_VERSION : undefined),
-            mode,
-        });
-        const buildMode = selectedPrompt.profile.mode;
-        this.runState.setBuildMode(threadId, buildMode);
-        const allowSendingParameterValues = await this.aiUsageService.isParameterValueSharingAllowed();
-        const thread = await memory.getThread(threadId);
-        const onboardingThread = thread?.metadata?.source === 'onboarding' && !thread.metadata.onboardingLeft;
-        const context = this.adapterService.createContext(user, {
-            searchProxyConfig,
-            pushRef,
-            threadId,
-            projectId: boundProjectId,
-            getCredentialIdAllowlist: () => this.evalCredentialAllowlists.get(threadId),
-            shouldBypassCredentialTest: (credentialId) => this.evalCredentialAllowlists.shouldBypassTest(threadId, credentialId),
-            getCredentialTestTarget: (credentialType) => this.evalCredentialAllowlists.getTestTarget(threadId, credentialType),
-            configEvalsEnabled,
-            setupPanelVariant,
-            mcpConnectionsAvailable,
-            nodeUsageEnabled,
-            instanceContextEnabled,
-            conversationHistory,
-            folderExplorationEnabled,
-            onboardingThread,
-            credentialDescriptionsEnabled,
-            aiPreferencesEnabled,
-            modelId,
-            allowSendingParameterValues,
-        });
-        this.gatewayService.applyToolPolicy(user.id);
-        const gatewayMcpServer = !localGatewayDisabledForUser && userGateway?.isConnected ? userGateway : undefined;
-        const browserMcpServer = browserUseEnabledGlobally
-            ? this.browserSessionService.findMcpServer(user.id)
-            : undefined;
-        const localMcpServer = (0, composite_local_mcp_server_1.composeLocalMcpServers)(gatewayMcpServer, browserMcpServer);
-        if (localMcpServer) {
-            context.localMcpServer = localMcpServer;
-        }
-        context.permissions = this.settingsService.getPermissions();
-        if (this.instanceWriteAccess.isReadOnly()) {
-            context.permissions = (0, api_types_1.applyBranchReadOnlyOverrides)(context.permissions);
-            context.branchReadOnly = true;
-        }
-        context.runId = runId;
-        if (setupPanelEnabled) {
-            context.setupItemsEmitter = (0, instance_ai_1.createSetupItemsEmitter)({
-                eventBus: this.eventBus,
-                threadId,
-                runId,
-                agentId: (0, instance_ai_1.orchestratorAgentId)(runId),
-                initialSnapshots: await this.eventLog.getSetupItemsSnapshots(threadId).catch((error) => {
-                    this.logger.warn('Failed to read setup panel snapshots', {
-                        threadId,
-                        error: (0, get_error_message_1.getErrorMessage)(error),
-                    });
-                    return [];
-                }),
-                readPersistedSnapshot: async (workflowId) => {
-                    const snapshots = await this.eventLog.getSetupItemsSnapshots(threadId);
-                    return snapshots.find((snapshot) => snapshot.workflowId === workflowId)?.items;
-                },
-            });
-            context.markWorkflowSetupHandled = async (workflowId) => {
-                await this.markWorkflowSetupHandled(threadId, workflowId, runId, {
-                    requirePersisted: true,
-                });
-            };
-        }
-        context.browserCredentialSetup = this.createBrowserCredentialSetupTracker(runId, user.id);
-        context.onArtifactChanged = async (artifact) => {
-            try {
-                await this.threadTabsService.showArtifactTab(threadId, user.id, artifact);
-            }
-            catch (error) {
-                this.logger.warn('Failed to show an Instance AI artifact tab', {
-                    threadId,
-                    error: (0, get_error_message_1.getErrorMessage)(error),
-                });
-            }
-        };
-        const sessionGrants = await this.loadThreadSessionGrants(threadId, user.id);
-        context.sessionApprovedToolKeys = sessionGrants;
-        const grantSessionToolApproval = async (key) => {
-            await this.persistThreadSessionGrant(threadId, user.id, key);
-            sessionGrants.add(key);
-        };
-        context.grantSessionToolApproval = grantSessionToolApproval;
-        context.revokeSessionToolApproval = async (key) => {
-            await this.revokeThreadSessionGrant(threadId, user.id, key);
-            sessionGrants.delete(key);
-        };
-        const domainTracker = (0, instance_ai_1.createDomainAccessTracker)({
-            grantedKeys: sessionGrants,
-            persistGrant: grantSessionToolApproval,
-        });
-        this.domainAccessTrackersByThread.set(threadId, domainTracker);
-        context.domainAccessTracker = domainTracker;
-        if (this.isRunDebugEnabled()) {
-            context.recordWorkflowCodeSnapshot = (snapshot) => {
-                this.runDebugBuffer.ensure(runId, threadId);
-                this.runDebugBuffer.recordWorkflowCode(runId, snapshot);
-            };
-        }
-        browserMcpServer?.setDomainGate({
-            tracker: domainTracker,
-            runId,
-            permissionMode: context.permissions?.fetchUrl,
-            createCredentialPermissionMode: context.permissions?.createCredential,
-        });
-        context.computerUseState = (0, computer_use_availability_1.resolveComputerUseState)({
-            localGatewayDisabledGlobally,
-            localGatewayDisabledForUser,
-            browserUseEnabledGlobally,
-            clientChannels: this.runState.getComputerUseChannels(threadId),
-            localComputerToolCategories: gatewayMcpServer
-                ? (0, computer_use_availability_1.enabledToolCategories)(gatewayMcpServer.getStatus().toolCategories)
-                : undefined,
-            browserConnected: browserMcpServer !== undefined,
-        });
-        const taskStorage = new instance_ai_1.ThreadTaskStorage(memory);
-        const iterationLog = this.dbIterationLogStorage;
-        const workflowLoopStorage = new instance_ai_1.WorkflowLoopStorage(memory);
-        const workflowTasks = this.createWorkflowTaskServiceWithUiSync(threadId, runId, new instance_ai_1.WorkflowTaskCoordinator(threadId, workflowLoopStorage));
-        const plannedTaskStorage = new instance_ai_1.PlannedTaskStorage(memory);
-        const plannedTaskService = new instance_ai_1.PlannedTaskCoordinator(plannedTaskStorage);
-        const nodeDefDirs = this.adapterService.getNodeDefinitionDirs();
-        if (nodeDefDirs.length > 0) {
-            (0, workflow_sdk_1.setSchemaBaseDirs)(nodeDefDirs);
-        }
-        const skillScope = {
-            profile: selectedPrompt.profile,
-            flags: { configEvalsEnabled, instanceContextEnabled },
-            agentBuildingEnabled: context.builderDelegate !== undefined,
-        };
-        const skills = await this.skillsService.loadSkills(skillScope);
-        const promptMetadata = (0, instance_ai_1.describePromptProfile)(selectedPrompt, skills.source);
-        this.runState.setPromptConfiguration(threadId, promptMetadata);
-        let runtimeWorkspace;
-        let workspaceRoot;
-        const sandboxStatus = this.settingsService.getSandboxStatus();
-        if (sandboxStatus.workflowBuilderAvailable) {
-            const sandboxConfig = await this.instanceAiErrorReporter.withBoundary('instance-ai-sandbox-setup', { threadId, runId, userId: user.id, messageGroupId }, async () => await this.sandboxService.resolveSandboxConfig(user));
-            if (sandboxConfig.enabled) {
-                workspaceRoot = (0, sandbox_1.getPromptWorkspaceRoot)(sandboxConfig.provider);
-                const scopeWorkspaceForAgent = async (workspace) => {
-                    if (!workspace)
-                        return undefined;
-                    const root = await (0, sandbox_1.getWorkspaceRoot)(workspace);
-                    return (0, agents_1.createScopedWorkspace)(workspace, root);
-                };
-                runtimeWorkspace = (0, instance_ai_1.createLazyRuntimeWorkspace)({
-                    sandboxInstructions: '',
-                    filesystemInstructions: '',
-                    ensureWorkspace: async () => await scopeWorkspaceForAgent((await this.sandboxService.getOrCreateWorkspace(threadId, user, context))?.workspace),
-                });
-            }
-        }
-        context.workspace = runtimeWorkspace;
-        context.workspaceRoot = workspaceRoot;
-        context.threadId = threadId;
-        context.threadMemory = memory;
-        context.trackTelemetry = (eventName, properties) => {
-            this.telemetry.track(eventName, (0, telemetry_1.redactTelemetryProperties)(properties));
-        };
-        const orchestrationContext = {
+        return await this.turnEnvironment.create({
+            user,
             threadId,
             runId,
+            abortSignal,
             messageGroupId,
-            userId: user.id,
-            projectId: boundProjectId,
-            promptConfiguration: promptMetadata,
-            disabledToolNames: new Set(skills.disabledTools),
-            setupPanelEnabled: (0, instance_ai_1.isSetupPanelEnabled)(context),
-            orchestratorAgentId: (0, instance_ai_1.orchestratorAgentId)(runId),
-            modelId,
-            modelStreamStallOptions: (0, model_stream_stall_options_1.modelStreamStallOptions)(this.aiConfig),
+            pushRef,
+            proxyRunConfig,
+            instanceContextGates,
+            experimentGates,
+        }, this.createTurnRuntime(user, threadId, runId));
+    }
+    createTurnRuntime(user, threadId, runId) {
+        return {
+            memory: this.agentMemory,
+            resourceId: user.id,
             eventBus: this.eventBus,
-            logger: this.logger,
-            trackTelemetry: (eventName, properties) => {
-                this.telemetry.track(eventName, (0, telemetry_1.redactTelemetryProperties)(properties));
+            checkpointStore: this.checkpointStore,
+            turnState: {
+                getBuildMode: () => this.runState.getBuildMode(threadId),
+                setBuildMode: (mode) => this.runState.setBuildMode(threadId, mode),
+                getPromptVersion: () => this.runState.getPromptVersion(threadId),
+                setPromptConfiguration: (configuration) => this.runState.setPromptConfiguration(threadId, configuration),
+                setSetupPanelEnabled: (enabled) => this.runState.setSetupPanelEnabled(threadId, enabled),
+                getBrowserUseAvailable: () => this.runState.getBrowserUseAvailable(threadId),
+                getObserverThresholdTokens: () => this.runState.getObserverThresholdTokens(threadId),
             },
-            claimSubAgentUsage: async (dedupeId, usage, status) => {
+            sessionGrants: {
+                load: async () => await this.loadThreadSessionGrants(threadId, user.id),
+                grant: async (key) => await this.persistThreadSessionGrant(threadId, user.id, key),
+                revoke: async (key) => await this.revokeThreadSessionGrant(threadId, user.id, key),
+            },
+            onDomainAccessTracker: (tracker) => {
+                this.domainAccessTrackersByThread.set(threadId, tracker);
+            },
+            readSetupItemsSnapshots: async () => await this.eventLog.getSetupItemsSnapshots(threadId),
+            markWorkflowSetupHandled: async (workflowId) => {
+                await this.markWorkflowSetupHandled(threadId, workflowId, runId, {
+                    requirePersisted: true,
+                });
+            },
+            browserCredentialSetup: this.createBrowserCredentialSetupTracker(runId, user.id),
+            onArtifactChanged: async (artifact) => {
                 try {
-                    await this.creditService.claimRunUsage(user, threadId, dedupeId, usage, status);
+                    await this.threadTabsService.showArtifactTab(threadId, user.id, artifact);
                 }
                 catch (error) {
-                    this.instanceAiErrorReporter.report(error, {
-                        component: 'instance-ai-agent-builder-usage',
+                    this.logger.warn('Failed to show an Instance AI artifact tab', {
                         threadId,
-                        runId,
-                        userId: user.id,
-                        ...(boundProjectId ? { projectId: boundProjectId } : {}),
-                        ...(messageGroupId ? { messageGroupId } : {}),
-                    });
-                    this.logger.warn('Failed to claim agent-builder usage', {
-                        threadId,
-                        runId,
-                        dedupeId,
                         error: (0, get_error_message_1.getErrorMessage)(error),
                     });
                 }
             },
-            abortSignal,
-            taskStorage,
-            timeZone: this.defaultTimeZone,
-            localMcpServer: context.localMcpServer,
-            skills: skills.source,
-            oauth2CallbackUrl: this.oauth2CallbackUrl,
-            cancelBackgroundTask: async (taskId) => this.cancelBackgroundTask(threadId, taskId),
+            recordWorkflowCodeSnapshot: this.isRunDebugEnabled()
+                ? (snapshot) => {
+                    this.runDebugBuffer.ensure(runId, threadId);
+                    this.runDebugBuffer.recordWorkflowCode(runId, snapshot);
+                }
+                : undefined,
+            syncWorkflowTasks: async () => await this.taskProjector.syncFromWorkflowLoop(threadId, runId),
+            sandbox: {
+                resolveConfig: async () => await this.sandboxService.resolveSandboxConfig(user),
+                getOrCreateWorkspace: async (context) => (await this.sandboxService.getOrCreateWorkspace(threadId, user, context))?.workspace,
+            },
             touchRun: () => this.runState.touchActiveRun(threadId),
+            cancelBackgroundTask: async (taskId) => this.cancelBackgroundTask(threadId, taskId),
             touchBackgroundTask: (taskId) => this.backgroundTasks.touchTask(threadId, taskId),
-            plannedTaskService,
-            schedulePlannedTasks: async () => await this.schedulePlannedTasks(user, threadId),
-            iterationLog,
             sendCorrectionToTask: (taskId, correction) => this.sendCorrectionToTask(threadId, taskId, correction),
-            workflowTaskService: workflowTasks,
-            workspace: runtimeWorkspace,
-            workspaceRoot,
-            nodeDefinitionDirs: nodeDefDirs.length > 0 ? nodeDefDirs : undefined,
-            domainContext: context,
-        };
-        return {
-            context,
-            memory,
-            taskStorage,
-            iterationLog,
-            workflowTasks,
-            plannedTaskService,
-            modelId,
-            memoryModelId,
-            orchestrationContext,
-            conversationHistory,
-            aiPreferencesEnabled,
-            instanceContextEnabled,
-            nodeUsageEnabled,
-            skillScope,
-        };
-    }
-    getAgentExecutionService() {
-        if (!(0, agents_access_1.isAgentsAccessEnabled)())
-            return null;
-        try {
-            return di_1.Container.get(agent_execution_service_1.AgentExecutionService);
-        }
-        catch {
-            return null;
-        }
-    }
-    async bindAgentContextReader(context, user) {
-        const projectId = context.projectId;
-        if (!projectId)
-            return;
-        if (!(await (0, check_access_1.userHasScopes)(user, ['agent:read'], false, { projectId })))
-            return;
-        if (!(0, agents_access_1.isAgentsAccessEnabled)())
-            return;
-        context.agentContextService = di_1.Container.get(instance_ai_agent_context_adapter_1.InstanceAiAgentContextAdapterService).createReader(user, projectId);
-    }
-    async bindAgentPreviewSession(context, user) {
-        await (0, instance_ai_1.resolveAgentPreviewSession)(context);
-        const projectId = context.projectId;
-        if (!context.agentPreviewSession || !projectId)
-            return;
-        if (!(0, agents_access_1.isAgentsAccessEnabled)()) {
-            context.agentPreviewSession = undefined;
-            return;
-        }
-        if (!(await this.canAccessAgentPreviewHandoff(user, projectId))) {
-            context.agentPreviewSession = undefined;
-            return;
-        }
-        context.resolvePreviewSession = async (ref) => {
-            const service = this.getAgentExecutionService();
-            if (!service)
-                return null;
-            const detail = await service.getThreadDetail(ref.threadId, projectId, ref.agentId, user.id);
-            if (!detail)
-                return null;
-            const transcript = (0, format_preview_context_1.formatPreviewSessionContext)(detail.thread, detail.executions, ref.executionId);
-            if (transcript === null)
-                return null;
-            return {
-                title: detail.thread.title?.trim() || `Session #${detail.thread.sessionNumber}`,
-                sessionNumber: detail.thread.sessionNumber,
-                transcript,
-            };
         };
     }
-    async dispatchPlannedTask(task, context, _graph) {
-        if (task.kind === 'build-workflow' || task.kind === 'checkpoint') {
-            this.logger.warn('dispatchPlannedTask called for a runtime planned-task kind', {
-                threadId: context.threadId,
-                taskId: task.id,
-                kind: task.kind,
-            });
-            return;
-        }
-        await context.plannedTaskService?.markFailed(context.threadId, task.id, {
-            error: `Planned task kind "${task.kind}" is no longer supported`,
-        });
-        const nextGraph = await context.plannedTaskService?.getGraph(context.threadId);
-        if (nextGraph) {
-            await this.syncPlannedTasksToUi(context.threadId, nextGraph);
-        }
-    }
-    collectWorkflowIds(value, workflowIds) {
-        if (value === null || value === undefined || typeof value !== 'object')
-            return;
-        if (Array.isArray(value)) {
-            for (const item of value) {
-                this.collectWorkflowIds(item, workflowIds);
-            }
-            return;
-        }
-        for (const [key, child] of Object.entries(value)) {
-            if (key === 'workflowId' && typeof child === 'string' && child.length > 0) {
-                workflowIds.add(child);
-                continue;
-            }
-            if (key === 'supportingWorkflowIds' && Array.isArray(child)) {
-                for (const workflowId of child) {
-                    if (typeof workflowId === 'string' && workflowId.length > 0) {
-                        workflowIds.add(workflowId);
-                    }
-                }
-                continue;
-            }
-            this.collectWorkflowIds(child, workflowIds);
-        }
-    }
-    getBuildTaskWorkflowName(task) {
-        if (task.kind !== 'build-workflow')
-            return undefined;
-        const titleMatch = task.title.match(/^Build '(.+)' workflow$/) ?? task.title.match(/^Build "(.+)" workflow$/);
-        return titleMatch?.[1];
-    }
-    checkpointRequiresRunApproval(graph, _checkpoint) {
-        return graph.postBuildRunApprovalRequired === true;
-    }
-    async getCheckpointRunPolicy(threadId, checkpointTaskId) {
-        try {
-            const { plannedTaskService } = await this.createPlannedTaskState();
-            const graph = await plannedTaskService.getGraph(threadId);
-            const checkpoint = graph?.tasks.find((t) => t.id === checkpointTaskId);
-            if (!graph || !checkpoint) {
-                return {
-                    allowedWorkflowIds: new Set(),
-                    allowedWorkflowNames: new Set(),
-                    requireApproval: false,
-                };
-            }
-            const deps = new Set(checkpoint.deps);
-            const ids = new Set();
-            const names = new Set();
-            for (const task of graph.tasks) {
-                if (!deps.has(task.id))
-                    continue;
-                const workflowName = this.getBuildTaskWorkflowName(task);
-                if (workflowName) {
-                    names.add(workflowName);
-                }
-                if (task.workflowId) {
-                    ids.add(task.workflowId);
-                }
-                this.collectWorkflowIds(task.outcome, ids);
-            }
-            const tracing = this.tracing.getTraceContextForContinuation(threadId);
-            for (const workflowId of [...ids]) {
-                const remappedWorkflowId = tracing?.idRemapper?.remapOutput(workflowId);
-                if (typeof remappedWorkflowId === 'string' && remappedWorkflowId.length > 0) {
-                    ids.add(remappedWorkflowId);
-                }
-            }
-            return {
-                allowedWorkflowIds: ids,
-                allowedWorkflowNames: names,
-                requireApproval: this.checkpointRequiresRunApproval(graph, checkpoint),
-            };
-        }
-        catch (error) {
-            this.logger.warn('Failed to resolve checkpoint allowed workflow IDs', {
-                threadId,
-                checkpointTaskId,
-                error: error instanceof Error ? error.message : String(error),
-            });
-            return {
-                allowedWorkflowIds: new Set(),
-                allowedWorkflowNames: new Set(),
-                requireApproval: false,
-            };
-        }
-    }
-    async handlePlannedTaskSettlement(user, task, status, { reschedule = true } = {}) {
-        if (!task.plannedTaskId)
-            return;
-        const { plannedTaskService } = await this.createPlannedTaskState();
-        let graph = null;
-        if (status === 'succeeded') {
-            graph = await plannedTaskService.markSucceeded(task.threadId, task.plannedTaskId, {
-                result: task.result,
-                outcome: task.outcome,
-            });
-        }
-        else if (status === 'failed') {
-            graph = await plannedTaskService.markFailed(task.threadId, task.plannedTaskId, {
-                error: task.error,
-            });
-        }
-        else {
-            graph = await plannedTaskService.markCancelled(task.threadId, task.plannedTaskId, {
-                error: task.error,
-            });
-        }
-        if (graph) {
-            await this.syncPlannedTasksToUi(task.threadId, graph);
-        }
-        if (!reschedule)
-            return;
-        await this.schedulePlannedTasks(user, task.threadId);
-    }
-    async buildWorkflowSetupStateBlock(context) {
-        const emitter = context.setupItemsEmitter;
-        if (!emitter)
-            return '';
-        const workflowIds = emitter.workflowIds().reverse();
-        if (workflowIds.length === 0)
-            return '';
-        try {
-            const note = (0, instance_ai_1.formatWorkflowSetupStateNote)(await (0, instance_ai_1.observeWorkflowSetupStates)(context, workflowIds));
-            return note
-                ? `${internal_messages_1.WORKFLOW_SETUP_STATE_OPEN_TAG}\n${note}\n${internal_messages_1.WORKFLOW_SETUP_STATE_CLOSE_TAG}`
-                : '';
-        }
-        catch (error) {
-            this.logger.warn('Failed to build the workflow setup state block', {
-                threadId: context.threadId,
-                error: error instanceof Error ? error.message : String(error),
-            });
-            return '';
-        }
-    }
     buildWorkflowSetupFollowUpMessage(obligation) {
         const payload = {
             workflowId: obligation.workflowId,
@@ -2023,11 +1349,7 @@ let InstanceAiService = InstanceAiService_1 = class InstanceAiService {
         for (const record of records) {
             if (record.state.setupRoutedAt)
                 continue;
-            if (this.workflowObligations.isPlannedRecord(record))
-                continue;
-            const obligation = this.workflowObligations.obligationFromRecord(threadId, record, {
-                source: 'direct',
-            });
+            const obligation = this.workflowObligations.obligationFromRecord(threadId, record);
             if (obligation.workflowId !== workflowId)
                 continue;
             if (obligation.setupRequirement?.status !== 'required')
@@ -2074,11 +1396,7 @@ let InstanceAiService = InstanceAiService_1 = class InstanceAiService {
         for (const record of records) {
             if (record.state.setupRoutedAt)
                 continue;
-            if (this.workflowObligations.isPlannedRecord(record))
-                continue;
-            const obligation = this.workflowObligations.obligationFromRecord(threadId, record, {
-                source: 'direct',
-            });
+            const obligation = this.workflowObligations.obligationFromRecord(threadId, record);
             const verificationConcluded = obligation.status === 'verified' ||
                 obligation.status === 'needs_setup' ||
                 obligation.status === 'not_verifiable';
@@ -2089,7 +1407,7 @@ let InstanceAiService = InstanceAiService_1 = class InstanceAiService {
             const claim = await this.claimWorkItemSetupRouting(threadId, record);
             if (!claim)
                 continue;
-            const startedRunId = await this.startInternalFollowUpRun(user, threadId, this.buildWorkflowSetupFollowUpMessage(obligation), this.runState.getMessageGroupId(threadId), false, undefined, 'workflow_setup');
+            const startedRunId = await this.startInternalFollowUpRun(user, threadId, this.buildWorkflowSetupFollowUpMessage(obligation), this.runState.getMessageGroupId(threadId), 'workflow_setup');
             if (startedRunId.length === 0) {
                 await this.releaseWorkItemSetupRoutingClaim(threadId, record.state.workItemId, claim.claimId);
                 return false;
@@ -2121,173 +1439,45 @@ let InstanceAiService = InstanceAiService_1 = class InstanceAiService {
     async claimWorkItemSetupRouting(threadId, record) {
         const claim = this.createWorkflowSetupRoutingClaim();
         const claimed = await new instance_ai_1.WorkflowLoopStorage(this.agentMemory).claimSetupRouting(threadId, record.state.workItemId, claim);
-        return claimed ? claim : null;
-    }
-    async markWorkItemSetupRouted(threadId, workItemId, claimId) {
-        return await new instance_ai_1.WorkflowLoopStorage(this.agentMemory).markSetupRouted(threadId, workItemId, claimId, new Date().toISOString());
-    }
-    async releaseWorkItemSetupRoutingClaim(threadId, workItemId, claimId) {
-        await new instance_ai_1.WorkflowLoopStorage(this.agentMemory).releaseSetupRoutingClaim(threadId, workItemId, claimId);
-    }
-    updateInternalFollowUpFailureStreak(threadId, status, isInternalFollowUp) {
-        if (status === 'completed' || status === 'suspended') {
-            this.failedInternalFollowUpStreaks.delete(threadId);
-            return;
-        }
-        if (status === 'error' && isInternalFollowUp) {
-            this.failedInternalFollowUpStreaks.set(threadId, (this.failedInternalFollowUpStreaks.get(threadId) ?? 0) + 1);
-        }
-    }
-    async startInternalFollowUpRun(user, threadId, message, messageGroupId, isReplanFollowUp = false, checkpoint, resumeReasonOverride, plannedBuild) {
-        if (this.runState.hasLiveRun(threadId)) {
-            this.logger.warn('Skipping internal follow-up: active run exists', { threadId });
-            return '';
-        }
-        const failedStreak = this.failedInternalFollowUpStreaks.get(threadId) ?? 0;
-        if (failedStreak >= MAX_CONSECUTIVE_FAILED_INTERNAL_FOLLOW_UPS) {
-            this.logger.warn('Skipping internal follow-up: consecutive follow-up runs keep failing', {
-                threadId,
-                failedStreak,
-                resumeReason: resumeReasonOverride,
-            });
-            return '';
-        }
-        const { runId, abortController } = this.runState.startRun({
-            threadId,
-            user,
-            messageGroupId,
-        });
-        const timeZone = this.runState.getTimeZone(threadId) ?? this.defaultTimeZone;
-        const resumeReason = resumeReasonOverride ??
-            (checkpoint
-                ? 'planned_checkpoint'
-                : isReplanFollowUp
-                    ? 'replan'
-                    : 'background_task_completed');
-        this.startExecuteRun(user, threadId, runId, message, abortController, undefined, undefined, messageGroupId, timeZone, isReplanFollowUp, checkpoint, resumeReason, plannedBuild);
-        return runId;
-    }
-    async schedulePlannedTasks(user, threadId) {
-        const prev = this.schedulerLocks.get(threadId) ?? Promise.resolve();
-        const current = prev.then(() => this.doSchedulePlannedTasks(user, threadId)).catch(() => { });
-        this.schedulerLocks.set(threadId, current);
-        await current;
-    }
-    createPlannedTaskActionRunner(activeUser, threadId, plannedTaskService) {
-        const scope = { user: activeUser, threadId };
-        return new planned_task_action_runner_1.PlannedTaskActionRunner({
-            scope,
-            plannedTaskService,
-            logger: this.logger,
-            view: this.createPlannedTaskView(),
-            runGate: this.createPlannedTaskRunGate(),
-            dispatcher: this.createPlannedTaskDispatcher(),
-            followUps: this.createPlannedTaskFollowUps(),
-            workflowVerificationGate: this.createPlannedWorkflowVerificationGate(threadId),
-            workflowVerificationTracker: this.createPlannedWorkflowVerificationTracker(),
-        });
-    }
-    createPlannedTaskView() {
-        return {
-            sync: async (scope, graph) => await this.syncPlannedTasksToUi(scope.threadId, graph),
-        };
-    }
-    createPlannedTaskRunGate() {
-        return {
-            hasLiveRun: (threadId) => this.runState.hasLiveRun(threadId),
-        };
-    }
-    createPlannedTaskDispatcher() {
-        return {
-            dispatch: async ({ scope, graph, tasks }) => {
-                const context = await this.createPlannedTaskDispatchContext(scope.user, scope.threadId, graph);
-                for (const task of tasks) {
-                    await this.dispatchPlannedTask(task, context, graph);
-                }
-            },
-        };
-    }
-    createPlannedTaskFollowUps() {
-        return {
-            startReplan: async ({ scope, graph, failedTask }) => await this.startInternalFollowUpRun(scope.user, scope.threadId, this.buildPlannedTaskFollowUpMessage('replan', graph, { failedTask }), graph.messageGroupId, true, undefined, undefined, undefined),
-            startWorkflowVerification: async ({ scope, graph, verification }) => await this.startInternalFollowUpRun(scope.user, scope.threadId, this.buildWorkflowVerificationFollowUpMessage({
-                obligation: verification.obligation,
-                outcome: verification.outcome,
-                sourceTask: this.toWorkflowVerificationSourceTask(verification),
-            }), graph.messageGroupId, false, undefined, 'workflow_verification', undefined),
-            startSynthesis: async ({ scope, graph }) => await this.startInternalFollowUpRun(scope.user, scope.threadId, this.buildPlannedTaskFollowUpMessage('synthesize', graph), graph.messageGroupId, false, undefined, 'synthesize', undefined),
-            startWorkflowBuild: async ({ scope, graph, task, workItemId }) => {
-                const plannedBuild = {
-                    isPlannedBuildFollowUp: true,
-                    buildTaskId: task.id,
-                    workItemId,
-                    isSupportingWorkflowTask: task.isSupportingWorkflow === true,
-                };
-                return await this.startInternalFollowUpRun(scope.user, scope.threadId, this.buildPlannedTaskFollowUpMessage('build-workflow', graph, { buildTask: task }), graph.messageGroupId, false, undefined, undefined, plannedBuild);
-            },
-            startCheckpoint: async ({ scope, graph, task }) => await this.startInternalFollowUpRun(scope.user, scope.threadId, this.buildPlannedTaskFollowUpMessage('checkpoint', graph, { checkpoint: task }), graph.messageGroupId, false, { isCheckpointFollowUp: true, checkpointTaskId: task.id }, undefined, undefined),
-        };
-    }
-    createPlannedWorkflowVerificationGate(threadId) {
-        return {
-            revalidate: async (verification) => await this.workflowObligations.revalidatePlannedWorkflowVerification(threadId, verification),
-        };
-    }
-    toWorkflowVerificationSourceTask(verification) {
-        return {
-            taskId: verification.task.backgroundTaskId ?? verification.task.id,
-            role: 'workflow-builder',
-            status: 'completed',
-            result: verification.task.result,
-            error: verification.task.error,
-            plannedTaskId: verification.task.id,
-            workItemId: verification.obligation.workItemId,
-        };
-    }
-    createPlannedWorkflowVerificationTracker() {
-        return {
-            scheduled: ({ obligation }) => this.trackWorkflowVerificationObligation(obligation, 'planned_verification_scheduled'),
-            followUpStartAttempted: ({ obligation }, started) => this.trackWorkflowVerificationObligation(obligation, 'follow_up_start_attempted', {
-                follow_up_started: started,
-            }),
-        };
+        return claimed ? claim : null;
     }
-    async createPlannedTaskDispatchContext(user, threadId, graph) {
-        const environment = await this.createExecutionEnvironment(user, threadId, graph.planRunId, createInertAbortSignal(), graph.messageGroupId, this.threadPushRef.get(threadId));
-        environment.orchestrationContext.tracing = this.tracing.getTraceContext(graph.planRunId);
-        return environment.orchestrationContext;
+    async markWorkItemSetupRouted(threadId, workItemId, claimId) {
+        return await new instance_ai_1.WorkflowLoopStorage(this.agentMemory).markSetupRouted(threadId, workItemId, claimId, new Date().toISOString());
     }
-    async doSchedulePlannedTasks(user, threadId) {
-        const revalidated = await this.revalidateActiveUser(user.id);
-        if (!revalidated) {
-            this.logger.warn('Cancelling run: user no longer authorized for n8n Assistant', {
-                userId: user.id,
-                threadId,
-            });
-            this.cancelRun(threadId);
+    async releaseWorkItemSetupRoutingClaim(threadId, workItemId, claimId) {
+        await new instance_ai_1.WorkflowLoopStorage(this.agentMemory).releaseSetupRoutingClaim(threadId, workItemId, claimId);
+    }
+    updateInternalFollowUpFailureStreak(threadId, status, isInternalFollowUp) {
+        if (status === 'completed' || status === 'suspended') {
+            this.failedInternalFollowUpStreaks.delete(threadId);
             return;
         }
-        const activeUser = revalidated;
-        const { plannedTaskService } = await this.createPlannedTaskState();
-        const actionRunner = this.createPlannedTaskActionRunner(activeUser, threadId, plannedTaskService);
-        while (true) {
-            const graph = await plannedTaskService.getGraph(threadId);
-            if (!graph)
-                return;
-            await this.syncPlannedTasksToUi(threadId, graph);
-            const availableSlots = Math.max(0, MAX_CONCURRENT_BACKGROUND_TASKS_PER_THREAD -
-                this.backgroundTasks.getRunningTasks(threadId).length);
-            const pendingWorkflowVerification = await this.workflowObligations.findPendingPlannedWorkflowVerification(threadId, graph);
-            const action = await plannedTaskService.tick(threadId, {
-                availableSlots,
-                pendingWorkflowVerification,
+        if (status === 'error' && isInternalFollowUp) {
+            this.failedInternalFollowUpStreaks.set(threadId, (this.failedInternalFollowUpStreaks.get(threadId) ?? 0) + 1);
+        }
+    }
+    async startInternalFollowUpRun(user, threadId, message, messageGroupId, resumeReason) {
+        if (this.runState.hasLiveRun(threadId)) {
+            this.logger.warn('Skipping internal follow-up: active run exists', { threadId });
+            return '';
+        }
+        const failedStreak = this.failedInternalFollowUpStreaks.get(threadId) ?? 0;
+        if (failedStreak >= MAX_CONSECUTIVE_FAILED_INTERNAL_FOLLOW_UPS) {
+            this.logger.warn('Skipping internal follow-up: consecutive follow-up runs keep failing', {
+                threadId,
+                failedStreak,
+                resumeReason,
             });
-            if (action.type === 'none')
-                return;
-            const result = await actionRunner.run(action);
-            if (result.type !== 'continue-scheduling')
-                return;
+            return '';
         }
+        const { runId, abortController } = this.runState.startRun({
+            threadId,
+            user,
+            messageGroupId,
+        });
+        const timeZone = this.runState.getTimeZone(threadId) ?? this.defaultTimeZone;
+        this.startExecuteRun(user, threadId, runId, message, abortController, undefined, undefined, messageGroupId, timeZone, resumeReason);
+        return runId;
     }
     async persistInterruptedUserMessage(threadId, userId, message, createdAt) {
         if (!message)
@@ -2337,7 +1527,7 @@ let InstanceAiService = InstanceAiService_1 = class InstanceAiService {
             return {};
         }
     }
-    async executeRun(user, threadId, runId, message, abortController, attachments, handoffContext, messageGroupId, timeZone, isReplanFollowUp = false, checkpoint, resumeReason, plannedBuild, threadArtifacts) {
+    async executeRun(user, threadId, runId, message, abortController, attachments, handoffContext, messageGroupId, timeZone, resumeReason, threadArtifacts) {
         const fileAttachments = (attachments ?? []).filter((attachment) => attachment.type === 'file');
         const experimentGates = await this.adapterService.resolveExperimentGates(user);
         const contextAttachments = this.resolveContextAttachments(attachments, experimentGates.nodeContextEnabled);
@@ -2357,7 +1547,6 @@ let InstanceAiService = InstanceAiService_1 = class InstanceAiService {
         let contextSegmentReported = false;
         let blockedForQuota = false;
         const observedContextWork = new instance_ai_1.WorkSummaryAccumulator();
-        const contextEventBus = this.observeInstanceContextEvents(observedContextWork);
         try {
             errorReporterExecutionToken = this.instanceAiErrorReporter.beginRun(runId);
             messageId = (0, nanoid_1.nanoid)();
@@ -2404,15 +1593,7 @@ let InstanceAiService = InstanceAiService_1 = class InstanceAiService {
                     userId: user.id,
                     input: traceInput,
                     resumeReason,
-                    metadata: {
-                        ...threadProvenance,
-                        ...(checkpoint?.isCheckpointFollowUp
-                            ? { checkpoint_task_id: checkpoint.checkpointTaskId }
-                            : {}),
-                        ...(plannedBuild?.isPlannedBuildFollowUp
-                            ? { build_task_id: plannedBuild.buildTaskId }
-                            : {}),
-                    },
+                    metadata: threadProvenance,
                     browserExtension,
                 });
             }
@@ -2469,60 +1650,20 @@ let InstanceAiService = InstanceAiService_1 = class InstanceAiService {
             }
             const executionPushRef = this.threadPushRef.get(threadId);
             const environment = await this.createExecutionEnvironment(user, threadId, runId, signal, messageGroupId, executionPushRef, proxyRunConfig, undefined, experimentGates);
-            const { context, memory, taskStorage, workflowTasks, plannedTaskService, modelId: resolvedModelId, orchestrationContext, conversationHistory, aiPreferencesEnabled, instanceContextEnabled, nodeUsageEnabled, skillScope, } = environment;
+            const { context, modelId: resolvedModelId, orchestrationContext, instanceContextEnabled, nodeUsageEnabled, } = environment;
+            const contextEventBus = this.createRunEventBus(observedContextWork, orchestrationContext);
             modelId = resolvedModelId;
             promptVersion = orchestrationContext.promptConfiguration?.version;
             (0, instance_ai_1.setTracePromptVersion)(tracing, promptVersion);
             (0, instance_ai_1.setTraceModelId)(tracing, modelId);
             aiCreatedWorkflowIds = context.aiCreatedWorkflowIds ??= new Set();
-            const isPostPlanFollowUp = isReplanFollowUp || checkpoint?.isCheckpointFollowUp === true;
-            orchestrationContext.currentUserMessage = message;
-            orchestrationContext.isReplanFollowUp = isReplanFollowUp;
-            orchestrationContext.timeZone = timeZone ?? this.defaultTimeZone;
-            if (checkpoint?.isCheckpointFollowUp) {
-                orchestrationContext.isCheckpointFollowUp = true;
-                orchestrationContext.checkpointTaskId = checkpoint.checkpointTaskId;
-                context.permissions = {
-                    ...context.permissions,
-                    ...(instance_ai_1.PLANNED_TASK_PERMISSION_OVERRIDES.checkpoint ?? {}),
-                };
-                const runPolicy = await this.getCheckpointRunPolicy(threadId, checkpoint.checkpointTaskId);
-                context.allowedRunWorkflowIds = runPolicy.allowedWorkflowIds;
-                context.allowedRunWorkflowNames = runPolicy.allowedWorkflowNames;
-                context.requireRunWorkflowApproval = runPolicy.requireApproval;
-            }
-            if (plannedBuild?.isPlannedBuildFollowUp) {
-                context.permissions = {
-                    ...context.permissions,
-                    ...(instance_ai_1.PLANNED_TASK_PERMISSION_OVERRIDES['build-workflow'] ?? {}),
-                };
-                context.workflowBuildContext = {
-                    threadId,
-                    runId,
-                    taskId: plannedBuild.buildTaskId,
-                    workItemId: plannedBuild.workItemId,
-                    allowPostPlanWorkflowCreate: true,
-                    isSupportingWorkflowTask: plannedBuild.isSupportingWorkflowTask,
-                    plannedTaskService,
-                    workflowTaskService: workflowTasks,
-                    onBuildOutcome: (outcome) => {
-                        plannedBuild.savedOutcome = outcome;
-                    },
-                };
-            }
-            else {
-                context.workflowBuildContext = {
-                    threadId,
-                    runId,
-                    taskId: `build-${runId}`,
-                    workItemId: `wi_${(0, nanoid_1.nanoid)(8)}`,
-                    allowPostPlanWorkflowCreate: isPostPlanFollowUp,
-                    workflowTaskService: workflowTasks,
-                };
-            }
-            if (fileAttachments.length > 0) {
-                context.currentUserAttachments = fileAttachments;
-            }
+            this.turnInput.applyTurnScope(environment, {
+                threadId,
+                runId,
+                message,
+                timeZone,
+                fileAttachments,
+            });
             if (!tracing && process.env.E2E_TESTS === 'true') {
                 const { createTraceReplayOnlyContext } = await (0, lazy_import_1.lazyImport)(async () => await import('@n8n/instance-ai'));
                 tracing = createTraceReplayOnlyContext();
@@ -2536,151 +1677,35 @@ let InstanceAiService = InstanceAiService_1 = class InstanceAiService {
                 }
             }
             await this.snapshotAttachedAgents(contextAttachments, orchestrationContext, tracing);
-            const enrichedMessage = await this.buildMessageWithRunningTasks(threadId, message);
-            let handoffContextBlock = '';
-            let agentPreviewTitleFallback;
-            if (handoffContext?.source === 'agent-preview') {
-                const projectId = context.projectId;
-                if (!projectId) {
-                    throw new n8n_workflow_1.UnexpectedError(`Instance AI thread "${threadId}" has no bound project; agent-preview handoff requires a project`);
-                }
-                await this.assertAgentPreviewHandoffScopes(user, projectId);
-                const agentExecutionService = this.getAgentExecutionService();
-                if (!agentExecutionService) {
-                    throw new n8n_workflow_1.UserError('Agent preview handoff is not available');
-                }
-                const resolved = await (0, agent_preview_handoff_1.resolveAgentPreviewHandoff)(handoffContext, {
-                    projectId,
-                    userId: user.id,
-                    getThreadDetail: agentExecutionService.getThreadDetail.bind(agentExecutionService),
-                });
-                handoffContextBlock = resolved.block;
-                agentPreviewTitleFallback = resolved.titleFallback;
-                context.agentBuilderTarget = resolved.target;
-                context.agentPreviewSession = {
-                    agentId: handoffContext.agentId,
-                    threadId: handoffContext.threadId,
-                    ...(handoffContext.executionId ? { executionId: handoffContext.executionId } : {}),
-                };
-                await (0, instance_ai_1.saveAgentBuilderTarget)(context, resolved.target, {
-                    previewSession: context.agentPreviewSession,
-                });
-            }
-            else if (handoffContext?.source === 'setup-panel-execute' && (0, instance_ai_1.isSetupPanelEnabled)(context)) {
-                handoffContextBlock = (0, internal_messages_1.buildWorkflowTestRequestBlock)(handoffContext.workflowId);
-            }
-            else {
-                handoffContextBlock = buildHandoffContextBlock(handoffContext);
-            }
-            const setupStateBlock = resumeReason === undefined ? await this.buildWorkflowSetupStateBlock(context) : '';
-            const thread = await memory.getThread(threadId);
-            const unopenedOnboarding = thread?.metadata?.source === 'onboarding' && !thread.metadata.titleRefined;
-            const isOpeningTurn = Boolean(thread && (!thread.title || unopenedOnboarding));
-            const onboardingSkill = unopenedOnboarding
-                ? (await this.skillsService.loadSkill(instance_ai_skills_service_1.SKILLS.suggestAutomations, skillScope)).instructions
-                : undefined;
-            if (isOpeningTurn) {
-                const handoffTitle = unopenedOnboarding
-                    ? onboarding_opening_1.ONBOARDING_OPENING.title
-                    : (contextAttachments.find(isNamedResourceAttachment)?.name ?? agentPreviewTitleFallback);
-                await (0, instance_ai_1.patchThread)(memory, {
-                    threadId,
-                    update: ({ metadata }) => handoffTitle
-                        ? {
-                            title: (0, instance_ai_1.truncateToTitle)(handoffTitle),
-                            metadata: { ...metadata, titleRefined: true },
-                        }
-                        :
-                            {
-                                title: (0, instance_ai_1.truncateToTitle)(message) || (0, instance_ai_1.truncateToTitle)(fileAttachments[0]?.fileName ?? ''),
-                            },
-                });
-            }
-            const isMachineFollowUp = checkpoint?.isCheckpointFollowUp === true || plannedBuild?.isPlannedBuildFollowUp === true;
-            const instanceContext = await this.instanceContext.buildBlock({
+            const turnInputRuntime = {
+                eventBus: this.eventBus,
+                resourceId: user.id,
+                getRunningBackgroundTasks: () => this.backgroundTasks.getRunningTasks(threadId),
+            };
+            const turnInput = await this.turnInput.buildInput(environment, turnInputRuntime, {
                 user,
-                scope: {
-                    surface: 'conversation',
-                    ...(context.projectId !== undefined ? { projectId: context.projectId } : {}),
-                },
-                cursor: (0, instance_context_service_1.readInstanceContextCursor)(thread?.metadata),
-                isMachineFollowUp,
-                enabled: instanceContextEnabled,
-            });
-            const contextInjection = (0, instance_context_service_1.toContextInjection)(instanceContext);
-            contextTurn = {
-                userId: user.id,
                 threadId,
                 runId,
-                injection: contextInjection,
-                instanceContextEnabled,
-                nodeUsageEnabled,
-            };
-            if ((0, instance_context_service_1.shouldTraceContextInjection)(contextInjection)) {
-                this.eventBus.publish(threadId, {
-                    type: 'instance-context',
-                    runId,
-                    agentId: (0, instance_ai_1.orchestratorAgentId)(runId),
-                    payload: { injection: contextInjection },
-                });
-            }
-            const existingTasks = await taskStorage.get(threadId);
-            if (existingTasks) {
-                this.eventBus.publish(threadId, {
-                    type: 'tasks-update',
-                    runId,
-                    agentId: (0, instance_ai_1.orchestratorAgentId)(runId),
-                    payload: { tasks: existingTasks },
-                });
-            }
-            let nonStructuredAttachments = [];
-            let attachmentManifest = '';
-            let hasParseableAttachment = false;
-            if (fileAttachments.length > 0) {
-                const classifiedAttachments = (0, instance_ai_1.classifyAttachments)(fileAttachments);
-                nonStructuredAttachments = fileAttachments.filter((attachment) => !(0, instance_ai_1.isParseableAttachment)(attachment));
-                turnHadFileAttachments = nonStructuredAttachments.length > 0;
-                hasParseableAttachment = classifiedAttachments.some((attachment) => attachment.parseable);
-                attachmentManifest = (0, instance_ai_1.buildAttachmentManifest)(classifiedAttachments);
-            }
-            const messageBody = !message && hasParseableAttachment
-                ? `The user attached file(s) without a message. Inspect the first parseable attachment with parse-file and provide a concise summary.\n\n${attachmentManifest}`
-                : attachmentManifest
-                    ? `${enrichedMessage}\n\n${attachmentManifest}`
-                    : enrichedMessage;
-            let replayedHistory;
-            const loadReplayedHistory = async () => await (replayedHistory ??= this.getReplayedMessages(threadId));
-            const threadArtifactsBlock = resumeReason === undefined
-                ? await this.resolveThreadArtifactsTurn(threadId, threadArtifacts, contextAttachments, loadReplayedHistory)
-                : '';
-            const [boundProject, pastConversationsSection] = await Promise.all([
-                this.resolveBoundProject(context),
-                isOpeningTurn ? conversationHistory?.getPastConversationsSection() : undefined,
-            ]);
-            const projectSection = boundProject ? (0, internal_messages_1.getProjectContextSection)(boundProject) : undefined;
-            const aiPreferencesTurn = aiPreferencesEnabled && resumeReason === undefined && !isMachineFollowUp
-                ? await this.resolveAiPreferencesTurn(user.id, boundProject, threadId, loadReplayedHistory)
-                : undefined;
-            const threadContextBlock = (0, internal_messages_1.buildThreadContextBlock)([
-                instanceContext.state === 'injected' ? instanceContext.block : '',
-                onboardingSkill ? (0, internal_messages_1.buildOnboardingSkillBlock)(onboardingSkill) : undefined,
-                threadArtifactsBlock,
-                projectSection ? (0, internal_messages_1.buildProjectContextBlock)(projectSection) : undefined,
-                resumeReason === undefined
-                    ? (0, internal_messages_1.buildInstanceUrlsBlock)({
-                        webhookBaseUrl: this.webhookBaseUrl,
-                        formBaseUrl: this.formBaseUrl,
-                    })
-                    : undefined,
-                pastConversationsSection
-                    ? (0, internal_messages_1.buildPastConversationsBlock)(pastConversationsSection)
-                    : undefined,
-                aiPreferencesTurn?.block,
-                (0, internal_messages_1.buildCurrentDateTimeBlock)((0, instance_ai_1.getDateTimeSection)(timeZone ?? this.defaultTimeZone)),
-            ]);
-            const fullMessage = [handoffContextBlock, setupStateBlock, threadContextBlock, messageBody]
-                .filter(Boolean)
-                .join('\n\n');
+                message,
+                fileAttachments,
+                contextAttachments,
+                handoffContext,
+                timeZone,
+                resumeReason,
+                threadArtifacts,
+                onInstanceContextInjection: (injection) => {
+                    contextTurn = {
+                        userId: user.id,
+                        threadId,
+                        runId,
+                        injection,
+                        instanceContextEnabled,
+                        nodeUsageEnabled,
+                    };
+                },
+            });
+            const { fullMessage, nonStructuredAttachments, contextInjection, aiPreferencesTurn } = turnInput;
+            turnHadFileAttachments = turnInput.turnHadFileAttachments;
             const promptBuildRun = tracing
                 ? await tracing.startChildRun(tracing.messageRun, {
                     name: 'prepare: prompt',
@@ -2695,25 +1720,7 @@ let InstanceAiService = InstanceAiService_1 = class InstanceAiService {
                 : undefined;
             let streamInput;
             try {
-                if (nonStructuredAttachments.length > 0) {
-                    const baseContent = [
-                        { type: 'text', text: fullMessage },
-                        ...nonStructuredAttachments.map((attachment) => ({
-                            type: 'file',
-                            data: attachment.data,
-                            mediaType: attachment.mimeType,
-                        })),
-                    ];
-                    streamInput = [
-                        {
-                            role: 'user',
-                            content: baseContent,
-                        },
-                    ];
-                }
-                else {
-                    streamInput = fullMessage;
-                }
+                streamInput = (0, assistant_turn_input_builder_1.buildTurnStreamInput)(turnInput);
                 if (promptBuildRun && tracing) {
                     const traceOutput = typeof streamInput === 'string'
                         ? { fullMessage: streamInput }
@@ -2757,29 +1764,11 @@ let InstanceAiService = InstanceAiService_1 = class InstanceAiService {
             const agent = await this.createAgentFromEnvironment(environment, threadId, runId, user, tracing);
             const streamOptions = this.buildOrchestratorAgentStreamOptions(user, threadId, runId, signal);
             streamReached = true;
-            if (instanceContext.state === 'injected') {
-                const injectedCursor = instanceContext.cursor;
-                try {
-                    await (0, instance_ai_1.patchThread)(memory, {
-                        threadId,
-                        update: ({ metadata }) => ({
-                            metadata: { ...metadata, [instance_context_service_1.INSTANCE_CONTEXT_CURSOR]: injectedCursor },
-                        }),
-                    });
-                }
-                catch (error) {
-                    this.logger.warn('Failed to store the instance-context cursor', { error });
-                }
-            }
-            if (aiPreferencesTurn) {
-                this.eventBus.publish(threadId, {
-                    type: 'preferences-applied',
-                    runId,
-                    agentId: (0, instance_ai_1.orchestratorAgentId)(runId),
-                    userId: user.id,
-                    payload: aiPreferencesTurn.payload,
-                });
-            }
+            await this.turnInput.onInputAccepted(environment, turnInputRuntime, turnInput, {
+                user,
+                threadId,
+                runId,
+            });
             const result = tracing
                 ? await tracing.withActiveSpan(tracing.actorRun, async () => {
                     return await (0, instance_ai_1.streamAgentRun)(agent, streamInput, streamOptions, {
@@ -2804,17 +1793,16 @@ let InstanceAiService = InstanceAiService_1 = class InstanceAiService {
                     stopSignal,
                 });
             contextResult = result;
-            if (aiPreferencesTurn) {
-                this.telemetry.track(telemetry_1.TELEMETRY_EVENT.CONTEXT.PREFERENCES_APPLIED_TO_TURN, {
-                    user_id: user.id,
-                    count: aiPreferencesTurn.payload.preferences.length,
-                    scope_types: [...new Set(aiPreferencesTurn.payload.preferences.map((p) => p.scope))],
-                    rendered_length: aiPreferencesTurn.payload.renderedLength,
-                    surface: 'aia',
-                    injected_this_turn: aiPreferencesTurn.payload.injectedThisTurn,
-                    turn_latency_ms: Date.now() - turnStartedAt.getTime(),
-                    ...(result.usage ? { turn_token_count: result.usage.promptTokens } : {}),
+            const preferencesApplied = aiPreferencesTurn &&
+                (0, ai_preferences_telemetry_1.buildPreferencesAppliedTelemetry)(aiPreferencesTurn.payload, {
+                    userId: user.id,
+                    threadId,
+                    runId,
+                    latencyMs: Date.now() - turnStartedAt.getTime(),
+                    promptTokens: result.usage?.promptTokens,
                 });
+            if (preferencesApplied) {
+                this.telemetry.track(telemetry_1.TELEMETRY_EVENT.CONTEXT.PREFERENCES_APPLIED_TO_TURN, preferencesApplied);
             }
             if (result.status === 'suspended') {
                 this.emitRunMetrics(threadId, 'suspended', {
@@ -2856,8 +1844,6 @@ let InstanceAiService = InstanceAiService_1 = class InstanceAiService {
                         createdAt: Date.now(),
                         tracing,
                         modelId,
-                        checkpoint,
-                        plannedBuild,
                         runHandoff: runControl.state,
                         instanceContext: suspendedContext,
                     });
@@ -2871,7 +1857,6 @@ let InstanceAiService = InstanceAiService_1 = class InstanceAiService {
                         kind: 'suspended',
                         toolCallId: result.suspension.toolCallId,
                         checkpointKey: result.agentRunId,
-                        checkpointTaskId: checkpoint?.checkpointTaskId,
                     });
                     void this.creditService.claimRunUsage(user, threadId, `${result.agentRunId || runId}:${result.suspension.requestId}`, result.usage?.usage ?? [], 'suspended');
                 }
@@ -2977,8 +1962,6 @@ let InstanceAiService = InstanceAiService_1 = class InstanceAiService {
                     workSummary: result.workSummary,
                     errorMessage: userFacingErrorMessage,
                     errorCode: userFacingErrorCode,
-                    suppressCompletedFallback: checkpoint?.isCheckpointFollowUp === true ||
-                        plannedBuild?.isPlannedBuildFollowUp === true,
                 });
             }
             const finalStatus = result.status === 'errored' ? 'error' : result.status;
@@ -3166,17 +2149,6 @@ let InstanceAiService = InstanceAiService_1 = class InstanceAiService {
             this.updateInternalFollowUpFailureStreak(threadId, messageTraceFinalization?.status, resumeReason !== undefined);
             if (!segmentSuspended && !this.runState.hasSuspendedRun(threadId)) {
                 const reschedule = !signal.aborted && !blockedForQuota;
-                if (checkpoint?.isCheckpointFollowUp) {
-                    await this.finalizeCheckpointFollowUp(user, threadId, checkpoint.checkpointTaskId, {
-                        reschedule,
-                    });
-                }
-                else if (plannedBuild?.isPlannedBuildFollowUp) {
-                    await this.finalizePlannedBuildFollowUp(user, threadId, plannedBuild, { reschedule });
-                }
-                else if (reschedule) {
-                    await this.schedulePlannedTasks(user, threadId);
-                }
                 await this.taskProjector.syncFromWorkflowLoop(threadId, runId);
                 if (reschedule) {
                     await this.maybeStartWorkflowSetupFollowUp(user, threadId);
@@ -3187,84 +2159,6 @@ let InstanceAiService = InstanceAiService_1 = class InstanceAiService {
             }
         }
     }
-    async finalizeCheckpointFollowUp(user, threadId, checkpointTaskId, { reschedule = true } = {}) {
-        try {
-            const { plannedTaskService } = await this.createPlannedTaskState();
-            const graph = await plannedTaskService.getGraph(threadId);
-            const task = graph?.tasks.find((t) => t.id === checkpointTaskId);
-            if (task && task.status === 'running') {
-                const inflightChildren = this.backgroundTasks.getRunningTasksByParentCheckpoint(threadId, checkpointTaskId);
-                if (inflightChildren.length > 0) {
-                    this.logger.debug('Checkpoint run ended with in-flight child tasks — deferring finalization', {
-                        threadId,
-                        checkpointTaskId,
-                        inflightTaskIds: inflightChildren.map((t) => t.taskId),
-                    });
-                }
-                else {
-                    this.logger.warn('Checkpoint run ended without reporting completion — marking failed', {
-                        threadId,
-                        checkpointTaskId,
-                    });
-                    await plannedTaskService.markCheckpointFailed(threadId, checkpointTaskId, {
-                        error: 'Checkpoint run ended without reporting completion',
-                    });
-                    const nextGraph = await plannedTaskService.getGraph(threadId);
-                    if (nextGraph) {
-                        await this.syncPlannedTasksToUi(threadId, nextGraph);
-                    }
-                }
-            }
-        }
-        catch (error) {
-            this.logger.error('Checkpoint finalization failed', {
-                threadId,
-                checkpointTaskId,
-                error: error instanceof Error ? error.message : String(error),
-            });
-        }
-        if (!reschedule)
-            return;
-        await this.schedulePlannedTasks(user, threadId);
-    }
-    async finalizePlannedBuildFollowUp(user, threadId, plannedBuild, { reschedule = true } = {}) {
-        try {
-            const { plannedTaskService } = await this.createPlannedTaskState();
-            const graph = await plannedTaskService.getGraph(threadId);
-            const task = graph?.tasks.find((t) => t.id === plannedBuild.buildTaskId);
-            if (task && task.status === 'running') {
-                if (plannedBuild.savedOutcome?.submitted === true) {
-                    await plannedTaskService.markSucceeded(threadId, plannedBuild.buildTaskId, {
-                        result: plannedBuild.savedOutcome.summary,
-                        outcome: plannedBuild.savedOutcome,
-                    });
-                }
-                else {
-                    this.logger.warn('Build workflow follow-up ended without saving — marking failed', {
-                        threadId,
-                        buildTaskId: plannedBuild.buildTaskId,
-                    });
-                    await plannedTaskService.markFailed(threadId, plannedBuild.buildTaskId, {
-                        error: 'Workflow build run ended without saving a workflow',
-                    });
-                }
-                const nextGraph = await plannedTaskService.getGraph(threadId);
-                if (nextGraph) {
-                    await this.syncPlannedTasksToUi(threadId, nextGraph);
-                }
-            }
-        }
-        catch (error) {
-            this.logger.error('Build workflow finalization failed', {
-                threadId,
-                buildTaskId: plannedBuild.buildTaskId,
-                error: error instanceof Error ? error.message : String(error),
-            });
-        }
-        if (!reschedule)
-            return;
-        await this.schedulePlannedTasks(user, threadId);
-    }
     async resolveConfirmation(requestingUserId, requestId, request) {
         const data = (0, confirmation_payload_1.toConfirmationData)(request);
         const freshUser = await this.revalidateActiveUser(requestingUserId);
@@ -3309,60 +2203,15 @@ let InstanceAiService = InstanceAiService_1 = class InstanceAiService {
         }
         return await this.suspendedRunRestorer.resolveOrphanedConfirmation(requestingUserId, requestId, data);
     }
-    async buildMcpServers(user, threadId, runId, tracing, messageGroupId) {
-        const staticMcpServers = this.parseMcpServers(this.instanceAiConfig.mcpServers);
-        const registryMcpServers = this.settingsService.isMcpAccessEnabled()
-            ? await this.instanceAiErrorReporter.withBoundary('instance-ai-mcp-setup', {
-                threadId,
-                runId,
-                tracing,
-                agentId: (0, instance_ai_1.orchestratorAgentId)(runId),
-                userId: user.id,
-                messageGroupId,
-            }, async () => await this.mcpRegistryService.getRegistryMcpServers(user))
-            : [];
-        return [...staticMcpServers, ...registryMcpServers];
-    }
     async createAgentFromEnvironment(environment, threadId, runId, user, tracing) {
-        if (tracing) {
-            environment.orchestrationContext.tracing = tracing;
-        }
-        await this.bindAgentContextReader(environment.context, user);
-        await this.bindAgentPreviewSession(environment.context, user);
-        const mcpServers = await this.buildMcpServers(user, threadId, runId, tracing, environment.orchestrationContext.messageGroupId);
-        const { agent, mcpConnectionFailures } = await (0, instance_ai_1.createInstanceAgent)({
-            modelId: environment.modelId,
-            context: environment.context,
-            orchestrationContext: environment.orchestrationContext,
-            mcpServers,
-            mcpManager: this.mcpClientManager,
-            memoryConfig: this.createAgentMemoryOptions(user, threadId, runId, environment.memoryModelId),
-            memory: environment.memory,
+        return await this.agentFactory.createAgent(environment, {
+            eventBus: this.eventBus,
             checkpointStore: this.checkpointStore,
             onMemoryTaskEvent: this.memoryTaskObserverFor(threadId, tracing),
-            thinkingEnabled: this.instanceAiConfig.thinkingEnabled,
-        });
-        if (mcpConnectionFailures.length > 0) {
-            const names = mcpConnectionFailures.map((f) => f.server).join(', ');
-            for (const failure of mcpConnectionFailures) {
-                this.errorReporter.error(new Error(`MCP server "${failure.server}" failed to connect: ${failure.error}`), {
-                    level: 'warning',
-                    tags: { component: 'instance-ai-mcp', server: failure.server },
-                    extra: { runId, threadId, server: failure.server, error: failure.error },
-                    shouldIsolate: true,
-                });
-            }
-            this.eventBus.publish(threadId, {
-                type: 'status',
-                runId,
-                agentId: (0, instance_ai_1.orchestratorAgentId)(runId),
-                payload: {
-                    message: `Couldn't reach MCP server${mcpConnectionFailures.length > 1 ? 's' : ''} ${names}; continuing without their tools.`,
-                },
-            });
-        }
-        this.subscribeToAgentErrors(agent, threadId, runId);
-        return agent;
+            turnState: {
+                getObserverThresholdTokens: () => this.runState.getObserverThresholdTokens(threadId),
+            },
+        }, { user, threadId, runId, tracing });
     }
     async buildFreshInstanceAgent(user, threadId, runId, abortSignal, tracing, messageGroupId, pushRef, instanceContextGates) {
         const environment = await this.createExecutionEnvironment(user, threadId, runId, abortSignal, messageGroupId, pushRef, undefined, instanceContextGates);
@@ -3437,9 +2286,6 @@ let InstanceAiService = InstanceAiService_1 = class InstanceAiService {
                 createdAt: Date.now(),
                 tracing: undefined,
                 modelId: environment.modelId,
-                checkpoint: orphan.checkpointTaskId
-                    ? { isCheckpointFollowUp: true, checkpointTaskId: orphan.checkpointTaskId }
-                    : undefined,
                 runHandoff: runControl.state,
             },
         };
@@ -3463,157 +2309,6 @@ let InstanceAiService = InstanceAiService_1 = class InstanceAiService {
             return null;
         }
     }
-    async resolveBoundProject(context) {
-        const projectId = context.projectId;
-        if (!projectId)
-            return undefined;
-        try {
-            const project = await context.workspaceService?.getProject?.(projectId);
-            if (project)
-                return project;
-            this.logger.warn('Instance AI could not name the bound project for this turn', {
-                projectId,
-                reason: context.workspaceService?.getProject ? 'not-readable' : 'no-workspace-adapter',
-            });
-            return undefined;
-        }
-        catch (error) {
-            this.logger.warn('Instance AI failed to resolve the bound project for this turn', {
-                projectId,
-                error: error instanceof Error ? error.message : String(error),
-            });
-            this.errorReporter.error(error, {
-                level: 'warning',
-                tags: { component: 'instance-ai-project-context' },
-                extra: { projectId },
-                shouldIsolate: true,
-            });
-            return undefined;
-        }
-    }
-    async resolveAiPreferencesTurn(userId, project, threadId, loadHistory = async () => await this.getReplayedMessages(threadId)) {
-        const resolved = await this.bestEffort('Instance AI failed to read the AI preferences for this turn', { userId }, async () => {
-            const preferences = await this.aiPreferenceService.getApplicable(userId, project ? [project] : []);
-            return { preferences, rendered: (0, ai_preference_service_1.renderAiPreferencesBlock)(preferences) };
-        });
-        if (!resolved) {
-            return {
-                block: undefined,
-                payload: { preferences: [], renderedLength: 0, injectedThisTurn: false },
-            };
-        }
-        const history = await this.bestEffort('Instance AI failed to read the last AI preferences block of this thread', { threadId }, async () => await this.findAiPreferencesHistory(loadHistory));
-        const lastBlock = history?.block;
-        const savedSinceLastBlock = history?.savedSinceLastBlock === true;
-        const { preferences, rendered } = resolved;
-        const freshBlock = rendered ??
-            (lastBlock !== undefined || savedSinceLastBlock ? ai_preference_service_1.AI_PREFERENCES_CLEARED_BLOCK : undefined);
-        if (freshBlock === undefined) {
-            return {
-                block: undefined,
-                payload: (0, ai_preference_service_1.buildAppliedPreferencesPayload)({
-                    preferences,
-                    renderedLength: 0,
-                    injectedThisTurn: false,
-                }),
-            };
-        }
-        if (!savedSinceLastBlock &&
-            lastBlock !== undefined &&
-            (0, internal_messages_1.asStoredThreadContextSection)(freshBlock) === lastBlock) {
-            const carriedFromRunId = await this.bestEffort('Instance AI failed to resolve which run sent the AI preferences block', { threadId }, async () => await this.eventLog.getLastPreferencesInjectionRunId(threadId));
-            return {
-                block: undefined,
-                payload: (0, ai_preference_service_1.buildAppliedPreferencesPayload)({
-                    preferences,
-                    renderedLength: freshBlock.length,
-                    injectedThisTurn: false,
-                    ...(carriedFromRunId ? { carriedFromRunId } : {}),
-                }),
-            };
-        }
-        return {
-            block: freshBlock,
-            payload: (0, ai_preference_service_1.buildAppliedPreferencesPayload)({
-                preferences,
-                renderedLength: freshBlock.length,
-                injectedThisTurn: true,
-            }),
-        };
-    }
-    async findAiPreferencesHistory(loadHistory) {
-        const history = await loadHistory();
-        let savedSinceLastBlock = false;
-        for (let i = history.length - 1; i >= 0; i--) {
-            const m = history[i];
-            if (!('role' in m))
-                continue;
-            if (m.role === 'assistant' && Array.isArray(m.content)) {
-                savedSinceLastBlock ||= m.content.some((part) => part.type === 'tool-call' &&
-                    part.toolName === 'save_user_preference' &&
-                    part.state === 'resolved' &&
-                    (0, is_record_1.isRecord)(part.output) &&
-                    part.output.ok === true);
-            }
-            if (m.role !== 'user')
-                continue;
-            const block = (0, internal_messages_1.extractAiPreferencesBlock)(this.extractStoredMessageText(m.content));
-            if (block !== undefined)
-                return { block, savedSinceLastBlock };
-        }
-        return { savedSinceLastBlock };
-    }
-    async resolveThreadArtifactsTurn(threadId, context, attachments, loadHistory) {
-        const freshBlock = (0, internal_messages_1.buildThreadArtifactsBlock)(context, attachments);
-        if (!freshBlock)
-            return '';
-        if (attachments.length > 0)
-            return freshBlock;
-        const history = await this.bestEffort('Instance AI failed to read the last thread artifacts block of this thread', { threadId }, async () => ({ block: await this.findLastThreadArtifactsBlock(loadHistory) }));
-        if (!history)
-            return freshBlock;
-        return (0, internal_messages_1.asStoredThreadContextSection)(freshBlock) === history.block ? '' : freshBlock;
-    }
-    async findLastThreadArtifactsBlock(loadHistory) {
-        const history = await loadHistory();
-        for (let i = history.length - 1; i >= 0; i--) {
-            const m = history[i];
-            if (!('role' in m) || m.role !== 'user')
-                continue;
-            const block = (0, internal_messages_1.extractThreadArtifactsBlock)(this.extractStoredMessageText(m.content));
-            if (block !== undefined)
-                return block;
-        }
-        return undefined;
-    }
-    async getReplayedMessages(threadId) {
-        const cursor = await this.agentMemory.getCursor(threadId);
-        if (cursor) {
-            const observations = await this.agentMemory.getActiveObservationLog({
-                observationScopeId: threadId,
-                limit: 1,
-                order: 'desc',
-            });
-            if (observations.length > 0) {
-                return await this.agentMemory.getMessagesForObservationScope(threadId, {
-                    since: {
-                        sinceCreatedAt: cursor.lastObservedAt,
-                        sinceMessageId: cursor.lastObservedMessageId,
-                    },
-                });
-            }
-        }
-        return await this.agentMemory.getMessages(threadId);
-    }
-    async canAccessAgentPreviewHandoff(user, projectId) {
-        const requiredScopes = ['agent:read', 'agent:update'];
-        return await (0, check_access_1.userHasScopes)(user, requiredScopes, false, { projectId });
-    }
-    async assertAgentPreviewHandoffScopes(user, projectId) {
-        if (!(await this.canAccessAgentPreviewHandoff(user, projectId))) {
-            throw new errors_1.ForbiddenError('You do not have permission to load or edit agent previews in this project.');
-        }
-    }
     async rebuildAgentForResume(user, threadId, runId, abortController, tracing, runHandoff, messageGroupId, instanceContextGates) {
         try {
             const rebuilt = await this.buildFreshInstanceAgent(user, threadId, runId, abortController.signal, tracing, messageGroupId, this.threadPushRef.get(threadId), instanceContextGates);
@@ -3642,7 +2337,7 @@ let InstanceAiService = InstanceAiService_1 = class InstanceAiService {
             });
             return null;
         }
-        const { agent, runId, agentRunId, threadId, user, toolCallId, toolName, suspendPayload, abortController, tracing, modelId, messageGroupId, checkpoint, plannedBuild, runHandoff, orchestrationContext, instanceContext, } = suspended;
+        const { agent, runId, agentRunId, threadId, user, toolCallId, toolName, suspendPayload, abortController, tracing, modelId, messageGroupId, runHandoff, orchestrationContext, instanceContext, } = suspended;
         if (user.id !== requestingUserId)
             return null;
         const activeRun = this.runState.getActiveRun(threadId);
@@ -3695,12 +2390,6 @@ let InstanceAiService = InstanceAiService_1 = class InstanceAiService {
                 request_id: requestId,
                 pending_tool_call_id: toolCallId,
                 approved: data.approved,
-                ...(checkpoint?.isCheckpointFollowUp
-                    ? { checkpoint_task_id: checkpoint.checkpointTaskId }
-                    : {}),
-                ...(plannedBuild?.isPlannedBuildFollowUp
-                    ? { build_task_id: plannedBuild.buildTaskId }
-                    : {}),
             },
             browserExtension: this.browserSessionService.getExtensionTraceContext(activeUser.id),
             register: false,
@@ -3753,8 +2442,6 @@ let InstanceAiService = InstanceAiService_1 = class InstanceAiService {
             tracing: effectiveTracing,
             orchestrationContext: resumeOrchestrationContext,
             modelId: resumeModelId,
-            checkpoint,
-            plannedBuild,
             runHandoff,
             resumeExecutionToken,
             messageGroupId,
@@ -3780,7 +2467,7 @@ let InstanceAiService = InstanceAiService_1 = class InstanceAiService {
         let contextSegmentReported = false;
         let blockedForQuota = false;
         const observedContextWork = new instance_ai_1.WorkSummaryAccumulator();
-        const contextEventBus = this.observeInstanceContextEvents(observedContextWork);
+        const contextEventBus = this.createRunEventBus(observedContextWork, opts.orchestrationContext);
         let resumedRunProducedOutput = false;
         const onResumeClaimed = async () => {
             if (resumeClaimed)
@@ -3891,8 +2578,6 @@ let InstanceAiService = InstanceAiService_1 = class InstanceAiService {
                         createdAt: Date.now(),
                         tracing: opts.tracing,
                         ...(opts.modelId !== undefined ? { modelId: opts.modelId } : {}),
-                        checkpoint: opts.checkpoint,
-                        plannedBuild: opts.plannedBuild,
                         runHandoff: runControl.state,
                         instanceContext: suspendedContext,
                     });
@@ -3906,7 +2591,6 @@ let InstanceAiService = InstanceAiService_1 = class InstanceAiService {
                         kind: 'suspended',
                         toolCallId: result.suspension.toolCallId,
                         checkpointKey: result.agentRunId,
-                        checkpointTaskId: opts.checkpoint?.checkpointTaskId,
                     });
                     void this.creditService.claimRunUsage(opts.user, opts.threadId, `${result.agentRunId || opts.runId}:${result.suspension.requestId}`, result.usage?.usage ?? [], 'suspended');
                 }
@@ -4016,8 +2700,6 @@ let InstanceAiService = InstanceAiService_1 = class InstanceAiService {
                     workSummary: result.workSummary,
                     errorMessage: userFacingErrorMessage,
                     errorCode: userFacingErrorCode,
-                    suppressCompletedFallback: opts.checkpoint?.isCheckpointFollowUp === true ||
-                        opts.plannedBuild?.isPlannedBuildFollowUp === true,
                 });
             }
             const finalStatus = result.status === 'errored' ? 'error' : result.status;
@@ -4221,17 +2903,6 @@ let InstanceAiService = InstanceAiService_1 = class InstanceAiService {
                 !segmentSuspended &&
                 !this.runState.hasSuspendedRun(opts.threadId)) {
                 const reschedule = !opts.signal.aborted && !blockedForQuota;
-                if (opts.checkpoint?.isCheckpointFollowUp) {
-                    await this.finalizeCheckpointFollowUp(opts.user, opts.threadId, opts.checkpoint.checkpointTaskId, { reschedule });
-                }
-                else if (opts.plannedBuild?.isPlannedBuildFollowUp) {
-                    await this.finalizePlannedBuildFollowUp(opts.user, opts.threadId, opts.plannedBuild, {
-                        reschedule,
-                    });
-                }
-                else if (reschedule) {
-                    await this.schedulePlannedTasks(opts.user, opts.threadId);
-                }
                 if (completedSetupWorkflowId) {
                     await this.markWorkflowSetupHandled(opts.threadId, completedSetupWorkflowId, opts.runId);
                 }
@@ -4362,11 +3033,6 @@ let InstanceAiService = InstanceAiService_1 = class InstanceAiService {
             });
         }
     }
-    async buildMessageWithRunningTasks(threadId, message) {
-        return await (0, instance_ai_1.enrichMessageWithBackgroundTasks)(message, this.backgroundTasks.getRunningTasks(threadId), {
-            formatTask: async (task) => `[Running task — ${task.role}]: taskId=${task.taskId}`,
-        });
-    }
     trackConfirmationRequest(userId, threadId, confirmationEvent) {
         const payload = confirmationEvent.payload;
         const inputThreadId = (0, nanoid_1.nanoid)();
@@ -4403,14 +3069,6 @@ let InstanceAiService = InstanceAiService_1 = class InstanceAiService {
         else if (mcpConnectServers) {
             numSteps = mcpConnectServers.length;
         }
-        if (inputType === 'plan-review') {
-            const planCount = (this.planRequestsByThread.get(threadId) ?? 0) + 1;
-            this.planRequestsByThread.set(threadId, planCount);
-            type = planCount === 1 ? 'first_plan' : 'revised_plan';
-            if (Array.isArray(payload.planItems)) {
-                numSteps = payload.planItems.length;
-            }
-        }
         const credentialRequests = (Array.isArray(payload.credentialRequests) ? payload.credentialRequests : []).filter((request) => typeof request === 'object' && request !== null);
         const containsTemplatedCred = credentialRequests.some((request) => request.credentialType === api_types_1.TEMPLATED_CUSTOM_AUTH_CREDENTIAL_TYPE ||
             (request.setupHint !== null && request.setupHint !== undefined));
@@ -4478,7 +3136,7 @@ let InstanceAiService = InstanceAiService_1 = class InstanceAiService {
                 status: effectiveStatus,
                 ...(status === 'cancelled'
                     ? { reason: reason ?? 'user_cancelled' }
-                    : status === 'errored' && reason
+                    : reason
                         ? { reason }
                         : {}),
                 ...(hasArchived ? { archivedWorkflowIds } : {}),
@@ -4636,16 +3294,18 @@ let InstanceAiService = InstanceAiService_1 = class InstanceAiService {
             nodeUsageEnabled: opts.instanceContext.nodeUsageEnabled,
         };
     }
-    observeInstanceContextEvents(workSummary) {
+    createRunEventBus(workSummary, context) {
         return {
             publish: (threadId, event) => {
                 workSummary.observe(event);
-                this.eventBus.publish(threadId, event);
+                this.eventBus.publish(threadId, context?.mapSkillEventForDisplay?.(event) ?? event);
             },
             subscribe: (threadId, handler) => this.eventBus.subscribe(threadId, handler),
         };
     }
     emitInstanceContextTurn(turn, input) {
+        if (!turn)
+            return;
         const { injection } = turn;
         this.telemetry.track(telemetry_1.TELEMETRY_EVENT.INSTANCE_AI.INSTANCE_CONTEXT_TURN, {
             user_id: turn.userId,
@@ -4705,7 +3365,7 @@ let InstanceAiService = InstanceAiService_1 = class InstanceAiService {
             for (const m of history) {
                 if (!('role' in m) || m.role !== 'user')
                     continue;
-                const text = (0, internal_messages_1.cleanStoredUserMessage)(this.extractStoredMessageText(m.content));
+                const text = (0, internal_messages_1.cleanStoredUserMessage)((0, internal_messages_1.extractStoredMessageText)(m.content));
                 if (text && text.length > 0)
                     userTexts.push(text);
                 if (userTexts.length >= 5)
@@ -4749,6 +3409,7 @@ let InstanceAiService = InstanceAiService_1 = class InstanceAiService {
                     llmTitle = await titleTracing.withActiveSpan(titleTracing.rootRun, async () => {
                         const title = await (0, instance_ai_1.generateTitleForRun)(modelId, userText, {
                             ...(titleTelemetry ? { telemetry: titleTelemetry } : {}),
+                            modelFetch: this.modelService.getModelFetch(),
                         });
                         if (title) {
                             await titleTracing.finishRun(titleTracing.rootRun, {
@@ -4770,7 +3431,9 @@ let InstanceAiService = InstanceAiService_1 = class InstanceAiService {
                 }
             }
             else {
-                llmTitle = await (0, instance_ai_1.generateTitleForRun)(modelId, userText);
+                llmTitle = await (0, instance_ai_1.generateTitleForRun)(modelId, userText, {
+                    modelFetch: this.modelService.getModelFetch(),
+                });
             }
             if (!llmTitle)
                 return;
@@ -4795,44 +3458,10 @@ let InstanceAiService = InstanceAiService_1 = class InstanceAiService {
             });
         }
     }
-    extractStoredMessageText(content) {
-        if (typeof content === 'string')
-            return content;
-        if (Array.isArray(content)) {
-            return content.flatMap((part) => (isTextMessagePart(part) ? [part.text] : [])).join('\n');
-        }
-        return '';
-    }
     async readRunEvents(threadId, runIds) {
         await this.eventLog.flush(threadId);
         return await this.eventLog.getEventsForRuns(threadId, runIds);
     }
-    parseMcpServers(raw) {
-        if (!raw.trim())
-            return [];
-        return raw.split(',').map((entry) => {
-            const [name, url] = entry.trim().split('=');
-            return { name: name.trim(), url: url?.trim() };
-        });
-    }
-    trackMcpToolCall({ server, toolName, success, }) {
-        const serverSlug = server.metadata?.serverSlug;
-        const userId = server.metadata?.userId;
-        const connectionId = server.metadata?.connectionId;
-        if (serverSlug && userId) {
-            this.telemetry.track('Instance AI mcp tool called', {
-                user_id: userId,
-                server_slug: serverSlug,
-                tool_name: toolName,
-                success,
-            });
-        }
-        if (!success && connectionId && userId) {
-            this.push.sendToUsers({ type: 'instanceAiMcpToolCallFailed', data: { connectionId } }, [
-                userId,
-            ]);
-        }
-    }
 };
 exports.InstanceAiService = InstanceAiService;
 InstanceAiService.BLOCK_CHARS_PER_TOKEN = 4;
@@ -4844,6 +3473,6 @@ __decorate([
 ], InstanceAiService.prototype, "handleRelayTaskControl", null);
 exports.InstanceAiService = InstanceAiService = InstanceAiService_1 = __decorate([
     (0, di_1.Service)(),
-    __metadata("design:paramtypes", [backend_common_1.Logger, config_1.GlobalConfig, n8n_core_1.InstanceSettings, instance_ai_adapter_service_1.InstanceAiAdapterService, in_process_event_bus_1.InProcessEventBus, durable_event_log_1.DurableEventLog, interrupted_run_sweeper_1.InterruptedRunSweeper, instance_ai_settings_service_1.InstanceAiSettingsService, instance_ai_gateway_service_1.InstanceAiGatewayService, instance_ai_browser_session_service_1.InstanceAiBrowserSessionService, instance_ai_memory_service_1.InstanceAiMemoryService, typeorm_agent_memory_1.TypeORMAgentMemory, typeorm_agent_checkpoint_store_1.TypeORMAgentCheckpointStore, ai_service_1.AiService, instance_ai_thread_grant_repository_1.InstanceAiThreadGrantRepository, instance_ai_pending_confirmation_repository_1.InstanceAiPendingConfirmationRepository, instance_ai_observation_repository_1.InstanceAiObservationRepository, instance_ai_observation_cursor_repository_1.InstanceAiObservationCursorRepository, backend_services_1.UrlService, instance_ai_event_log_repository_1.InstanceAiEventLogRepository, db_iteration_log_storage_1.DbIterationLogStorage, backend_services_1.InstanceWriteAccessService, telemetry_2.Telemetry, mcp_1.InstanceAiMcpRegistryService, db_1.UserRepository, instance_ai_temporary_workflow_service_1.InstanceAiTemporaryWorkflowService, n8n_core_1.ErrorReporter, config_1.SsrfProtectionConfig, backend_network_1.SsrfProtectionService, backend_services_1.EventService, thread_credential_allowlist_service_1.EvalThreadCredentialAllowlistService, instance_ai_run_probe_1.InstanceAiRunProbe, instance_ai_model_service_1.InstanceAiModelService, instance_ai_credit_service_1.InstanceAiCreditService, publisher_service_1.Publisher, instance_ai_error_reporter_service_1.InstanceAiErrorReporterService, push_1.Push, instance_ai_conversation_history_service_1.InstanceAiConversationHistoryService, instance_context_service_1.InstanceContextService, ai_preference_service_1.AiPreferenceService, ai_usage_service_1.AiUsageService, instance_ai_thread_tabs_service_1.InstanceAiThreadTabsService, instance_ai_skills_service_1.InstanceAiSkillsService])
+    __metadata("design:paramtypes", [backend_common_1.Logger, config_1.GlobalConfig, n8n_core_1.InstanceSettings, instance_ai_adapter_service_1.InstanceAiAdapterService, in_process_event_bus_1.InProcessEventBus, durable_event_log_1.DurableEventLog, interrupted_run_sweeper_1.InterruptedRunSweeper, instance_ai_settings_service_1.InstanceAiSettingsService, instance_ai_browser_session_service_1.InstanceAiBrowserSessionService, instance_ai_memory_service_1.InstanceAiMemoryService, typeorm_agent_memory_1.TypeORMAgentMemory, typeorm_agent_checkpoint_store_1.TypeORMAgentCheckpointStore, ai_service_1.AiService, instance_ai_thread_grant_repository_1.InstanceAiThreadGrantRepository, instance_ai_pending_confirmation_repository_1.InstanceAiPendingConfirmationRepository, instance_ai_observation_repository_1.InstanceAiObservationRepository, instance_ai_observation_cursor_repository_1.InstanceAiObservationCursorRepository, instance_ai_event_log_repository_1.InstanceAiEventLogRepository, telemetry_2.Telemetry, db_1.UserRepository, instance_ai_temporary_workflow_service_1.InstanceAiTemporaryWorkflowService, n8n_core_1.ErrorReporter, backend_services_1.EventService, thread_credential_allowlist_service_1.EvalThreadCredentialAllowlistService, instance_ai_run_probe_1.InstanceAiRunProbe, instance_ai_model_service_1.InstanceAiModelService, instance_ai_credit_service_1.InstanceAiCreditService, publisher_service_1.Publisher, instance_ai_error_reporter_service_1.InstanceAiErrorReporterService, instance_ai_thread_tabs_service_1.InstanceAiThreadTabsService, self_healing_agent_service_1.SelfHealingAgentService, assistant_turn_environment_factory_1.AssistantTurnEnvironmentFactory, assistant_turn_input_builder_1.AssistantTurnInputBuilder, assistant_agent_factory_1.AssistantAgentFactory])
 ], InstanceAiService);
 //# sourceMappingURL=instance-ai.service.js.map