@myagentroam/node 0.10.61 → 0.10.63

package/dist/connector.js

@@ -3,8 +3,8 @@ import { isImageAttachment } from './util/node-operation-parsers.js';
 import { ModelUsageOutbox } from './service/model-usage-outbox.js';
 import { NodeModelUsageService } from './service/model-usage-service.js';
 import { dirname, resolve } from 'node:path';
-import { createEnvelope, composerVisibleText, directNodeCommandSchema } from '@myagentroam/protocol';
-import { hostedConversationStorePath, loadNodeConfig, computerUseRuntimeExecutable, directTransferUdpPortRange, nodeDataDirectory, nodeDatabasePath } from './config.js';
+import { createEnvelope, directNodeCommandSchema } from '@myagentroam/protocol';
+import { loadNodeConfig, computerUseRuntimeExecutable, directTransferUdpPortRange, nodeDataDirectory, nodeDatabasePath } from './config.js';
 import { NodeMetrics, nodeLog } from './operational.js';
 import { assertLocalSqlitePath } from './storage.js';
 import { detectCapabilitiesAsync, unavailableCapabilities } from './capabilities.js';
@@ -12,9 +12,9 @@ import { NodeDatabase } from './database.js';
 import { TerminalManager } from './terminal.js';
 import { NodeRuntimeState } from './runtime-state.js';
 import { CommandStateStore } from './runner-command-engine.js';
-import { goalUnrestrictedAccess, GoalRuntime } from './service/goal-runtime.js';
+import { GoalRuntime } from './service/goal-runtime.js';
+import { GoalContinuationCoordinator } from './service/goal-continuation-coordinator.js';
 import { GoalMcpBridge } from './service/goal-mcp-bridge.js';
-import { NODE_MCP } from './mcp/naming.js';
 import { RunnerUsageReader } from './runner-usage.js';
 import { ClaudeCodeRunner } from './runner/claude-code-runner.js';
 import { ClaudeManagedRunController } from './runner/claude/managed-run-controller.js';
@@ -61,13 +61,12 @@ import { WorkspaceQueueWorkbenchService } from './service/workspace-queue-workbe
 import { ContinuousRunCoordinator } from './service/continuous-run-coordinator.js';
 import { SessionIdentityService } from './service/session-identity-service.js';
 import { NativeSessionProjectionService } from './service/native-session-projection-service.js';
-import { composeConversationRuntimePage, ConversationHistoryService, convergeConversationWatchPage, hasManagedActiveRun } from './service/conversation-history-service.js';
+import { ConversationHistoryService, hasManagedActiveRun } from './service/conversation-history-service.js';
 import { ConversationSegmentService } from './service/conversation-segment-service.js';
 import { RunnerInteractionService } from './service/runner-interaction-service.js';
 import { SessionLifecycleService } from './service/session-lifecycle-service.js';
 import { ExternalSessionResumeService } from './service/external-session-resume-service.js';
 import { SessionMessageService } from './service/session-message-service.js';
-import { composerResourceInputTags } from './service/composer-message-input.js';
 import { SessionScheduleService } from './service/session-schedule-service.js';
 import { ScheduledSessionCoordinator } from './service/scheduled-session-coordinator.js';
 import { ScheduledSessionStore } from './service/scheduled-session-store.js';
@@ -94,14 +93,8 @@ import { RunnerChannelMessageService } from './service/runner-channel-message-se
 import { ManagedRunnerSessionService } from './service/managed-runner-session-service.js';
 import { NodeConnectionLifecycleService } from './service/node-connection-lifecycle-service.js';
 import { NodeUpgradeCoordinator, nodeUpgradeRequestPath } from './service/node-upgrade-coordinator.js';
-import { HostedConversationStore } from './service/hosted-conversation-store.js';
-import { ConversationTemplateNodeService } from './service/conversation-template-node-service.js';
-import { HostedConversationNodeService } from './service/hosted-conversation-node-service.js';
-import { BubblewrapSandboxExecutor } from '@myagentroam/agent/sandbox/linux';
-import { hostedConversationSandboxProfile } from './service/hosted-conversation-sandbox-profile.js';
-import { MarAgentHostedConversationRuntime } from './runner/mar-agent/hosted-conversation-runtime.js';
-import { conversationHostingCapability, probeBubblewrap } from './service/conversation-hosting-capability-service.js';
-import { ConversationHostingMaintenanceService } from './service/conversation-hosting-maintenance-service.js';
+import { probeBubblewrap } from './service/conversation-hosting-capability-service.js';
+import { ConversationHostingLifecycleService } from './service/conversation-hosting-lifecycle-service.js';
 import { ConversationHostingEnablementService } from './service/conversation-hosting-enablement-service.js';
 import { ComputerUseEnablementService } from './service/computer-use-enablement-service.js';
 import { safeErrorCode } from './util/safe-error.js';
@@ -205,14 +198,7 @@ export class NodeConnector {
     capabilities;
     capabilityDetector;
     conversationHostingProbe;
-    conversationHostingStorageReady = false;
-    conversationHostingFailureCode;
-    conversationTemplateOperations;
-    hostedConversationOperations;
-    conversationHostingMaintenanceOperations;
-    hostedConversationRuntime;
-    hostedConversationService;
-    conversationHostingMaintenanceService;
+    conversationHosting;
     configPath;
     reconnect;
     claudeApprovalTimeoutMs;
@@ -283,25 +269,8 @@ export class NodeConnector {
     workspaceService;
     commandStates = new CommandStateStore();
     goalRuntime = new GoalRuntime(() => undefined);
-    goalRetryTimers = new Map();
-    goalContinuationPending = new Map();
-    goalSubmissionAttempts = new Map();
-    goalContinuationEpochs = new Map();
-    goalExecutionProgress = new Set();
-    nativeGoalBindings = new Map();
     sessionScheduleService;
-    goalMcpBridge = new GoalMcpBridge(this.goalRuntime, (sessionId) => {
-        const goal = this.goalRuntime.get(sessionId);
-        const session = this.runtime.getAgentSession(sessionId);
-        if (goal === undefined || session === undefined)
-            return;
-        if (goal.status !== 'active') {
-            this.nativeGoalBindings.delete(goal.id);
-            this.retireGoalContinuation(sessionId);
-            this.continuousRunCoordinator.removeGoalQueue(sessionId);
-        }
-        this.publishGoalState(session, goal);
-    });
+    goalMcpBridge = new GoalMcpBridge(this.goalRuntime, (sessionId) => this.goalCoordinator.changed(sessionId));
     scheduleMcpBridge = new ScheduleMcpBridge(() => {
         if (this.database === undefined)
             throw new Error('NODE_DATABASE_UNAVAILABLE');
@@ -313,7 +282,7 @@ export class NodeConnector {
                 session: this.sessionPresentationService.present(session)
             });
         this.scheduledSessions.changed();
-    }, (sessionId, proposalId) => this.emitScheduledProposalNotification(sessionId, proposalId), (input) => {
+    }, (sessionId, proposalId) => this.scheduledSessions.proposalCreated(sessionId, proposalId), (input) => {
         if (this.sessionScheduleService === undefined)
             throw new Error('SCHEDULE_SERVICE_UNAVAILABLE');
         return this.sessionScheduleService.createFromMcp(input);
@@ -355,6 +324,17 @@ export class NodeConnector {
     recentRunProjectionService = new RecentRunProjectionService((message) => this.send('recent-runs', message));
     /** Runtime/session state is intentionally not persisted to Node SQLite. */
     runtime = new NodeRuntimeState(() => this.config?.nodeId ?? 'runtime-node', (workspaceId) => this.database?.getWorkspace(workspaceId), Date.now, (run, session, userMessage) => this.recentRunProjectionService.record(run, session, userMessage));
+    goalCoordinator = new GoalContinuationCoordinator({
+        goals: this.goalRuntime,
+        runtime: this.runtime,
+        commands: this.commandStates,
+        queue: () => this.continuousRunCoordinator,
+        submit: (input) => this.sessionMessageService.submitGoal(input),
+        emitRun: (...args) => this.runEventBridge.emitRun(...args),
+        present: (session) => this.sessionPresentationService.present(session),
+        emitSession: (session) => this.emitSessionWorkbenchEvent({ session: this.sessionPresentationService.present(session) }),
+        database: () => this.database
+    });
     metrics = new NodeMetrics();
     runEventService = new RunEventService({
         runtime: this.runtime,
@@ -375,21 +355,8 @@ export class NodeConnector {
         scheduleContextRefresh: (sessionId) => this.sessionContextService.schedule(sessionId),
         refreshWorkspaceSessions: (workspaceId) => this.workspaceWorkbenchService.ensureTopicSnapshot(workspaceId, 'sessions'),
         onTerminalRun: (run, status) => {
-            if (run.source !== 'SCHEDULED' || this.database === undefined)
-                return;
-            const store = new ScheduledSessionStore(this.database.raw);
-            store.finish(run.clientMessageId, status === 'SUCCEEDED' ? 'SUCCEEDED' : 'FAILED', status === 'SUCCEEDED' ? undefined : `SCHEDULE_RUN_${status}`, run.id);
-            const task = store.getById(run.clientMessageId.split(':', 1)[0]);
-            if (task !== undefined) {
-                if (task.notifyOnTerminal)
-                    this.publishScheduledTaskNotification(task, run.clientMessageId, {
-                        kind: 'SCHEDULE_TERMINAL',
-                        outcome: status,
-                        runId: run.id
-                    });
-                else if (status !== 'SUCCEEDED')
-                    this.emitScheduledNotification(task, run.clientMessageId, `SCHEDULE_RUN_${status}`, 'FAILED');
-            }
+            if (this.database !== undefined)
+                this.scheduledSessions.executionTerminated(run, status);
         },
         dispatchQueue: async (sessionId, delayMs = 0) => {
             if (this.upgradeCoordinator.pending())
@@ -401,77 +368,14 @@ export class NodeConnector {
             await this.continuousRunCoordinator.dispatch(sessionId);
         },
         executionStarted: (executionId) => this.continuousRunCoordinator.executionStarted(executionId),
-        keepRunActive: (sessionId) => (this.goalRetryTimers.has(sessionId) || this.goalContinuationPending.has(sessionId)) &&
-            this.goalRuntime.get(sessionId)?.status === 'active',
+        keepRunActive: (sessionId) => this.goalCoordinator.keepRunActive(sessionId),
         executionTerminating: (executionId, status, permissionStop) => {
             this.gitOperationService.executionFinished(executionId);
-            if (this.stopped)
-                return;
-            const pending = this.continuousRunCoordinator.pending(executionId);
-            if (pending?.goal === undefined)
-                return;
-            const started = this.continuousRunCoordinator.hasExecutionStarted(executionId);
-            const progressed = this.goalExecutionProgress.delete(executionId);
-            if (!this.goalGenerationCurrent(pending.sessionId, pending.goal))
-                return;
-            if (permissionStop !== undefined) {
-                this.retireGoalContinuation(pending.sessionId);
-                this.continuousRunCoordinator.removeGoalQueue(pending.sessionId);
-                return;
-            }
-            const disposition = this.goalRuntime.recordExecutionResult(pending.sessionId, {
-                failed: status === 'FAILED',
-                progressed: status !== 'SUCCEEDED' || progressed
-            });
-            if (disposition === 'blocked' || disposition === 'completed') {
-                this.nativeGoalBindings.delete(pending.goal.id);
-                this.retireGoalContinuation(pending.sessionId);
-                this.continuousRunCoordinator.removeGoalQueue(pending.sessionId);
-                const terminalGoal = this.goalRuntime.get(pending.sessionId);
-                const session = this.runtime.getAgentSession(pending.sessionId);
-                if (terminalGoal !== undefined && session !== undefined)
-                    this.publishGoalState(session, terminalGoal);
-                return;
-            }
-            if (status !== 'FAILED' || started)
-                return;
-            this.clearGoalRetry(pending.sessionId);
-            const continuationEpoch = this.goalContinuationEpochs.get(pending.sessionId) ?? 0;
-            const retry = {
-                sessionId: pending.sessionId,
-                timer: setTimeout(() => {
-                    this.goalRetryTimers.delete(retry.sessionId);
-                    void this.enqueueGoalContinuation({
-                        sessionId: retry.sessionId,
-                        goal: pending.goal,
-                        ...(pending.usageGrant === undefined ? {} : { usageGrant: pending.usageGrant }),
-                        secretEnvironment: pending.secretEnvironment,
-                        ...(pending.personalInstructions === undefined
-                            ? {}
-                            : { personalInstructions: pending.personalInstructions }),
-                        ...(pending.marAgentModel === undefined
-                            ? {}
-                            : { marAgentModel: pending.marAgentModel }),
-                        ...(pending.marAgentModels === undefined
-                            ? {}
-                            : { marAgentModels: pending.marAgentModels }),
-                        ...(pending.marAgentCompact === undefined
-                            ? {}
-                            : { marAgentCompact: pending.marAgentCompact }),
-                        ...(pending.marAgentRuntimeScopeId === undefined
-                            ? {}
-                            : { marAgentRuntimeScopeId: pending.marAgentRuntimeScopeId }),
-                        continuationEpoch,
-                        deliveryIntent: 'SEND'
-                    });
-                }, 15_000)
-            };
-            this.goalRetryTimers.set(pending.sessionId, retry);
-            retry.timer.unref();
+            this.goalCoordinator.executionTerminating(executionId, status, permissionStop);
         },
         releaseExecution: (executionId) => {
             this.modelUsage.release(executionId);
-            this.goalExecutionProgress.delete(executionId);
+            this.goalCoordinator.releaseExecution(executionId);
             this.revokeExecutionMcps(executionId);
             this.continuousRunCoordinator.remove(executionId);
         }
@@ -491,8 +395,6 @@ export class NodeConnector {
         present: (session) => this.sessionPresentationService.present(session),
         readPage: (session, limit) => this.conversationHistoryService.read(session, { limit }),
         readHistoryPage: (session, limit) => this.conversationHistoryService.readHistoryPage(session, { limit }),
-        convergePage: convergeConversationWatchPage,
-        composeRuntimePage: composeConversationRuntimePage,
         projectInitialPage: (session, page, _unit, limit) => {
             const context = this.sessionContextService.snapshot(session.id);
             this.sessionContextService.schedule(session);
@@ -526,6 +428,35 @@ export class NodeConnector {
         this.capabilitiesProvided = options.capabilities !== undefined;
         this.capabilities = options.capabilities ?? unavailableCapabilities();
         this.conversationHostingProbe = options.conversationHostingProbe ?? probeBubblewrap;
+        this.conversationHosting = new ConversationHostingLifecycleService({
+            config: () => this.config,
+            configPath: this.configPath,
+            database: () => this.database,
+            capabilities: () => this.capabilities,
+            probe: this.conversationHostingProbe,
+            runtime: {
+                webSearch: (input, signal) => this.webToolService.webSearch(input, signal),
+                webFetch: (input, signal) => this.webToolService.webFetch(input, signal, false),
+                modelFactory: this.marAgentRuntimeModels,
+                registerNativeImages: (runId, roots, images) => this.runAttachmentService.registerNativeImages(runId, roots, images, {
+                    reuseCachedRunImages: false
+                })
+            },
+            host: {
+                modelUsage: (grant, usage) => {
+                    const runId = usage.executionId ?? usage.requestId;
+                    this.modelUsage.bind(runId, grant, usage.sessionId, 'mar-agent');
+                    this.modelUsage.record(runId, normalizeMarAgentUsage(usage));
+                    this.modelUsage.release(runId);
+                },
+                nodeGeneration: () => this.nodeGeneration,
+                sessionWatchSlots: this.sessionWatchSlots,
+                emitWatchEvent: (payload) => this.send('watch.event', payload),
+                nextWorkbenchEvent: (payload) => this.workbenchEventService.next('hosted-conversation', payload),
+                emitWorkbenchEvent: (event) => this.workbenchEventService.publish(event),
+                readImage: (runId, imageRef) => this.runAttachmentService.readNative(runId, imageRef)
+            }
+        });
         this.upgradeCoordinator = new NodeUpgradeCoordinator(() => {
             if (this.config === undefined)
                 throw new Error('NODE_CONFIG_UNAVAILABLE');
@@ -547,7 +478,7 @@ export class NodeConnector {
         const detect = options.capabilityDetector ?? detectCapabilitiesAsync;
         this.capabilityDetector = async () => {
             const capabilities = await detect();
-            return this.projectComputerUseCapability(await this.projectConversationHostingCapability({
+            return this.projectComputerUseCapability(await this.conversationHosting.project({
                 ...capabilities,
                 metadata: upgradeMetadata(capabilities.metadata, this.upgradeCoordinator.snapshot())
             }));
@@ -576,10 +507,10 @@ export class NodeConnector {
             promoteSession: (sessionId, nativeSessionId) => this.sessionIdentityService.promote(sessionId, nativeSessionId),
             send: (type, payload) => this.send(type, payload),
             emit: (runId, eventType, payload, status) => this.runEventBridge.emitRun(runId, eventType, payload, status),
-            nativeGoalUpdated: (runId, goal) => this.handleNativeGoalUpdate(runId, goal),
+            nativeGoalUpdated: (runId, goal) => this.goalCoordinator.handleNativeGoalUpdate(runId, goal),
             cancel: (runId, threadId, turnId, cwd, status) => this.runnerInteractionService.cancelCodexTurn(runId, threadId, turnId, cwd, status),
             createApproval: (input) => this.runtime.createApproval(input),
-            publishApproval: (input) => this.publishApprovalForRun(input),
+            publishApproval: (input) => this.runnerInteractionService.publishApproval(input),
             emitItem: (runId, item) => this.emitConversationItem(runId, item),
             appendImages: (runId, images) => this.runAttachmentService.append(runId, images.filter(isRunnerImageAttachment)),
             syncTitle: (sessionId, nativeSessionId, cwd) => this.managedRunnerSessions.refreshTitle(sessionId, nativeSessionId, cwd),
@@ -620,7 +551,7 @@ export class NodeConnector {
         this.capabilities = this.projectComputerUseCapability(this.capabilities);
         this.marAgentRunController = new MarAgentManagedRunController(this.marAgentClient, {
             createApproval: (input) => this.runtime.createApproval(input),
-            publishApproval: (input) => this.publishApprovalForRun(input),
+            publishApproval: (input) => this.runnerInteractionService.publishApproval(input),
             active: this.runState.active,
             adopt: (input) => this.runtime.adoptRun(input),
             promote: (sessionId, nativeSessionId) => this.sessionIdentityService.promote(sessionId, nativeSessionId),
@@ -683,7 +614,7 @@ export class NodeConnector {
             expireApproval: (approvalId) => {
                 this.runtime.expireApproval(approvalId);
             },
-            publishApproval: (input) => this.publishApprovalForRun(input),
+            publishApproval: (input) => this.runnerInteractionService.publishApproval(input),
             commandState: (sessionId, commandId) => this.commandStates.get(sessionId, commandId),
             setCommandState: (sessionId, state) => this.commandStates.set(sessionId, state),
             clearCommandState: (sessionId, commandId) => this.commandStates.clear(sessionId, commandId),
@@ -732,7 +663,7 @@ export class NodeConnector {
             emitRun: (runId, eventType, payload, status) => this.runEventBridge.emitRun(runId, eventType, payload, status),
             emitItem: (runId, item) => this.emitConversationItem(runId, item),
             approvalTimeoutMs: this.claudeApprovalTimeoutMs,
-            publishApproval: (input) => this.publishApprovalForRun(input)
+            publishApproval: (input) => this.runEventBridge.publishApproval(input)
         });
         this.runnerChannelMessages = new RunnerChannelMessageService({
             interactions: this.runnerInteractionService,
@@ -781,7 +712,7 @@ export class NodeConnector {
             respondUserInput: (runId, requestId, answers) => this.runnerInteractionService.respondUserInput(runId, requestId, answers),
             pauseQueue: (sessionId) => this.workspaceQueueWorkbenchService.pauseSessionQueue(sessionId),
             runInterrupted: (sessionId) => {
-                const goalExit = this.clearGoalState(sessionId, 'stopped');
+                const goalExit = this.goalCoordinator.clearGoalState(sessionId, 'stopped');
                 return goalExit === undefined ? undefined : { goalExit };
             },
             emitRun: (runId, eventType, payload, status) => this.runEventBridge.emitRun(runId, eventType, payload, status),
@@ -857,10 +788,11 @@ export class NodeConnector {
             markInterrupted: (runId) => this.runState.interruptRequested.add(runId),
             mcps: (workspaceId) => this.database?.effectiveMcpInstallations(workspaceId) ?? [],
             retainEnvironment: (environment) => this.gitExecution().retain(environment),
-            goalCurrent: (input) => input.goal === undefined || this.goalGenerationCurrent(input.sessionId, input.goal),
+            goalCurrent: (input) => input.goal === undefined ||
+                this.goalCoordinator.goalGenerationCurrent(input.sessionId, input.goal),
             goalActive: (sessionId) => this.goalRuntime.get(sessionId)?.status === 'active',
-            afterExecutionStarted: (input) => this.maintainGoalContinuation(input, true),
-            afterExecutionSteered: (input) => this.maintainGoalContinuation(input, false),
+            afterExecutionStarted: (input) => this.goalCoordinator.maintainGoalContinuation(input, true),
+            afterExecutionSteered: (input) => this.goalCoordinator.maintainGoalContinuation(input, false),
             afterExecutionStartFailed: (input, error) => {
                 nodeLog('goal.execution-start.failed', {
                     sessionId: input.sessionId,
@@ -939,35 +871,8 @@ export class NodeConnector {
             migrateCommands: (previousId, nextId) => this.commandStates.promoteSessionIdentity(previousId, nextId),
             migrateGoal: (previousId, nextId) => {
                 this.runAttachmentService.migrateSession(previousId, nextId);
-                this.goalRuntime.migrateSession(previousId, nextId);
+                this.goalCoordinator.migrateSession(previousId, nextId);
                 this.goalMcpBridge.migrateSession(previousId, nextId);
-                const retry = this.goalRetryTimers.get(previousId);
-                if (retry !== undefined) {
-                    this.goalRetryTimers.delete(previousId);
-                    retry.sessionId = nextId;
-                    this.goalRetryTimers.set(nextId, retry);
-                }
-                const pendingContinuation = this.goalContinuationPending.get(previousId);
-                if (pendingContinuation !== undefined) {
-                    this.goalContinuationPending.delete(previousId);
-                    pendingContinuation.sessionId = nextId;
-                    this.goalContinuationPending.set(nextId, pendingContinuation);
-                }
-                const submissionAttempts = this.goalSubmissionAttempts.get(previousId);
-                if (submissionAttempts !== undefined) {
-                    this.goalSubmissionAttempts.delete(previousId);
-                    const currentAttempts = this.goalSubmissionAttempts.get(nextId) ?? new Set();
-                    for (const attempt of submissionAttempts) {
-                        attempt.sessionId = nextId;
-                        currentAttempts.add(attempt);
-                    }
-                    this.goalSubmissionAttempts.set(nextId, currentAttempts);
-                }
-                const continuationEpoch = this.goalContinuationEpochs.get(previousId);
-                if (continuationEpoch !== undefined) {
-                    this.goalContinuationEpochs.delete(previousId);
-                    this.goalContinuationEpochs.set(nextId, continuationEpoch);
-                }
             },
             migrateQueue: (previousId, nextId) => this.continuousRunCoordinator.migrateSession(previousId, nextId),
             migrateRunnerState: (previousId, nextId) => {
@@ -990,9 +895,12 @@ export class NodeConnector {
             projection: this.nativeSessionProjectionService,
             identity: this.sessionIdentityService,
             present: (session) => this.sessionPresentationService.present(session),
-            emitSession: (session) => this.emitSessionWorkbenchEvent({
+            emitSession: (session) => this.publishWorkbenchEvent('session', {
                 session: this.sessionPresentationService.present(session)
             }),
+            invalidateWorkspaceSessions: (workspaceId) => {
+                void this.workspaceWorkbenchService?.invalidateTopic(workspaceId, 'sessions');
+            },
             execute: (operation, data) => this.modelUsage.withGrant(isPlainRecord(data) ? data.__usageGrant : undefined, () => this.executeNodeOperation(operation, data)),
             interceptedSessionId: (clientMessageId) => this.fakeRunner === undefined ? undefined : `fake:${clientMessageId}`
         });
@@ -1026,83 +934,9 @@ export class NodeConnector {
             emitSession: (session) => this.emitSessionWorkbenchEvent({
                 session: this.sessionPresentationService.present(session)
             }),
-            beginGoal: (session) => {
-                const existing = this.commandStates.get(session.id, 'goal');
-                if (existing?.active === true)
-                    return {
-                        session: this.sessionPresentationService.present(session),
-                        goalAlreadyActive: true
-                    };
-                if (existing !== undefined) {
-                    const previousGoal = this.goalRuntime.get(session.id);
-                    if (previousGoal !== undefined)
-                        this.nativeGoalBindings.delete(previousGoal.id);
-                    this.goalRuntime.clear(session.id);
-                    this.commandStates.clear(session.id, 'goal');
-                }
-                const prepared = this.prepareGoalSession(session);
-                this.continuousRunCoordinator.removePendingQueue(session.id);
-                this.commandStates.set(session.id, this.pendingGoalCommandState());
-                this.emitWorkbenchEvent('session', {
-                    session: this.sessionPresentationService.present(prepared.session)
-                });
-                return {
-                    session: this.sessionPresentationService.present(prepared.session),
-                    goalAccessChanged: prepared.changed
-                };
-            },
-            goal: async ({ session, objective, initiatedByUserId, suppressNotifications, secretEnvironment, personalInstructions, marAgentModel, marAgentModels, marAgentCompact, marAgentRuntimeScopeId, usageGrant }) => {
-                this.invalidateGoalContinuation(session.id);
-                const prepared = this.prepareGoalSession(session);
-                const goalSession = prepared.session;
-                const activeRun = this.runtime.activeSessionRun(session.id);
-                const replacing = activeRun !== undefined && this.runtime.currentExecutionId(activeRun.id) !== undefined;
-                this.continuousRunCoordinator.removeGoalQueue(session.id);
-                const goal = this.goalRuntime.start(session.id, objective);
-                this.publishGoalState(goalSession, goal);
-                const attempt = this.beginGoalSubmission(session.id);
-                const goalRef = { id: goal.id, revision: goal.revision, epoch: attempt.epoch };
-                let result;
-                try {
-                    result = await this.sessionMessageService.submitGoal({
-                        sessionId: attempt.sessionId,
-                        kind: 'start',
-                        content: this.goalRuntime.prompt(attempt.sessionId, 'start'),
-                        objective: goal.objective,
-                        deliveryIntent: replacing ? 'REPLACE_CURRENT' : 'SEND',
-                        goal: goalRef,
-                        ...(suppressNotifications === true ? { suppressNotifications: true } : {}),
-                        ...(usageGrant === undefined ? {} : { usageGrant }),
-                        ...(initiatedByUserId === undefined ? {} : { initiatedByUserId }),
-                        secretEnvironment,
-                        ...(personalInstructions === undefined ? {} : { personalInstructions }),
-                        ...(marAgentModel === undefined ? {} : { marAgentModel }),
-                        ...(marAgentModels === undefined ? {} : { marAgentModels }),
-                        ...(marAgentCompact === undefined ? {} : { marAgentCompact }),
-                        ...(marAgentRuntimeScopeId === undefined ? {} : { marAgentRuntimeScopeId })
-                    });
-                    if (!this.goalGenerationCurrent(attempt.sessionId, goalRef)) {
-                        this.removeStaleGoalSubmission(attempt.sessionId, result);
-                        throw new Error('GOAL_REVISION_STALE');
-                    }
-                }
-                finally {
-                    this.finishGoalSubmissionAttempt(attempt);
-                }
-                return {
-                    ...(isPlainRecord(result) ? result : { result }),
-                    goalAccessChanged: prepared.changed
-                };
-            },
-            clearGoal: (session) => {
-                const goalExit = this.clearGoalState(session.id, 'removed');
-                this.finishIdleGoalRun(session.id, 'SUCCEEDED');
-                return {
-                    session: this.sessionPresentationService.present(session),
-                    cleared: true,
-                    ...(goalExit === undefined ? {} : { goalExit })
-                };
-            }
+            beginGoal: (session) => this.goalCoordinator.begin(session),
+            goal: (input) => this.goalCoordinator.start(input),
+            clearGoal: (session) => this.goalCoordinator.clear(session)
         });
         this.sessionMessageService = new SessionMessageService({
             runtime: this.runtime,
@@ -1121,53 +955,9 @@ export class NodeConnector {
                 const session = this.runtime.getAgentSession(sessionId);
                 return session?.channelToken ?? undefined;
             },
-            goalMessage: (session, content, intent) => {
-                const state = this.commandStates.get(session.id, 'goal');
-                if (state?.active !== true)
-                    return undefined;
-                const current = this.goalRuntime.get(session.id);
-                if (current?.status === 'active') {
-                    const idlePausedGoal = this.runtime.activeSessionRun(session.id) === undefined &&
-                        this.runtime.sessionQueue(session.id).paused;
-                    if (intent !== 'REPLACE_CURRENT' && !idlePausedGoal)
-                        return undefined;
-                    this.invalidateGoalContinuation(session.id);
-                    const resumed = this.goalRuntime.resume(session.id);
-                    if (resumed !== current)
-                        this.publishGoalState(session, resumed);
-                    return {
-                        runnerContent: content,
-                        goal: {
-                            id: resumed.id,
-                            revision: resumed.revision,
-                            epoch: this.goalContinuationEpochs.get(session.id) ?? 0
-                        },
-                        activated: false
-                    };
-                }
-                const objective = composerVisibleText(content);
-                if (objective.length === 0)
-                    return undefined;
-                this.invalidateGoalContinuation(session.id);
-                const goal = this.goalRuntime.start(session.id, objective, composerResourceInputTags(content));
-                this.publishGoalState(session, goal);
-                return {
-                    runnerContent: this.goalRuntime.prompt(session.id, 'start'),
-                    goal: {
-                        id: goal.id,
-                        revision: goal.revision,
-                        epoch: this.goalContinuationEpochs.get(session.id) ?? 0
-                    },
-                    activated: true
-                };
-            },
-            prepareGoalInsertion: (sessionId, submissionId, goal) => {
-                if (!this.goalGenerationCurrent(sessionId, goal))
-                    return false;
-                this.continuousRunCoordinator.removeGoalQueue(sessionId, undefined, submissionId);
-                return true;
-            },
-            goalPreparationFailed: (session, goal, activated) => this.handleGoalPreparationFailed(session, goal, activated)
+            goalMessage: (session, content, intent) => this.goalCoordinator.goalMessage(session, content, intent),
+            prepareGoalInsertion: (sessionId, submissionId, goal) => this.goalCoordinator.prepareInsertion(sessionId, submissionId, goal),
+            goalPreparationFailed: (session, goal, activated) => this.goalCoordinator.handleGoalPreparationFailed(session, goal, activated)
         });
         const inputState = (entry, message) => this.marAgentClient.restartInputState(entry.session.id, message.clientMessageId);
         const restorer = new RestartSessionRestorer({
@@ -1180,7 +970,8 @@ export class NodeConnector {
             authorize: (request) => this.restartAuthorization.authorize(request),
             inputState,
             withGrant: (context, work) => this.modelUsage.withGrant(context.usageGrant, work),
-            publishGoal: (session, goal) => this.publishGoalState(session, goal),
+            publishGoal: (session, goal) => this.goalCoordinator.publishGoalState(session, goal),
+            goalReference: (sessionId) => this.goalCoordinator.reference(sessionId),
             publishQueue: (session) => this.continuousRunCoordinator.publish(session.id)
         });
         this.restartHandoff = new PlannedRestartHandoff({
@@ -1284,7 +1075,7 @@ export class NodeConnector {
                 runtime: this.runtime,
                 state: this.runState,
                 emitRun: (runId, type, payload, status) => this.runEventBridge.emitRun(runId, type, payload, status),
-                publishApproval: (input) => this.publishApprovalForRun(input),
+                publishApproval: (input) => this.runnerInteractionService.publishApproval(input),
                 disconnect: () => this.controlChannel.close(4010, 'FAKE_RUNNER_DISCONNECT')
             });
         this.fakeRunner?.bindControl({
@@ -1437,7 +1228,8 @@ export class NodeConnector {
             heartbeatMs: HEARTBEAT_MS,
             refreshMs: CAPABILITY_REFRESH_MS,
             onRegistered: async () => {
-                await this.initializeConversationHosting();
+                await this.conversationHosting.initialize();
+                this.capabilities = await this.conversationHosting.project(this.capabilities);
                 this.computerUseEnablement.initialize();
             },
             onConnected: () => {
@@ -1499,7 +1291,11 @@ export class NodeConnector {
                 }));
                 return { runId: result.run.id };
             },
-            notify: (task, occurrenceId, code, status) => this.emitScheduledNotification(task, occurrenceId, code, status)
+            sessionTitle: (sessionId) => {
+                const session = this.runtime.getAgentSession(sessionId);
+                return session?.customTitle ?? session?.runnerTitle ?? sessionId;
+            },
+            emitNotification: (payload) => this.emitWorkbenchEvent('conversation', payload)
         });
         this.runnerService = new RunnerService(requireDatabase, () => this.capabilities, this.runners, this.runnerUsageReader);
         this.workbenchManifestService = new WorkbenchManifestService({
@@ -1588,21 +1384,21 @@ export class NodeConnector {
         this.operationRouter.registerAll(this.promptCompletion.operations());
         for (const operation of CONVERSATION_TEMPLATE_OPERATIONS)
             this.operationRouter.register(operation, (data) => {
-                const handler = this.conversationTemplateOperations?.[operation];
+                const handler = this.conversationHosting.handler(operation);
                 if (handler === undefined)
                     throw new Error('CONVERSATION_HOSTING_UNAVAILABLE');
                 return handler(data);
             });
         for (const operation of HOSTED_CONVERSATION_OPERATIONS)
             this.operationRouter.register(operation, (data) => {
-                const handler = this.hostedConversationOperations?.[operation];
+                const handler = this.conversationHosting.handler(operation);
                 if (handler === undefined)
                     throw new Error('CONVERSATION_HOSTING_UNAVAILABLE');
                 return handler(data);
             });
         for (const operation of CONVERSATION_HOSTING_MAINTENANCE_OPERATIONS)
             this.operationRouter.register(operation, (data) => {
-                const handler = this.conversationHostingMaintenanceOperations?.[operation];
+                const handler = this.conversationHosting.handler(operation);
                 if (handler === undefined)
                     throw new Error('CONVERSATION_HOSTING_UNAVAILABLE');
                 return handler(data);
@@ -1630,7 +1426,7 @@ export class NodeConnector {
                 session: this.sessionPresentationService.present(session)
             }),
             changed: () => this.scheduledSessions.changed(),
-            proposed: (sessionId, proposalId) => this.emitScheduledProposalNotification(sessionId, proposalId)
+            proposed: (sessionId, proposalId) => this.scheduledSessions.proposalCreated(sessionId, proposalId)
         });
         this.operationRouter.registerAll(this.sessionScheduleService.operations());
         this.operationRouter.registerAll(this.sessionMessageService.operations());
@@ -1645,8 +1441,11 @@ export class NodeConnector {
             configPath: this.configPath,
             platform: () => this.capabilities.platform,
             capability: () => this.capabilities.conversationHosting,
-            initialize: () => this.initializeConversationHosting(),
-            prepareForDisable: () => this.hostedConversationService?.prepareForDisable() ?? (() => { }),
+            initialize: async () => {
+                await this.conversationHosting.initialize();
+                this.capabilities = await this.conversationHosting.project(this.capabilities);
+            },
+            prepareForDisable: () => this.conversationHosting.prepareForDisable(),
             publishCapabilities: () => this.send('capabilities', this.capabilities)
         }).operations());
         this.operationRouter.registerAll(this.computerUseEnablement.operations());
@@ -1670,147 +1469,12 @@ export class NodeConnector {
             binaryTerminal: true
         }));
     }
-    async initializeConversationHosting() {
-        const previousRuntime = this.hostedConversationRuntime;
-        const previousService = this.hostedConversationService;
-        const previousMaintenance = this.conversationHostingMaintenanceService;
-        this.hostedConversationRuntime = undefined;
-        this.hostedConversationService = undefined;
-        this.conversationHostingMaintenanceService = undefined;
-        this.hostedConversationOperations = undefined;
-        this.conversationHostingMaintenanceOperations = undefined;
-        this.conversationTemplateOperations = undefined;
-        this.conversationHostingStorageReady = false;
-        this.conversationHostingFailureCode = undefined;
-        await previousMaintenance?.dispose();
-        previousService?.dispose();
-        await previousRuntime?.dispose().catch(() => undefined);
-        const config = this.config;
-        if (config?.conversationHosting?.enabled === true && this.capabilities.platform === 'linux') {
-            if (config.nodeId === undefined) {
-                this.conversationHostingFailureCode = 'NODE_UNAUTHENTICATED';
-            }
-            else {
-                let runtime;
-                let hostedService;
-                let maintenanceService;
-                try {
-                    if (this.database === undefined)
-                        throw new Error('NODE_DATABASE_UNAVAILABLE');
-                    const rootDirectory = hostedConversationStorePath(config, this.configPath);
-                    if (rootDirectory === undefined)
-                        throw new Error('CONVERSATION_HOSTING_STORAGE_UNAVAILABLE');
-                    const store = new HostedConversationStore({
-                        dataDirectory: nodeDataDirectory(config, this.configPath),
-                        rootDirectory,
-                        nodeId: config.nodeId,
-                        database: this.database
-                    });
-                    await store.initialize();
-                    const templateService = new ConversationTemplateNodeService({
-                        database: this.database,
-                        store,
-                        nodeId: () => this.config?.nodeId ?? 'unregistered'
-                    });
-                    await templateService.recoverInterruptedPublications();
-                    await store.rebuildConversationIndex();
-                    runtime = new MarAgentHostedConversationRuntime({
-                        webSearch: (input, signal) => this.webToolService.webSearch(input, signal),
-                        webFetch: (input, signal) => this.webToolService.webFetch(input, signal, false),
-                        modelFactory: this.marAgentRuntimeModels,
-                        registerNativeImages: (runId, roots, images) => this.runAttachmentService.registerNativeImages(runId, roots, images, {
-                            reuseCachedRunImages: false
-                        })
-                    });
-                    hostedService = new HostedConversationNodeService({
-                        modelUsage: (grant, usage) => {
-                            const runId = usage.executionId ?? usage.requestId;
-                            this.modelUsage.bind(runId, grant, usage.sessionId, 'mar-agent');
-                            this.modelUsage.record(runId, normalizeMarAgentUsage(usage));
-                            this.modelUsage.release(runId);
-                        },
-                        database: this.database,
-                        store,
-                        runtime,
-                        nodeId: () => this.config?.nodeId ?? 'unregistered',
-                        nodeAppVersion: () => this.capabilities.nodeAppVersion ?? 'unknown',
-                        nodeGeneration: () => this.nodeGeneration,
-                        sessionWatchSlots: this.sessionWatchSlots,
-                        emitWatchEvent: (payload) => this.send('watch.event', payload),
-                        nextWorkbenchEvent: (payload) => this.workbenchEventService.next('hosted-conversation', payload),
-                        emitWorkbenchEvent: (event) => this.workbenchEventService.publish(event),
-                        readImage: (runId, imageRef) => this.runAttachmentService.readNative(runId, imageRef),
-                        processExecutorFactory: (input) => new BubblewrapSandboxExecutor({
-                            profile: hostedConversationSandboxProfile(input)
-                        }),
-                        assertCanCreate: () => {
-                            if (maintenanceService === undefined)
-                                throw new Error('CONVERSATION_HOSTING_UNAVAILABLE');
-                            return maintenanceService.assertCanCreate();
-                        }
-                    });
-                    maintenanceService = new ConversationHostingMaintenanceService({
-                        store,
-                        inactiveRetentionDays: config.conversationHosting.inactiveRetentionDays ?? 60,
-                        isConversationInUse: (conversationId) => hostedService?.isConversationInUse(conversationId) ?? true,
-                        beginConversationCleanup: (conversationId) => hostedService?.beginConversationCleanup(conversationId),
-                        releaseConversation: (conversation) => {
-                            if (hostedService === undefined)
-                                throw new Error('CONVERSATION_HOSTING_UNAVAILABLE');
-                            return hostedService.releaseConversationForCleanup(conversation);
-                        },
-                        onAutomaticCleanupError: (error) => nodeLog('conversation.hosting.cleanup.failed', {
-                            nodeId: config.nodeId,
-                            code: safeErrorCode(error, 'CONVERSATION_HOSTING_CLEANUP_FAILED')
-                        })
-                    });
-                    this.conversationTemplateOperations = templateService.operations();
-                    this.hostedConversationOperations = hostedService.operations();
-                    this.conversationHostingMaintenanceOperations = maintenanceService.operations();
-                    this.hostedConversationRuntime = runtime;
-                    this.hostedConversationService = hostedService;
-                    this.conversationHostingMaintenanceService = maintenanceService;
-                    await maintenanceService.start();
-                    this.conversationHostingStorageReady = true;
-                }
-                catch (error) {
-                    await maintenanceService?.dispose();
-                    hostedService?.dispose();
-                    await runtime?.dispose().catch(() => undefined);
-                    this.conversationHostingFailureCode = safeErrorCode(error, 'CONVERSATION_HOSTING_RECOVERY_FAILED');
-                    nodeLog('conversation.hosting.initialization.failed', {
-                        nodeId: config.nodeId,
-                        code: this.conversationHostingFailureCode
-                    });
-                }
-            }
-        }
-        this.capabilities = await this.projectConversationHostingCapability(this.capabilities);
-    }
     projectComputerUseCapability(capabilities) {
         return {
             ...capabilities,
             computerUse: this.computerUseEnablement.capability()
         };
     }
-    async projectConversationHostingCapability(capabilities) {
-        let storageReady = this.conversationHostingStorageReady;
-        let storageFailureCode = this.conversationHostingFailureCode;
-        let capacity = 'AVAILABLE';
-        if (storageReady && this.conversationHostingMaintenanceService !== undefined) {
-            try {
-                capacity = (await this.conversationHostingMaintenanceService.storageCapacity()).capacity;
-            }
-            catch (error) {
-                storageReady = false;
-                storageFailureCode = safeErrorCode(error, 'CONVERSATION_HOSTING_STORAGE_UNAVAILABLE');
-            }
-        }
-        return {
-            ...capabilities,
-            conversationHosting: await conversationHostingCapability(capabilities, this.config, storageReady, storageFailureCode, this.conversationHostingProbe, capacity)
-        };
-    }
     async start() {
         if (this.stopping !== undefined)
             await this.stopping;
@@ -1837,7 +1501,8 @@ export class NodeConnector {
         await this.restartHandoff.load();
         this.scheduledSessions.recoverInterrupted();
         this.scheduledSessions.start();
-        await this.initializeConversationHosting();
+        await this.conversationHosting.initialize();
+        this.capabilities = await this.conversationHosting.project(this.capabilities);
         this.computerUseEnablement.initialize();
         this.directTransferService ??= await this.createDirectTransferService();
         this.connectionLifecycle.start();
@@ -1914,287 +1579,12 @@ export class NodeConnector {
         };
         return this.directTransferService?.handleTerminal(command) ?? false;
     }
-    clearGoalRetry(sessionId) {
-        const retry = this.goalRetryTimers.get(sessionId);
-        if (retry !== undefined)
-            clearTimeout(retry.timer);
-        this.goalRetryTimers.delete(sessionId);
-        this.goalContinuationPending.delete(sessionId);
-    }
-    invalidateGoalContinuation(sessionId) {
-        this.goalContinuationEpochs.set(sessionId, (this.goalContinuationEpochs.get(sessionId) ?? 0) + 1);
-        this.clearGoalRetry(sessionId);
-    }
-    retireGoalContinuation(sessionId) {
-        this.invalidateGoalContinuation(sessionId);
-        this.goalContinuationEpochs.delete(sessionId);
-    }
-    goalGenerationCurrent(sessionId, goal) {
-        const current = this.goalRuntime.get(sessionId);
-        return ((this.goalContinuationEpochs.get(sessionId) ?? 0) === goal.epoch &&
-            current?.status === 'active' &&
-            current.id === goal.id &&
-            current.revision === goal.revision);
-    }
-    async maintainGoalContinuation(input, started) {
-        if (this.stopped || input.goal === undefined)
-            return;
-        if (!this.goalGenerationCurrent(input.sessionId, input.goal))
-            return;
-        const updated = started ? this.goalRuntime.recordTurn(input.sessionId) : undefined;
-        const session = this.runtime.getAgentSession(input.sessionId);
-        const run = this.runtime.getRun(input.runId);
-        await this.enqueueGoalContinuation({
-            sessionId: input.sessionId,
-            goal: { id: input.goal.id, revision: input.goal.revision },
-            continuationEpoch: input.goal.epoch,
-            ...(run?.initiatedByUserId === undefined ? {} : { initiatedByUserId: run.initiatedByUserId }),
-            ...(input.usageGrant === undefined ? {} : { usageGrant: input.usageGrant }),
-            secretEnvironment: input.secretEnvironment,
-            ...(input.personalInstructions === undefined
-                ? {}
-                : { personalInstructions: input.personalInstructions }),
-            ...(input.marAgentModel === undefined ? {} : { marAgentModel: input.marAgentModel }),
-            ...(input.marAgentModels === undefined ? {} : { marAgentModels: input.marAgentModels }),
-            ...(input.marAgentCompact === undefined ? {} : { marAgentCompact: input.marAgentCompact }),
-            ...(input.marAgentRuntimeScopeId === undefined
-                ? {}
-                : { marAgentRuntimeScopeId: input.marAgentRuntimeScopeId })
-        });
-        if (updated !== undefined && session !== undefined)
-            this.publishGoalState(session, updated);
-    }
-    handleNativeGoalUpdate(runId, nativeGoal) {
-        const pending = this.continuousRunCoordinator.pending(runId);
-        if (pending?.goal === undefined || !this.goalGenerationCurrent(pending.sessionId, pending.goal))
-            return;
-        const goal = this.goalRuntime.get(pending.sessionId);
-        if (nativeGoal.status === 'active') {
-            if ((nativeGoal.createdAt + 1) * 1_000 < goal.revisionStartedAt)
-                return;
-            const previous = this.nativeGoalBindings.get(goal.id);
-            if (previous !== undefined &&
-                previous.revision !== goal.revision &&
-                previous.threadId === nativeGoal.threadId &&
-                previous.createdAt === nativeGoal.createdAt &&
-                previous.objective === nativeGoal.objective)
-                return;
-            this.nativeGoalBindings.set(goal.id, {
-                revision: goal.revision,
-                threadId: nativeGoal.threadId,
-                createdAt: nativeGoal.createdAt,
-                objective: nativeGoal.objective
-            });
-            return;
-        }
-        const bound = this.nativeGoalBindings.get(goal.id);
-        if (bound?.revision !== goal.revision ||
-            bound.threadId !== nativeGoal.threadId ||
-            bound.createdAt !== nativeGoal.createdAt ||
-            bound.objective !== nativeGoal.objective)
-            return;
-        this.nativeGoalBindings.delete(goal.id);
-        const completed = this.goalRuntime.update(pending.sessionId, goal.id, goal.revision, 'completed');
-        this.retireGoalContinuation(pending.sessionId);
-        this.continuousRunCoordinator.removeGoalQueue(pending.sessionId);
-        const session = this.runtime.getAgentSession(pending.sessionId);
-        if (session !== undefined)
-            this.publishGoalState(session, completed);
-    }
-    beginGoalSubmission(sessionId, continuationEpoch = this.goalContinuationEpochs.get(sessionId) ?? 0) {
-        const attempt = { sessionId, epoch: continuationEpoch };
-        const attempts = this.goalSubmissionAttempts.get(sessionId) ?? new Set();
-        attempts.add(attempt);
-        this.goalSubmissionAttempts.set(sessionId, attempts);
-        return attempt;
-    }
-    finishGoalSubmissionAttempt(attempt) {
-        const attempts = this.goalSubmissionAttempts.get(attempt.sessionId);
-        attempts?.delete(attempt);
-        if (attempts?.size === 0)
-            this.goalSubmissionAttempts.delete(attempt.sessionId);
-    }
-    finishGoalContinuationAttempt(attempt) {
-        if (this.goalContinuationPending.get(attempt.sessionId) === attempt)
-            this.goalContinuationPending.delete(attempt.sessionId);
-        this.finishGoalSubmissionAttempt(attempt);
-    }
-    removeStaleGoalSubmission(sessionId, result) {
-        if (!isPlainRecord(result))
-            return;
-        if (typeof result.queueItemId === 'string') {
-            const item = this.runtime.getQueueItem(result.queueItemId);
-            if (item?.sessionId === sessionId)
-                this.continuousRunCoordinator.deleteQueueItem(item.id);
-            return;
-        }
-        if (!isPlainRecord(result.run) || typeof result.run.id !== 'string')
-            return;
-        const run = this.runtime.getRun(result.run.id);
-        if (run?.sessionId === sessionId && this.runtime.currentExecutionId(run.id) === undefined)
-            this.runEventBridge.emitRun(run.id, 'run.completed', { code: 'GOAL_SUBMISSION_STALE' }, 'INTERRUPTED');
-    }
-    async enqueueGoalContinuation(input) {
-        const attempt = this.beginGoalSubmission(input.sessionId, input.continuationEpoch);
-        const generation = { ...input.goal, epoch: attempt.epoch };
-        if (!this.goalGenerationCurrent(attempt.sessionId, generation)) {
-            this.finishGoalSubmissionAttempt(attempt);
-            return;
-        }
-        this.goalContinuationPending.set(input.sessionId, attempt);
-        try {
-            const result = await this.sessionMessageService.submitGoal({
-                sessionId: attempt.sessionId,
-                kind: 'continue',
-                content: this.goalRuntime.prompt(attempt.sessionId, 'continue'),
-                deliveryIntent: input.deliveryIntent ?? 'QUEUE',
-                goal: generation,
-                ...(input.initiatedByUserId === undefined
-                    ? {}
-                    : { initiatedByUserId: input.initiatedByUserId }),
-                ...(input.usageGrant === undefined ? {} : { usageGrant: input.usageGrant }),
-                secretEnvironment: input.secretEnvironment,
-                ...(input.personalInstructions === undefined
-                    ? {}
-                    : { personalInstructions: input.personalInstructions }),
-                ...(input.marAgentModel === undefined ? {} : { marAgentModel: input.marAgentModel }),
-                ...(input.marAgentModels === undefined ? {} : { marAgentModels: input.marAgentModels }),
-                ...(input.marAgentCompact === undefined ? {} : { marAgentCompact: input.marAgentCompact }),
-                ...(input.marAgentRuntimeScopeId === undefined
-                    ? {}
-                    : { marAgentRuntimeScopeId: input.marAgentRuntimeScopeId })
-            });
-            if (!this.goalGenerationCurrent(attempt.sessionId, generation)) {
-                this.removeStaleGoalSubmission(attempt.sessionId, result);
-                this.finishGoalContinuationAttempt(attempt);
-                return;
-            }
-            const retry = this.goalRetryTimers.get(attempt.sessionId);
-            if (retry !== undefined)
-                clearTimeout(retry.timer);
-            this.goalRetryTimers.delete(attempt.sessionId);
-            this.finishGoalContinuationAttempt(attempt);
-        }
-        catch (error) {
-            const failedAttempts = (input.failedAttempts ?? 0) + 1;
-            nodeLog('goal.continuation.enqueue.failed', {
-                sessionId: attempt.sessionId,
-                goalId: input.goal.id,
-                revision: input.goal.revision,
-                attempt: failedAttempts,
-                code: safeErrorCode(error, 'GOAL_CONTINUATION_ENQUEUE_FAILED')
-            });
-            if (!this.goalGenerationCurrent(attempt.sessionId, generation)) {
-                this.finishGoalContinuationAttempt(attempt);
-                return;
-            }
-            const session = this.runtime.getAgentSession(attempt.sessionId);
-            if (failedAttempts > 3 || session === undefined) {
-                this.clearGoalRetry(attempt.sessionId);
-                if (failedAttempts > 3) {
-                    const blocked = this.goalRuntime.blockAfterRuntimeFailure(attempt.sessionId, input.goal.id, input.goal.revision);
-                    this.nativeGoalBindings.delete(input.goal.id);
-                    this.continuousRunCoordinator.removeGoalQueue(attempt.sessionId);
-                    this.goalContinuationEpochs.delete(attempt.sessionId);
-                    this.finishIdleGoalRun(attempt.sessionId, 'FAILED');
-                    if (session !== undefined)
-                        this.publishGoalState(session, blocked);
-                }
-                return;
-            }
-            this.finishGoalContinuationAttempt(attempt);
-            const previousRetry = this.goalRetryTimers.get(attempt.sessionId);
-            if (previousRetry !== undefined)
-                clearTimeout(previousRetry.timer);
-            const retry = {
-                sessionId: attempt.sessionId,
-                timer: setTimeout(() => {
-                    if (!this.goalGenerationCurrent(retry.sessionId, generation))
-                        return;
-                    void this.enqueueGoalContinuation({
-                        ...input,
-                        sessionId: retry.sessionId,
-                        failedAttempts,
-                        continuationEpoch: attempt.epoch
-                    });
-                }, 15_000)
-            };
-            this.goalRetryTimers.set(attempt.sessionId, retry);
-            retry.timer.unref();
-        }
-    }
-    handleGoalPreparationFailed(session, goal, activated) {
-        if (!activated || !this.goalGenerationCurrent(session.id, goal))
-            return;
-        this.goalRuntime.clear(session.id);
-        this.finishIdleGoalRun(session.id, 'FAILED');
-        this.commandStates.set(session.id, this.pendingGoalCommandState());
-        this.emitWorkbenchEvent('session', {
-            session: this.sessionPresentationService.present(session)
-        });
-    }
-    finishIdleGoalRun(sessionId, status) {
-        const run = this.runtime.activeSessionRun(sessionId);
-        if (run === undefined || this.runtime.currentExecutionId(run.id) !== undefined)
-            return;
-        this.runEventBridge.emitRun(run.id, status === 'SUCCEEDED' ? 'run.completed' : 'run.failed', status === 'SUCCEEDED' ? {} : { code: 'GOAL_CONTINUATION_FAILED' }, status);
-    }
-    clearGoalState(sessionId, status) {
-        const goalExit = this.goalRuntime.exitSummary(sessionId, status);
-        const goal = this.goalRuntime.get(sessionId);
-        if (goal !== undefined)
-            this.nativeGoalBindings.delete(goal.id);
-        this.retireGoalContinuation(sessionId);
-        const removed = this.goalRuntime.clear(sessionId);
-        this.continuousRunCoordinator.removeGoalQueue(sessionId);
-        const commandState = this.commandStates.get(sessionId, 'goal');
-        if (commandState !== undefined)
-            this.commandStates.clear(sessionId, 'goal');
-        if (!removed && commandState === undefined)
-            return goalExit;
-        const session = this.runtime.getAgentSession(sessionId);
-        if (session !== undefined)
-            this.emitWorkbenchEvent('session', {
-                session: this.sessionPresentationService.present(session)
-            });
-        return goalExit;
-    }
-    prepareGoalSession(session) {
-        const access = goalUnrestrictedAccess(session.runner, session.access);
-        const requiresUpdate = session.access !== access;
-        const changed = session.runner !== 'mar-agent' && requiresUpdate;
-        const prepared = requiresUpdate
-            ? this.runtime.updateAgentSessionAccess(session.id, access)
-            : session;
-        if (changed &&
-            prepared.externalSessionId !== null &&
-            prepared.model !== null &&
-            prepared.effort !== null)
-            this.database?.saveNativeSessionMetadata({
-                runner: prepared.runner,
-                externalSessionId: prepared.externalSessionId,
-                workspaceId: prepared.workspaceId,
-                model: prepared.model,
-                effort: prepared.effort,
-                access
-            });
-        return { session: prepared, changed };
-    }
-    pendingGoalCommandState() {
-        return {
-            commandId: 'goal',
-            active: true,
-            label: 'Goal',
-            detail: null,
-            closable: true,
-            closeInput: '/goal --clear'
-        };
-    }
     stop(options = {}) {
         if (this.stopping !== undefined)
             return this.stopping;
         this.stopped = true;
         this.continuousRunCoordinator.suspend();
+        this.goalCoordinator.freeze();
         this.scheduledSessions.stop();
         this.stopping = (async () => {
             let snapshot;
@@ -2219,43 +1609,18 @@ export class NodeConnector {
         this.recentRunProjectionService.dispose();
         this.upgradeCoordinator.stop();
         this.connectionLifecycle.stop();
-        for (const approval of this.claudeClient.execution.approvals.values()) {
-            clearTimeout(approval.timer);
-            approval.resolve('REJECTED');
-        }
-        this.claudeClient.execution.approvals.clear();
-        for (const pending of this.claudeClient.execution.userInputs.values()) {
-            clearTimeout(pending.timer);
-            pending.reject('NODE_STOPPED');
-        }
-        this.claudeClient.execution.userInputs.clear();
         this.nativeSessionWatchService.clear();
         this.promptCompletion.dispose();
         this.sessionIdentityService.dispose();
         this.sessionLifecycleService.clear();
         this.continuousRunCoordinator.clear();
         this.gitOperationService.clear();
-        for (const retry of this.goalRetryTimers.values())
-            clearTimeout(retry.timer);
-        this.goalRetryTimers.clear();
-        this.goalContinuationPending.clear();
-        this.goalSubmissionAttempts.clear();
-        this.goalContinuationEpochs.clear();
+        this.goalCoordinator.dispose();
         this.runEventService.clear();
         this.sessionContextService.dispose();
-        for (const run of this.claudeClient.execution.runs.values())
-            run.handle.cancel();
-        this.claudeClient.execution.runs.clear();
         this.runAttachmentService.dispose();
         const marAgentDrain = this.marAgentRunController.dispose();
-        const conversationHostingMaintenanceDrain = this.conversationHostingMaintenanceService?.dispose();
-        this.conversationHostingMaintenanceService = undefined;
-        this.hostedConversationService?.dispose();
-        this.hostedConversationService = undefined;
-        const hostedConversationRuntime = this.hostedConversationRuntime;
-        this.hostedConversationRuntime = undefined;
-        this.hostedConversationOperations = undefined;
-        this.conversationHostingMaintenanceOperations = undefined;
+        const conversationHostingDrain = this.conversationHosting.dispose();
         const uploadDrain = this.workspaceUploadService.shutdown();
         this.workspaceFileService.dispose();
         this.workspaceWatchService.clearAll();
@@ -2271,7 +1636,7 @@ export class NodeConnector {
         this.terminalChannel.stop();
         this.runtimeCredentials.close();
         this.chatgptLogins.close();
-        this.scheduledSessions.stop();
+        const scheduledDrain = this.scheduledSessions.stop();
         this.scheduledRunAuthorization.close();
         this.restartAuthorization.close();
         this.mailNotificationControl.close();
@@ -2281,8 +1646,8 @@ export class NodeConnector {
         this.directTransferService = undefined;
         this.controlChannel.stop();
         const database = this.database;
-        this.database = undefined;
         const drains = Promise.allSettled([
+            scheduledDrain,
             marAgentDrain,
             runnerDrain,
             terminalDrain,
@@ -2295,11 +1660,11 @@ export class NodeConnector {
         return (async () => {
             let failed;
             try {
-                await conversationHostingMaintenanceDrain;
+                await conversationHostingDrain;
             }
             finally {
-                await hostedConversationRuntime?.dispose().catch(() => undefined);
                 const results = await drains;
+                this.database = undefined;
                 await this.gitExecutionService?.close();
                 this.usageOutbox?.disconnected();
                 this.usageOutbox = undefined;
@@ -2313,97 +1678,9 @@ export class NodeConnector {
     }
     /** @internal Thin compatibility delegates; all behavior remains in the extracted services. */
     handleMessage = (raw) => this.controlMessages.handle(raw);
-    publishApprovalForRun = (input) => {
-        const run = this.runtime.getRun(this.runtime.canonicalRunId(input.runId));
-        if (run?.source !== 'SCHEDULED') {
-            this.runEventBridge.publishApproval(input);
-            return;
-        }
-        this.runEventBridge.emitRun(input.runId, 'approval.request', input);
-        queueMicrotask(() => {
-            try {
-                this.runtime.decideApproval(input.approvalId, 'APPROVED');
-                this.runEventBridge.emitRun(input.runId, 'approval.decided', {
-                    approvalId: input.approvalId,
-                    decision: 'APPROVED',
-                    source: 'SCHEDULED'
-                });
-                this.runners.decideApproval({
-                    runId: input.runId,
-                    approvalId: input.approvalId,
-                    decision: 'APPROVED'
-                });
-            }
-            catch {
-                // A cancelled execution cannot receive an approval after its pending request expires.
-            }
-        });
-    };
-    emitScheduledNotification = (task, occurrenceId, code, status) => this.publishScheduledTaskNotification(task, occurrenceId, {
-        kind: status === 'FAILED' ? 'SCHEDULE_FAILED' : 'SCHEDULE_SKIPPED',
-        code
-    });
-    publishScheduledTaskNotification = (task, occurrenceId, event) => {
-        const occurredAt = Date.now();
-        const recipient = (this.database === undefined
-            ? undefined
-            : new ScheduledSessionStore(this.database.raw).getById(task.id))?.ownerUserId ?? task.ownerUserId;
-        const session = this.runtime.getAgentSession(task.sessionId);
-        this.emitWorkbenchEvent('conversation', {
-            event: {
-                runId: event.kind === 'SCHEDULE_TERMINAL' ? event.runId : occurrenceId,
-                sequence: 1,
-                eventType: 'notification',
-                payload: {
-                    targetType: 'WORKSPACE_SESSION',
-                    userId: recipient,
-                    workspaceId: task.workspaceId,
-                    sessionId: task.sessionId,
-                    sessionTitle: session?.customTitle ?? session?.runnerTitle ?? task.sessionId,
-                    runId: event.kind === 'SCHEDULE_TERMINAL' ? event.runId : occurrenceId,
-                    notificationId: event.kind === 'SCHEDULE_TERMINAL'
-                        ? `schedule-terminal:${task.id}:${occurrenceId}`
-                        : `schedule:${task.id}:${occurrenceId}`,
-                    ...event,
-                    occurredAt
-                },
-                createdAt: occurredAt
-            }
-        });
-    };
-    emitScheduledProposalNotification = (sessionId, proposalId) => {
-        if (this.database === undefined)
-            return;
-        const task = new ScheduledSessionStore(this.database.raw).get(sessionId);
-        if (task === undefined)
-            return;
-        const occurredAt = Date.now();
-        const session = this.runtime.getAgentSession(sessionId);
-        this.emitWorkbenchEvent('conversation', {
-            event: {
-                runId: proposalId,
-                sequence: 1,
-                eventType: 'notification',
-                payload: {
-                    targetType: 'WORKSPACE_SESSION',
-                    userId: task.ownerUserId,
-                    workspaceId: task.workspaceId,
-                    sessionId,
-                    sessionTitle: session?.customTitle ?? session?.runnerTitle ?? sessionId,
-                    runId: proposalId,
-                    notificationId: `schedule-proposal:${task.id}:${proposalId}`,
-                    kind: 'SCHEDULE_PROPOSAL',
-                    occurredAt
-                },
-                createdAt: occurredAt
-            }
-        });
-    };
     emitRunEvent = (runId, eventType, payload, status) => this.runEventBridge.emitRun(runId, eventType, payload, status);
     emitConversationItem = (runId, item) => {
-        if (this.continuousRunCoordinator.pending(runId)?.goal !== undefined &&
-            isGoalProgressItem(item))
-            this.goalExecutionProgress.add(runId);
+        this.goalCoordinator.executionProgress(runId, item);
         this.runEventBridge.emitConversationItem(runId, item);
     };
     emitConversationTurn = (turn) => {
@@ -2483,33 +1760,6 @@ export class NodeConnector {
         });
         return this.gitExecutionService;
     }
-    publishGoalState(session, goal) {
-        if (goal.status !== 'active') {
-            this.commandStates.clear(session.id, 'goal');
-            this.emitWorkbenchEvent('session', {
-                session: this.sessionPresentationService.present(session)
-            });
-            return;
-        }
-        this.commandStates.set(session.id, {
-            commandId: 'goal',
-            active: goal.status === 'active',
-            label: 'Goal',
-            detail: goal.objective.slice(0, 500),
-            closable: true,
-            closeInput: '/goal',
-            goal: {
-                id: goal.id,
-                objective: goal.objective,
-                revision: goal.revision,
-                status: goal.status,
-                turns: goal.turns
-            }
-        });
-        this.emitWorkbenchEvent('session', {
-            session: this.sessionPresentationService.present(session)
-        });
-    }
     send(type, payload, replyTo) {
         this.controlChannel.send(type, payload, replyTo);
     }
@@ -2517,20 +1767,3 @@ export class NodeConnector {
         this.controlChannel.sendEnvelope(envelope);
     }
 }
-const goalReadToolNames = new Set([
-    `${NODE_MCP.goal.name}.${NODE_MCP.goal.tools.get}`,
-    `${NODE_MCP.goal.name}_${NODE_MCP.goal.tools.get}`,
-    `mcp__${NODE_MCP.goal.name}__${NODE_MCP.goal.tools.get}`
-]);
-function isGoalProgressItem(item) {
-    if (!isPlainRecord(item) || typeof item.kind !== 'string')
-        return false;
-    if (item.kind === 'command_execution' || item.kind === 'file_change')
-        return true;
-    if (item.kind !== 'tool_call' || !isPlainRecord(item.payload))
-        return false;
-    const toolName = item.payload.toolName;
-    return (typeof toolName === 'string' &&
-        !goalReadToolNames.has(toolName) &&
-        !(item.payload.namespace === NODE_MCP.goal.name && toolName === NODE_MCP.goal.tools.get));
-}