@myagentroam/node 0.10.35 → 0.10.37

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

@@ -50,20 +50,16 @@ export class NativeSessionProjectionService {
         this.remember(sessions);
         return sessions;
     }
-    async resolve(sessionId) {
+    async resolve(sessionId, registeredOnly = false) {
         const cached = this.options.state.directNative.get(sessionId);
         if (cached !== undefined)
             return cached;
-        const discovered = (await this.list()).find((session) => session.id === sessionId);
-        if (discovered !== undefined)
-            return discovered;
         const database = this.options.database();
-        const record = database
-            ?.listWorkspaces()
-            .flatMap((workspace) => database.listSessionRecords(workspace.id))
-            .find((candidate) => candidate.id === sessionId);
+        const record = database?.getSessionRecord(sessionId);
         if (record === undefined)
-            return undefined;
+            return registeredOnly
+                ? undefined
+                : (await this.list()).find((session) => session.id === sessionId);
         const workspace = database?.getWorkspace(record.workspaceId);
         if (workspace === undefined)
             return undefined;
@@ -80,6 +76,7 @@ export class NativeSessionProjectionService {
             effort: record.metadata.effort,
             access: record.metadata.access,
             customTitle: record.metadata.customTitle,
+            parentSessionId: record.metadata.parentSessionId ?? null,
             sessionPrompt: record.metadata.sessionPrompt ?? null,
             runnerTitle: record.metadata.runnerTitle,
             pinnedAt: record.pinOrder === null ? null : 1,
@@ -114,7 +111,8 @@ export class NativeSessionProjectionService {
             ...(direct.access === null ? {} : { access: direct.access }),
             ...(direct.runnerTitle === null ? {} : { title: direct.runnerTitle }),
             ...(direct.customTitle === null ? {} : { customTitle: direct.customTitle }),
-            sessionPrompt: direct.sessionPrompt ?? null
+            sessionPrompt: direct.sessionPrompt ?? null,
+            parentSessionId: direct.parentSessionId ?? null
         });
     }
     resumedConfiguration(session) {
@@ -186,6 +184,7 @@ export class NativeSessionProjectionService {
             access: metadata?.access ?? null,
             customTitle: metadata?.customTitle ?? null,
             sessionPrompt: metadata?.sessionPrompt ?? null,
+            parentSessionId: metadata?.parentSessionId ?? null,
             runnerTitle,
             pinnedAt: metadata?.pinnedAt ?? null,
             pinOrder: metadata?.pinOrder ?? null,
@@ -202,8 +201,61 @@ export class NativeSessionProjectionService {
         };
     }
     remember(sessions) {
-        for (const session of sessions)
+        const database = this.options.database();
+        for (const session of sessions) {
             this.options.state.directNative.set(session.id, session);
+            if (database === undefined || session.externalSessionId === null)
+                continue;
+            const metadata = database.getNativeSessionMetadata(session.runner, session.externalSessionId, session.workspaceId);
+            const title = session.runnerTitle?.trim().slice(0, 160) || undefined;
+            if (metadata === undefined ||
+                (title !== undefined && title !== metadata.runnerTitle && !metadata.runnerTitlePending))
+                database.saveNativeSessionMetadata({
+                    runner: session.runner,
+                    externalSessionId: session.externalSessionId,
+                    workspaceId: session.workspaceId,
+                    ...(title === undefined || metadata?.runnerTitlePending ? {} : { runnerTitle: title })
+                });
+        }
+    }
+    similarSessionDetails(sessionId, workspaceId) {
+        if (sessionId.length < 8 || sessionId.length > 128)
+            return undefined;
+        const records = this.options.database()?.listSessionRecords(workspaceId) ?? [];
+        const recordById = new Map(records.map((record) => [record.id, record]));
+        const known = new Map(records.map((record) => [
+            record.id,
+            record.metadata.customTitle ?? record.metadata.runnerTitle ?? 'Untitled session'
+        ]));
+        for (const session of [
+            ...this.options.state.directNative.values(),
+            ...this.options.runtime.listAgentSessions()
+        ]) {
+            if (session.workspaceId !== workspaceId)
+                continue;
+            const metadata = recordById.get(session.id)?.metadata;
+            known.set(session.id, metadata?.customTitle ??
+                session.customTitle ??
+                session.runnerTitle ??
+                metadata?.runnerTitle ??
+                'Untitled session');
+        }
+        const maximum = Math.min(3, Math.floor(sessionId.length / 8));
+        const candidates = [...known]
+            .map(([id, title]) => ({
+            id,
+            title,
+            distance: sessionIdDistance(sessionId.toLowerCase(), id.toLowerCase(), maximum)
+        }))
+            .filter((candidate) => candidate.distance <= maximum)
+            .sort((left, right) => left.distance - right.distance || left.id.localeCompare(right.id))
+            .slice(0, 3);
+        return candidates.length === 0
+            ? undefined
+            : [
+                'Similar Sessions (suggestions only; no action was redirected):',
+                ...candidates.map(({ id, title }) => id + ' ' + title.replace(/[\u0000-\u001f\u007f]/gu, ' ').slice(0, 160))
+            ].join('\n');
     }
     projectionForNative(native) {
         if (native.externalSessionId === null)
@@ -297,3 +349,17 @@ export class NativeSessionProjectionService {
         return database;
     }
 }
+function sessionIdDistance(left, right, maximum) {
+    if (Math.abs(left.length - right.length) > maximum)
+        return maximum + 1;
+    let previous = Array.from({ length: right.length + 1 }, (_, index) => index);
+    for (let row = 1; row <= left.length; row += 1) {
+        const current = [row];
+        for (let column = 1; column <= right.length; column += 1)
+            current[column] = Math.min(current[column - 1] + 1, previous[column] + 1, previous[column - 1] + (left[row - 1] === right[column - 1] ? 0 : 1));
+        if (Math.min(...current) > maximum)
+            return maximum + 1;
+        previous = current;
+    }
+    return previous[right.length];
+}

package/dist/service/planned-restart-handoff.js

@@ -0,0 +1,279 @@
+import { randomUUID } from 'node:crypto';
+import { mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { z } from 'zod';
+import { parseComposerTags } from '@myagentroam/protocol';
+const identifier = z.string().min(1).max(512);
+const count = z.number().int().nonnegative();
+const attachmentSchema = z
+    .object({
+    name: z.string().min(1).max(512),
+    mime: z.string().min(1).max(128),
+    dataBase64: z.string().min(1).max(7_000_000)
+})
+    .strict();
+const messageSchema = z
+    .object({
+    id: identifier,
+    clientMessageId: identifier,
+    content: z.string().max(1_000_000),
+    attachments: z.array(attachmentSchema).max(5),
+    initiatedByUserId: z.number().int().positive(),
+    immediate: z.boolean()
+})
+    .strict();
+const goalSchema = z
+    .object({
+    goal: z
+        .object({
+        id: identifier,
+        sessionId: identifier,
+        objective: z.string().min(1).max(20_000),
+        inputTags: z.string().default(''),
+        startedAt: count,
+        revisionStartedAt: count,
+        revision: z.number().int().positive(),
+        status: z.enum(['active', 'completed', 'blocked']),
+        turns: count,
+        retryRequired: z.boolean(),
+        retryStartedAtTurn: count.nullable(),
+        consecutiveNoProgressTurns: count
+    })
+        .strict(),
+    executionFailures: count
+})
+    .strict();
+const sessionSchema = z
+    .object({
+    session: z
+        .object({
+        id: identifier,
+        workspaceId: identifier,
+        cwd: z.string().min(1),
+        model: z.string().nullable(),
+        effort: z.string().nullable(),
+        access: z.string().nullable()
+    })
+        .strict(),
+    ownerUserId: z.number().int().positive(),
+    paused: z.boolean(),
+    plan: z.boolean(),
+    awaitingGoal: z.boolean(),
+    goal: goalSchema.optional(),
+    current: messageSchema.optional(),
+    queue: z.array(messageSchema)
+})
+    .strict();
+export const plannedRestartSchema = z
+    .object({
+    schemaVersion: z.literal(1),
+    id: identifier,
+    nodeId: identifier,
+    serverUrl: z.string().min(1),
+    createdAt: count,
+    sessions: z.array(sessionSchema)
+})
+    .strict();
+export const RESTART_NOTICE = 'The previous execution was interrupted by a system restart. Check the session history and current workspace, then continue unfinished work. Verify completed or uncertain actions before proceeding; do not blindly repeat actions with external side effects.';
+/** A one-shot orderly-shutdown handoff, not a crash-recovery journal. */
+export class PlannedRestartHandoff {
+    options;
+    pending;
+    blocked = new Set();
+    recovery;
+    owners = new Map();
+    constructor(options) {
+        this.options = options;
+    }
+    path(processing = false) {
+        return resolve(this.options.directory(), processing ? 'planned-restart-handoff.processing.json' : 'planned-restart-handoff.json');
+    }
+    blocks(sessionId) {
+        return this.blocked.has(sessionId);
+    }
+    blocksOperation(operation, input) {
+        const sessionId = typeof input.sessionId === 'string'
+            ? input.sessionId
+            : typeof input.queueItemId === 'string'
+                ? this.options.runtime.getQueueItem(input.queueItemId)?.sessionId
+                : undefined;
+        if (sessionId === undefined || !this.blocks(sessionId))
+            return false;
+        return (operation === 'session.message' ||
+            operation.startsWith('session.command.') ||
+            (operation.startsWith('workspace.queue.') && operation !== 'workspace.queue.get') ||
+            [
+                'session.remove',
+                'session.rewind',
+                'session.rollback',
+                'session.config.update',
+                'session.metadata.update'
+            ].includes(operation));
+    }
+    rememberUser(sessionId, userId) {
+        this.owners.set(sessionId, userId);
+    }
+    async load() {
+        this.recovery = undefined;
+        this.pending = undefined;
+        this.blocked.clear();
+        let text;
+        try {
+            text = await readFile(this.path(), 'utf8');
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                this.options.diagnose('RESTART_HANDOFF_READ_FAILED');
+            return;
+        }
+        try {
+            const value = plannedRestartSchema.parse(JSON.parse(text));
+            const identity = this.options.identity();
+            if (value.nodeId !== identity.nodeId || value.serverUrl !== identity.serverUrl)
+                throw new Error('RESTART_HANDOFF_IDENTITY_MISMATCH');
+            this.pending = value;
+            for (const entry of value.sessions)
+                this.blocked.add(entry.session.id);
+        }
+        catch {
+            this.options.diagnose('RESTART_HANDOFF_INVALID');
+        }
+    }
+    capture() {
+        const { runtime, coordinator, goals } = this.options;
+        const sessions = [...(this.pending?.sessions ?? [])];
+        for (const session of runtime.listAgentSessions()) {
+            if (session.runner !== 'mar-agent' || this.blocks(session.id))
+                continue;
+            const queue = runtime.sessionQueue(session.id);
+            const active = runtime.activeSessionRun(session.id);
+            const goal = goals.restartState(session.id);
+            const awaitingGoal = goal === undefined && this.options.commandActive(session.id, 'goal');
+            const currentId = active && (runtime.currentExecutionId(active.id) ?? active.id);
+            const pending = currentId === undefined ? undefined : coordinator.pending(currentId);
+            const toMessage = (id, clientMessageId, content, attachments, owner) => ({
+                id,
+                clientMessageId,
+                content: withoutAttachmentTags(content),
+                attachments,
+                initiatedByUserId: owner,
+                immediate: coordinator.isImmediate(id)
+            });
+            const items = queue.itemIds.flatMap((id) => {
+                if (coordinator.pending(id)?.goal !== undefined)
+                    return [];
+                const item = runtime.getQueueItem(id);
+                const original = coordinator.pending(id)?.restartMessage;
+                return [
+                    toMessage(id, item.clientMessageId, original?.content ?? item.content, [...(original?.attachments ?? item.attachments)], item.initiatedByUserId)
+                ];
+            });
+            const current = pending?.restartMessage === undefined || pending.goal !== undefined
+                ? undefined
+                : toMessage(currentId, pending.clientMessageId ?? active.clientMessageId, pending.restartMessage.content, [...pending.restartMessage.attachments], pending.restartMessage.initiatedByUserId ?? active?.initiatedByUserId);
+            if (current === undefined && items.length === 0 && goal === undefined && !awaitingGoal)
+                continue;
+            if (session.externalSessionId === null)
+                throw new Error('RESTART_SESSION_NOT_READY');
+            const ownerUserId = active?.initiatedByUserId ??
+                items[0]?.initiatedByUserId ??
+                this.owners.get(session.id) ??
+                runtime.listRunsForSession(session.id).find((run) => run.initiatedByUserId !== undefined)
+                    ?.initiatedByUserId;
+            sessions.push({
+                session: {
+                    id: session.externalSessionId,
+                    workspaceId: session.workspaceId,
+                    cwd: session.cwd,
+                    model: session.model,
+                    effort: session.effort,
+                    access: session.access
+                },
+                ownerUserId: ownerUserId,
+                paused: queue.paused,
+                plan: this.options.commandActive(session.id, 'plan'),
+                awaitingGoal,
+                ...(goal === undefined ? {} : { goal: goalSchema.parse(goal) }),
+                ...(current === undefined ? {} : { current }),
+                queue: items
+            });
+        }
+        return plannedRestartSchema.parse({
+            schemaVersion: 1,
+            id: randomUUID(),
+            ...this.options.identity(),
+            createdAt: Date.now(),
+            sessions
+        });
+    }
+    async publish(snapshot) {
+        for (const entry of snapshot.sessions) {
+            const goal = this.options.goals.restartState(entry.session.id);
+            if (goal !== undefined)
+                entry.goal = goalSchema.parse(goal);
+            if (entry.current !== undefined) {
+                const state = await this.options.inputState(entry, entry.current);
+                if (state === 'completed')
+                    delete entry.current;
+                if (state === 'paused')
+                    entry.paused = true;
+            }
+        }
+        if (snapshot.sessions.length === 0)
+            return;
+        const temporary = `${this.path()}.${process.pid}.tmp`;
+        await mkdir(this.options.directory(), { recursive: true, mode: 0o700 });
+        try {
+            await writeFile(temporary, JSON.stringify(plannedRestartSchema.parse(snapshot)), {
+                mode: 0o600
+            });
+            await rename(temporary, this.path());
+        }
+        finally {
+            await rm(temporary, { force: true });
+        }
+    }
+    recover() {
+        if (this.pending === undefined)
+            return this.recovery ?? Promise.resolve();
+        return (this.recovery ??= this.consume());
+    }
+    async wait() {
+        await this.recovery;
+    }
+    async consume() {
+        const value = this.pending;
+        this.pending = undefined;
+        let failed = false;
+        try {
+            await rename(this.path(), this.path(true));
+            for (const entry of value.sessions) {
+                try {
+                    this.rememberUser(entry.session.id, entry.ownerUserId);
+                    await this.options.restore(entry, value.id);
+                }
+                catch {
+                    failed = true;
+                    this.options.diagnose('RESTART_SESSION_RESTORE_FAILED', entry.session.id);
+                }
+                finally {
+                    this.blocked.delete(entry.session.id);
+                }
+            }
+            if (!failed)
+                await rm(this.path(true), { force: true });
+        }
+        catch {
+            this.options.diagnose('RESTART_HANDOFF_CONSUME_FAILED');
+        }
+        finally {
+            this.blocked.clear();
+        }
+    }
+}
+function withoutAttachmentTags(content) {
+    return parseComposerTags(content)
+        .map((part) => part.kind === 'text' ? part.text : part.kind === 'mar_attachments' ? '' : part.raw)
+        .join('')
+        .trim();
+}

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

@@ -0,0 +1,141 @@
+import { serializeComposerTag } from '@myagentroam/protocol';
+import { parseMessageAttachments } from '../util/node-operation-parsers.js';
+import { RESTART_NOTICE } from './planned-restart-handoff.js';
+/** Rebuild inputs through the existing preparation and FIFO boundary. */
+export class RestartSessionRestorer {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async restore(entry, handoffId) {
+        const contexts = new Map();
+        const authorize = async (ownerUserId) => {
+            if (!contexts.has(ownerUserId))
+                contexts.set(ownerUserId, await this.options.authorize({
+                    handoffId,
+                    sessionId: entry.session.id,
+                    workspaceId: entry.session.workspaceId,
+                    ownerUserId,
+                    runner: 'mar-agent',
+                    model: entry.session.model
+                }));
+            return contexts.get(ownerUserId);
+        };
+        await authorize(entry.ownerUserId);
+        for (const input of [...entry.queue, ...(entry.current ? [entry.current] : [])]) {
+            parseMessageAttachments(input.attachments);
+            await authorize(input.initiatedByUserId);
+        }
+        let session = await this.options.resolve(entry.session.id);
+        if (session.runner !== 'mar-agent' ||
+            session.workspaceId !== entry.session.workspaceId ||
+            session.cwd !== entry.session.cwd ||
+            session.externalSessionId !== entry.session.id)
+            throw new Error('RESTART_SESSION_MISMATCH');
+        session = this.options.runtime.updateAgentSessionConfiguration({
+            sessionId: session.id,
+            model: entry.session.model ?? session.model,
+            effort: entry.session.effort ?? session.effort,
+            access: entry.session.access ?? session.access
+        });
+        const { runtime, coordinator, goals, commands } = this.options;
+        runtime.pauseSessionQueue(session.id);
+        if (entry.plan)
+            commands.set(session.id, {
+                commandId: 'plan',
+                active: true,
+                label: 'Plan',
+                detail: null,
+                closable: true,
+                closeInput: '/plan'
+            });
+        if (entry.goal) {
+            if (entry.goal.goal.sessionId !== session.id)
+                throw new Error('RESTART_GOAL_SESSION_MISMATCH');
+            goals.restoreRestartState(entry.goal);
+            this.options.publishGoal(session, entry.goal.goal);
+        }
+        else if (entry.awaitingGoal)
+            commands.set(session.id, {
+                commandId: 'goal',
+                active: true,
+                label: 'Goal',
+                detail: null,
+                closable: true,
+                closeInput: '/goal --clear'
+            });
+        const submit = async (input, content = input.content) => {
+            const context = contexts.get(input.initiatedByUserId);
+            await this.options.withGrant(context, () => this.options.messages.restoreQueued({
+                sessionId: session.id,
+                content,
+                clientMessageId: input.clientMessageId,
+                ...(content.startsWith('<mar_restart>')
+                    ? { __runnerContent: `${content}${RESTART_NOTICE}` }
+                    : {}),
+                attachments: input.attachments,
+                __queueItemId: input.id,
+                __requestUserId: input.initiatedByUserId,
+                secretEnvironment: context.secretEnvironment,
+                personalInstructions: context.personalInstructions,
+                marAgentModel: context.marAgentModel,
+                marAgentModels: context.marAgentModels,
+                marAgentCompact: context.marAgentCompact,
+                marAgentRuntimeScopeId: context.marAgentRuntimeScopeId,
+                __usageGrant: context.usageGrant
+            }));
+            if (input.immediate)
+                coordinator.restoreImmediate(input.id);
+        };
+        try {
+            if (entry.current &&
+                entry.goal?.goal.status !== 'active' &&
+                !entry.queue.some((item) => item.immediate)) {
+                const state = await this.options.inputState(entry, entry.current);
+                if (state === 'paused')
+                    entry.paused = true;
+                if (state === 'missing')
+                    await submit(entry.current);
+                else if (state !== 'completed')
+                    await submit({
+                        ...entry.current,
+                        id: `restart:${handoffId}:${session.id}`,
+                        clientMessageId: `restart:${handoffId}:${session.id}`,
+                        attachments: []
+                    }, serializeComposerTag('mar_restart', {}));
+            }
+            for (const input of entry.queue)
+                await submit(input);
+            if (entry.goal?.goal.status === 'active') {
+                const context = contexts.get(entry.ownerUserId);
+                await this.options.withGrant(context, () => this.options.messages.submitGoal({
+                    sessionId: session.id,
+                    kind: 'continue',
+                    deliveryIntent: 'QUEUE',
+                    content: `${goals.prompt(session.id, 'continue')}
+${RESTART_NOTICE}`,
+                    goal: { id: entry.goal.goal.id, revision: entry.goal.goal.revision, epoch: 0 },
+                    initiatedByUserId: entry.ownerUserId,
+                    secretEnvironment: context.secretEnvironment,
+                    restoreQueued: true,
+                    ...(context.usageGrant === undefined ? {} : { usageGrant: context.usageGrant }),
+                    ...(typeof context.personalInstructions === 'string'
+                        ? { personalInstructions: context.personalInstructions }
+                        : {}),
+                    marAgentModel: context.marAgentModel,
+                    marAgentModels: context.marAgentModels,
+                    marAgentCompact: context.marAgentCompact,
+                    marAgentRuntimeScopeId: context.marAgentRuntimeScopeId
+                }));
+            }
+            if (!entry.paused)
+                coordinator.resume(session.id);
+            this.options.publishQueue(session);
+        }
+        catch (error) {
+            runtime.pauseSessionQueue(session.id);
+            this.options.publishQueue(session);
+            throw error;
+        }
+    }
+}

package/dist/service/{scheduled-run-authorization-control.js → run-authorization-control.js}

@@ -1,12 +1,17 @@
-import { createEnvelope, scheduledRunAuthorizeRequestSchema, scheduledRunAuthorizeResponseSchema } from '@myagentroam/protocol';
-export class ScheduledRunAuthorizationControl {
+import { createEnvelope, scheduledRunAuthorizeRequestSchema, scheduledRunAuthorizeResponseSchema, restartRunAuthorizeRequestSchema } from '@myagentroam/protocol';
+export class RunAuthorizationControl {
     send;
+    purpose;
     #pending = new Map();
     #generation = 0;
     #connected = false;
     #closed = false;
-    constructor(send) {
+    constructor(send, purpose = 'schedule') {
         this.send = send;
+        this.purpose = purpose;
+    }
+    code(suffix) {
+        return `${this.purpose.toUpperCase()}_${suffix}`;
     }
     connected() {
         this.disconnected();
@@ -16,29 +21,31 @@ export class ScheduledRunAuthorizationControl {
         this.#connected = false;
         this.#generation++;
         for (const pending of [...this.#pending.values()])
-            pending.reject(new Error('SCHEDULE_SERVER_UNAVAILABLE'));
+            pending.reject(new Error(this.code('SERVER_UNAVAILABLE')));
     }
     close() {
         this.#closed = true;
         this.disconnected();
     }
     handle(envelope) {
-        if (envelope.type !== 'schedule.authorize.response')
+        if (envelope.type !== `${this.purpose}.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'));
+            pending.reject(new Error(this.code('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 Promise.reject(new Error(this.code('SERVER_UNAVAILABLE')));
+        const envelope = createEnvelope(`${this.purpose}.authorize`, (this.purpose === 'schedule'
+            ? scheduledRunAuthorizeRequestSchema
+            : restartRunAuthorizeRequestSchema).parse(request));
         return new Promise((resolve, reject) => {
             const settle = (action) => {
                 const pending = this.#pending.get(envelope.id);
@@ -48,7 +55,7 @@ export class ScheduledRunAuthorizationControl {
                 clearTimeout(pending.timer);
                 action();
             };
-            const timer = setTimeout(() => settle(() => reject(new Error('SCHEDULE_AUTH_TIMEOUT'))), 15_000);
+            const timer = setTimeout(() => settle(() => reject(new Error(this.code('AUTH_TIMEOUT')))), 15_000);
             timer.unref();
             this.#pending.set(envelope.id, {
                 generation: this.#generation,
@@ -65,7 +72,7 @@ export class ScheduledRunAuthorizationControl {
                 this.send(envelope);
             }
             catch {
-                settle(() => reject(new Error('SCHEDULE_SERVER_UNAVAILABLE')));
+                settle(() => reject(new Error(this.code('SERVER_UNAVAILABLE'))));
             }
         });
     }

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

@@ -232,6 +232,8 @@ export class RunEventService {
         const run = this.options.runtime.getRun(runId);
         if (run === undefined)
             return undefined;
+        if (run.suppressNotifications === true)
+            return undefined;
         if (run.source === 'SCHEDULED' && eventType === 'approval.request')
             return undefined;
         const session = this.options.runtime.getAgentSession(run.sessionId);

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

@@ -1,13 +1,26 @@
+import { SCHEDULE_RESTART_OUTCOME_UNKNOWN } from './scheduled-session-store.js';
 export class ScheduledSessionCoordinator {
     options;
     #now;
     #timer;
     #running = false;
     #closed = true;
+    #recovered = [];
     constructor(options) {
         this.options = options;
         this.#now = options.now ?? Date.now;
     }
+    /** Called only at Node startup, before admitting any new scheduled occurrence. */
+    recoverInterrupted() {
+        for (const recovered of this.options.store().recoverInterrupted())
+            this.#recovered.push(recovered);
+    }
+    connected() {
+        // Startup has no control connection yet. Send these best-effort alerts once it is ready.
+        for (const { task, occurrenceId } of this.#recovered.splice(0)) {
+            this.options.notify(task, occurrenceId, SCHEDULE_RESTART_OUTCOME_UNKNOWN, 'FAILED');
+        }
+    }
     start() {
         if (!this.#closed)
             return;