@myagentroam/node 0.11.6 → 0.11.8

package/dist/runner/opencode/managed-run-controller.js

@@ -18,6 +18,7 @@ export class OpenCodeManagedRunController {
     startingCwds = new Map();
     promptAdmitted = new Set();
     pendingIdle = new Set();
+    cancelling = new Set();
     messageRoles = new Map();
     messageParents = new Map();
     compactionPartIds = new Map();
@@ -158,11 +159,12 @@ export class OpenCodeManagedRunController {
         const execution = this.runner.execution.get(runId);
         if (execution === undefined)
             return false;
-        void execution.client.abort(execution.cwd, execution.nativeSessionId).finally(() => {
-            this.finish(runId, intent === 'INTERRUPT' ? 'INTERRUPTED' : 'CANCELLED', 'run.completed', {
-                status: intent === 'INTERRUPT' ? 'INTERRUPTED' : 'CANCELLED'
-            });
-        });
+        if (this.cancelling.has(runId))
+            return true;
+        this.cancelling.add(runId);
+        void execution.client.abort(execution.cwd, execution.nativeSessionId).then(() => this.finish(runId, intent === 'INTERRUPT' ? 'INTERRUPTED' : 'CANCELLED', 'run.completed', {
+            status: intent === 'INTERRUPT' ? 'INTERRUPTED' : 'CANCELLED'
+        }), (error) => this.finish(runId, 'FAILED', 'run.failed', error, 'OPENCODE_CANCEL_FAILED'));
         return true;
     }
     decideApproval(input) {
@@ -207,6 +209,10 @@ export class OpenCodeManagedRunController {
         this.startingCwds.set(input.runId, input.cwd);
         this.host.active.add(input.runId);
         this.host.emit(input.runId, 'run.started', {}, 'STARTING');
+        let settlePrompt;
+        const promptSettled = new Promise((resolve) => {
+            settlePrompt = resolve;
+        });
         try {
             if (hasMcpConfiguration(input.mcp))
                 await client.configureMcp(input.cwd, input.mcp);
@@ -251,16 +257,22 @@ export class OpenCodeManagedRunController {
             });
             void client
                 .subscribe(input.cwd, abort.signal, (event) => this.event(input.runId, nativeSessionId, event), ready)
-                .catch((error) => {
-                if (abort.signal.aborted)
-                    return;
+                .then(() => {
+                throw new Error('OPENCODE_EVENT_STREAM_ENDED');
+            })
+                .catch(async (error) => {
                 if (!subscriptionStarted) {
                     rejectReady(error);
                     return;
                 }
-                this.finish(input.runId, 'FAILED', 'run.failed', error, 'OPENCODE_EVENT_FAILED');
+                await promptSettled;
+                if (abort.signal.aborted || this.cancelling.has(input.runId))
+                    return;
+                await this.recoverSubscription(input.runId);
             });
             await subscriptionReady;
+            if (abort.signal.aborted || this.cancelling.has(input.runId))
+                return;
             this.host.emit(input.runId, 'run.running', {}, 'RUNNING');
             // The initial SSE snapshot can contain an idle event from before this prompt.
             this.pendingIdle.delete(input.runId);
@@ -277,7 +289,7 @@ export class OpenCodeManagedRunController {
                     ? existingImagePaths
                     : await this.host.persistAttachments(input.cwd, input.runId, input.attachments);
             const execution = this.runner.execution.get(input.runId);
-            if (execution?.abort !== abort || abort.signal.aborted)
+            if (execution?.abort !== abort || abort.signal.aborted || this.cancelling.has(input.runId))
                 return;
             execution.responseLatency = new ResponseLatencyTracker();
             execution.responsePartKinds = new Map();
@@ -294,12 +306,103 @@ export class OpenCodeManagedRunController {
                 ...(input.personalInstructions === undefined ? {} : { system: input.personalInstructions }),
                 attachments: input.attachments
             });
+            if (this.runner.execution.get(input.runId) !== execution || abort.signal.aborted)
+                return;
             this.promptAdmitted.add(input.runId);
             if (this.pendingIdle.delete(input.runId))
                 this.finish(input.runId, 'SUCCEEDED', 'run.completed', { status: 'SUCCEEDED' });
         }
         catch (error) {
-            this.finish(input.runId, 'FAILED', 'run.failed', error, 'OPENCODE_RUN_START_FAILED');
+            if (!this.cancelling.has(input.runId))
+                this.finish(input.runId, 'FAILED', 'run.failed', error, 'OPENCODE_RUN_START_FAILED');
+        }
+        finally {
+            settlePrompt();
+        }
+    }
+    async recoverSubscription(runId) {
+        const execution = this.runner.execution.get(runId);
+        if (execution === undefined)
+            return;
+        const { client, cwd, nativeSessionId, abort } = execution;
+        // A missing event interval and historical replay cannot produce live performance timings.
+        delete execution.responseLatency;
+        delete execution.generationTiming;
+        const buffered = [];
+        let reconciling = true;
+        let reconciliation;
+        const fail = (error) => {
+            if (!abort.signal.aborted && !this.cancelling.has(runId))
+                this.finish(runId, 'FAILED', 'run.failed', error, 'OPENCODE_EVENT_FAILED');
+        };
+        try {
+            await client.subscribe(cwd, abort.signal, (event) => {
+                if (reconciling)
+                    buffered.push(event);
+                else
+                    this.event(runId, nativeSessionId, event);
+            }, () => {
+                reconciliation = (async () => {
+                    const signal = AbortSignal.any([abort.signal, AbortSignal.timeout(10_000)]);
+                    const status = record(await client.sessionStatus(cwd, nativeSessionId, signal));
+                    if (abort.signal.aborted || this.cancelling.has(runId))
+                        return;
+                    const messages = await client.messages(cwd, nativeSessionId, 100, {
+                        since: execution.responseStartedAt ?? Infinity,
+                        signal
+                    });
+                    if (abort.signal.aborted || this.cancelling.has(runId))
+                        return;
+                    // Fold queued content before the authoritative snapshot; terminal events must
+                    // wait until the recovered items have been published.
+                    const terminalEvents = [];
+                    for (const event of buffered) {
+                        const type = record(event)?.type;
+                        if (type === 'session.idle' || type === 'session.error')
+                            terminalEvents.push(event);
+                        else
+                            this.event(runId, nativeSessionId, event);
+                    }
+                    buffered.length = 0;
+                    for (const value of messages) {
+                        const message = record(value);
+                        const info = record(message?.info);
+                        // Do not replay earlier turns into the current Run.
+                        const created = record(info?.time)?.created;
+                        if (typeof created !== 'number' ||
+                            created < (execution.responseStartedAt ?? Infinity))
+                            continue;
+                        this.event(runId, nativeSessionId, { type: 'message.updated', properties: { info } });
+                        if (Array.isArray(message?.parts))
+                            for (const part of message.parts)
+                                this.event(runId, nativeSessionId, {
+                                    type: 'message.part.updated',
+                                    properties: { part }
+                                });
+                        if (info?.role === 'assistant' && info.error !== undefined) {
+                            this.finish(runId, 'FAILED', 'run.failed', info.error);
+                            return;
+                        }
+                    }
+                    reconciling = false;
+                    for (const event of terminalEvents)
+                        this.event(runId, nativeSessionId, event);
+                    if (abort.signal.aborted)
+                        return;
+                    if (status?.type === 'idle')
+                        this.event(runId, nativeSessionId, {
+                            type: 'session.idle',
+                            properties: { sessionID: nativeSessionId }
+                        });
+                    else if (status?.type !== 'busy' && status?.type !== 'retry')
+                        throw new Error('OPENCODE_SESSION_STATUS_INVALID');
+                })().catch(fail);
+            });
+            await reconciliation;
+            fail(new Error('OPENCODE_EVENT_STREAM_ENDED'));
+        }
+        catch (error) {
+            fail(error);
         }
     }
     event(runId, nativeSessionId, value) {
@@ -307,6 +410,8 @@ export class OpenCodeManagedRunController {
         const properties = record(event?.properties);
         const nested = record(properties?.part) ?? record(properties?.info);
         const execution = this.runner.execution.get(runId);
+        if (execution === undefined)
+            return;
         const receiptAt = execution?.generationTiming?.timestamp();
         const sessionID = typeof properties?.sessionID === 'string'
             ? properties.sessionID
@@ -648,6 +753,7 @@ export class OpenCodeManagedRunController {
         this.startingClients.delete(runId);
         this.promptAdmitted.delete(runId);
         this.pendingIdle.delete(runId);
+        this.cancelling.delete(runId);
         this.messageRoles.delete(runId);
         this.messageParents.delete(runId);
         this.compactionPartIds.delete(runId);

package/dist/runner/opencode-runner.js

@@ -1,3 +1,4 @@
+import { withMarctlGuide } from '../mcp/marctl-guide.js';
 import { OpenCodeServerClient } from '../opencode-server.js';
 import { openCodeContextLimits, openCodeProfileModels } from '../opencode-runtime.js';
 import { declaredRunnerProfiles } from '../runner-profiles.js';
@@ -169,7 +170,7 @@ export class OpenCodeRunner extends AbstractRunner {
         this.profileRefreshTimer.unref();
     }
     mcpConfiguration(raw, secrets, executionServers = []) {
-        const servers = super.mcpConfiguration(raw, secrets, executionServers);
+        const servers = withMarctlGuide(super.mcpConfiguration(raw, secrets, executionServers), secrets);
         return Object.fromEntries(servers.map((server) => [
             server.name,
             server.transport === 'STDIO'

package/dist/runtime-state.js

@@ -25,6 +25,7 @@ export class NodeRuntimeState {
     recentUserMessages = new Map();
     messageSubmissions = new Map();
     failedMessageSubmissions = new Map();
+    terminalMessageSubmissions = new Map();
     queueItems = new Map();
     executions = new Map();
     retainedExecutionTurns = new Map();
@@ -286,6 +287,10 @@ export class NodeRuntimeState {
             this.messageSubmissions.delete(key);
             this.messageSubmissions.set(`${nativeSessionId}${key.slice(id.length)}`, submission);
         }
+        const terminalSubmissions = [...this.terminalMessageSubmissions];
+        this.terminalMessageSubmissions.clear();
+        for (const [key, runId] of terminalSubmissions)
+            this.terminalMessageSubmissions.set(key.startsWith(`${id}\u0000`) ? `${nativeSessionId}${key.slice(id.length)}` : key, runId);
         for (const [executionId, reference] of this.retainedExecutionTurns)
             if (reference.sessionId === id)
                 this.retainedExecutionTurns.set(executionId, {
@@ -689,9 +694,13 @@ export class NodeRuntimeState {
         return submission?.kind === 'run' ? this.runs.get(submission.id) : undefined;
     }
     findMessageSubmission(sessionId, clientMessageId) {
-        const submission = this.messageSubmissions.get(`${sessionId}\u0000${clientMessageId}`);
-        if (submission === undefined)
-            return undefined;
+        const key = `${sessionId}\u0000${clientMessageId}`;
+        const submission = this.messageSubmissions.get(key);
+        if (submission === undefined) {
+            const runId = this.terminalMessageSubmissions.get(key);
+            const run = runId === undefined ? undefined : this.terminalRunIds.get(runId);
+            return run === undefined ? undefined : { kind: 'run', run };
+        }
         if (submission.kind === 'run')
             return { kind: 'run', run: this.requireRun(submission.id) };
         const item = this.requireQueueItem(submission.id);
@@ -1016,8 +1025,13 @@ export class NodeRuntimeState {
         if (!terminal(run.status))
             throw new Error('RUN_ACTIVE');
         this.terminalRunIds.set(runId, run);
-        if (this.terminalRunIds.size > 1_024)
-            this.terminalRunIds.delete(this.terminalRunIds.keys().next().value);
+        if (this.terminalRunIds.size > 1_024) {
+            const oldest = this.terminalRunIds.keys().next().value;
+            this.terminalRunIds.delete(oldest);
+            for (const [key, id] of this.terminalMessageSubmissions)
+                if (id === oldest)
+                    this.terminalMessageSubmissions.delete(key);
+        }
         const executionIds = new Set([...this.executions.values()]
             .filter((execution) => execution.runId === runId)
             .map((execution) => execution.id));
@@ -1051,12 +1065,21 @@ export class NodeRuntimeState {
         this.recentUserMessages.delete(runId);
         this.runSequences.delete(runId);
         for (const [key, candidate] of this.messageSubmissions)
-            if (candidate.kind === 'run' && candidate.id === runId)
+            if (candidate.kind === 'run' && candidate.id === runId) {
                 this.messageSubmissions.delete(key);
+                this.terminalMessageSubmissions.set(key, runId);
+                if (this.terminalMessageSubmissions.size > 1_024)
+                    this.terminalMessageSubmissions.delete(this.terminalMessageSubmissions.keys().next().value);
+            }
         for (const [approvalId, approval] of this.approvals)
             if (approval.runId === runId || executionIds.has(approval.runId))
                 this.approvals.delete(approvalId);
     }
+    clearTerminalMessageSubmissions(sessionId) {
+        for (const key of this.terminalMessageSubmissions.keys())
+            if (key.startsWith(`${sessionId}\u0000`))
+                this.terminalMessageSubmissions.delete(key);
+    }
     hasActiveWorkspaceLease(workspaceId) {
         return [...this.leases.values()]
             .map((runId) => this.runs.get(runId))
@@ -1073,6 +1096,7 @@ export class NodeRuntimeState {
             .filter((execution) => runIds.has(execution.runId))
             .map((execution) => execution.id));
         this.sessions.delete(sessionId);
+        this.clearTerminalMessageSubmissions(sessionId);
         this.completeHistorySessions.delete(sessionId);
         this.removePromotedSessionAliases(sessionId);
         this.turns.delete(sessionId);
@@ -1125,6 +1149,7 @@ export class NodeRuntimeState {
         if (this.sessionQueue(sessionId).itemIds.length > 0)
             throw new Error('SESSION_QUEUE_NOT_EMPTY');
         this.turns.delete(sessionId);
+        this.clearTerminalMessageSubmissions(sessionId);
         for (const [id, run] of this.terminalRunIds)
             if (run?.sessionId === sessionId)
                 this.terminalRunIds.set(id, undefined);
@@ -1148,6 +1173,7 @@ export class NodeRuntimeState {
         const queueItemIds = new Set([...sessionIds].flatMap((sessionId) => this.queuedItems.get(sessionId) ?? []));
         for (const sessionId of sessionIds) {
             this.sessions.delete(sessionId);
+            this.clearTerminalMessageSubmissions(sessionId);
             this.completeHistorySessions.delete(sessionId);
             this.removePromotedSessionAliases(sessionId);
             this.turns.delete(sessionId);

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

@@ -605,7 +605,7 @@ export class ContinuousRunCoordinator {
                 runId: executionId,
                 sessionId: pending.sessionId,
                 workspaceId: pending.workspaceId,
-                runner: pending.runner,
+                ...pending.executionContext,
                 input: pending.input,
                 ...(pending.clientMessageId === undefined
                     ? {}
@@ -626,17 +626,9 @@ export class ContinuousRunCoordinator {
                     MAR_CTL_WORKSPACE_ID: pending.workspaceId,
                     MAR_CTL_SESSION_ID: this.options.runtime.getAgentSession(pending.sessionId)?.id ?? pending.sessionId,
                     MAR_CTL_RUN_ID: active.id,
-                    MAR_CTL_RUNNER: pending.runner
+                    MAR_CTL_RUNNER: pending.executionContext.runner
                 },
                 ...(personalInstructions === undefined ? {} : { personalInstructions }),
-                ...(pending.marAgentModel === undefined ? {} : { marAgentModel: pending.marAgentModel }),
-                ...(pending.marAgentModels === undefined ? {} : { marAgentModels: pending.marAgentModels }),
-                ...(pending.marAgentCompact === undefined
-                    ? {}
-                    : { marAgentCompact: pending.marAgentCompact }),
-                ...(pending.marAgentRuntimeScopeId === undefined
-                    ? {}
-                    : { marAgentRuntimeScopeId: pending.marAgentRuntimeScopeId }),
                 ...(pending.computerUse === undefined ? {} : { computerUse: pending.computerUse }),
                 mcpInstallations: this.options.mcps(pending.workspaceId),
                 executionMcpServers: [goalMcp, scheduleMcp, notificationMcp].filter((server) => server !== undefined)

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

@@ -2,6 +2,7 @@ import { projectConversationWorkProcesses } from './conversation-work-process.js
 import { discoverNativeSessions, readNativeSession } from '../native-session-history.js';
 import { nativeConversationPage } from '../util/runner-native-session-parsers.js';
 import { isPlainRecord } from '../util/node-operation-parsers.js';
+import { conversationClientMessageId } from '../util/conversation-identity.js';
 import { nodeLog } from '../operational.js';
 export function hasManagedActiveRun(runtime, session) {
     return (session.nativeControl === 'MAR_MANAGED' &&
@@ -475,34 +476,29 @@ export class ConversationHistoryService {
     }
     async readManagedRuntime(session, input, cursor, snapshotSequence, readAt) {
         const page = await this.readManagedActive(session, input, cursor, snapshotSequence, readAt);
-        const codexActive = session.runner === 'codex' && this.options.hasManagedActiveRun(session);
-        if (input.cursor !== undefined ||
-            session.externalSessionId === null ||
-            !codexActive ||
-            !page.turns.some((turn) => turn.rewind === undefined &&
-                terminalConversationTurn(turn.status) &&
-                conversationClientMessageId(turn) !== null))
-            return page;
-        // A completed managed Turn keeps its live items and Run identity until Runtime cleanup.
-        // Only its matched native Turn may supply a Rewind boundary.
-        const historyInput = { limit: Math.min(500, Math.max(30, page.turns.length + 1)) };
-        const authoritative = (await this.readRunnerHistory(session, historyInput).catch(() => undefined))?.page;
-        if (authoritative === undefined)
+        try {
+            const supplements = await this.options.runners
+                .require(session.runner)
+                .readConversationRewind({
+                session,
+                turns: page.turns,
+                managedActive: this.options.hasManagedActiveRun(session),
+                firstPage: input.cursor === undefined,
+                readHistory: async (historyInput) => (await this.readRunnerHistory(session, historyInput)).page
+            });
+            if (supplements.size === 0)
+                return page;
+            return {
+                ...page,
+                turns: page.turns.map((turn) => {
+                    const rewind = supplements.get(turn.id);
+                    return turn.rewind !== undefined || rewind === undefined ? turn : { ...turn, rewind };
+                })
+            };
+        }
+        catch {
             return page;
-        return {
-            ...page,
-            turns: page.turns.map((turn) => {
-                if (turn.rewind !== undefined || !terminalConversationTurn(turn.status))
-                    return turn;
-                const messageId = conversationClientMessageId(turn);
-                if (messageId === null)
-                    return turn;
-                const native = authoritative.turns.find((candidate) => candidate.rewind !== undefined &&
-                    candidate.userItemId !== null &&
-                    conversationClientMessageId(candidate) === messageId);
-                return native?.rewind === undefined ? turn : { ...turn, rewind: native.rewind };
-            })
-        };
+        }
     }
     async refreshExternalActivity(session) {
         const runner = this.options.runners.require(session.runner);
@@ -754,19 +750,6 @@ function sameConversationTurn(left, right) {
         candidate.id === `${local.runId}:${item.id}` &&
         ((native.userItemId === null && local.userItemId === null) || item.kind === 'error')));
 }
-function terminalConversationTurn(status) {
-    return ['SUCCEEDED', 'FAILED', 'CANCELLED', 'INTERRUPTED', 'LOST'].includes(status);
-}
-function conversationClientMessageId(turn) {
-    for (const item of turn.items) {
-        if (item.kind !== 'user_message' || !isPlainRecord(item.payload))
-            continue;
-        const value = item.payload.clientMessageId;
-        if (typeof value === 'string' && value.length > 0)
-            return value;
-    }
-    return null;
-}
 function sourceRank(source) {
     if (source === 'official')
         return 3;

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

@@ -43,7 +43,9 @@ export function conversationSegments(turn) {
             ...(turn.rewind === undefined ? {} : { rewind: turn.rewind }),
             items: projectedItems,
             startedAt: projectedItems[0]?.startedAt ?? turn.startedAt,
-            completedAt: projectedItems.at(-1)?.completedAt ?? null
+            completedAt: latest
+                ? (turn.completedAt ?? null)
+                : (projectedItems.at(-1)?.completedAt ?? null)
         };
     });
 }

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

@@ -111,16 +111,7 @@ export class GoalContinuationCoordinator {
                     ...(pending.personalInstructions === undefined
                         ? {}
                         : { personalInstructions: pending.personalInstructions }),
-                    ...(pending.marAgentModel === undefined ? {} : { marAgentModel: pending.marAgentModel }),
-                    ...(pending.marAgentModels === undefined
-                        ? {}
-                        : { marAgentModels: pending.marAgentModels }),
-                    ...(pending.marAgentCompact === undefined
-                        ? {}
-                        : { marAgentCompact: pending.marAgentCompact }),
-                    ...(pending.marAgentRuntimeScopeId === undefined
-                        ? {}
-                        : { marAgentRuntimeScopeId: pending.marAgentRuntimeScopeId }),
+                    executionContext: pending.executionContext,
                     continuationEpoch,
                     deliveryIntent: 'SEND'
                 });
@@ -182,7 +173,7 @@ export class GoalContinuationCoordinator {
             goalAccessChanged: prepared.changed
         };
     }
-    async start({ session, objective, initiatedByUserId, suppressNotifications, secretEnvironment, personalInstructions, marAgentModel, marAgentModels, marAgentCompact, marAgentRuntimeScopeId, usageGrant }) {
+    async start({ session, objective, initiatedByUserId, suppressNotifications, secretEnvironment, personalInstructions, executionContext, usageGrant }) {
         this.invalidateGoalContinuation(session.id);
         const prepared = this.prepareGoalSession(session);
         const goalSession = prepared.session;
@@ -208,10 +199,7 @@ export class GoalContinuationCoordinator {
                 ...(initiatedByUserId === undefined ? {} : { initiatedByUserId }),
                 secretEnvironment,
                 ...(personalInstructions === undefined ? {} : { personalInstructions }),
-                ...(marAgentModel === undefined ? {} : { marAgentModel }),
-                ...(marAgentModels === undefined ? {} : { marAgentModels }),
-                ...(marAgentCompact === undefined ? {} : { marAgentCompact }),
-                ...(marAgentRuntimeScopeId === undefined ? {} : { marAgentRuntimeScopeId })
+                executionContext
             });
             if (!this.goalGenerationCurrent(attempt.sessionId, goalRef)) {
                 this.removeStaleGoalSubmission(attempt.sessionId, result);
@@ -330,12 +318,7 @@ export class GoalContinuationCoordinator {
             ...(input.personalInstructions === undefined
                 ? {}
                 : { personalInstructions: input.personalInstructions }),
-            ...(input.marAgentModel === undefined ? {} : { marAgentModel: input.marAgentModel }),
-            ...(input.marAgentModels === undefined ? {} : { marAgentModels: input.marAgentModels }),
-            ...(input.marAgentCompact === undefined ? {} : { marAgentCompact: input.marAgentCompact }),
-            ...(input.marAgentRuntimeScopeId === undefined
-                ? {}
-                : { marAgentRuntimeScopeId: input.marAgentRuntimeScopeId })
+            executionContext: input.executionContext
         });
         if (updated !== undefined &&
             session !== undefined &&
@@ -440,12 +423,7 @@ export class GoalContinuationCoordinator {
                 ...(input.personalInstructions === undefined
                     ? {}
                     : { personalInstructions: input.personalInstructions }),
-                ...(input.marAgentModel === undefined ? {} : { marAgentModel: input.marAgentModel }),
-                ...(input.marAgentModels === undefined ? {} : { marAgentModels: input.marAgentModels }),
-                ...(input.marAgentCompact === undefined ? {} : { marAgentCompact: input.marAgentCompact }),
-                ...(input.marAgentRuntimeScopeId === undefined
-                    ? {}
-                    : { marAgentRuntimeScopeId: input.marAgentRuntimeScopeId })
+                executionContext: input.executionContext
             });
             if (!this.goalGenerationCurrent(attempt.sessionId, generation)) {
                 this.removeStaleGoalSubmission(attempt.sessionId, result);

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

@@ -1,5 +1,6 @@
 import { parseComposerTags, serializeComposerTag } from '@myagentroam/protocol';
 import { parseMessageAttachments } from '../util/node-operation-parsers.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. */
 export class RestartSessionRestorer {
@@ -79,10 +80,7 @@ export class RestartSessionRestorer {
                 __suppressNotifications: input.suppressNotifications === true,
                 secretEnvironment: context.secretEnvironment,
                 personalInstructions: context.personalInstructions,
-                marAgentModel: context.marAgentModel,
-                marAgentModels: context.marAgentModels,
-                marAgentCompact: context.marAgentCompact,
-                marAgentRuntimeScopeId: context.marAgentRuntimeScopeId,
+                [RUNNER_EXECUTION_CONTEXT]: context.executionContext,
                 __usageGrant: context.usageGrant
             }));
             if (input.immediate)
@@ -124,10 +122,7 @@ ${RESTART_NOTICE}`,
                     ...(typeof context.personalInstructions === 'string'
                         ? { personalInstructions: context.personalInstructions }
                         : {}),
-                    marAgentModel: context.marAgentModel,
-                    marAgentModels: context.marAgentModels,
-                    marAgentCompact: context.marAgentCompact,
-                    marAgentRuntimeScopeId: context.marAgentRuntimeScopeId
+                    executionContext: context.executionContext
                 }));
             }
             if (!entry.paused)

package/dist/service/scheduled-session-coordinator.js

@@ -14,7 +14,9 @@ export class ScheduledSessionCoordinator {
         if (run.source !== 'SCHEDULED')
             return;
         const store = this.options.store();
-        store.finish(run.clientMessageId, status === 'SUCCEEDED' ? 'SUCCEEDED' : 'FAILED', status === 'SUCCEEDED' ? undefined : `SCHEDULE_RUN_${status}`, run.id);
+        const finished = store.finish(run.clientMessageId, status === 'SUCCEEDED' ? 'SUCCEEDED' : 'FAILED', status === 'SUCCEEDED' ? undefined : `SCHEDULE_RUN_${status}`, run.id);
+        if (!finished)
+            return;
         const task = store.getById(run.clientMessageId.split(':', 1)[0]);
         if (task !== undefined)
             this.publishTaskNotification(task, run.clientMessageId, {
@@ -169,8 +171,8 @@ export class ScheduledSessionCoordinator {
             }
             if (failureCode !== undefined) {
                 const status = submitting && failureCode !== 'SCHEDULE_SESSION_BUSY' ? 'FAILED' : 'SKIPPED';
-                this.options.store().finish(occurrenceId, status, failureCode);
-                this.notify(task, occurrenceId, failureCode, status);
+                if (this.options.store().finish(occurrenceId, status, failureCode))
+                    this.notify(task, occurrenceId, failureCode, status);
             }
         }
     }

package/dist/service/scheduled-session-recurrence.js

@@ -37,17 +37,44 @@ export function nextScheduledAt(cron, timezone, after) {
         year: 'numeric',
         month: '2-digit',
         day: '2-digit',
-        weekday: 'short',
         hour: '2-digit',
         minute: '2-digit',
         hourCycle: 'h23'
     });
-    const previousKey = localKey(formatter, after);
-    let candidate = Math.floor(after / 60_000) * 60_000 + 60_000;
-    for (let index = 0; index < 8 * 366 * 24 * 60; index++, candidate += 60_000) {
-        const local = localParts(formatter, candidate);
-        if (matches(schedule, local) && local.key !== previousKey)
-            return candidate;
+    const start = localParts(formatter, after);
+    const dayMs = 24 * 60 * 60_000;
+    const limit = Math.floor(after / 60_000) * 60_000 + 8 * 366 * dayMs;
+    const firstDay = Date.UTC(start.year, start.month - 1, start.day);
+    const hours = [...schedule.hour].sort((a, b) => a - b);
+    const minutes = [...schedule.minute].sort((a, b) => a - b);
+    // These are calendar dates represented in UTC, not fixed-length local days.
+    for (let day = firstDay; day <= limit + dayMs; day += dayMs) {
+        const date = new Date(day);
+        if (!matchesDate(schedule, date))
+            continue;
+        // Sample both sides of this date to include offsets on either side of a
+        // transition, including half-hour folds and whole-day calendar jumps.
+        const offsets = new Set([day - dayMs, day, day + 2 * dayMs].map((time) => localParts(formatter, time).timestamp - time));
+        for (const hour of hours) {
+            if (day === firstDay && hour < start.hour)
+                continue;
+            for (const minute of minutes) {
+                if (day === firstDay && hour === start.hour && minute < start.minute)
+                    continue;
+                const localTime = day + (hour * 60 + minute) * 60_000;
+                let earliest = Infinity;
+                for (const offset of offsets) {
+                    const candidate = localTime - offset;
+                    if (localParts(formatter, candidate).timestamp === localTime) {
+                        earliest = Math.min(earliest, candidate);
+                    }
+                }
+                // Resolve an ambiguous minute before filtering by after: the second
+                // physical occurrence must never become a replacement for the first.
+                if (earliest > after && earliest <= limit)
+                    return earliest;
+            }
+        }
     }
     throw new Error('SCHEDULE_NEXT_TIME_UNAVAILABLE');
 }
@@ -135,23 +162,21 @@ function localParts(formatter, time) {
     const minute = Number(fields['minute']);
     const day = Number(fields['day']);
     const month = Number(fields['month']);
-    const weekday = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'].indexOf(fields['weekday'] ?? '');
+    const year = Number(fields['year']);
     return {
+        year,
         hour,
         minute,
         day,
         month,
-        weekday,
-        key: `${fields['year']}-${fields['month']}-${fields['day']}T${fields['hour']}:${fields['minute']}`
+        timestamp: Date.UTC(year, month - 1, day, hour, minute)
     };
 }
-function matches(schedule, local) {
-    if (!schedule.minute.has(local.minute) ||
-        !schedule.hour.has(local.hour) ||
-        !schedule.month.has(local.month))
+function matchesDate(schedule, date) {
+    if (!schedule.month.has(date.getUTCMonth() + 1))
         return false;
-    const dayOfMonthMatches = schedule.dayOfMonth.has(local.day);
-    const dayOfWeekMatches = schedule.dayOfWeek.has(local.weekday);
+    const dayOfMonthMatches = schedule.dayOfMonth.has(date.getUTCDate());
+    const dayOfWeekMatches = schedule.dayOfWeek.has(date.getUTCDay());
     const dayMatches = schedule.dayOfMonthWildcard && schedule.dayOfWeekWildcard
         ? true
         : schedule.dayOfMonthWildcard
@@ -161,6 +186,3 @@ function matches(schedule, local) {
                 : dayOfMonthMatches || dayOfWeekMatches;
     return dayMatches;
 }
-function localKey(formatter, time) {
-    return localParts(formatter, time).key;
-}