@myagentroam/node 0.9.122 → 0.9.125

package/dist/runner/opencode-runner.js

@@ -8,7 +8,6 @@ import { homedir } from 'node:os';
 import { openCodeConversationPage } from './opencode/conversation-parser.js';
 import { nodeLog } from '../operational.js';
 const PROFILE_ENTRY_TTL_MS = 30 * 60_000;
-const PROFILE_STALE_TTL_MS = 60 * 60_000;
 const PROFILE_FAILURE_RETRY_MS = 30_000;
 const PROFILE_REFRESH_TIMEOUT_MS = 90_000;
 export class OpenCodeRunner extends AbstractRunner {
@@ -21,6 +20,7 @@ export class OpenCodeRunner extends AbstractRunner {
     profileCache;
     profileRetryAt = 0;
     profileRefresh;
+    profileRefreshTimer;
     profileGeneration = 0;
     execution = new Map();
     managedTurns = new Map();
@@ -40,7 +40,6 @@ export class OpenCodeRunner extends AbstractRunner {
         return { ...base, models: [] };
     }
     cachedProfile(capabilities, environment = {}) {
-        this.pruneProfileCaches(Date.now());
         const cached = this.profileCache;
         return cached === undefined
             ? this.profile(capabilities)
@@ -51,7 +50,6 @@ export class OpenCodeRunner extends AbstractRunner {
             return this.profile(capabilities);
         }
         const now = Date.now();
-        this.pruneProfileCaches(now);
         const cached = this.profileCache;
         if (cached !== undefined && cached.expiresAt > now) {
             nodeLog('runner.opencode.profile.cache-hit', {
@@ -93,11 +91,11 @@ export class OpenCodeRunner extends AbstractRunner {
             this.contextLimitsExpiresAt = expiresAt;
             this.profileCache = {
                 expiresAt,
-                discardAt: Date.now() + PROFILE_STALE_TTL_MS,
                 models,
                 contextLimits
             };
             this.profileRetryAt = 0;
+            this.scheduleProfileRefresh(PROFILE_ENTRY_TTL_MS, capabilities, environment);
             nodeLog('runner.opencode.profile.providers.completed', {
                 models: models.length,
                 durationMs: Math.round(performance.now() - startedAt)
@@ -108,6 +106,7 @@ export class OpenCodeRunner extends AbstractRunner {
             if (generation !== this.profileGeneration)
                 return this.profile(capabilities);
             this.profileRetryAt = Date.now() + PROFILE_FAILURE_RETRY_MS;
+            this.scheduleProfileRefresh(PROFILE_FAILURE_RETRY_MS, capabilities, environment);
             nodeLog('runner.opencode.profile.providers.failed', {
                 durationMs: Math.round(performance.now() - startedAt)
             });
@@ -153,17 +152,17 @@ export class OpenCodeRunner extends AbstractRunner {
         };
     }
     cachedModels(environment) {
-        this.pruneProfileCaches(Date.now());
         void environment;
         return this.profileCache?.models ?? [];
     }
-    pruneProfileCaches(now) {
-        if (this.profileCache !== undefined && this.profileCache.discardAt <= now)
-            this.profileCache = undefined;
-        if (this.profileRetryAt <= now &&
-            this.profileCache === undefined &&
-            this.profileRefresh === undefined)
-            this.profileRetryAt = 0;
+    scheduleProfileRefresh(delayMs, capabilities, environment) {
+        if (this.profileRefreshTimer !== undefined)
+            clearTimeout(this.profileRefreshTimer);
+        this.profileRefreshTimer = setTimeout(() => {
+            this.profileRefreshTimer = undefined;
+            void this.refreshProfile(capabilities, undefined, environment, true);
+        }, delayMs);
+        this.profileRefreshTimer.unref();
     }
     mcpConfiguration(raw, secrets) {
         const servers = super.mcpConfiguration(raw, secrets);
@@ -331,6 +330,9 @@ export class OpenCodeRunner extends AbstractRunner {
         this.managedTurns.clear();
         this.profileCache = undefined;
         this.profileRefresh = undefined;
+        if (this.profileRefreshTimer !== undefined)
+            clearTimeout(this.profileRefreshTimer);
+        this.profileRefreshTimer = undefined;
         this.profileRetryAt = 0;
         this.contextLimits = new Map();
         this.contextLimitsExpiresAt = 0;

package/dist/runtime-state.js

@@ -288,9 +288,12 @@ export class NodeRuntimeState {
         const value = title.trim().replace(/\s+/g, ' ').slice(0, 160);
         if (value.length === 0 ||
             current.customTitle !== null ||
-            current.runnerTitle === value ||
             (current.titleSource === 'AUTO' && isDefaultRunnerTitle(value)))
             return current;
+        if (current.runnerTitle === value)
+            return current.titleSource === 'RUNNER'
+                ? current
+                : this.replaceSession(id, { titleSource: 'RUNNER' });
         return this.replaceSession(id, { runnerTitle: value, titleSource: 'RUNNER' });
     }
     createMessageRun(input) {
@@ -316,6 +319,7 @@ export class NodeRuntimeState {
             recoveryState: 'ACTIVE',
             version: 0,
             clientMessageId: input.clientMessageId,
+            ...(input.source === undefined ? {} : { source: input.source }),
             ...(input.initiatedByUserId === undefined
                 ? {}
                 : { initiatedByUserId: input.initiatedByUserId }),
@@ -338,6 +342,7 @@ export class NodeRuntimeState {
             payload: {
                 clientMessageId: input.clientMessageId,
                 text: input.content,
+                ...(input.source === undefined ? {} : { source: input.source }),
                 contexts: [],
                 attachments,
                 delivery: 'ACCEPTED'

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

@@ -286,6 +286,7 @@ export class ContinuousRunCoordinator {
             const goalMcp = pending.goal === undefined
                 ? undefined
                 : await this.options.goalMcp?.(pending);
+            const scheduledMcp = await this.options.scheduledMcp?.(pending);
             if (!this.goalCurrent(pending)) {
                 this.dispatchedExecutions.delete(executionId);
                 this.rejectStaleGoal(executionId);
@@ -311,7 +312,11 @@ export class ContinuousRunCoordinator {
                 collaborationMode: pending.collaborationMode,
                 ...(pending.serviceTier === undefined ? {} : { serviceTier: pending.serviceTier }),
                 secretEnvironment: pending.secretEnvironment,
-                ...(goalMcp === undefined ? {} : { mcpSecretEnvironment: goalMcp.secrets }),
+                ...(goalMcp === undefined && scheduledMcp === undefined
+                    ? {}
+                    : {
+                        mcpSecretEnvironment: { ...goalMcp?.secrets, ...scheduledMcp?.secrets }
+                    }),
                 ...(pending.personalInstructions === undefined
                     ? {}
                     : { personalInstructions: pending.personalInstructions }),
@@ -323,7 +328,8 @@ export class ContinuousRunCoordinator {
                 ...(pending.computerUse === undefined ? {} : { computerUse: pending.computerUse }),
                 mcpInstallations: [
                     ...this.options.mcps(pending.workspaceId),
-                    ...(goalMcp === undefined ? [] : [goalMcp.installation])
+                    ...(goalMcp === undefined ? [] : [goalMcp.installation]),
+                    ...(scheduledMcp === undefined ? [] : [scheduledMcp.installation])
                 ]
             });
         }

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

@@ -123,7 +123,7 @@ export class ConversationHistoryService {
         if (activeCursor !== undefined ||
             this.options.hasManagedActiveRun(session) ||
             this.hasManagedRuntimeHistory(session))
-            return this.readManagedActive(session, input, activeCursor, snapshotSequence, readAt);
+            return this.readManagedRuntime(session, input, activeCursor, snapshotSequence, readAt);
         return this.readHistory(session, input, snapshotSequence, readAt);
     }
     async readHistoryPage(session, input) {
@@ -140,7 +140,7 @@ export class ConversationHistoryService {
                     cursor: null
                 }
                 : undefined;
-            return this.readManagedActive(session, input, olderCursor, this.options.snapshotSequence(), Date.now());
+            return this.readManagedRuntime(session, input, olderCursor, this.options.snapshotSequence(), Date.now());
         }
         return this.readHistory(session, input, this.options.snapshotSequence(), Date.now());
     }
@@ -220,7 +220,7 @@ export class ConversationHistoryService {
                     const runtimeTurn = runtimeTurnsByOfficialId.get(turn.id);
                     const hydratedTurn = runtimeTurn === undefined
                         ? turn
-                        : mergeRuntimeUserImageReferences(turn, runtimeTurn, this.options.attachments);
+                        : mergeRuntimeUserMetadata(turn, runtimeTurn, this.options.attachments);
                     const runtimeSupplementalItems = runtimeSupplementalItemsByOfficialId.get(turn.id) ?? [];
                     const items = [
                         ...hydratedTurn.items.filter((item) => (item.kind !== 'approval_request' && item.kind !== 'user_input_request') ||
@@ -367,6 +367,38 @@ export class ConversationHistoryService {
             deferredOlderHistory: true
         });
     }
+    async readManagedRuntime(session, input, cursor, snapshotSequence, readAt) {
+        const page = await this.readManagedActive(session, input, cursor, snapshotSequence, readAt);
+        if (input.cursor !== undefined ||
+            session.externalSessionId === null ||
+            this.options.hasManagedActiveRun(session) ||
+            !this.hasManagedRuntimeHistory(session) ||
+            !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 the SDK's matched native Turn may supply a destructive history boundary.
+        const official = await this.readOfficial(session, {
+            limit: Math.min(500, Math.max(30, page.turns.length + 1))
+        }).catch(() => undefined);
+        if (official === undefined)
+            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 = official.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);
         if (!runner.available(this.options.capabilities())) {
@@ -514,7 +546,7 @@ function latestTurnActivityAt(turn) {
 function oldestTurnActivityAt(turns) {
     return turns.length === 0 ? 0 : Math.min(...turns.map(earliestTurnActivityAt));
 }
-function mergeRuntimeUserImageReferences(officialTurn, runtimeTurn, attachments) {
+function mergeRuntimeUserMetadata(officialTurn, runtimeTurn, attachments) {
     const officialUser = officialTurn.items.find((item) => item.kind === 'user_message');
     const runtimeUser = runtimeTurn.items.find((item) => item.kind === 'user_message');
     if (officialUser === undefined ||
@@ -524,14 +556,19 @@ function mergeRuntimeUserImageReferences(officialTurn, runtimeTurn, attachments)
         return officialTurn;
     const officialPayload = officialUser.payload;
     const runtimePayload = runtimeUser.payload;
-    if (!Array.isArray(officialPayload.attachments) || !Array.isArray(runtimePayload.attachments))
-        return officialTurn;
-    const runtimeImages = runtimePayload.attachments.filter((attachment) => isPlainRecord(attachment) &&
+    const scheduledSource = runtimePayload.source === 'SCHEDULED' && officialPayload.source !== 'SCHEDULED';
+    const officialAttachments = Array.isArray(officialPayload.attachments)
+        ? officialPayload.attachments
+        : [];
+    const runtimeAttachments = Array.isArray(runtimePayload.attachments)
+        ? runtimePayload.attachments
+        : [];
+    const runtimeImages = runtimeAttachments.filter((attachment) => isPlainRecord(attachment) &&
         typeof attachment.mime === 'string' &&
         attachment.mime.startsWith('image/'));
     let runtimeImageIndex = 0;
     let changed = false;
-    const mergedAttachments = officialPayload.attachments.map((attachment) => {
+    const mergedAttachments = officialAttachments.map((attachment) => {
         if (!isPlainRecord(attachment) ||
             typeof attachment.mime !== 'string' ||
             !attachment.mime.startsWith('image/'))
@@ -562,7 +599,7 @@ function mergeRuntimeUserImageReferences(officialTurn, runtimeTurn, attachments)
             imageIndex: runtimeAttachment.imageIndex
         };
     });
-    if (!changed)
+    if (!changed && !scheduledSource)
         return officialTurn;
     return {
         ...officialTurn,
@@ -571,7 +608,8 @@ function mergeRuntimeUserImageReferences(officialTurn, runtimeTurn, attachments)
                 ...item,
                 payload: {
                     ...officialPayload,
-                    attachments: mergedAttachments
+                    ...(scheduledSource ? { source: 'SCHEDULED' } : {}),
+                    ...(changed ? { attachments: mergedAttachments } : {})
                 }
             }
             : item)
@@ -583,6 +621,9 @@ function sameConversationTurn(left, right) {
     const leftMessageId = conversationClientMessageId(left);
     return leftMessageId !== null && leftMessageId === conversationClientMessageId(right);
 }
+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))

package/dist/service/managed-runner-session-service.js

@@ -25,7 +25,8 @@ export class ManagedRunnerSessionService {
             if (title === undefined)
                 return;
             const updated = this.runtime.setRunnerTitleFromNative(session.id, title);
-            if (updated.runnerTitle !== session.runnerTitle)
+            if (updated.runnerTitle !== session.runnerTitle ||
+                updated.titleSource !== session.titleSource)
                 this.emitSession(updated);
         }
         catch {

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

@@ -174,7 +174,9 @@ export class NativeSessionProjectionService {
             titleSource: metadata?.customTitle === null || metadata?.customTitle === undefined
                 ? runnerTitle === null
                     ? 'AUTO'
-                    : 'RUNNER'
+                    : input.titleOrigin === 'PREVIEW'
+                        ? 'AUTO'
+                        : 'RUNNER'
                 : 'CUSTOM',
             lastActivityAt: timestamp,
             createdAt: timestamp

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

@@ -35,6 +35,8 @@ export class NodeControlMessageService {
         }
         if (this.options.handleRuntimeCredentialResponse(envelope))
             return;
+        if (this.options.handleScheduledRunAuthorizeResponse?.(envelope) === true)
+            return;
         if (envelope.type.startsWith('direct.') &&
             this.options.handleDirectTransfer?.(envelope) === true)
             return;

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

@@ -72,8 +72,19 @@ export class RunEventService {
             eventType,
             payload
         };
-        if (eventType !== 'text.delta')
-            nodeLog('run.event', { runId, eventType, status });
+        if (eventType !== 'text.delta') {
+            const errorCode = (eventType === 'run.failed' || eventType === 'run.rejected') &&
+                isPlainRecord(payload) &&
+                typeof payload.code === 'string'
+                ? payload.code
+                : undefined;
+            nodeLog('run.event', {
+                runId,
+                eventType,
+                status,
+                ...(errorCode === undefined ? {} : { errorCode })
+            });
+        }
         if (status === 'FAILED')
             this.options.metrics.runnerFailed();
         let recorded = undefined;
@@ -170,6 +181,7 @@ export class RunEventService {
             return;
         }
         this.options.scheduleContextRefresh(run.sessionId);
+        this.options.onTerminalRun?.(run, finalStatus);
         const idleSnapshot = this.options.refreshWorkspaceSessions(run.workspaceId);
         this.options.runtime.removeTerminalRun(runId);
         if (terminalNotification)
@@ -195,6 +207,8 @@ export class RunEventService {
         const run = this.options.runtime.getRun(runId);
         if (run === undefined)
             return undefined;
+        if (run.source === 'SCHEDULED' && eventType === 'approval.request')
+            return undefined;
         const session = this.options.runtime.getAgentSession(run.sessionId);
         if (session === undefined)
             return undefined;
@@ -209,6 +223,8 @@ export class RunEventService {
         if (!Number.isSafeInteger(base.userId))
             return undefined;
         if (status !== undefined && isTerminalRunStatus(status)) {
+            if (run.source === 'SCHEDULED')
+                return undefined;
             if (suppressTerminal)
                 return undefined;
             return {

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

@@ -105,11 +105,11 @@ export class RunnerInteractionService {
     }
     decideCodexApproval(approvalId, decision) {
         const codex = this.options.codex();
-        const requestId = codex.execution.approvals.get(approvalId);
-        if (requestId === undefined)
+        const approval = codex.execution.approvals.get(approvalId);
+        if (approval === undefined)
             return false;
         try {
-            codex.respond(requestId, { decision: decision === 'APPROVED' ? 'accept' : 'decline' });
+            codex.respond(approval.requestId, { decision: decision === 'APPROVED' ? 'accept' : 'decline' }, approval.runId);
         }
         catch {
             // A disconnected App Server cannot safely receive a late approval.
@@ -148,7 +148,7 @@ export class RunnerInteractionService {
     async cancelCodexTurn(runId, threadId, turnId, cwd, terminalStatus) {
         const codex = this.options.codex();
         try {
-            await codex.interruptTurn(threadId, turnId);
+            await codex.interruptTurn(threadId, turnId, runId);
             const run = this.options.runtime.getRun(runId);
             if (run !== undefined && !isTerminalRunStatus(run.status))
                 this.options.emitRun(runId, 'run.completed', { status: terminalStatus }, terminalStatus);
@@ -167,7 +167,7 @@ export class RunnerInteractionService {
     respondUserInput(runId, requestId, rawAnswers) {
         if (this.options.runners.respondUserInput(runId, requestId, rawAnswers))
             return;
-        if (this.options.codex().execution.userInputs.has(requestId)) {
+        if (this.options.codex().execution.userInputs.has(`${runId}\0${requestId}`)) {
             this.respondCodexUserInput(runId, requestId, rawAnswers);
             return;
         }
@@ -209,7 +209,8 @@ export class RunnerInteractionService {
     }
     respondCodexUserInput(runId, requestId, rawAnswers) {
         const codex = this.options.codex();
-        const pending = codex.execution.userInputs.get(requestId);
+        const pendingKey = `${runId}\0${requestId}`;
+        const pending = codex.execution.userInputs.get(pendingKey);
         if (pending === undefined ||
             pending.runId !== runId ||
             this.options.runtime.getRun(runId) === undefined)
@@ -219,8 +220,8 @@ export class RunnerInteractionService {
             answers[question.id] = {
                 answers: this.answers(rawAnswers[question.id], question.allowOther, (value) => question.options.includes(value))
             };
-        codex.respond(pending.requestId, { answers });
-        codex.execution.userInputs.delete(requestId);
+        codex.respond(pending.requestId, { answers }, runId);
+        codex.execution.userInputs.delete(pendingKey);
         this.options.emitItem(runId, {
             itemId: boundedConversationItemId('codex-input', requestId),
             kind: 'user_input_request',

package/dist/service/scheduled-run-authorization-control.js

@@ -0,0 +1,72 @@
+import { createEnvelope, scheduledRunAuthorizeRequestSchema, scheduledRunAuthorizeResponseSchema } from '@myagentroam/protocol';
+export class ScheduledRunAuthorizationControl {
+    send;
+    #pending = new Map();
+    #generation = 0;
+    #connected = false;
+    #closed = false;
+    constructor(send) {
+        this.send = send;
+    }
+    connected() {
+        this.disconnected();
+        this.#connected = true;
+    }
+    disconnected() {
+        this.#connected = false;
+        this.#generation++;
+        for (const pending of [...this.#pending.values()])
+            pending.reject(new Error('SCHEDULE_SERVER_UNAVAILABLE'));
+    }
+    close() {
+        this.#closed = true;
+        this.disconnected();
+    }
+    handle(envelope) {
+        if (envelope.type !== 'schedule.authorize.response')
+            return false;
+        const pending = envelope.replyTo === undefined ? undefined : this.#pending.get(envelope.replyTo);
+        if (pending === undefined || pending.generation !== this.#generation)
+            return true;
+        const parsed = scheduledRunAuthorizeResponseSchema.safeParse(envelope.payload);
+        if (!parsed.success)
+            pending.reject(new Error('SCHEDULE_AUTH_RESPONSE_INVALID'));
+        else
+            pending.resolve(parsed.data);
+        return true;
+    }
+    authorize(request) {
+        if (!this.#connected || this.#closed)
+            return Promise.reject(new Error('SCHEDULE_SERVER_UNAVAILABLE'));
+        const envelope = createEnvelope('schedule.authorize', scheduledRunAuthorizeRequestSchema.parse(request));
+        return new Promise((resolve, reject) => {
+            const settle = (action) => {
+                const pending = this.#pending.get(envelope.id);
+                if (pending === undefined)
+                    return;
+                this.#pending.delete(envelope.id);
+                clearTimeout(pending.timer);
+                action();
+            };
+            const timer = setTimeout(() => settle(() => reject(new Error('SCHEDULE_AUTH_TIMEOUT'))), 15_000);
+            timer.unref();
+            this.#pending.set(envelope.id, {
+                generation: this.#generation,
+                timer,
+                resolve: (response) => settle(() => {
+                    if ('error' in response)
+                        reject(new Error(response.error.code));
+                    else
+                        resolve(response.context);
+                }),
+                reject: (error) => settle(() => reject(error))
+            });
+            try {
+                this.send(envelope);
+            }
+            catch {
+                settle(() => reject(new Error('SCHEDULE_SERVER_UNAVAILABLE')));
+            }
+        });
+    }
+}

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

@@ -0,0 +1,95 @@
+export class ScheduledSessionCoordinator {
+    options;
+    #now;
+    #timer;
+    #running = false;
+    #closed = true;
+    constructor(options) {
+        this.options = options;
+        this.#now = options.now ?? Date.now;
+    }
+    start() {
+        if (!this.#closed)
+            return;
+        this.#closed = false;
+        void this.#tick(true);
+    }
+    changed() {
+        if (!this.#closed)
+            this.#arm();
+    }
+    stop() {
+        this.#closed = true;
+        if (this.#timer !== undefined)
+            clearTimeout(this.#timer);
+        this.#timer = undefined;
+    }
+    #arm() {
+        if (this.#timer !== undefined)
+            clearTimeout(this.#timer);
+        this.#timer = undefined;
+        if (this.#running || this.#closed)
+            return;
+        const next = this.options.store().nextDueAt();
+        if (next === null)
+            return;
+        const delay = Math.max(0, Math.min(next - this.#now(), 2_147_483_647));
+        this.#timer = setTimeout(() => void this.#tick(false), delay);
+        this.#timer.unref();
+    }
+    async #tick(initial) {
+        if (this.#closed || this.#running)
+            return;
+        this.#running = true;
+        try {
+            const now = this.#now();
+            for (const task of this.options.store().listDue(now)) {
+                if (this.#closed || task.nextRunAt === null)
+                    break;
+                const occurrenceId = this.options
+                    .store()
+                    .claim(task.sessionId, task.nextRunAt, task.revision);
+                if (occurrenceId === undefined)
+                    continue;
+                let failureCode;
+                let submitting = false;
+                try {
+                    if (initial && task.nextRunAt < now)
+                        failureCode = 'SCHEDULE_NODE_RESTARTED';
+                    else if (this.options.busy(task))
+                        failureCode = 'SCHEDULE_SESSION_BUSY';
+                    if (failureCode === undefined) {
+                        const context = await this.options.authorize(task, occurrenceId);
+                        const currentTask = this.options.store().get(task.sessionId);
+                        if (this.#closed)
+                            failureCode = 'SCHEDULE_NODE_STOPPED';
+                        else if (currentTask?.revision !== task.revision || currentTask.enabled !== true)
+                            failureCode = 'SCHEDULE_TASK_CHANGED';
+                        else if (this.options.busy(task))
+                            failureCode = 'SCHEDULE_SESSION_BUSY';
+                        else {
+                            submitting = true;
+                            const submitted = await this.options.submit(task, occurrenceId, context);
+                            this.options.store().finish(occurrenceId, 'SUBMITTED', undefined, submitted.runId);
+                        }
+                    }
+                }
+                catch (error) {
+                    failureCode =
+                        error instanceof Error && /^[A-Z][A-Z0-9_]{0,127}$/.test(error.message)
+                            ? error.message
+                            : 'SCHEDULE_EXECUTION_FAILED';
+                }
+                if (failureCode !== undefined) {
+                    const status = submitting && failureCode !== 'SCHEDULE_SESSION_BUSY' ? 'FAILED' : 'SKIPPED';
+                    this.options.store().finish(occurrenceId, status, failureCode);
+                    this.options.notify(task, occurrenceId, failureCode, status);
+                }
+            }
+        }
+        finally {
+            this.#running = false;
+            this.#arm();
+        }
+    }
+}

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

@@ -0,0 +1,72 @@
+export function parseScheduledCron(cron) {
+    const fields = cron.trim().split(/\s+/);
+    if (fields.length !== 5 || fields[2] !== '*' || fields[3] !== '*')
+        throw new Error('SCHEDULE_CRON_INVALID');
+    const minute = boundedInteger(fields[0], 0, 59);
+    if (fields[1] === '*' && fields[4] === '*')
+        return { kind: 'HOURLY', minute };
+    const hour = boundedInteger(fields[1], 0, 23);
+    if (fields[4] === '*')
+        return { kind: 'DAILY', minute, hour };
+    return { kind: 'WEEKLY', minute, hour, weekday: boundedInteger(fields[4], 0, 6) };
+}
+export function assertScheduleTimezone(timezone) {
+    if (timezone.length < 1 || timezone.length > 128)
+        throw new Error('SCHEDULE_TIMEZONE_INVALID');
+    try {
+        new Intl.DateTimeFormat('en-US', { timeZone: timezone });
+    }
+    catch {
+        throw new Error('SCHEDULE_TIMEZONE_INVALID');
+    }
+}
+export function nextScheduledAt(cron, timezone, after) {
+    const cadence = parseScheduledCron(cron);
+    assertScheduleTimezone(timezone);
+    if (!Number.isSafeInteger(after) || after < 0)
+        throw new Error('SCHEDULE_TIME_INVALID');
+    const formatter = new Intl.DateTimeFormat('en-US', {
+        timeZone: timezone,
+        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 * 24 * 60 + 120; index++, candidate += 60_000) {
+        const local = localParts(formatter, candidate);
+        if (local.minute === cadence.minute &&
+            (cadence.kind === 'HOURLY' || local.hour === cadence.hour) &&
+            (cadence.kind !== 'WEEKLY' || local.weekday === cadence.weekday) &&
+            local.key !== previousKey)
+            return candidate;
+    }
+    throw new Error('SCHEDULE_NEXT_TIME_UNAVAILABLE');
+}
+function boundedInteger(value, min, max) {
+    if (value === undefined || !/^(0|[1-9][0-9]*)$/.test(value))
+        throw new Error('SCHEDULE_CRON_INVALID');
+    const number = Number(value);
+    if (!Number.isInteger(number) || number < min || number > max)
+        throw new Error('SCHEDULE_CRON_INVALID');
+    return number;
+}
+function localParts(formatter, time) {
+    const fields = Object.fromEntries(formatter.formatToParts(time).map((part) => [part.type, part.value]));
+    const hour = Number(fields['hour']);
+    const minute = Number(fields['minute']);
+    const weekday = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'].indexOf(fields['weekday'] ?? '');
+    return {
+        hour,
+        minute,
+        weekday,
+        key: `${fields['year']}-${fields['month']}-${fields['day']}T${fields['hour']}:${fields['minute']}`
+    };
+}
+function localKey(formatter, time) {
+    return localParts(formatter, time).key;
+}