@myagentroam/node 0.11.35 → 0.11.37

package/dist/service/conversation-observation.js

@@ -1,4 +1,4 @@
-import { isPlainRecord } from '../util/node-operation-parsers.js';
+import { isPlainRecord } from '../util/records.js';
 import { composeConversationRuntimePage, convergeConversationWatchPage } from './conversation-history-service.js';
 const INITIAL_TURN_LIMIT = 30;
 const EMITTED_TURN_LIMIT = 10;

package/dist/service/conversation-segment-service.js

@@ -1,4 +1,4 @@
-import { projectConversationWorkProcesses } from './conversation-work-process.js';
+import { projectConversationWorkProcesses } from '../session/runtime/work-process.js';
 const MAX_INITIAL_TURN_PAGE_SIZE = 30;
 function conversationSegmentPrefix(turn) {
     const user = turn.items.find((item) => item.kind === 'user_message');

package/dist/service/external-session-resume-service.js

@@ -1,25 +1,45 @@
 const RESUME_FAILURE_TTL_MS = 30 * 60_000;
 export class ExternalSessionResumeService {
     options;
+    externalActivity = new Map();
+    resumedByDirectId = new Map();
+    resumeFailures = new Map();
+    messageResumeFailures = new Map();
+    resumeFailureDetails = new Map();
+    failureTimers = new Map();
+    activity(sessionId) {
+        return this.externalActivity.get(sessionId);
+    }
     transitions = new Set();
     resumeTasks = new Map();
     constructor(options) {
         this.options = options;
     }
+    async close() {
+        await Promise.allSettled([...this.resumeTasks.values()]);
+        for (const timer of this.failureTimers.values())
+            clearTimeout(timer);
+        this.failureTimers.clear();
+        this.externalActivity.clear();
+        this.resumedByDirectId.clear();
+        this.resumeFailures.clear();
+        this.messageResumeFailures.clear();
+        this.resumeFailureDetails.clear();
+    }
     setActivity(sessionId, activity) {
-        this.options.state.externalActivity.set(sessionId, activity);
+        this.externalActivity.set(sessionId, activity);
     }
     forgetSessions(directIds, projectionIds) {
         for (const directId of directIds) {
-            this.options.state.externalActivity.delete(directId);
-            this.options.state.resumedByDirectId.delete(directId);
+            this.externalActivity.delete(directId);
+            this.resumedByDirectId.delete(directId);
             this.clearFailure(directId);
         }
-        for (const [directId, resumedId] of this.options.state.resumedByDirectId)
+        for (const [directId, resumedId] of this.resumedByDirectId)
             if (projectionIds.has(resumedId))
-                this.options.state.resumedByDirectId.delete(directId);
+                this.resumedByDirectId.delete(directId);
         for (const projectionId of projectionIds)
-            this.options.state.externalActivity.delete(projectionId);
+            this.externalActivity.delete(projectionId);
     }
     transitioning(sessionId) {
         return this.transitions.has(sessionId);
@@ -40,13 +60,13 @@ export class ExternalSessionResumeService {
     }
     async performResume(external) {
         this.clearFailure(external.id);
-        const priorId = this.options.state.resumedByDirectId.get(external.id);
+        const priorId = this.resumedByDirectId.get(external.id);
         const prior = priorId === undefined ? undefined : this.options.runtime.getAgentSession(priorId);
         if (prior !== undefined)
             return this.options.ensureConfiguration(prior);
         const runner = this.options.runners.product(external.runner);
         if (runner === undefined) {
-            this.options.state.externalActivity.set(external.id, 'IDLE');
+            this.externalActivity.set(external.id, 'IDLE');
             this.setFailure(external.id, 'RUNNER_UNAVAILABLE');
             return undefined;
         }
@@ -64,7 +84,7 @@ export class ExternalSessionResumeService {
                 projectionFor: this.options.projectionFor,
                 managedAliasFor: this.options.managedAliasFor,
                 currentResumed: (sessionId) => {
-                    const resumedId = this.options.state.resumedByDirectId.get(sessionId);
+                    const resumedId = this.resumedByDirectId.get(sessionId);
                     return resumedId === undefined
                         ? undefined
                         : this.options.runtime.getAgentSession(resumedId);
@@ -104,24 +124,24 @@ export class ExternalSessionResumeService {
             releaseMutation();
         }
         if (result.activity !== undefined)
-            this.options.state.externalActivity.set(external.id, result.activity);
+            this.externalActivity.set(external.id, result.activity);
         else if (result.failureCode === 'RUNNER_UNAVAILABLE')
-            this.options.state.externalActivity.set(external.id, 'IDLE');
+            this.externalActivity.set(external.id, 'IDLE');
         if (result.session !== undefined) {
-            this.options.state.resumedByDirectId.set(external.id, result.session.id);
+            this.resumedByDirectId.set(external.id, result.session.id);
             return result.session;
         }
         this.setFailure(external.id, result.failureCode ?? 'SESSION_RESUME_REJECTED', result.failureDetail);
-        this.options.state.messageResumeFailures.set(external.id, result.messageFailureCode ?? result.failureCode ?? 'SESSION_RESUME_REJECTED');
+        this.messageResumeFailures.set(external.id, result.messageFailureCode ?? result.failureCode ?? 'SESSION_RESUME_REJECTED');
         return undefined;
     }
     failure(sessionId) {
-        const code = this.options.state.resumeFailures.get(sessionId) ?? 'SESSION_RESUME_REJECTED';
-        const detail = this.options.state.resumeFailureDetails.get(sessionId);
+        const code = this.resumeFailures.get(sessionId) ?? 'SESSION_RESUME_REJECTED';
+        const detail = this.resumeFailureDetails.get(sessionId);
         return detail === undefined ? { code } : { code, detail };
     }
     async resolveForMessage(sessionId) {
-        const resumedId = this.options.state.resumedByDirectId.get(sessionId);
+        const resumedId = this.resumedByDirectId.get(sessionId);
         const current = this.options.runtime.getAgentSession(resumedId ?? sessionId) ??
             (await this.options.resolve(sessionId));
         if (current === undefined)
@@ -131,31 +151,31 @@ export class ExternalSessionResumeService {
         const resumed = await this.resume(current);
         if (resumed !== undefined)
             return resumed;
-        if (this.options.state.externalActivity.get(current.id) === 'BUSY')
+        if (this.externalActivity.get(current.id) === 'BUSY')
             throw new Error('EXTERNAL_SESSION_ACTIVE');
-        throw new Error(this.options.state.messageResumeFailures.get(current.id) ?? this.failure(current.id).code);
+        throw new Error(this.messageResumeFailures.get(current.id) ?? this.failure(current.id).code);
     }
     async acceptForMessage(sessionId) {
         return { session: await this.resolveForMessage(sessionId) };
     }
     clearFailure(sessionId) {
-        const timer = this.options.state.failureTimers.get(sessionId);
+        const timer = this.failureTimers.get(sessionId);
         if (timer !== undefined)
             clearTimeout(timer);
-        this.options.state.failureTimers.delete(sessionId);
-        this.options.state.resumeFailures.delete(sessionId);
-        this.options.state.resumeFailureDetails.delete(sessionId);
-        this.options.state.messageResumeFailures.delete(sessionId);
+        this.failureTimers.delete(sessionId);
+        this.resumeFailures.delete(sessionId);
+        this.resumeFailureDetails.delete(sessionId);
+        this.messageResumeFailures.delete(sessionId);
     }
     setFailure(sessionId, code, detail) {
         this.clearFailure(sessionId);
-        this.options.state.resumeFailures.set(sessionId, code);
+        this.resumeFailures.set(sessionId, code);
         if (detail === undefined)
-            this.options.state.resumeFailureDetails.delete(sessionId);
+            this.resumeFailureDetails.delete(sessionId);
         else
-            this.options.state.resumeFailureDetails.set(sessionId, detail);
+            this.resumeFailureDetails.set(sessionId, detail);
         const timer = setTimeout(() => this.clearFailure(sessionId), RESUME_FAILURE_TTL_MS);
         timer.unref();
-        this.options.state.failureTimers.set(sessionId, timer);
+        this.failureTimers.set(sessionId, timer);
     }
 }

package/dist/service/fake-managed-run-service.js

@@ -1,4 +1,3 @@
-import { isTerminalRunStatus } from '../util/node-operation-parsers.js';
 /** Test-only managed Run adapter; production Runner paths never depend on it. */
 export class FakeManagedRunService {
     options;
@@ -7,7 +6,7 @@ export class FakeManagedRunService {
     }
     start(envelope) {
         const payload = envelope.payload;
-        if (typeof payload.runId !== 'string' || this.options.state.active.has(payload.runId))
+        if (typeof payload.runId !== 'string' || this.options.runtime.isExecutionActive(payload.runId))
             return;
         const runId = payload.runId;
         const cwd = typeof payload.cwd === 'string' ? payload.cwd : undefined;
@@ -25,14 +24,11 @@ export class FakeManagedRunService {
                 cwd
             });
         }
-        this.options.state.active.add(runId);
+        this.options.runtime.executionAccepted(runId);
         void this.options.runner
             .start(runId, this.options.script(payload.input, runId), {
             event: (eventType, eventPayload, status) => {
                 this.options.emitRun(runId, eventType, eventPayload, status);
-                if (status !== undefined && isTerminalRunStatus(status)) {
-                    this.options.state.active.delete(runId);
-                }
             },
             approval: (approvalId, approvalPayload, expiresAt) => {
                 try {
@@ -55,6 +51,6 @@ export class FakeManagedRunService {
             },
             disconnect: this.options.disconnect
         })
-            .finally(() => this.options.state.active.delete(runId));
+            .finally(() => this.options.runtime.executionReleased(runId));
     }
 }

package/dist/service/git-operation-service.js

@@ -1,6 +1,6 @@
 import { AsyncLocalStorage } from 'node:async_hooks';
 import { personalGitRuntimeSchema } from '@myagentroam/protocol';
-import { parseSecretEnvironment } from '../util/secret-environment.js';
+import { parseSecretEnvironment } from '../mcp/secret-environment.js';
 export const gitOperationEnvironment = new AsyncLocalStorage();
 /** Binds authenticated operations to the same lease mechanism as Runner queues. */
 export class GitOperationService {

package/dist/service/goal-continuation-coordinator.js

@@ -1,6 +1,6 @@
 import { composerVisibleText } from '@myagentroam/protocol';
 import { nodeLog } from '../operational.js';
-import { isPlainRecord } from '../util/node-operation-parsers.js';
+import { isPlainRecord } from '../util/records.js';
 import { safeErrorCode } from '../util/safe-error.js';
 import { NODE_MCP } from '../mcp/naming.js';
 import { composerResourceInputTags } from './composer-message-input.js';
@@ -77,8 +77,10 @@ export class GoalContinuationCoordinator {
             return;
         if (permissionStop !== undefined) {
             this.retireGoalContinuation(pending.sessionId);
-            this.options.queue().removeGoalQueue(pending.sessionId);
-            return;
+            const changed = this.options
+                .queue()
+                .removeGoalQueue(pending.sessionId, undefined, undefined, false);
+            return changed ? { queueChangedSessionId: pending.sessionId } : undefined;
         }
         const disposition = this.options.goals.recordExecutionResult(pending.sessionId, {
             failed: status === 'FAILED',
@@ -87,12 +89,17 @@ export class GoalContinuationCoordinator {
         if (disposition === 'blocked' || disposition === 'completed') {
             this.nativeGoalBindings.delete(pending.goal.id);
             this.retireGoalContinuation(pending.sessionId);
-            this.options.queue().removeGoalQueue(pending.sessionId);
+            const changed = this.options
+                .queue()
+                .removeGoalQueue(pending.sessionId, undefined, undefined, false);
             const terminalGoal = this.options.goals.get(pending.sessionId);
             const session = this.options.runtime.getAgentSession(pending.sessionId);
-            if (terminalGoal !== undefined && session !== undefined)
-                this.publishGoalState(session, terminalGoal);
-            return;
+            return {
+                ...(terminalGoal !== undefined && session !== undefined
+                    ? { goalUpdate: { session, goal: terminalGoal } }
+                    : {}),
+                ...(changed ? { queueChangedSessionId: pending.sessionId } : {})
+            };
         }
         if (status !== 'FAILED' || started)
             return;

package/dist/service/mar-agent-model-transport-test-service.js

@@ -1,6 +1,6 @@
 import { testAgentModelTransport } from '@myagentroam/agent';
 import { marAgentModelTransportTestInputSchema, marAgentModelTransportTestResultSchema } from '@myagentroam/protocol';
-import { runnerErrorProjection } from '../util/runner-error.js';
+import { runnerErrorProjection } from '../runner/runner-error.js';
 export class MarAgentModelTransportTestService {
     options;
     #timeoutMs;

package/dist/service/native-session-watch-service.js

@@ -1,4 +1,4 @@
-import { isPlainRecord } from '../util/node-operation-parsers.js';
+import { isPlainRecord } from '../util/records.js';
 import { ConversationObservation } from './conversation-observation.js';
 import { safeErrorCode } from '../util/safe-error.js';
 import { SessionWatchSlotCoordinator } from './session-watch-slot-coordinator.js';

package/dist/service/node-control-channel.js

@@ -1,7 +1,7 @@
 import WebSocket from 'ws';
 import { createEnvelope } from '@myagentroam/protocol';
 import { ControlOutboundScheduler } from '../control-outbound-scheduler.js';
-import { nodeConnectEndpoint } from '../util/node-operation-parsers.js';
+import { nodeConnectEndpoint } from '../connection/endpoints.js';
 export class NodeControlChannel {
     options;
     socket;
@@ -50,10 +50,6 @@ export class NodeControlChannel {
     connected() {
         return this.socket?.readyState === WebSocket.OPEN;
     }
-    /** Keeps transport injection at the transport boundary for contract tests. */
-    replaceSocketForTesting(socket) {
-        this.socket = socket;
-    }
     close(code, reason) {
         this.socket?.close(code, reason);
     }

package/dist/service/node-request-service.js

@@ -1,5 +1,5 @@
 import { nodeLog } from '../operational.js';
-import { validUserAuthorization } from '../util/node-operation-parsers.js';
+import { validUserAuthorization } from '../connection/authorization.js';
 import { safePublicError } from '../util/safe-error.js';
 /** Validates and executes the closed Admin-facing Node operation envelope. */
 export class NodeRequestService {

package/dist/service/node-terminal-channel.js

@@ -1,6 +1,7 @@
 import WebSocket from 'ws';
 import { terminalDataFrameSchema } from '@myagentroam/protocol';
-import { nodeTerminalConnectEndpoint, isPlainRecord } from '../util/node-operation-parsers.js';
+import { nodeTerminalConnectEndpoint } from '../connection/endpoints.js';
+import { isPlainRecord } from '../util/records.js';
 import { TerminalRelayState } from './terminal-relay-state.js';
 import { TerminalRelaySender } from '@myagentroam/marctl/src/terminal-relay-sender.mjs';
 export class NodeTerminalChannel {

package/dist/service/node-workspace-coordinator.js

@@ -1,7 +1,8 @@
 import { realpath } from 'node:fs/promises';
 import { nodeLog } from '../operational.js';
-import { inspectWorkspace, normalizeWorkspacePath } from '../workspace.js';
-import { ensureWorkspaceGitExclude } from './workspace-git-exclude-service.js';
+import { inspectWorkspace } from '../workspace/git.js';
+import { normalizeWorkspacePath } from '../workspace/path-access.js';
+import { ensureWorkspaceGitExclude } from '../workspace/workspace-git-exclude-service.js';
 /** Coordinates Workspace invalidation, inspection and persisted Terminal summaries. */
 export class NodeWorkspaceCoordinator {
     options;

package/dist/service/notification-mcp-bridge.js

@@ -7,7 +7,7 @@ import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { notificationInputSchema, notificationChannelsRequestSchema, mailNotificationRequestSchema } from '@myagentroam/protocol';
-import { sessionGroup } from './session-presentation-service.js';
+import { sessionGroup } from '../session/session-presentation-service.js';
 export class NotificationMcpBridge {
     resolve;
     send;
@@ -146,7 +146,11 @@ export class NotificationMcpBridge {
                 typeof callId !== 'string')
                 throw new Error('MAIL_INPUT_INVALID');
             const parsed = mailNotificationRequestSchema.safeParse({
-                ...current,
+                executionId: current.executionId,
+                sessionId: current.sessionId,
+                workspaceId: current.workspaceId,
+                userId: current.userId,
+                source: current.source,
                 templateId: templateId ?? '',
                 ...(title === undefined ? {} : { title }),
                 ...(recipientEmail === undefined ? {} : { recipientEmail }),

package/dist/service/recent-run-projection-service.js

@@ -1,4 +1,4 @@
-import { sessionGroup } from './session-presentation-service.js';
+import { sessionGroup } from '../session/session-presentation-service.js';
 import { composerVisibleText } from '@myagentroam/protocol';
 const TERMINAL_TTL_MS = 12 * 60 * 60_000;
 const CLEANUP_INTERVAL_MS = 5 * 60_000;

package/dist/service/restart-session-restorer.js

@@ -1,5 +1,5 @@
 import { parseComposerTags, serializeComposerTag } from '@myagentroam/protocol';
-import { parseMessageAttachments } from '../util/node-operation-parsers.js';
+import { parseMessageAttachments } from '../session/attachments.js';
 import { RUNNER_EXECUTION_CONTEXT } from '../runner/execution-context.js';
 import { RESTART_NOTICE } from './planned-restart-handoff.js';
 /** Rebuild inputs through the existing preparation and FIFO boundary. */

package/dist/service/run-event-service.js

@@ -1,7 +1,8 @@
-import { sessionGroup } from './session-presentation-service.js';
+import { sessionGroup } from '../session/session-presentation-service.js';
 import { permissionStopSchema, runPerformanceSchema } from '@myagentroam/protocol';
 import { nodeLog } from '../operational.js';
-import { isPlainRecord, isTerminalRunStatus } from '../util/node-operation-parsers.js';
+import { isPlainRecord } from '../util/records.js';
+import { isTerminalRunStatus } from '../session/runtime/type-guards.js';
 const COALESCE_MS = 200;
 const MAX_BATCH_CHARS = 16_384;
 export class RunEventService {
@@ -18,7 +19,7 @@ export class RunEventService {
             const parsed = runPerformanceSchema.safeParse({ ...payload, runId: run.id });
             if (parsed.success && this.options.runtime.updateRunPerformance(runId, parsed.data)) {
                 this.flushText(runId);
-                this.options.emitWorkbench('conversation', {
+                this.emitWorkbench('conversation', {
                     sessionId: run.sessionId,
                     performance: parsed.data
                 });
@@ -35,6 +36,13 @@ export class RunEventService {
         this.flushText(runId);
         this.emitNow(runId, eventType, payload, status);
     }
+    emitWorkbench(category, payload) {
+        if (category === 'conversation' && isPlainRecord(payload) && 'turn' in payload) {
+            this.options.emitWorkbench(category, { turn: payload.turn });
+            return;
+        }
+        this.options.emitWorkbench(category, payload);
+    }
     clear() {
         for (const pending of this.pendingText.values())
             clearTimeout(pending.timer);
@@ -104,59 +112,58 @@ export class RunEventService {
         if (status === 'FAILED')
             this.options.metrics.runnerFailed();
         let recorded = undefined;
-        try {
-            recorded = this.options.runtime.appendRunEvent({
-                runId: executionId,
+        let finalStatus;
+        let manuallyInterrupted = false;
+        if (terminalExecution) {
+            const parsedStop = isPlainRecord(payload)
+                ? permissionStopSchema.safeParse(payload.permissionStop)
+                : undefined;
+            const result = this.options.acceptExecutionTerminal({
+                executionId,
                 sequence: event.sequence,
                 eventType,
                 payload,
-                ...(status === undefined ? {} : { status })
+                status: status,
+                ...(parsedStop?.success ? { permissionStop: parsedStop.data } : {})
             });
+            recorded = result.recorded;
+            if (recorded === undefined)
+                return;
+            finalStatus = result.finalStatus;
+            manuallyInterrupted = result.manuallyInterrupted;
+            if (result.queueChangedSessionId !== undefined)
+                this.options.publishQueueChange(result.queueChangedSessionId);
+            if (result.goalUpdate !== undefined)
+                this.options.publishGoalUpdate(result.goalUpdate);
         }
-        catch {
-            /* A stale Runner callback may race process-local Run cleanup. */
+        else {
+            try {
+                recorded = this.options.runtime.appendRunEvent({
+                    runId: executionId,
+                    sequence: event.sequence,
+                    eventType,
+                    payload,
+                    ...(status === undefined ? {} : { status })
+                });
+            }
+            catch {
+                /* A stale Runner callback may race process-local Run cleanup. */
+            }
         }
         if (eventType === 'run.started' || eventType === 'run.running')
             this.options.executionStarted?.(executionId);
         if (!terminalExecution)
             this.options.refreshAttachments?.(run.sessionId);
-        let finalStatus;
-        let manuallyInterrupted = false;
-        if (terminalCurrentExecution) {
-            const parsedStop = isPlainRecord(payload)
-                ? permissionStopSchema.safeParse(payload.permissionStop)
-                : undefined;
-            const permissionStop = parsedStop?.success ? parsedStop.data : undefined;
-            if (permissionStop !== undefined)
-                this.options.runtime.pauseSessionQueue(run.sessionId);
-            this.options.executionTerminating?.(executionId, status, permissionStop);
-            this.options.state.active.delete(executionId);
-            const interrupted = this.options.state.interruptRequested.delete(executionId);
-            manuallyInterrupted = interrupted;
-            const queue = this.options.runtime.sessionQueue(run.sessionId);
-            const continues = run.status !== 'CANCELLING' &&
-                permissionStop === undefined &&
-                ((!queue.paused && queue.itemIds.length > 0) ||
-                    this.options.keepRunActive?.(run.sessionId) === true);
-            if (!continues) {
-                finalStatus =
-                    status === 'CANCELLED' || interrupted ? 'INTERRUPTED' : status;
-                if (finalStatus === 'SUCCEEDED' ||
-                    finalStatus === 'FAILED' ||
-                    finalStatus === 'INTERRUPTED')
-                    this.options.runtime.finishRun(runId, finalStatus);
-            }
-        }
         const publicStatus = terminalExecution ? finalStatus : status;
         const notificationPayload = this.notificationPayload(runId, eventType, payload, publicStatus, manuallyInterrupted || !targetsCurrentTurn);
         if (publicStatus !== undefined) {
             const currentRun = this.options.runtime.getRun(runId);
-            this.options.emitWorkbench('run', { run: currentRun });
+            this.emitWorkbench('run', { run: currentRun });
             const session = currentRun === undefined
                 ? undefined
                 : this.options.runtime.getAgentSession(currentRun.sessionId);
             if (session !== undefined)
-                this.options.emitWorkbench('session', { session: this.options.presentSession(session) });
+                this.emitWorkbench('session', { session: this.options.presentSession(session) });
         }
         const createdTurn = targetsCurrentTurn && targetTurn === undefined && currentTurn === undefined
             ? this.options.runtime.conversationTurnForRun(runId)
@@ -169,7 +176,7 @@ export class RunEventService {
                 (previousGroups.get(item.id)?.id !== item.processGroup?.id ||
                     previousGroups.get(item.id)?.isStart !== item.processGroup?.isStart));
         if (targetsCurrentTurn)
-            this.options.emitWorkbench('conversation', createdTurn === undefined && !correctedGroups
+            this.emitWorkbench('conversation', createdTurn === undefined && !correctedGroups
                 ? {
                     event: {
                         ...event,
@@ -181,7 +188,7 @@ export class RunEventService {
         else {
             const projectedTurn = this.options.runtime.conversationTurnForExecution(executionId);
             if (projectedTurn !== undefined)
-                this.options.emitWorkbench('conversation', { turn: projectedTurn });
+                this.emitWorkbench('conversation', { turn: projectedTurn });
         }
         const occurredAt = recorded?.createdAt ?? Date.now();
         const terminalNotification = notificationPayload !== undefined && terminalCurrentExecution && finalStatus !== undefined;
@@ -198,7 +205,7 @@ export class RunEventService {
                 targetTurn?.items.some((item) => item.status === 'PENDING' || item.status === 'IN_PROGRESS'))) {
             const turn = this.options.runtime.conversationTurnForRun(runId);
             if (turn !== undefined)
-                this.options.emitWorkbench('conversation', { turn });
+                this.emitWorkbench('conversation', { turn });
         }
         this.options.cleanupAttachments(executionId);
         this.options.expireImages(executionId);
@@ -225,7 +232,7 @@ export class RunEventService {
     }
     emitNotification(runId, event, payload, occurredAt) {
         nodeLog('run.event', { runId, eventType: 'notification' });
-        this.options.emitWorkbench('conversation', {
+        this.emitWorkbench('conversation', {
             event: {
                 runId,
                 sequence: event.sequence,

package/dist/service/run-workbench-service.js

@@ -1,7 +1,7 @@
 import { modelResourceReadInputSchema, runImageReadInputSchema } from '@myagentroam/protocol';
-import { nodeOperationData } from '../util/node-operation-data.js';
-import { isTerminalRunStatus } from '../util/node-operation-parsers.js';
-import { isPlainRecord } from '../util/node-operation-parsers.js';
+import { nodeOperationData } from '../connection/node-operation-data.js';
+import { isTerminalRunStatus } from '../session/runtime/type-guards.js';
+import { isPlainRecord } from '../util/records.js';
 import { isHostedConversationImageRunId } from '../runner/mar-agent/generated-images.js';
 import { assertRunOwner } from './run-ownership-policy.js';
 import { imagePreviews } from './image-preview-service.js';

package/dist/service/runner-interaction-service.js

@@ -1,5 +1,6 @@
-import { denyPermission } from '../claude-agent-sdk.js';
-import { boundedConversationItemId, isTerminalRunStatus } from '../util/node-operation-parsers.js';
+import { denyPermission } from '../runner/claude/claude-agent-sdk.js';
+import { boundedConversationItemId } from '../runner/normalization.js';
+import { isTerminalRunStatus } from '../session/runtime/type-guards.js';
 import { claudeUserInputQuestions } from '../runner/claude/conversation-parser.js';
 export class RunnerInteractionService {
     options;
@@ -223,7 +224,6 @@ export class RunnerInteractionService {
         finally {
             codex.execution.runs.delete(runId);
             codex.releaseEnvironment(runId);
-            this.options.state.active.delete(runId);
         }
     }
     respondUserInput(runId, requestId, rawAnswers) {
@@ -260,13 +260,14 @@ export class RunnerInteractionService {
         if (run === undefined)
             return false;
         if (run.status === 'CANCELLING') {
-            const status = this.options.state.interruptRequested.has(runId) ? 'INTERRUPTED' : 'CANCELLED';
+            const status = this.options.runtime.isExecutionInterruptRequested(runId)
+                ? 'INTERRUPTED'
+                : 'CANCELLED';
             this.options.emitRun(runId, 'run.completed', { status }, status);
         }
         else if (!isTerminalRunStatus(run.status))
             return false;
         this.options.codex().execution.runs.delete(runId);
-        this.options.state.active.delete(runId);
         return true;
     }
     respondCodexUserInput(runId, requestId, rawAnswers) {

package/dist/service/runner-service.js

@@ -1,5 +1,5 @@
 import { runnerDefaultConfigurationSchema } from '@myagentroam/protocol';
-import { parseSecretEnvironment } from '../util/secret-environment.js';
+import { parseSecretEnvironment } from '../mcp/secret-environment.js';
 export class RunnerService {
     database;
     capabilities;

package/dist/service/session-recent-activity.js

@@ -1,4 +1,5 @@
-import { isPlainRecord, isTerminalRunStatus } from '../util/node-operation-parsers.js';
+import { isPlainRecord } from '../util/records.js';
+import { isTerminalRunStatus } from '../session/runtime/type-guards.js';
 /** Projects only already-observed, process-local public facts. Never reads native history. */
 function activity(runtime, sessionId) {
     const candidate = runtime.activeSessionRun(sessionId);

package/dist/service/skill-directory-service.js

@@ -1,7 +1,7 @@
 import { lstat, open, readdir, readlink, realpath } from 'node:fs/promises';
 import path from 'node:path';
 import { skillInstallMetadataSchema } from '@myagentroam/protocol';
-import { hasBrokenWorkspaceSkillGitExclude } from './workspace-git-exclude-service.js';
+import { hasBrokenWorkspaceSkillGitExclude } from '../workspace/workspace-git-exclude-service.js';
 const MAX_METADATA_BYTES = 64 * 1024;
 const SKILL_NAME = /^[a-z0-9]+(?:-[a-z0-9]+)*$/u;
 const WINDOWS_DEVICE_NAME = /^(?:con|prn|aux|nul|com[1-9]|lpt[1-9])$/u;

package/dist/service/skill-install-service.js

@@ -4,8 +4,8 @@ import { promisify } from 'node:util';
 import { lstat, mkdir, readFile, readdir, readlink, realpath, rename, rm, symlink, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 import { skillInstallMetadataSchema } from '@myagentroam/protocol';
-import { GitCommandError, resolveWorkspaceGitRoot } from '../workspace.js';
-import { rewriteWorkspaceGitExclude, updateWorkspaceSkillGitExclude } from './workspace-git-exclude-service.js';
+import { GitCommandError, resolveWorkspaceGitRoot } from '../workspace/git.js';
+import { rewriteWorkspaceGitExclude, updateWorkspaceSkillGitExclude } from '../workspace/workspace-git-exclude-service.js';
 export class SkillInstallService {
     async recoverNodeHome(home) {
         const agentsRoot = path.join(home, '.agents', 'skills');

package/dist/service/terminal-service.js

@@ -1,4 +1,4 @@
-import { parseSecretEnvironment } from '../util/secret-environment.js';
+import { parseSecretEnvironment } from '../mcp/secret-environment.js';
 export class TerminalService {
     database;
     terminalManager;

package/dist/service/workbench-event-projection.js

@@ -1,6 +1,7 @@
 import { conversationSegmentIdentityForItem, conversationSegments } from './conversation-segment-service.js';
-import { runConversationItemId } from '../runtime-state.js';
-import { isNodeAgentRun, isNodeConversationTurn, isPlainRecord } from '../util/node-operation-parsers.js';
+import { runConversationItemId } from '../session/runtime/conversation-projection.js';
+import { isNodeAgentRun, isNodeConversationTurn } from '../session/runtime/type-guards.js';
+import { isPlainRecord } from '../util/records.js';
 export function workbenchPayloadSessionId(getRun, category, payload) {
     if (!isPlainRecord(payload))
         return undefined;

package/dist/service/workbench-event-service.js

@@ -1,5 +1,5 @@
 import { createEnvelope } from '@myagentroam/protocol';
-import { isPlainRecord } from '../util/node-operation-parsers.js';
+import { isPlainRecord } from '../util/records.js';
 import { projectWorkbenchPayload, workbenchPayloadSessionId } from './workbench-event-projection.js';
 export class WorkbenchEventService {
     options;