@myagentroam/node 0.11.35 → 0.11.37

package/dist/connector.js

@@ -1,5 +1,12 @@
+import { composeWorkspaceApplication } from './application/workspace-application.js';
+import { composeSessionProjection } from './application/session-projection-composition.js';
+import { composeWorkspaceResources } from './application/workspace-composition.js';
+import { composeRunners } from './application/runner-composition.js';
+import { ExecutionLifecycle } from './application/execution-lifecycle.js';
+import { NodeOperationAdmission } from './application/node-operation-admission.js';
 import { normalizeMarAgentUsage } from './runner/mar-agent/conversation-normalizer.js';
-import { isImageAttachment } from './util/node-operation-parsers.js';
+import { NodeLifecycle } from './application/node-lifecycle.js';
+import { isImageAttachment } from './session/attachments.js';
 import { ModelUsageOutbox } from './service/model-usage-outbox.js';
 import { NodeModelUsageService } from './service/model-usage-service.js';
 import { dirname, resolve } from 'node:path';
@@ -7,7 +14,7 @@ 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 { resolveWorkspaceExecutionDirectory } from './workspace.js';
+import { resolveWorkspaceExecutionDirectory } from './workspace/path-access.js';
 import { detectCapabilitiesAsync, unavailableCapabilities } from './capabilities.js';
 import { NodeDatabase } from './database.js';
 import { TerminalManager } from './terminal.js';
@@ -17,59 +24,43 @@ import { GoalRuntime } from './service/goal-runtime.js';
 import { GoalContinuationCoordinator } from './service/goal-continuation-coordinator.js';
 import { GoalMcpBridge } from './service/goal-mcp-bridge.js';
 import { RunnerUsageReader } from './runner-usage.js';
-import { ClaudeCodeRunner } from './runner/claude-code-runner.js';
 import { ClaudeManagedRunController } from './runner/claude/managed-run-controller.js';
-import { CodexRunner } from './runner/codex-runner.js';
 import { CodexManagedRunController } from './runner/codex/managed-run-controller.js';
-import { FakeTestRunner } from './runner/fake-test-runner.js';
-import { RunnerRegistry } from './runner/runner-registry.js';
-import { OpenCodeRunner } from './runner/opencode-runner.js';
-import { MarAgentRunner } from './runner/mar-agent-runner.js';
 import { MarAgentManagedRunController } from './runner/mar-agent/managed-run-controller.js';
 import { PyAutoGuiComputerUseProvider } from './runner/mar-agent/computer-use.js';
 import { ManagedComputerUseRuntime } from './computer-use-runtime.js';
 import { OpenCodeManagedRunController } from './runner/opencode/managed-run-controller.js';
-import { NodeOperationRouter } from './connector/node-operation-router.js';
+import { NodeOperationRouter } from './connection/node-operation-router.js';
 import { SkillNodeOperationService } from './service/skill-node-operation-service.js';
 import { McpNodeOperationService } from './service/mcp-node-operation-service.js';
 import { RunnerService } from './service/runner-service.js';
 import { TerminalService } from './service/terminal-service.js';
 import { GitExecutionService } from './service/git-execution-service.js';
 import { GitOperationService } from './service/git-operation-service.js';
-import { WorkspaceService } from './service/workspace-service.js';
-import { WorkspaceWatchService } from './service/workspace-watch-service.js';
-import { WorkspaceFileService } from './service/workspace-file-service.js';
-import { WorkspaceUploadService } from './service/workspace-upload-service.js';
-import { DirectTransferService } from './service/direct-transfer-service.js';
-import { WorkspaceChangeService } from './service/workspace-change-service.js';
-import { WorkspaceSessionService } from './service/workspace-session-service.js';
+import { DirectTransferService } from './connection/direct-transfer-service.js';
+import { WorkspaceChangeService } from './workspace/workspace-change-service.js';
 import { WorkbenchEventService } from './service/workbench-event-service.js';
-import { RunDomainState } from './service/run-domain-state.js';
 import { RecentRunProjectionService } from './service/recent-run-projection-service.js';
 import { sessionGroupChangedSchema } from '@myagentroam/protocol';
-import { SessionDomainState } from './service/session-domain-state.js';
 import { RunEventService } from './service/run-event-service.js';
 import { RunAttachmentService } from './service/run-attachment-service.js';
 import { NodeTerminalChannel } from './service/node-terminal-channel.js';
-import { WorkspaceWorkbenchService } from './service/workspace-workbench-service.js';
 import { NativeSessionWatchService } from './service/native-session-watch-service.js';
 import { SessionWatchSlotCoordinator } from './service/session-watch-slot-coordinator.js';
-import { SessionContextService } from './service/session-context-service.js';
-import { WorkspaceDomainState } from './service/workspace-domain-state.js';
+import { SessionContextService } from './session/session-context-service.js';
 import { RunWorkbenchService } from './service/run-workbench-service.js';
-import { SessionQueryService } from './service/session-query-service.js';
+import { SessionQueryService } from './session/session-query-service.js';
 import { marctlSessionProgress } from './service/session-recent-activity.js';
-import { WorkspaceQueueWorkbenchService } from './service/workspace-queue-workbench-service.js';
+import { WorkspaceQueueWorkbenchService } from './workspace/workspace-queue-workbench-service.js';
 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 { SessionIdentityService } from './session/session-identity-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 { SessionLifecycleService } from './session/session-lifecycle-service.js';
 import { ExternalSessionResumeService } from './service/external-session-resume-service.js';
-import { SessionMessageService } from './service/session-message-service.js';
-import { SessionScheduleService } from './service/session-schedule-service.js';
+import { SessionMessageService } from './session/session-message-service.js';
+import { SessionScheduleService } from './session/session-schedule-service.js';
 import { ScheduledSessionCoordinator } from './service/scheduled-session-coordinator.js';
 import { ScheduledSessionStore } from './service/scheduled-session-store.js';
 import { RunAuthorizationControl } from './service/run-authorization-control.js';
@@ -78,20 +69,20 @@ import { RestartSessionRestorer } from './service/restart-session-restorer.js';
 import { ScheduleMcpBridge } from './service/schedule-mcp-bridge.js';
 import { MailNotificationControl } from './service/mail-notification-control.js';
 import { NotificationMcpBridge, resolveNotificationCapability } from './service/notification-mcp-bridge.js';
-import { SessionCatalogService } from './service/session-catalog-service.js';
-import { SessionCommandService } from './service/session-command-service.js';
-import { SessionPresentationService, sessionGroup } from './service/session-presentation-service.js';
-import { isPlainRecord, isRunnerImageAttachment, parseRunnerImageAttachments } from './util/node-operation-parsers.js';
+import { SessionCatalogService } from './session/session-catalog-service.js';
+import { SessionCommandService } from './session/session-command-service.js';
+import { sessionGroup } from './session/session-presentation-service.js';
+import { isPlainRecord } from './util/records.js';
+import { isRunnerImageAttachment, parseRunnerImageAttachments } from './session/attachments.js';
 import { WebToolService } from './service/web-tool-service.js';
 import { ModelResourcePublicationService } from './service/model-resource-publication-service.js';
-export { nodeConnectEndpoint, validatedCapabilities } from './util/node-operation-parsers.js';
+export { nodeConnectEndpoint, validatedCapabilities } from './connection/endpoints.js';
 import { NodeControlChannel } from './service/node-control-channel.js';
 import { NodeControlMessageService } from './service/node-control-message-service.js';
 import { NodeRequestService } from './service/node-request-service.js';
 import { WorkbenchManifestService } from './service/workbench-manifest-service.js';
 import { NodeRunEventBridge } from './service/node-run-event-bridge.js';
 import { workbenchPayloadSessionId } from './service/workbench-event-projection.js';
-import { NodeWorkspaceCoordinator } from './service/node-workspace-coordinator.js';
 import { FakeManagedRunService } from './service/fake-managed-run-service.js';
 import { RunnerChannelMessageService } from './service/runner-channel-message-service.js';
 import { ManagedRunnerSessionService } from './service/managed-runner-session-service.js';
@@ -175,7 +166,8 @@ export class NodeConnector {
     scheduledRunAuthorization;
     restartAuthorization;
     restartHandoff;
-    inFlightOperations = new Set();
+    operationAdmission;
+    executionLifecycle;
     pendingSessionGroups = new Map();
     mailNotificationControl = new MailNotificationControl((envelope) => this.sendEnvelope(envelope));
     scheduledSessions;
@@ -194,12 +186,25 @@ export class NodeConnector {
             throw new Error('NODE_CONFIG_UNAVAILABLE');
         return nodeDataDirectory(this.config, this.configPath);
     });
-    /** @internal Existing contract tests inject their socket through this boundary. */
-    set socket(value) {
-        this.controlChannel.replaceSocketForTesting(value);
+    lifecycle = new NodeLifecycle(() => this.startResources(), () => {
+        this.continuousRunCoordinator.suspend();
+        this.goalCoordinator.freeze();
+        this.scheduledSessions.stop();
+    }, {
+        waitForRecovery: () => this.restartHandoff.wait(),
+        drainInput: async () => {
+            this.sessionMessageService.setAccepting(false);
+            await this.operationAdmission.drain();
+            await this.sessionMessageService.drain();
+        },
+        closeResume: () => this.externalSessionResumeService.close(),
+        capture: () => (this.config?.nodeId ? this.restartHandoff.capture() : undefined),
+        dispose: () => this.disposeRuntime(),
+        publish: (snapshot) => this.restartHandoff.publish(snapshot)
+    });
+    get stopped() {
+        return this.lifecycle.stopped;
     }
-    stopped = false;
-    stopping;
     config;
     capabilitiesProvided;
     capabilities;
@@ -224,10 +229,8 @@ export class NodeConnector {
     });
     fakeRunner;
     fakeScript;
-    runState = new RunDomainState();
     runEventBridge;
     workspaceCoordinator;
-    sessionState = new SessionDomainState();
     sessionIdentityService;
     nativeSessionProjectionService;
     conversationHistoryService;
@@ -311,30 +314,33 @@ export class NodeConnector {
     runnerUsageReader;
     terminalManager;
     upgradeCoordinator;
-    workspaceState = new WorkspaceDomainState();
-    workspaceWatchService = new WorkspaceWatchService(this.workspaceState, (workspaceId) => this.workspaceSessionService.ensureWatch(workspaceId), (workspaceId) => this.workspaceSessionService.stopWatch(workspaceId), (workspaceId) => this.workspaceWorkbenchService?.releaseWorkspace(workspaceId), (watch) => this.workspaceWorkbenchService?.cancelFilePrewarm(watch));
-    workspaceSessionService = new WorkspaceSessionService(this.workspaceState, {
+    workspaceResources = composeWorkspaceResources({
         discover: (workspaceId, onRunnerDiscovered) => this.discoverWorkspaceSessions(workspaceId, onRunnerDiscovered),
         listPage: (workspaceId) => this.executeNodeOperation('session.list', { workspaceId, limit: 30 }),
-        active: (workspaceId) => this.workspaceWatchService.topicActive(workspaceId, 'sessions'),
-        invalidate: (workspaceId) => void this.workspaceWorkbenchService?.invalidateTopic(workspaceId, 'sessions')
+        invalidateSessions: (workspaceId) => void this.workspaceWorkbenchService?.invalidateTopic(workspaceId, 'sessions'),
+        invalidateFiles: (workspaceId) => {
+            this.workspaceWorkbenchService?.invalidateWorkspaceFiles(workspaceId);
+            this.workspaceCoordinator.invalidate(workspaceId);
+        },
+        releaseWatch: (workspaceId) => this.workspaceWorkbenchService?.releaseWorkspace(workspaceId),
+        removeWatch: (watch) => this.workspaceWorkbenchService?.cancelFilePrewarm(watch),
+        temporaryRoot: () => this.attachmentTemporaryRoot(),
+        attachmentResource: (id, path) => this.runAttachmentService.fileResource(id, path)
     });
-    invalidateWorkspaceFiles = (workspaceId) => {
-        this.workspaceFileService.dispose(workspaceId);
-        this.workspaceWorkbenchService?.invalidateWorkspaceFiles(workspaceId);
-        this.workspaceCoordinator.invalidate(workspaceId);
-    };
-    workspaceFileService = new WorkspaceFileService(this.workspaceState, this.invalidateWorkspaceFiles, {}, (workspaceId, resourcePath) => this.workspaceUploadService.fileResource(workspaceId, resourcePath) ??
-        this.runAttachmentService.fileResource(workspaceId, resourcePath));
-    workspaceUploadService = new WorkspaceUploadService(this.workspaceState, this.invalidateWorkspaceFiles, () => this.attachmentTemporaryRoot());
+    workspaceWatchService = this.workspaceResources.watch;
+    workspaceSessionService = this.workspaceResources.sessions;
+    workspaceFileService = this.workspaceResources.files;
+    workspaceUploadService = this.workspaceResources.uploads;
+    invalidateWorkspaceFiles = this.workspaceResources.invalidateFiles;
     directTransferService;
     attachmentTemporaryRoot() {
         if (this.config === undefined)
             throw new Error('NODE_CONFIG_UNAVAILABLE');
         return resolve(nodeDataDirectory(this.config, this.configPath), 'temp-files');
     }
-    workspaceChangeService = new WorkspaceChangeService(this.workspaceState);
+    workspaceChangeService = new WorkspaceChangeService();
     workspaceWorkbenchService;
+    publishWorkspaceSession;
     database;
     recentRunProjectionService = new RecentRunProjectionService((message) => this.send('recent-runs', message));
     /** Runtime/session state is intentionally not persisted to Node SQLite. */
@@ -355,53 +361,23 @@ export class NodeConnector {
     runEventService = new RunEventService({
         runtime: this.runtime,
         metrics: this.metrics,
-        state: this.runState,
         isBootstrapSession: (sessionId) => this.sessionIdentityService.bootstrapIds.has(sessionId),
         presentSession: (session) => this.sessionPresentationService.present(session),
         rejectBootstrap: (sessionId, code) => this.sessionIdentityService.reject(sessionId, code),
-        emitWorkbench: (category, payload) => {
-            if (category === 'conversation' && isPlainRecord(payload) && 'turn' in payload)
-                this.emitConversationTurn(payload.turn);
-            else
-                this.publishWorkbenchEvent(category, payload);
-        },
+        emitWorkbench: (category, payload) => this.publishWorkbenchEvent(category, payload),
         cleanupAttachments: (runId) => this.runAttachmentService.cleanup(runId),
         refreshAttachments: (sessionId) => this.runAttachmentService.refreshSession(sessionId),
         expireImages: (runId) => this.runAttachmentService.expire(runId),
         scheduleContextRefresh: (sessionId) => this.sessionContextService.schedule(sessionId),
         refreshWorkspaceSessions: (workspaceId) => this.workspaceWorkbenchService.ensureTopicSnapshot(workspaceId, 'sessions'),
-        onTerminalRun: (run, status) => {
-            if (this.database !== undefined)
-                this.scheduledSessions.executionTerminated(run, status);
-            this.continuousRunCoordinator.runTerminated(run.sessionId);
-        },
-        dispatchQueue: async (sessionId, delayMs = 0) => {
-            if (this.upgradeCoordinator.pending())
-                return;
-            if (delayMs > 0) {
-                this.continuousRunCoordinator.schedule(sessionId, delayMs);
-                return;
-            }
-            await this.continuousRunCoordinator.dispatch(sessionId);
-        },
+        onTerminalRun: (run, status) => this.executionLifecycle.terminal(run, status),
+        dispatchQueue: (sessionId, delayMs) => this.executionLifecycle.dispatchQueue(sessionId, delayMs),
         executionStarted: (executionId) => this.continuousRunCoordinator.executionStarted(executionId),
-        keepRunActive: (sessionId) => this.goalCoordinator.keepRunActive(sessionId),
-        executionTerminating: (executionId, status, permissionStop) => {
-            this.gitOperationService.executionFinished(executionId);
-            this.goalCoordinator.executionTerminating(executionId, status, permissionStop);
-        },
-        releaseExecution: (executionId) => {
-            this.modelUsage.release(executionId);
-            this.goalCoordinator.releaseExecution(executionId);
-            this.revokeExecutionMcps(executionId);
-            this.continuousRunCoordinator.remove(executionId);
-        }
+        acceptExecutionTerminal: (input) => this.continuousRunCoordinator.acceptExecutionTerminal(input),
+        publishGoalUpdate: ({ session, goal }) => this.goalCoordinator.publishGoalState(session, goal),
+        publishQueueChange: (sessionId) => this.continuousRunCoordinator.publish(sessionId),
+        releaseExecution: (executionId) => this.executionLifecycle.release(executionId)
     });
-    revokeExecutionMcps(executionId) {
-        this.goalMcpBridge.revoke(executionId);
-        this.scheduleMcpBridge.revoke(executionId);
-        this.notificationMcpBridge.revoke(executionId);
-    }
     sessionWatchSlots = new SessionWatchSlotCoordinator();
     nativeSessionWatchService = new NativeSessionWatchService({
         resolve: async (sessionId) => this.runtime.getAgentSession(sessionId) ??
@@ -483,7 +459,7 @@ export class NodeConnector {
             if (this.config === undefined)
                 throw new Error('NODE_CONFIG_UNAVAILABLE');
             return nodeUpgradeRequestPath(nodeDatabasePath(this.config, this.configPath));
-        }, () => this.runState.active.size, (status) => {
+        }, () => this.runtime.activeExecutionCount(), (status) => {
             this.capabilities = {
                 ...this.capabilities,
                 metadata: upgradeMetadata(this.capabilities.metadata, status)
@@ -506,8 +482,8 @@ export class NodeConnector {
             }));
         };
         this.reconnect = options.reconnect ?? true;
-        this.fakeRunner =
-            options.fakeRunner === undefined ? undefined : new FakeTestRunner(options.fakeRunner);
+        const composedRunners = composeRunners(options);
+        this.fakeRunner = composedRunners.fake;
         this.fakeScript = options.fakeScript;
         this.runAttachmentService = new RunAttachmentService((session) => this.runners.require(session.runner).nativeImageRoots(session), (sessionId) => this.runtime.activeSessionRun(sessionId) !== undefined ||
             this.runtime.sessionQueue(sessionId).itemIds.length > 0, () => this.attachmentTemporaryRoot());
@@ -525,18 +501,17 @@ export class NodeConnector {
                 return url.protocol === 'http:' || url.protocol === 'https:' ? url.origin : undefined;
             }
         });
-        this.codexClient = new CodexRunner(options.codexClient, options.codexProfileClientFactory, options.codexRunClientFactory);
+        this.codexClient = composedRunners.codex;
         this.codexRunController = new CodexManagedRunController(this.codexClient, {
             available: () => this.capabilities.codex.available,
             intercepted: () => this.fakeRunner !== undefined,
-            active: this.runState.active,
-            addActive: (runId) => this.runState.active.add(runId),
-            removeActive: (runId) => this.runState.active.delete(runId),
+            isExecutionActive: (runId) => this.runtime.isExecutionActive(runId),
+            executionAccepted: (runId) => this.runtime.executionAccepted(runId),
             adopt: (input) => this.runtime.adoptRun(input),
             session: (sessionId) => this.runtime.getAgentSession(sessionId),
             runStatus: (runId) => this.runtime.getRun(runId)?.status,
             run: (runId) => this.runtime.getRun(runId),
-            interrupted: (runId) => this.runState.interruptRequested.has(runId),
+            interrupted: (runId) => this.runtime.isExecutionInterruptRequested(runId),
             parseAttachments: parseRunnerImageAttachments,
             materialize: (runId, attachments) => this.runAttachmentService.materializeCodex(runId, attachments),
             completeCancelled: (runId) => this.runnerInteractionService.completeCancelledRun(runId),
@@ -562,9 +537,9 @@ export class NodeConnector {
             })
         });
         this.codexClient.onNotification((notification) => this.codexRunController.handleNotification(notification));
-        this.claudeClient = new ClaudeCodeRunner(options.claudeClient);
-        this.openCodeClient = new OpenCodeRunner(options.openCodeClient);
-        this.marAgentClient = new MarAgentRunner();
+        this.claudeClient = composedRunners.claude;
+        this.openCodeClient = composedRunners.openCode;
+        this.marAgentClient = composedRunners.marAgent;
         this.marAgentClient.setGeneratedImageRegistrar((session, images) => this.runAttachmentService.registerNative(session, images));
         this.computerUseProvider = new PyAutoGuiComputerUseProvider(() => {
             if (this.config?.computerUse?.enabled !== true)
@@ -588,7 +563,8 @@ export class NodeConnector {
         this.marAgentRunController = new MarAgentManagedRunController(this.marAgentClient, {
             createApproval: (input) => this.runtime.createApproval(input),
             publishApproval: (input) => this.runnerInteractionService.publishApproval(input),
-            active: this.runState.active,
+            isExecutionActive: (runId) => this.runtime.isExecutionActive(runId),
+            executionAccepted: (runId) => this.runtime.executionAccepted(runId),
             adopt: (input) => this.runtime.adoptRun(input),
             promote: (sessionId, nativeSessionId) => this.sessionIdentityService.promote(sessionId, nativeSessionId),
             customTitle: (sessionId) => this.runtime.getAgentSession(sessionId)?.customTitle,
@@ -632,7 +608,8 @@ export class NodeConnector {
         this.marAgentClient.setSessionResourceReleaser((sessionId) => this.marAgentRunController.releaseSession(sessionId));
         this.openCodeRunController = new OpenCodeManagedRunController(this.openCodeClient, {
             intercepted: () => this.fakeRunner !== undefined,
-            active: this.runState.active,
+            isExecutionActive: (runId) => this.runtime.isExecutionActive(runId),
+            executionAccepted: (runId) => this.runtime.executionAccepted(runId),
             parseAttachments: parseRunnerImageAttachments,
             persistAttachments: async (_cwd, runId, attachments) => {
                 const run = this.runtime.getRun(runId);
@@ -668,7 +645,8 @@ export class NodeConnector {
         }, this.claudeApprovalTimeoutMs);
         this.claudeRunController = new ClaudeManagedRunController(this.claudeClient, {
             intercepted: () => this.fakeRunner !== undefined,
-            active: this.runState.active,
+            isExecutionActive: (runId) => this.runtime.isExecutionActive(runId),
+            executionAccepted: (runId) => this.runtime.executionAccepted(runId),
             parseAttachments: parseRunnerImageAttachments,
             emit: (runId, eventType, payload, status) => this.runEventBridge.emitRun(runId, eventType, payload, status),
             adopt: (input) => this.runtime.adoptRun(input),
@@ -689,19 +667,12 @@ export class NodeConnector {
             clearCommandState: (sessionId, commandId) => this.commandStates.clear(sessionId, commandId),
             commandStates: (sessionId) => this.commandStates.list(sessionId)
         });
-        this.runners = new RunnerRegistry([
-            this.openCodeClient,
-            this.marAgentClient,
-            this.codexClient,
-            this.claudeClient,
-            ...(this.fakeRunner === undefined ? [] : [this.fakeRunner])
-        ]);
+        this.runners = composedRunners.registry;
         this.managedRunnerSessions = new ManagedRunnerSessionService(this.runtime, this.runners, (session) => this.emitSessionWorkbenchEvent({
             session: this.sessionPresentationService.present(session)
         }));
         this.runnerInteractionService = new RunnerInteractionService({
             runtime: this.runtime,
-            state: this.runState,
             codex: () => this.codexClient,
             settleCodexUsage: (runId, turnId) => this.codexRunController.settleUsage(runId, turnId),
             claude: () => this.claudeClient,
@@ -715,26 +686,17 @@ export class NodeConnector {
             interactions: this.runnerInteractionService,
             send: (type, payload, replyTo) => this.send(type, payload, replyTo)
         });
-        this.sessionPresentationService = new SessionPresentationService({
-            database: () => this.database,
-            runtime: this.runtime,
-            commands: this.commandStates,
-            runners: this.runners,
-            capabilities: () => this.capabilities,
-            hasManagedActiveRun: (session) => hasManagedActiveRun(this.runtime, session),
-            projectionForNative: (session) => this.nativeSessionProjectionService.projectionForNative(session)
-        });
-        this.nativeSessionProjectionService = new NativeSessionProjectionService({
+        const sessionProjection = composeSessionProjection({
             database: () => this.database,
             nodeId: () => this.config?.nodeId ?? 'recorded-session',
             runtime: this.runtime,
             runners: this.runners,
             capabilities: () => this.capabilities,
-            state: this.sessionState,
             commands: this.commandStates,
-            releaseResumeState: (directIds, projectionIds) => this.externalSessionResumeService.forgetSessions(directIds, projectionIds),
-            present: (session) => this.sessionPresentationService.present(session)
+            releaseResumeState: (directIds, projectionIds) => this.externalSessionResumeService.forgetSessions(directIds, projectionIds)
         });
+        this.sessionPresentationService = sessionProjection.presentation;
+        this.nativeSessionProjectionService = sessionProjection.native;
         this.conversationHistoryService = new ConversationHistoryService({
             runtime: this.runtime,
             runners: this.runners,
@@ -765,7 +727,7 @@ export class NodeConnector {
             },
             emitRun: (runId, eventType, payload, status) => this.runEventBridge.emitRun(runId, eventType, payload, status),
             control: (operation, payload) => this.controlMessages.handle(JSON.stringify(createEnvelope(operation, payload))),
-            markInterrupted: (runId) => this.runState.interruptRequested.add(runId)
+            markInterrupted: (runId) => this.runtime.requestExecutionInterrupt(runId)
         });
         this.sessionQueryService = new SessionQueryService({
             queuedCount: (sessionId) => this.workspaceQueueWorkbenchService.queuedCount(sessionId),
@@ -843,7 +805,12 @@ export class NodeConnector {
             emitConversation: (turn) => this.emitConversationTurn(turn),
             control: (operation, payload) => this.controlMessages.handle(JSON.stringify(createEnvelope(operation, payload))),
             stopped: () => this.stopped,
-            markInterrupted: (runId) => this.runState.interruptRequested.add(runId),
+            markInterrupted: (runId) => this.runtime.requestExecutionInterrupt(runId),
+            keepRunActive: (sessionId) => this.goalCoordinator.keepRunActive(sessionId),
+            executionTerminating: (executionId, status, permissionStop) => {
+                this.gitOperationService.executionFinished(executionId);
+                return this.goalCoordinator.executionTerminating(executionId, status, permissionStop);
+            },
             mcps: (workspaceId) => this.database?.effectiveMcpInstallations(workspaceId) ?? [],
             retainEnvironment: (environment) => this.gitExecution().retain(environment),
             goalCurrent: (input) => input.goal === undefined ||
@@ -860,7 +827,7 @@ export class NodeConnector {
                     code: safeErrorCode(error, 'GOAL_EXECUTION_START_FAILED')
                 });
             },
-            revokeExecutionMcps: (executionId) => this.revokeExecutionMcps(executionId),
+            revokeExecutionMcps: (executionId) => this.executionLifecycle.revokeMcps(executionId),
             goalMcp: async (input) => {
                 if (input.goal === undefined)
                     throw new Error('GOAL_NOT_ACTIVE');
@@ -979,7 +946,6 @@ export class NodeConnector {
             resolveExecutionDirectory,
             runtime: this.runtime,
             runners: this.runners,
-            state: this.sessionState,
             available: (runner) => this.runners.require(runner).available(this.capabilities),
             projectionFor: (session) => this.nativeSessionProjectionService.projectionForNative(session),
             managedAliasFor: (session) => this.nativeSessionProjectionService.managedForNative(session),
@@ -1078,7 +1044,7 @@ export class NodeConnector {
             runners: this.runners,
             runnerAvailable: (runner) => this.runners.require(runner).available(this.capabilities),
             projection: this.nativeSessionProjectionService,
-            cachedNative: () => [...this.sessionState.directNative.values()],
+            cachedNative: () => this.nativeSessionProjectionService.cachedNative(),
             cachedWorkspace: (workspaceId) => this.workspaceCoordinator.cachedSessions(workspaceId),
             discoveryPending: (workspaceId) => this.workspaceSessionService.discoveryPending(workspaceId),
             discoverWorkspace: (workspaceId, cleanup) => this.nativeSessionProjectionService.discoverWorkspace(workspaceId, undefined, cleanup),
@@ -1090,7 +1056,7 @@ export class NodeConnector {
                 void this.runAttachmentService.releaseSession(session.id);
             },
             refreshActivity: (session) => this.conversationHistoryService.refreshExternalActivity(session),
-            externalActivity: (sessionId) => this.sessionState.externalActivity.get(sessionId),
+            externalActivity: (sessionId) => this.externalSessionResumeService.activity(sessionId),
             isWatching: (sessionId) => this.nativeSessionWatchService.isWatching(sessionId),
             isRecovering: (sessionId) => this.restartHandoff.blocks(sessionId),
             history: (session, input) => this.conversationHistoryService.read(session, input),
@@ -1154,7 +1120,6 @@ export class NodeConnector {
                 script: this.fakeScript,
                 runners: this.runners,
                 runtime: this.runtime,
-                state: this.runState,
                 emitRun: (runId, type, payload, status) => this.runEventBridge.emitRun(runId, type, payload, status),
                 publishApproval: (input) => this.runnerInteractionService.publishApproval(input),
                 disconnect: () => this.controlChannel.close(4010, 'FAKE_RUNNER_DISCONNECT')
@@ -1278,15 +1243,29 @@ export class NodeConnector {
             execute: (operation, data) => this.modelUsage.withGrant(isPlainRecord(data) ? data.__usageGrant : undefined, () => this.executeNodeOperation(operation, data)),
             send: (type, payload, replyTo) => this.send(type, payload, replyTo)
         });
-        this.workspaceCoordinator = new NodeWorkspaceCoordinator({
+        const workspaceApplication = composeWorkspaceApplication({
             config: () => this.config,
             database: () => this.database,
-            watches: this.workspaceWatchService,
-            sessions: this.workspaceSessionService,
+            runtime: this.runtime,
+            terminals: this.terminalManager,
+            resources: this.workspaceResources,
             changes: this.workspaceChangeService,
-            emit: (workspaceId, topic) => void this.workspaceWorkbenchService?.invalidateTopic(workspaceId, topic),
-            send: (type, payload, replyTo) => this.send(type, payload, replyTo)
+            listSessions: (workspaceId, sessionGroup) => this.executeNodeOperation('session.list', {
+                workspaceId,
+                limit: 30,
+                ...(sessionGroup === undefined ? {} : { sessionGroup })
+            }),
+            invalidatePrompt: (id) => this.promptCompletion?.invalidateWorkspace(id),
+            nodeId: () => this.config?.nodeId ?? 'runtime-node',
+            nodeGeneration: () => this.nodeGeneration,
+            send: (type, payload, replyTo) => this.send(type, payload, replyTo),
+            emitWatchEvent: (payload) => this.send('watch.event', payload),
+            publishSession: (payload) => this.emitWorkbenchEvent('session', payload)
         });
+        this.workspaceCoordinator = workspaceApplication.coordinator;
+        this.workspaceService = workspaceApplication.workspace;
+        this.workspaceWorkbenchService = workspaceApplication.workbench;
+        this.publishWorkspaceSession = workspaceApplication.publishSession;
         this.runEventBridge = new NodeRunEventBridge({
             bindModelUsage: (runId) => {
                 const run = this.runtime.getRun(runId);
@@ -1401,43 +1380,12 @@ export class NodeConnector {
             terminals: this.terminalManager
         });
         this.terminalService = new TerminalService(requireDatabase, this.terminalManager, (environment) => this.gitExecution().retain(environment));
-        this.workspaceService = new WorkspaceService(requireDatabase, () => {
-            if (this.config === undefined)
-                throw new Error('NODE_CONFIG_UNAVAILABLE');
-            return this.config;
-        }, this.runtime, (workspaceId) => {
-            this.terminalManager.removeWorkspaceAssociation(workspaceId);
-            this.workspaceFileService.dispose(workspaceId);
-            this.workspaceCoordinator.invalidateChanges(workspaceId);
-            this.workspaceSessionService.invalidate(workspaceId);
-            this.workspaceCoordinator.clearWatches(workspaceId);
-            this.workspaceWorkbenchService.clearWorkspace(workspaceId);
-            this.promptCompletion?.invalidateWorkspace(workspaceId);
-        }, (workspaceId) => this.workspaceCoordinator.gitPolicyChanged(workspaceId));
-        this.workspaceWorkbenchService = new WorkspaceWorkbenchService({
-            requireWorkspace: (workspaceId) => this.workspaceCoordinator.require(workspaceId),
-            inspectWorkspace: (workspace) => this.workspaceCoordinator.inspectMetadata(workspace),
-            commitWorkspace: (workspace, inspection) => this.workspaceCoordinator.commitMetadata(workspace, inspection),
-            watch: this.workspaceWatchService,
-            files: this.workspaceFileService,
-            uploads: this.workspaceUploadService,
-            changes: this.workspaceChangeService,
-            listSessions: (workspaceId, sessionGroup) => this.executeNodeOperation('session.list', {
-                workspaceId,
-                limit: 30,
-                ...(sessionGroup === undefined ? {} : { sessionGroup })
-            }),
-            invalidate: this.invalidateWorkspaceFiles,
-            nodeId: () => this.config?.nodeId ?? 'runtime-node',
-            nodeGeneration: () => this.nodeGeneration,
-            emitWatchEvent: (payload) => this.send('watch.event', payload)
-        });
         const completionWorkspace = new PromptCompletionWorkspaceSource({
             requireWorkspace: (workspaceId) => this.workspaceCoordinator.require(workspaceId),
             observesWorkspace: (workspaceId, actor, connectionId) => this.workspaceWatchService.observes(workspaceId, actor.sessionHash, connectionId),
             observesSession: (workspaceId, sessionId, actor, connectionId) => this.nativeSessionWatchService.observes(actor.sessionHash, connectionId, workspaceId, sessionId),
             resolveSession: (sessionId) => this.nativeSessionProjectionService.resolve(sessionId),
-            cachedSessions: (workspaceId) => this.workspaceState.sessionCache.get(workspaceId)?.sessions ?? [],
+            cachedSessions: (workspaceId) => this.workspaceSessionService.cachedSnapshot(workspaceId),
             readHistory: (session, limit) => this.conversationHistoryService.read(session, { limit })
         });
         this.promptCompletion = new PromptCompletionNodeService({
@@ -1555,7 +1503,7 @@ export class NodeConnector {
         this.operationRouter.register('node.metrics', () => ({
             metrics: {
                 ...this.metrics.snapshot(),
-                activeRuns: this.runState.active.size,
+                activeRuns: this.runtime.activeExecutionCount(),
                 workspaceLeases: this.runtime.activeWorkspaceLeaseCount()
             }
         }));
@@ -1565,6 +1513,8 @@ export class NodeConnector {
             manifest: await this.workbenchManifestService.read(),
             binaryTerminal: true
         }));
+        this.executionLifecycle = new ExecutionLifecycle(() => this.database !== undefined, this.scheduledSessions, this.continuousRunCoordinator, this.goalCoordinator, this.modelUsage, this.goalMcpBridge, this.scheduleMcpBridge, this.notificationMcpBridge, this.runEventBridge, this.upgradeCoordinator);
+        this.operationAdmission = new NodeOperationAdmission(() => this.stopped, () => this.database !== undefined, () => this.config?.nodeId, this.restartHandoff, this.upgradeCoordinator, this.gitOperationService, this.operationRouter);
     }
     projectComputerUseCapability(capabilities) {
         return {
@@ -1572,11 +1522,10 @@ export class NodeConnector {
             computerUse: this.computerUseEnablement.capability()
         };
     }
-    async start() {
-        if (this.stopping !== undefined)
-            await this.stopping;
-        this.stopping = undefined;
-        this.stopped = false;
+    start() {
+        return this.lifecycle.start();
+    }
+    async startResources() {
         this.continuousRunCoordinator.resumeScheduling();
         this.sessionMessageService.setAccepting(true);
         this.config ??= await loadNodeConfig(this.configPath);
@@ -1677,30 +1626,7 @@ export class NodeConnector {
         return this.directTransferService?.handleTerminal(command) ?? false;
     }
     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;
-            try {
-                // In-flight recovery must rebuild accepted inputs before preparation closes.
-                await this.restartHandoff.wait();
-                this.sessionMessageService.setAccepting(false);
-                await Promise.allSettled([...this.inFlightOperations]);
-                await this.sessionMessageService.drain();
-                if (options.handoff && this.config?.nodeId)
-                    snapshot = this.restartHandoff.capture();
-            }
-            finally {
-                await this.disposeRuntime();
-            }
-            if (snapshot !== undefined)
-                await this.restartHandoff.publish(snapshot);
-        })();
-        return this.stopping;
+        return this.lifecycle.stop(options.handoff === true);
     }
     disposeRuntime() {
         this.recentRunProjectionService.dispose();
@@ -1756,19 +1682,20 @@ export class NodeConnector {
             webToolDrain
         ]);
         return (async () => {
-            let failed;
+            const hosting = await Promise.allSettled([conversationHostingDrain]);
+            const results = await drains;
+            this.database = undefined;
+            const git = await Promise.allSettled([this.gitExecutionService?.close()]);
+            this.usageOutbox?.disconnected();
+            this.usageOutbox = undefined;
+            this.modelUsage.clear();
+            const failed = [...hosting, ...results, ...git].find((result) => result.status === 'rejected');
             try {
-                await conversationHostingDrain;
-            }
-            finally {
-                const results = await drains;
-                this.database = undefined;
-                await this.gitExecutionService?.close();
-                this.usageOutbox?.disconnected();
-                this.usageOutbox = undefined;
-                this.modelUsage.clear();
                 database?.close();
-                failed = results.find((result) => result.status === 'rejected');
+            }
+            catch (error) {
+                if (failed === undefined)
+                    throw error;
             }
             if (failed !== undefined)
                 throw failed.reason;
@@ -1777,10 +1704,7 @@ export class NodeConnector {
     /** @internal Thin compatibility delegates; all behavior remains in the extracted services. */
     handleMessage = (raw) => this.controlMessages.handle(raw);
     emitRunEvent = (runId, eventType, payload, status) => this.runEventBridge.emitRun(runId, eventType, payload, status);
-    emitConversationItem = (runId, item) => {
-        this.goalCoordinator.executionProgress(runId, item);
-        this.runEventBridge.emitConversationItem(runId, item);
-    };
+    emitConversationItem = (runId, item) => this.executionLifecycle.emitItem(runId, item);
     emitConversationTurn = (turn) => {
         this.emitWorkbenchEvent('conversation', { turn });
     };
@@ -1791,46 +1715,14 @@ export class NodeConnector {
         }
         this.emitWorkbenchEvent(category, payload);
     };
-    emitSessionWorkbenchEvent = (payload) => {
-        if (isPlainRecord(payload) && isPlainRecord(payload.session)) {
-            const workspaceId = payload.session.workspaceId;
-            if (typeof workspaceId === 'string') {
-                this.workspaceSessionService.markCacheStale(workspaceId);
-                void this.workspaceWorkbenchService?.invalidateTopic(workspaceId, 'sessions');
-            }
-        }
-        this.emitWorkbenchEvent('session', payload);
-    };
+    emitSessionWorkbenchEvent = (payload) => this.publishWorkspaceSession(payload);
     emitWorkbenchEvent = (category, payload) => this.workbenchEventService.dispatch(category, payload);
     discoverWorkspaceSessions = (workspaceId, onRunnerDiscovered) => this.nativeSessionProjectionService.discoverWorkspace(workspaceId, onRunnerDiscovered);
     invalidateWorkspaceWatchTopics = (workspaceId) => this.workspaceCoordinator.invalidate(workspaceId);
     startCapabilityRefresh = () => this.connectionLifecycle.startCapabilityRefresh();
     refreshCapabilities = () => this.connectionLifecycle.refreshCapabilities();
-    async executeNodeOperation(operation, data) {
-        if (this.stopped)
-            throw new Error('NODE_STOPPED');
-        const input = isPlainRecord(data) ? data : {};
-        const sessionId = typeof input.sessionId === 'string' ? input.sessionId : undefined;
-        if (this.restartHandoff.blocksOperation(operation, input))
-            throw new Error('SESSION_RESTART_PENDING');
-        if (this.database === undefined)
-            throw new Error('NODE_DATABASE_UNAVAILABLE');
-        if (this.upgradeCoordinator.blocks(operation))
-            throw new Error('NODE_UPGRADE_PENDING');
-        nodeLog('node.operation', { nodeId: this.config?.nodeId, operation });
-        const task = this.gitOperationService.execute(operation, data, (input) => this.operationRouter.execute(operation, input));
-        this.inFlightOperations.add(task);
-        try {
-            const result = await task;
-            if ((operation === 'session.command.execute' || operation === 'session.message') &&
-                sessionId !== undefined &&
-                Number.isSafeInteger(input.__requestUserId))
-                this.restartHandoff.rememberUser(sessionId, input.__requestUserId);
-            return result;
-        }
-        finally {
-            this.inFlightOperations.delete(task);
-        }
+    executeNodeOperation(operation, data) {
+        return this.operationAdmission.execute(operation, data);
     }
     gitExecution() {
         this.gitExecutionService ??= new GitExecutionService({