@myagentroam/node 0.9.89 → 0.9.90

package/dist/connector.js

@@ -244,13 +244,18 @@ export class NodeConnector {
     missionRuntime = new MissionRuntime(() => undefined);
     missionRetryTimers = new Map();
     missionContinuationPending = new Map();
+    missionSubmissionAttempts = new Map();
+    missionContinuationEpochs = new Map();
+    missionExecutionProgress = new Set();
     missionMcpServer = new MissionMcpServer(this.missionRuntime, (sessionId) => {
         const mission = this.missionRuntime.get(sessionId);
         const session = this.runtime.getAgentSession(sessionId);
         if (mission === undefined || session === undefined)
             return;
-        if (mission.status !== 'active')
+        if (mission.status !== 'active') {
+            this.retireMissionContinuation(sessionId);
             this.continuousRunCoordinator.removeMissionQueue(sessionId);
+        }
         this.publishMissionState(session, mission);
     });
     runnerUsageReader;
@@ -317,9 +322,18 @@ export class NodeConnector {
             if (pending?.mission === undefined)
                 return;
             const started = this.continuousRunCoordinator.hasExecutionStarted(executionId);
-            const blocked = this.missionRuntime.recordExecutionResult(pending.sessionId, status === 'FAILED');
-            if (blocked) {
-                this.clearMissionRetry(pending.sessionId);
+            const progressed = this.missionExecutionProgress.delete(executionId);
+            if (!this.missionGenerationCurrent(pending.sessionId, pending.mission))
+                return;
+            const disposition = this.missionRuntime.recordExecutionResult(pending.sessionId, {
+                failed: status === 'FAILED',
+                progressed: status !== 'SUCCEEDED' || progressed
+            });
+            if (disposition === 'blocked' || disposition === 'paused') {
+                if (disposition === 'blocked')
+                    this.retireMissionContinuation(pending.sessionId);
+                else
+                    this.invalidateMissionContinuation(pending.sessionId);
                 this.continuousRunCoordinator.removeMissionQueue(pending.sessionId);
                 const terminalMission = this.missionRuntime.get(pending.sessionId);
                 const session = this.runtime.getAgentSession(pending.sessionId);
@@ -330,22 +344,14 @@ export class NodeConnector {
             if (status !== 'FAILED' || started)
                 return;
             this.clearMissionRetry(pending.sessionId);
+            const continuationEpoch = this.missionContinuationEpochs.get(pending.sessionId) ?? 0;
             const retry = {
                 sessionId: pending.sessionId,
                 timer: setTimeout(() => {
                     this.missionRetryTimers.delete(retry.sessionId);
-                    const mission = this.missionRuntime.get(retry.sessionId);
-                    if (mission?.status !== 'active' ||
-                        mission.id !== pending.mission?.id ||
-                        mission.revision !== pending.mission.revision)
-                        return;
-                    void this.sessionMessageService
-                        .submitMission({
+                    void this.enqueueMissionContinuation({
                         sessionId: retry.sessionId,
-                        kind: 'continue',
-                        content: this.missionRuntime.prompt(retry.sessionId, 'continue'),
-                        deliveryIntent: 'SEND',
-                        mission: { id: mission.id, revision: mission.revision },
+                        mission: pending.mission,
                         secretEnvironment: pending.secretEnvironment,
                         ...(pending.personalInstructions === undefined
                             ? {}
@@ -358,15 +364,17 @@ export class NodeConnector {
                             : { marAgentModels: pending.marAgentModels }),
                         ...(pending.marAgentRuntimeScopeId === undefined
                             ? {}
-                            : { marAgentRuntimeScopeId: pending.marAgentRuntimeScopeId })
-                    })
-                        .catch(() => undefined);
+                            : { marAgentRuntimeScopeId: pending.marAgentRuntimeScopeId }),
+                        continuationEpoch,
+                        deliveryIntent: 'SEND'
+                    });
                 }, 15_000)
             };
             this.missionRetryTimers.set(pending.sessionId, retry);
             retry.timer.unref();
         },
         releaseExecution: (executionId) => {
+            this.missionExecutionProgress.delete(executionId);
             this.missionMcpServer.revoke(executionId);
             this.continuousRunCoordinator.remove(executionId);
         }
@@ -634,6 +642,7 @@ export class NodeConnector {
                 (await this.runAttachmentService.readNative(runId, imageIndex)),
             respondUserInput: (runId, requestId, answers) => this.runnerInteractionService.respondUserInput(runId, requestId, answers),
             pauseQueue: (sessionId) => this.workspaceQueueWorkbenchService.pauseSessionQueue(sessionId),
+            runInterrupted: (sessionId) => this.clearMissionState(sessionId),
             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)
@@ -662,20 +671,19 @@ export class NodeConnector {
             markInterrupted: (runId) => this.runState.interruptRequested.add(runId),
             mcps: (workspaceId) => this.database?.effectiveMcpInstallations(workspaceId) ?? [],
             retainEnvironment: (environment) => this.gitExecution().retain(environment),
+            missionCurrent: (input) => input.mission === undefined ||
+                this.missionGenerationCurrent(input.sessionId, input.mission),
             afterExecutionStarted: async (input) => {
                 if (input.mission === undefined)
                     return;
-                const mission = this.missionRuntime.get(input.sessionId);
-                if (mission?.status !== 'active' ||
-                    mission.id !== input.mission.id ||
-                    mission.revision !== input.mission.revision)
+                if (!this.missionGenerationCurrent(input.sessionId, input.mission))
                     return;
                 const updated = this.missionRuntime.recordTurn(input.sessionId);
                 const session = this.runtime.getAgentSession(input.sessionId);
                 const run = this.runtime.getRun(input.runId);
                 await this.enqueueMissionContinuation({
                     sessionId: input.sessionId,
-                    mission: { id: mission.id, revision: mission.revision },
+                    mission: { id: input.mission.id, revision: input.mission.revision },
                     ...(run?.initiatedByUserId === undefined
                         ? {}
                         : { initiatedByUserId: run.initiatedByUserId }),
@@ -761,8 +769,24 @@ export class NodeConnector {
                 const pendingContinuation = this.missionContinuationPending.get(previousId);
                 if (pendingContinuation !== undefined) {
                     this.missionContinuationPending.delete(previousId);
+                    pendingContinuation.sessionId = nextId;
                     this.missionContinuationPending.set(nextId, pendingContinuation);
                 }
+                const submissionAttempts = this.missionSubmissionAttempts.get(previousId);
+                if (submissionAttempts !== undefined) {
+                    this.missionSubmissionAttempts.delete(previousId);
+                    const currentAttempts = this.missionSubmissionAttempts.get(nextId) ?? new Set();
+                    for (const attempt of submissionAttempts) {
+                        attempt.sessionId = nextId;
+                        currentAttempts.add(attempt);
+                    }
+                    this.missionSubmissionAttempts.set(nextId, currentAttempts);
+                }
+                const continuationEpoch = this.missionContinuationEpochs.get(previousId);
+                if (continuationEpoch !== undefined) {
+                    this.missionContinuationEpochs.delete(previousId);
+                    this.missionContinuationEpochs.set(nextId, continuationEpoch);
+                }
             },
             migrateQueue: (previousId, nextId) => this.continuousRunCoordinator.migrateSession(previousId, nextId),
             migrateRunnerState: (previousId, nextId) => this.runEventBridge.migrateRunnerSessionIdentity(previousId, nextId),
@@ -855,7 +879,7 @@ export class NodeConnector {
                 };
             },
             mission: async ({ session, objective, initiatedByUserId, secretEnvironment, personalInstructions, marAgentModel, marAgentModels, marAgentRuntimeScopeId }) => {
-                this.clearMissionRetry(session.id);
+                this.invalidateMissionContinuation(session.id);
                 const prepared = this.prepareMissionSession(session);
                 const missionSession = prepared.session;
                 const activeRun = this.runtime.activeSessionRun(session.id);
@@ -863,33 +887,39 @@ export class NodeConnector {
                 this.continuousRunCoordinator.removeMissionQueue(session.id);
                 const mission = this.missionRuntime.start(session.id, objective);
                 this.publishMissionState(missionSession, mission);
-                const result = await this.sessionMessageService.submitMission({
-                    sessionId: session.id,
-                    kind: 'start',
-                    content: this.missionRuntime.prompt(session.id, 'start'),
-                    deliveryIntent: replacing ? 'REPLACE_CURRENT' : 'SEND',
-                    mission: { id: mission.id, revision: mission.revision },
-                    ...(initiatedByUserId === undefined ? {} : { initiatedByUserId }),
-                    secretEnvironment,
-                    ...(personalInstructions === undefined ? {} : { personalInstructions }),
-                    ...(marAgentModel === undefined ? {} : { marAgentModel }),
-                    ...(marAgentModels === undefined ? {} : { marAgentModels }),
-                    ...(marAgentRuntimeScopeId === undefined ? {} : { marAgentRuntimeScopeId })
-                });
+                const attempt = this.beginMissionSubmission(session.id);
+                const missionRef = { id: mission.id, revision: mission.revision, epoch: attempt.epoch };
+                let result;
+                try {
+                    result = await this.sessionMessageService.submitMission({
+                        sessionId: attempt.sessionId,
+                        kind: 'start',
+                        content: this.missionRuntime.prompt(attempt.sessionId, 'start'),
+                        deliveryIntent: replacing ? 'REPLACE_CURRENT' : 'SEND',
+                        mission: missionRef,
+                        ...(initiatedByUserId === undefined ? {} : { initiatedByUserId }),
+                        secretEnvironment,
+                        ...(personalInstructions === undefined ? {} : { personalInstructions }),
+                        ...(marAgentModel === undefined ? {} : { marAgentModel }),
+                        ...(marAgentModels === undefined ? {} : { marAgentModels }),
+                        ...(marAgentRuntimeScopeId === undefined ? {} : { marAgentRuntimeScopeId })
+                    });
+                    if (!this.missionGenerationCurrent(attempt.sessionId, missionRef)) {
+                        this.removeStaleMissionSubmission(attempt.sessionId, result);
+                        throw new Error('MISSION_REVISION_STALE');
+                    }
+                }
+                finally {
+                    this.finishMissionSubmissionAttempt(attempt);
+                }
                 return {
                     ...(isPlainRecord(result) ? result : { result }),
                     missionAccessChanged: prepared.changed
                 };
             },
             clearMission: (session) => {
-                this.clearMissionRetry(session.id);
-                this.missionRuntime.clear(session.id);
-                this.continuousRunCoordinator.removeMissionQueue(session.id);
+                this.clearMissionState(session.id);
                 this.finishIdleMissionRun(session.id, 'SUCCEEDED');
-                this.commandStates.clear(session.id, 'mission');
-                this.emitWorkbenchEvent('session', {
-                    session: this.sessionPresentationService.present(session)
-                });
                 return { session: this.sessionPresentationService.present(session), cleared: true };
             }
         });
@@ -915,34 +945,40 @@ export class NodeConnector {
                     return undefined;
                 const current = this.missionRuntime.get(session.id);
                 if (current?.status === 'active') {
+                    this.invalidateMissionContinuation(session.id);
+                    const resumed = this.missionRuntime.resume(session.id);
+                    if (resumed !== current)
+                        this.publishMissionState(session, resumed);
                     return {
                         runnerContent: content,
-                        mission: { id: current.id, revision: current.revision },
+                        mission: {
+                            id: resumed.id,
+                            revision: resumed.revision,
+                            epoch: this.missionContinuationEpochs.get(session.id) ?? 0
+                        },
                         activated: false
                     };
                 }
+                this.invalidateMissionContinuation(session.id);
                 const mission = this.missionRuntime.start(session.id, content);
                 this.publishMissionState(session, mission);
                 return {
                     runnerContent: this.missionRuntime.prompt(session.id, 'start'),
-                    mission: { id: mission.id, revision: mission.revision },
+                    mission: {
+                        id: mission.id,
+                        revision: mission.revision,
+                        epoch: this.missionContinuationEpochs.get(session.id) ?? 0
+                    },
                     activated: true
                 };
             },
-            prepareMissionInsertion: (sessionId, submissionId) => this.continuousRunCoordinator.removePendingQueue(sessionId, submissionId),
-            missionPreparationFailed: (session, mission, activated) => {
-                if (!activated)
-                    return;
-                const current = this.missionRuntime.get(session.id);
-                if (current?.id !== mission.id || current.revision !== mission.revision)
-                    return;
-                this.missionRuntime.clear(session.id);
-                this.finishIdleMissionRun(session.id, 'FAILED');
-                this.commandStates.set(session.id, this.pendingMissionCommandState());
-                this.emitWorkbenchEvent('session', {
-                    session: this.sessionPresentationService.present(session)
-                });
-            }
+            prepareMissionInsertion: (sessionId, submissionId, mission) => {
+                if (!this.missionGenerationCurrent(sessionId, mission))
+                    return false;
+                this.continuousRunCoordinator.removePendingQueue(sessionId, submissionId);
+                return true;
+            },
+            missionPreparationFailed: (session, mission, activated) => this.handleMissionPreparationFailed(session, mission, activated)
         });
         this.sessionCatalogService = new SessionCatalogService({
             database: () => {
@@ -1461,16 +1497,70 @@ export class NodeConnector {
         this.missionRetryTimers.delete(sessionId);
         this.missionContinuationPending.delete(sessionId);
     }
+    invalidateMissionContinuation(sessionId) {
+        this.missionContinuationEpochs.set(sessionId, (this.missionContinuationEpochs.get(sessionId) ?? 0) + 1);
+        this.clearMissionRetry(sessionId);
+    }
+    retireMissionContinuation(sessionId) {
+        this.invalidateMissionContinuation(sessionId);
+        this.missionContinuationEpochs.delete(sessionId);
+    }
+    missionGenerationCurrent(sessionId, mission) {
+        const current = this.missionRuntime.get(sessionId);
+        return ((this.missionContinuationEpochs.get(sessionId) ?? 0) === mission.epoch &&
+            current?.status === 'active' &&
+            !current.continuationPaused &&
+            current.id === mission.id &&
+            current.revision === mission.revision);
+    }
+    beginMissionSubmission(sessionId, continuationEpoch = this.missionContinuationEpochs.get(sessionId) ?? 0) {
+        const attempt = { sessionId, epoch: continuationEpoch };
+        const attempts = this.missionSubmissionAttempts.get(sessionId) ?? new Set();
+        attempts.add(attempt);
+        this.missionSubmissionAttempts.set(sessionId, attempts);
+        return attempt;
+    }
+    finishMissionSubmissionAttempt(attempt) {
+        const attempts = this.missionSubmissionAttempts.get(attempt.sessionId);
+        attempts?.delete(attempt);
+        if (attempts?.size === 0)
+            this.missionSubmissionAttempts.delete(attempt.sessionId);
+    }
+    finishMissionContinuationAttempt(attempt) {
+        if (this.missionContinuationPending.get(attempt.sessionId) === attempt)
+            this.missionContinuationPending.delete(attempt.sessionId);
+        this.finishMissionSubmissionAttempt(attempt);
+    }
+    removeStaleMissionSubmission(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: 'MISSION_SUBMISSION_STALE' }, 'INTERRUPTED');
+    }
     async enqueueMissionContinuation(input) {
-        const attemptKey = `${input.mission.id}:${input.mission.revision}`;
-        this.missionContinuationPending.set(input.sessionId, attemptKey);
+        const attempt = this.beginMissionSubmission(input.sessionId, input.continuationEpoch);
+        const generation = { ...input.mission, epoch: attempt.epoch };
+        if (!this.missionGenerationCurrent(attempt.sessionId, generation)) {
+            this.finishMissionSubmissionAttempt(attempt);
+            return;
+        }
+        this.missionContinuationPending.set(input.sessionId, attempt);
         try {
-            await this.sessionMessageService.submitMission({
-                sessionId: input.sessionId,
+            const result = await this.sessionMessageService.submitMission({
+                sessionId: attempt.sessionId,
                 kind: 'continue',
-                content: this.missionRuntime.prompt(input.sessionId, 'continue'),
-                deliveryIntent: 'QUEUE',
-                mission: input.mission,
+                content: this.missionRuntime.prompt(attempt.sessionId, 'continue'),
+                deliveryIntent: input.deliveryIntent ?? 'QUEUE',
+                mission: generation,
                 ...(input.initiatedByUserId === undefined
                     ? {}
                     : { initiatedByUserId: input.initiatedByUserId }),
@@ -1484,72 +1574,95 @@ export class NodeConnector {
                     ? {}
                     : { marAgentRuntimeScopeId: input.marAgentRuntimeScopeId })
             });
-            const current = this.missionRuntime.get(input.sessionId);
-            if (current?.status !== 'active' ||
-                current.id !== input.mission.id ||
-                current.revision !== input.mission.revision) {
-                this.continuousRunCoordinator.removeMissionQueue(input.sessionId, current?.status === 'active' ? { id: current.id, revision: current.revision } : undefined);
-                if (this.missionContinuationPending.get(input.sessionId) === attemptKey)
-                    this.missionContinuationPending.delete(input.sessionId);
+            if (!this.missionGenerationCurrent(attempt.sessionId, generation)) {
+                this.removeStaleMissionSubmission(attempt.sessionId, result);
+                this.finishMissionContinuationAttempt(attempt);
                 return;
             }
-            this.clearMissionRetry(input.sessionId);
+            const retry = this.missionRetryTimers.get(attempt.sessionId);
+            if (retry !== undefined)
+                clearTimeout(retry.timer);
+            this.missionRetryTimers.delete(attempt.sessionId);
+            this.finishMissionContinuationAttempt(attempt);
         }
         catch (error) {
-            const current = this.missionRuntime.get(input.sessionId);
             const failedAttempts = (input.failedAttempts ?? 0) + 1;
             nodeLog('mission.continuation.enqueue.failed', {
-                sessionId: input.sessionId,
+                sessionId: attempt.sessionId,
                 missionId: input.mission.id,
                 revision: input.mission.revision,
                 attempt: failedAttempts,
                 code: safeErrorCode(error, 'MISSION_CONTINUATION_ENQUEUE_FAILED')
             });
-            if (current?.status !== 'active' ||
-                current.id !== input.mission.id ||
-                current.revision !== input.mission.revision) {
-                if (this.missionContinuationPending.get(input.sessionId) === attemptKey)
-                    this.missionContinuationPending.delete(input.sessionId);
+            if (!this.missionGenerationCurrent(attempt.sessionId, generation)) {
+                this.finishMissionContinuationAttempt(attempt);
                 return;
             }
-            const session = this.runtime.getAgentSession(input.sessionId);
+            const session = this.runtime.getAgentSession(attempt.sessionId);
             if (failedAttempts > 3 || session === undefined) {
-                this.clearMissionRetry(input.sessionId);
+                this.clearMissionRetry(attempt.sessionId);
                 if (failedAttempts > 3) {
-                    const blocked = this.missionRuntime.blockAfterRuntimeFailure(input.sessionId, input.mission.id, input.mission.revision);
-                    this.continuousRunCoordinator.removeMissionQueue(input.sessionId);
-                    this.finishIdleMissionRun(input.sessionId, 'FAILED');
+                    const blocked = this.missionRuntime.blockAfterRuntimeFailure(attempt.sessionId, input.mission.id, input.mission.revision);
+                    this.continuousRunCoordinator.removeMissionQueue(attempt.sessionId);
+                    this.missionContinuationEpochs.delete(attempt.sessionId);
+                    this.finishIdleMissionRun(attempt.sessionId, 'FAILED');
                     if (session !== undefined)
                         this.publishMissionState(session, blocked);
                 }
                 return;
             }
-            this.clearMissionRetry(input.sessionId);
+            this.finishMissionContinuationAttempt(attempt);
+            const previousRetry = this.missionRetryTimers.get(attempt.sessionId);
+            if (previousRetry !== undefined)
+                clearTimeout(previousRetry.timer);
             const retry = {
-                sessionId: input.sessionId,
+                sessionId: attempt.sessionId,
                 timer: setTimeout(() => {
-                    const current = this.missionRuntime.get(retry.sessionId);
-                    if (current?.status !== 'active' ||
-                        current.id !== input.mission.id ||
-                        current.revision !== input.mission.revision)
+                    if (!this.missionGenerationCurrent(retry.sessionId, generation))
                         return;
                     void this.enqueueMissionContinuation({
                         ...input,
                         sessionId: retry.sessionId,
-                        failedAttempts
+                        failedAttempts,
+                        continuationEpoch: attempt.epoch
                     });
                 }, 15_000)
             };
-            this.missionRetryTimers.set(input.sessionId, retry);
+            this.missionRetryTimers.set(attempt.sessionId, retry);
             retry.timer.unref();
         }
     }
+    handleMissionPreparationFailed(session, mission, activated) {
+        if (!activated || !this.missionGenerationCurrent(session.id, mission))
+            return;
+        this.missionRuntime.clear(session.id);
+        this.finishIdleMissionRun(session.id, 'FAILED');
+        this.commandStates.set(session.id, this.pendingMissionCommandState());
+        this.emitWorkbenchEvent('session', {
+            session: this.sessionPresentationService.present(session)
+        });
+    }
     finishIdleMissionRun(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: 'MISSION_CONTINUATION_FAILED' }, status);
     }
+    clearMissionState(sessionId) {
+        this.retireMissionContinuation(sessionId);
+        const removed = this.missionRuntime.clear(sessionId);
+        this.continuousRunCoordinator.removeMissionQueue(sessionId);
+        const commandState = this.commandStates.get(sessionId, 'mission');
+        if (commandState !== undefined)
+            this.commandStates.clear(sessionId, 'mission');
+        if (!removed && commandState === undefined)
+            return;
+        const session = this.runtime.getAgentSession(sessionId);
+        if (session !== undefined)
+            this.emitWorkbenchEvent('session', {
+                session: this.sessionPresentationService.present(session)
+            });
+    }
     prepareMissionSession(session) {
         const access = missionUnrestrictedAccess(session.runner);
         const changed = session.access !== access;
@@ -1604,6 +1717,8 @@ export class NodeConnector {
             clearTimeout(retry.timer);
         this.missionRetryTimers.clear();
         this.missionContinuationPending.clear();
+        this.missionSubmissionAttempts.clear();
+        this.missionContinuationEpochs.clear();
         this.runEventService.clear();
         this.sessionContextService.dispose();
         for (const run of this.claudeClient.execution.runs.values())
@@ -1655,6 +1770,9 @@ export class NodeConnector {
     emitRunEvent = (runId, eventType, payload, status) => this.runEventBridge.emitRun(runId, eventType, payload, status);
     emitConversationItem = (runId, item) => {
         this.runEventService.flushPendingText(runId);
+        if (this.continuousRunCoordinator.pending(runId)?.mission !== undefined &&
+            isMissionProgressItem(item))
+            this.missionExecutionProgress.add(runId);
         const itemId = isPlainRecord(item) && typeof item.itemId === 'string' ? item.itemId : undefined;
         const itemKind = isPlainRecord(item) && typeof item.kind === 'string' ? item.kind : undefined;
         const turn = this.runtime.conversationTurnForRun(runId);
@@ -1832,3 +1950,13 @@ export class NodeConnector {
         this.controlChannel.sendEnvelope(envelope);
     }
 }
+function isMissionProgressItem(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' && !toolName.endsWith('mar_get_mission');
+}

package/dist/runner/mar-agent/managed-run-controller.js

@@ -30,7 +30,7 @@ export class MarAgentManagedRunController {
     constructor(runner, host, options = {}) {
         this.runner = runner;
         this.host = host;
-        this.#resourceIdleTtlMs = options.resourceIdleTtlMs ?? 60_000;
+        this.#resourceIdleTtlMs = options.resourceIdleTtlMs ?? 10 * 60_000;
         this.#createAgent = options.createAgent ?? createMarAgent;
         this.#modelFactory = options.modelFactory ?? {
             create: (configurations) => configurations.map((configuration) => {
@@ -241,6 +241,8 @@ export class MarAgentManagedRunController {
         });
         this.host.emit(input.runId, 'run.started', {}, 'STARTING');
         let runtime;
+        let executionMcpLease;
+        let executionMcpBinding;
         try {
             const sessionKey = input.externalSessionId ?? input.sessionId;
             const acquisitionKeys = [...new Set([sessionKey, input.sessionId])];
@@ -268,6 +270,17 @@ export class MarAgentManagedRunController {
                 throw new Error('MAR_AGENT_SESSION_RUNTIME_ACTIVE');
             runtime.activeRunId = input.runId;
             runtime.activeAccess = input.access;
+            const executionMcpServers = input.mcpServers.filter((server) => server.lifecycle === 'EXECUTION');
+            if (executionMcpServers.length > 0) {
+                executionMcpLease = await this.#mcpClients.acquire(executionMcpServers, input.cwd, {
+                    reusable: false
+                });
+                const mcp = executionMcpLease.pool;
+                executionMcpBinding = runtime.host.bindExecutionMcp({
+                    tools: mcp.definitions(),
+                    call: async (call) => mcp.call(call.name, call.arguments)
+                });
+            }
             const session = runtime.session;
             const reasoningEffort = input.effort
                 ? marAgentReasoningEffortSchema.parse(input.effort)
@@ -332,6 +345,8 @@ export class MarAgentManagedRunController {
             this.#normalizers.delete(input.runId);
             this.host.active.delete(input.runId);
             this.#executions.delete(input.runId);
+            runtime?.host.unbindExecutionMcp(executionMcpBinding);
+            await executionMcpLease?.release().catch(() => undefined);
             if (runtime !== undefined)
                 await this.#finishRuntimeExecution(input.runId, runtime).catch(() => undefined);
         }
@@ -341,20 +356,14 @@ export class MarAgentManagedRunController {
             delete runtime.activeRunId;
             delete runtime.activeAccess;
         }
-        if (runtime.retainable)
-            this.#scheduleRuntimeRelease(runtime);
-        else
-            void this.#releaseRuntime(runtime).catch(() => undefined);
+        this.#scheduleRuntimeRelease(runtime);
     }
     async #finishRuntimeExecution(runId, runtime) {
         if (runtime.activeRunId === runId) {
             delete runtime.activeRunId;
             delete runtime.activeAccess;
         }
-        if (runtime.retainable)
-            this.#scheduleRuntimeRelease(runtime);
-        else
-            await this.#releaseRuntime(runtime);
+        this.#scheduleRuntimeRelease(runtime);
     }
     async #acquireRuntime(input) {
         if (this.#disposed)
@@ -424,10 +433,8 @@ export class MarAgentManagedRunController {
     async #createRuntime(input, sessionKey, fingerprint, hostConfiguration) {
         const dynamicCredentials = input.models.some((model) => model.credential?.type === 'RUNTIME_TICKET' ||
             model.imageGeneration?.credential?.type === 'RUNTIME_TICKET');
-        const retainable = !executionScopedMcp(input.mcpServers);
-        const mcpLease = await this.#mcpClients.acquire(input.mcpServers, input.cwd, {
-            reusable: retainable
-        });
+        const sharedMcpServers = input.mcpServers.filter((server) => server.lifecycle !== 'EXECUTION');
+        const mcpLease = await this.#mcpClients.acquire(sharedMcpServers, input.cwd);
         let agent;
         let runtime;
         try {
@@ -473,8 +480,8 @@ export class MarAgentManagedRunController {
                 fingerprint,
                 agent,
                 session,
+                host: localHost,
                 mcpLease,
-                retainable,
                 dynamicCredentials,
                 released: false
             };
@@ -672,7 +679,7 @@ function sessionRuntimeFingerprint(input, hostConfiguration) {
         defaultModelId: input.model.id,
         models: input.models.map(runtimeModelFingerprint),
         personalInstructions: input.personalInstructions ?? '',
-        mcpServers: input.mcpServers,
+        mcpServers: input.mcpServers.filter((server) => server.lifecycle !== 'EXECUTION'),
         environment: Object.entries(hostConfiguration.environment)
             .filter((entry) => entry[1] !== undefined)
             .sort(([left], [right]) => left.localeCompare(right)),
@@ -683,9 +690,6 @@ function sessionRuntimeFingerprint(input, hostConfiguration) {
 export function allowsUntrustedWebFetchTls(environment) {
     return environment['MAR_AGENT_WEB_FETCH_ALLOW_UNTRUSTED_TLS'] !== '0';
 }
-function executionScopedMcp(servers) {
-    return servers.some((server) => server.lifecycle === 'EXECUTION');
-}
 async function resolveMarAgentHostRuntimeConfiguration(secretEnvironment = {}) {
     const environment = { ...process.env, ...secretEnvironment };
     const ripgrep = await availableBundledRipgrep();

package/dist/service/continuous-run-coordinator.js

@@ -242,6 +242,11 @@ export class ContinuousRunCoordinator {
             const item = this.options.runtime.getQueueItem(itemId);
             if (item === undefined)
                 return;
+            if (!this.missionCurrent(pending)) {
+                this.deleteQueueItem(item.id);
+                this.schedule(sessionId);
+                return;
+            }
             if (this.options.runtime.claimNextQueueItem(sessionId, withNonImageAttachmentPrompt(item.content, pending.attachmentPaths)) === undefined)
                 return;
             const execution = this.options.runtime.createExecution(active.id);
@@ -257,6 +262,10 @@ export class ContinuousRunCoordinator {
             this.options.emitConversation(turn);
         }
         else if (executionId === undefined && pending !== undefined) {
+            if (!this.missionCurrent(pending)) {
+                this.rejectStaleMission(active.id);
+                return;
+            }
             const execution = this.options.runtime.createExecution(active.id);
             executionId = execution.id;
             this.preparedInputs.delete(active.id);
@@ -268,11 +277,20 @@ export class ContinuousRunCoordinator {
             return;
         if (this.dispatchedExecutions.has(executionId))
             return;
+        if (!this.missionCurrent(pending)) {
+            this.rejectStaleMission(executionId);
+            return;
+        }
         this.dispatchedExecutions.add(executionId);
         try {
             const missionMcp = pending.mission === undefined
                 ? undefined
                 : await this.options.missionMcp?.(pending);
+            if (!this.missionCurrent(pending)) {
+                this.dispatchedExecutions.delete(executionId);
+                this.rejectStaleMission(executionId);
+                return;
+            }
             this.options.control('run.start', {
                 runId: executionId,
                 sessionId: pending.sessionId,
@@ -395,6 +413,11 @@ export class ContinuousRunCoordinator {
         const item = this.options.runtime.getQueueItem(itemId);
         if (item === undefined)
             throw new Error('QUEUE_ITEM_INVALID');
+        if (!this.missionCurrent(pending)) {
+            this.deleteQueueItem(item.id);
+            this.startIdleQueue(sessionId);
+            return;
+        }
         const { run, turn } = this.options.runtime.startRunFromQueueItem(itemId, withNonImageAttachmentPrompt(item.content, pending.attachmentPaths));
         this.preparedInputs.delete(itemId);
         this.preparedInputs.set(run.id, { ...pending, runId: run.id });
@@ -410,6 +433,14 @@ export class ContinuousRunCoordinator {
             throw new Error('QUEUE_INPUT_LOST');
         return item;
     }
+    missionCurrent(pending) {
+        return (pending.mission === undefined ||
+            this.options.missionCurrent?.(pending) !== false);
+    }
+    rejectStaleMission(runId) {
+        this.remove(runId);
+        this.options.emitRun(runId, 'run.completed', { code: 'MISSION_SUBMISSION_STALE' }, 'INTERRUPTED');
+    }
     isMessageRun(run) {
         return this.options.runtime.findMessageRun(run.sessionId, run.clientMessageId)?.id === run.id;
     }

package/dist/service/mission-runtime.js

@@ -62,7 +62,9 @@ export class MissionRuntime {
             status: 'active',
             turns: 0,
             retryRequired: false,
-            retryStartedAtTurn: null
+            retryStartedAtTurn: null,
+            consecutiveNoProgressTurns: 0,
+            continuationPaused: false
         };
         this.missions.set(sessionId, mission);
         this.executionFailures.delete(sessionId);
@@ -77,22 +79,70 @@ export class MissionRuntime {
         this.missions.set(sessionId, mission);
         return mission;
     }
-    recordExecutionResult(sessionId, failed) {
+    recordExecutionResult(sessionId, input) {
         const current = this.missions.get(sessionId);
         if (current?.status !== 'active')
-            return false;
-        if (!failed) {
+            return 'continue';
+        if (!input.failed && !input.progressed) {
             this.executionFailures.delete(sessionId);
-            return false;
+            const consecutiveNoProgressTurns = current.consecutiveNoProgressTurns + 1;
+            const paused = consecutiveNoProgressTurns >= 3;
+            const mission = {
+                ...current,
+                consecutiveNoProgressTurns,
+                continuationPaused: paused
+            };
+            this.missions.set(sessionId, mission);
+            this.changed(mission);
+            return paused ? 'paused' : 'continue';
+        }
+        if (!input.failed) {
+            this.executionFailures.delete(sessionId);
+            if (current.consecutiveNoProgressTurns > 0 || current.continuationPaused) {
+                const mission = {
+                    ...current,
+                    consecutiveNoProgressTurns: 0,
+                    continuationPaused: false
+                };
+                this.missions.set(sessionId, mission);
+                this.changed(mission);
+            }
+            return 'continue';
+        }
+        if (current.consecutiveNoProgressTurns > 0 || current.continuationPaused) {
+            const mission = {
+                ...current,
+                consecutiveNoProgressTurns: 0,
+                continuationPaused: false
+            };
+            this.missions.set(sessionId, mission);
         }
         const failures = (this.executionFailures.get(sessionId) ?? 0) + 1;
         this.executionFailures.set(sessionId, failures);
         if (failures <= 3)
-            return false;
-        const blocked = { ...current, status: 'blocked' };
+            return 'continue';
+        const blocked = {
+            ...(this.missions.get(sessionId) ?? current),
+            status: 'blocked'
+        };
         this.missions.set(sessionId, blocked);
         this.changed(blocked);
-        return true;
+        return 'blocked';
+    }
+    resume(sessionId) {
+        const current = this.missions.get(sessionId);
+        if (current?.status !== 'active')
+            return current;
+        if (!current.continuationPaused && current.consecutiveNoProgressTurns === 0)
+            return current;
+        const mission = {
+            ...current,
+            consecutiveNoProgressTurns: 0,
+            continuationPaused: false
+        };
+        this.missions.set(sessionId, mission);
+        this.changed(mission);
+        return mission;
     }
     blockAfterRuntimeFailure(sessionId, missionId, revision) {
         const current = this.requireCurrent(sessionId, missionId, revision);
@@ -137,7 +187,7 @@ export class MissionRuntime {
         if (mission?.status !== 'active')
             throw new Error('MISSION_NOT_ACTIVE');
         const heading = kind === 'start' ? 'A Mission has started or changed.' : 'Continue the active Mission.';
-        return `${START_OPEN}\n${heading}\n\nOriginal objective:\n${mission.objective}\n\nMission rules:\n- The Mission persists across turns; ending this turn does not end it.\n- Do not narrow or rewrite the original objective to finish early. Continue making concrete progress while it is incomplete.\n- Before completion, review the full original objective and verify it with actual evidence such as code, tests, commands, or runtime results.\n- Call mar_update_mission with status=completed only after every part is complete and verified.\n- A single failed command, test, or edit is not a blocker. Analyze it, adapt, and retry.\n- Request blocked only after the same blocker has persisted for three Mission turns. One additional real retry is required before blocked can be accepted.\n- Use mar_get_mission whenever you need to reread the authoritative objective or status.\n${START_CLOSE}`;
+        return `${START_OPEN}\n${heading}\n\nOriginal objective:\n${mission.objective}\n\nContinue executing this Mission across turns:\n- Work on the objective now. If it is incomplete, use tools to finish a coherent unit or obtain decisive evidence; do not stop at an acknowledgement, status, plan, or promise.\n- Preserve the original scope. Before completion, review the full objective and verify it with real evidence, then call mar_update_mission with status=completed.\n- Adapt and retry after individual failures. Request blocked only after the same blocker persists for three turns and the required additional retry.\n- Use mar_get_mission only when you need to reread the authoritative objective or status.\n${START_CLOSE}`;
     }
     requireCurrent(sessionId, missionId, revision) {
         const current = this.missions.get(sessionId);

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

@@ -55,10 +55,11 @@ export class RunWorkbenchService {
         const run = this.options.runtime.activeSessionRun(session.id);
         if (run === undefined || isTerminalRunStatus(run.status))
             throw new Error('RUN_NOT_FOUND');
-        return this.cancelOrInterrupt('run.interrupt', {
+        const result = this.cancelOrInterrupt('run.interrupt', {
             runId: run.id,
             __requestUserId: input.__requestUserId
         });
+        return result;
     }
     cancelOrInterrupt(operation, input) {
         const run = this.requireOwnedRun(input.runId, input.__requestUserId);
@@ -66,14 +67,19 @@ export class RunWorkbenchService {
         const executionId = this.options.runtime.currentExecutionId(run.id);
         const turn = this.options.runtime.conversationTurnForRun(run.id);
         const controlRunId = executionId ?? (turn === undefined || turn.userItemId === null ? run.id : undefined);
-        this.options.pauseQueue(run.sessionId);
-        if (controlRunId === undefined) {
-            this.options.markInterrupted(run.id);
-            this.options.emitRun(run.id, 'run.interrupted', { code: 'USER_INTERRUPTED' }, 'INTERRUPTED');
+        try {
+            this.options.pauseQueue(run.sessionId);
+            if (controlRunId === undefined) {
+                this.options.markInterrupted(run.id);
+                this.options.emitRun(run.id, 'run.interrupted', { code: 'USER_INTERRUPTED' }, 'INTERRUPTED');
+            }
+            else {
+                this.options.markInterrupted(controlRunId);
+                this.options.control(operation, { runId: controlRunId });
+            }
         }
-        else {
-            this.options.markInterrupted(controlRunId);
-            this.options.control(operation, { runId: controlRunId });
+        finally {
+            this.options.runInterrupted(run.sessionId);
         }
         return { run: next };
     }

package/dist/service/session-message-service.js

@@ -168,8 +168,9 @@ export class SessionMessageService {
                         ...(runner.serviceTier() === 'fast' ? { serviceTier: 'fast' } : {})
                     });
                     this.options.attachments.cache(submissionId, imageAttachments);
-                    if (missionMessage !== undefined)
-                        this.options.prepareMissionInsertion(session.id, submissionId);
+                    if (missionMessage !== undefined &&
+                        !this.options.prepareMissionInsertion(session.id, submissionId, missionMessage.mission))
+                        throw new Error('MISSION_REVISION_STALE');
                     const delivery = this.options.coordinator.settle({
                         submissionId,
                         intent,
@@ -269,5 +270,6 @@ function isMissionRef(value) {
     return (value !== null &&
         typeof value === 'object' &&
         typeof value.id === 'string' &&
-        Number.isInteger(value.revision));
+        Number.isInteger(value.revision) &&
+        Number.isInteger(value.epoch));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myagentroam/node",
-  "version": "0.9.89",
+  "version": "0.9.90",
   "description": "MyAgentRoam Node runtime CLI.",
   "license": "Apache-2.0",
   "type": "module",
@@ -28,8 +28,8 @@
     "node-pty": "1.1.0",
     "ws": "^8.21.3",
     "zod": "4.4.3",
-    "@myagentroam/agent": "0.9.89",
-    "@myagentroam/protocol": "0.9.89"
+    "@myagentroam/agent": "0.9.90",
+    "@myagentroam/protocol": "0.9.90"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1"