@myagentroam/node 0.10.34 → 0.10.36

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/session-catalog-service.js

@@ -11,6 +11,7 @@ export class SessionCatalogService {
     operations() {
         return {
             'session.list': (data) => this.list(record(data)),
+            'session.graph': (data) => this.graph(record(data)),
             'session.remove': (data) => this.enqueueMutation(() => this.remove(record(data))),
             'workspace.sessions.cleanup': (data) => this.enqueueMutation(() => this.cleanupWorkspaceSessions(record(data))),
             'session.rewind': (data) => this.enqueueMutation(() => this.rewind(record(data))),
@@ -18,11 +19,59 @@ export class SessionCatalogService {
         };
     }
     async list(input) {
+        const sessions = await this.collect(input);
+        return sessionPage(sessions.filter((session) => input.parentSessionId === undefined || session.parentSessionId === input.parentSessionId), input);
+    }
+    async graph(input) {
+        if (typeof input.workspaceId !== 'string')
+            throw new Error('WORKSPACE_NOT_FOUND');
+        if (typeof input.sessionId !== 'string')
+            throw new Error('SESSION_INVALID');
+        const limit = input.limit === undefined ? 100 : input.limit;
+        if (typeof limit !== 'number' || !Number.isInteger(limit) || limit < 1 || limit > 100)
+            throw new Error('SESSION_INVALID');
+        const sessions = await this.collect({ workspaceId: input.workspaceId, registeredOnly: true });
+        const root = sessions.find((session) => session.id === input.sessionId);
+        if (root === undefined)
+            throw new Error('SESSION_NOT_FOUND');
+        const children = new Map();
+        for (const session of sessions) {
+            if (session.parentSessionId == null)
+                continue;
+            const siblings = children.get(session.parentSessionId) ?? [];
+            siblings.push(session);
+            children.set(session.parentSessionId, siblings);
+        }
+        const queue = [root];
+        const visited = new Set([root.id]);
+        const nodes = [];
+        for (let index = 0; index < queue.length && index < limit; index += 1) {
+            const session = queue[index];
+            nodes.push({
+                id: session.id,
+                parentSessionId: session.parentSessionId ?? null,
+                title: session.customTitle ?? session.runnerTitle ?? 'Untitled session',
+                runner: session.runner,
+                ...('activity' in session ? { activity: session.activity } : {})
+            });
+            for (const child of children.get(session.id) ?? []) {
+                if (visited.has(child.id))
+                    continue;
+                visited.add(child.id);
+                queue.push(child);
+            }
+        }
+        return { rootSessionId: root.id, nodes, truncated: queue.length > nodes.length };
+    }
+    async collect(input) {
         const workspaceId = typeof input.workspaceId === 'string' ? input.workspaceId : undefined;
+        const registeredOnly = input.registeredOnly === true;
+        if (registeredOnly && workspaceId === undefined)
+            throw new Error('WORKSPACE_NOT_FOUND');
         const query = typeof input.query === 'string' && input.query.trim().length > 0
             ? input.query.trim().normalize('NFKC').toLocaleLowerCase()
             : undefined;
-        const nativeSessions = workspaceId === undefined
+        const nativeSessions = registeredOnly || workspaceId === undefined
             ? this.options.cachedNative()
             : query === undefined
                 ? await this.options.cachedWorkspace(workspaceId)
@@ -57,7 +106,7 @@ export class SessionCatalogService {
                 this.options.projectionForNative(candidate) === undefined)
         ].map((session) => [session.id, session]));
         if (workspaceId !== undefined)
-            this.mergePersisted(merged, workspaceId, query === undefined && this.options.discoveryPending(workspaceId));
+            this.mergePersisted(merged, workspaceId, !registeredOnly && query === undefined && this.options.discoveryPending(workspaceId));
         const sessions = [...merged.values()].filter((session) => {
             if (query === undefined)
                 return true;
@@ -66,9 +115,9 @@ export class SessionCatalogService {
                 .toLocaleLowerCase();
             return title.includes(query);
         });
-        return sessionPage(workspaceId === undefined
+        return workspaceId === undefined
             ? sessions
-            : sessions.filter((session) => session.workspaceId === workspaceId), input);
+            : sessions.filter((session) => session.workspaceId === workspaceId);
     }
     mergePersisted(merged, workspaceId, discoveryPending) {
         const database = this.options.database();
@@ -95,6 +144,7 @@ export class SessionCatalogService {
                 access: persisted.metadata.access,
                 customTitle: persisted.metadata.customTitle,
                 sessionPrompt: persisted.metadata.sessionPrompt ?? null,
+                parentSessionId: persisted.metadata.parentSessionId ?? null,
                 runnerTitle: persisted.metadata.runnerTitle,
                 pinnedAt: persisted.pinOrder === null ? null : 1,
                 pinOrder: persisted.pinOrder,
@@ -249,6 +299,7 @@ export class SessionCatalogService {
                         session.lastActivityAt >= cutoff)) ||
                 (session.pinOrder !== null && session.pinOrder !== undefined) ||
                 this.options.isWatching(session.id) ||
+                this.options.isRecovering?.(session.id) ||
                 this.options.runtime.sessionQueue(session.id).itemIds.length > 0 ||
                 this.options.runtime
                     .listRunsForSession(session.id)
@@ -301,6 +352,8 @@ export class SessionCatalogService {
             ? this.options.runtime.beginSessionHistoryMutation(session.id)
             : undefined;
         try {
+            if (this.options.isRecovering?.(session.id))
+                throw new Error('SESSION_RESTART_PENDING');
             const runner = this.options.runners.require(session.runner);
             const missingCandidate = requireCleanupSafety && session.externalDiscovered === false;
             if (missingCandidate && !(await runner.isNativeSessionMissing(session)))

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

@@ -72,6 +72,7 @@ export class SessionCommandService {
             return this.options.goal({
                 session,
                 objective: invocation.argument,
+                ...(input.__suppressNotifications === true ? { suppressNotifications: true } : {}),
                 ...(input.__usageGrant === undefined
                     ? {}
                     : { usageGrant: modelUsageGrantSchema.parse(input.__usageGrant) }),

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

@@ -97,6 +97,20 @@ export class SessionLifecycleService {
         const workspace = database.getWorkspace(input.workspaceId);
         if (workspace === undefined)
             throw new Error('WORKSPACE_NOT_FOUND');
+        let parentSessionId;
+        if (input.parentSessionId !== undefined) {
+            if (typeof input.parentSessionId !== 'string' ||
+                input.parentSessionId.length === 0 ||
+                input.parentSessionId.length > 512)
+                throw new Error('SESSION_INVALID');
+            const liveParent = this.options.runtime.getAgentSession(input.parentSessionId);
+            const parent = liveParent ?? database.getSessionRecord(input.parentSessionId);
+            if (parent === undefined || parent.workspaceId !== workspace.id)
+                throw new Error('SESSION_NOT_FOUND');
+            if (liveParent?.externalSessionId === null)
+                throw new Error('SESSION_ACTIVATION_REQUIRED');
+            parentSessionId = liveParent?.externalSessionId ?? parent.id;
+        }
         const environment = parseSecretEnvironment(input.secretEnvironment);
         const saved = database.getRunnerDefaults().find((value) => value.runner === runner.name);
         const fallback = runner.defaultConfiguration(workspace, environment);
@@ -113,6 +127,7 @@ export class SessionLifecycleService {
         if (runner.name === 'mar-agent' && !['auto', 'full-access'].includes(configuration.access))
             throw new Error('SESSION_INVALID');
         const session = this.options.runtime.createAgentSession({
+            ...(parentSessionId === undefined ? {} : { parentSessionId }),
             workspaceId: input.workspaceId,
             runner: runner.name,
             cwd: input.cwd,
@@ -134,24 +149,25 @@ export class SessionLifecycleService {
     }
     async updateConfiguration(input) {
         if (typeof input.sessionId !== 'string' ||
-            typeof input.model !== 'string' ||
+            (input.model === undefined && input.effort === undefined && input.access === undefined) ||
             !validSessionOption(input.model) ||
-            typeof input.effort !== 'string' ||
             !validSessionEffort(input.effort) ||
-            typeof input.access !== 'string' ||
             !validSessionOption(input.access))
             throw new Error('SESSION_INVALID');
         const current = this.options.runtime.getAgentSession(input.sessionId) ??
             (await this.options.projection.createMetadataProjection(input.sessionId));
-        if (current === undefined)
+        if (current === undefined ||
+            (typeof input.workspaceId === 'string' && input.workspaceId !== current.workspaceId))
             throw new Error('SESSION_NOT_FOUND');
-        if (current.runner === 'mar-agent' && !['auto', 'full-access'].includes(input.access))
+        if (current.runner === 'mar-agent' &&
+            input.access !== undefined &&
+            !['auto', 'full-access'].includes(input.access))
             throw new Error('SESSION_INVALID');
         const session = this.options.runtime.updateAgentSessionConfiguration({
             sessionId: current.id,
-            model: input.model,
-            effort: input.effort,
-            access: input.access
+            ...(typeof input.model === 'string' ? { model: input.model } : {}),
+            ...(typeof input.effort === 'string' ? { effort: input.effort } : {}),
+            ...(typeof input.access === 'string' ? { access: input.access } : {})
         });
         if (session.externalSessionId !== null)
             this.options.database().saveNativeSessionMetadata({
@@ -232,6 +248,7 @@ export class SessionLifecycleService {
                 sessionId: messageSessionId,
                 clientMessageId: input.clientMessageId,
                 content: input.content,
+                ...(input.__suppressNotifications === true ? { __suppressNotifications: true } : {}),
                 ...(input.__requestUserId === undefined ? {} : { __requestUserId: input.__requestUserId }),
                 ...(input.__usageGrant === undefined ? {} : { __usageGrant: input.__usageGrant }),
                 ...(input.secretEnvironment === undefined

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

@@ -10,12 +10,24 @@ import { relative } from 'node:path';
 import { prepareComposerResourceInput, composerResourceInputTags, validateComposerSkills } from './composer-message-input.js';
 const INTERNAL_GOAL = Symbol('internalGoal');
 const INTERNAL_SCHEDULE = Symbol('internalSchedule');
+const INTERNAL_RESTORE = Symbol('internalRestore');
 export class SessionMessageService {
     options;
     pendingMessages = new Map();
+    preparations = new Set();
+    accepting = true;
     constructor(options) {
         this.options = options;
     }
+    async drain() {
+        await Promise.allSettled([...this.preparations]);
+    }
+    setAccepting(accepting) {
+        this.accepting = accepting;
+    }
+    restoreQueued(input) {
+        return this.message({ ...input, [INTERNAL_RESTORE]: true });
+    }
     operations() {
         return {
             'session.message': (data) => this.message(record(data)),
@@ -26,7 +38,11 @@ export class SessionMessageService {
     submitGoal(input) {
         return this.message({
             [INTERNAL_GOAL]: true,
+            [INTERNAL_RESTORE]: input.restoreQueued === true,
             sessionId: input.sessionId,
+            __suppressNotifications: input.suppressNotifications === true ||
+                (input.kind === 'continue' &&
+                    this.options.runtime.activeSessionRun(input.sessionId)?.suppressNotifications === true),
             clientMessageId: `goal:${randomUUID()}`,
             content: input.kind === 'start'
                 ? publicGoalStartText(input.objective ?? '')
@@ -64,7 +80,14 @@ export class SessionMessageService {
             marAgentRuntimeScopeId: input.marAgentRuntimeScopeId
         });
     }
-    async message(input) {
+    message(input) {
+        if (!this.accepting)
+            return Promise.reject(new Error('NODE_STOPPED'));
+        const task = this.prepareMessage(input);
+        this.preparations.add(task);
+        return task.finally(() => this.preparations.delete(task));
+    }
+    async prepareMessage(input) {
         if (typeof input.sessionId !== 'string' ||
             typeof input.clientMessageId !== 'string' ||
             input.clientMessageId.length === 0 ||
@@ -77,7 +100,9 @@ export class SessionMessageService {
         const content = input.content;
         const internalGoal = input[INTERNAL_GOAL] === true;
         const internalSchedule = input[INTERNAL_SCHEDULE] === true;
-        const internalRunnerContent = (internalGoal || internalSchedule) && typeof input.__runnerContent === 'string'
+        const internalRestore = input[INTERNAL_RESTORE] === true;
+        const internalRunnerContent = (internalGoal || internalSchedule || internalRestore) &&
+            typeof input.__runnerContent === 'string'
             ? input.__runnerContent
             : content;
         const inlineAttachments = parseMessageAttachments(input.attachments);
@@ -112,9 +137,9 @@ export class SessionMessageService {
                 ...(existing.kind === 'queue' ? { queueItemId: existing.item.id } : {}),
                 delivery: existing.kind === 'queue' ? 'QUEUED' : 'STARTED',
                 idempotent: true,
-                auditReceipt: auditReceipt(session, existing.kind === 'queue' ? 'QUEUE' : 'SEND', existing.run.id, existing.kind === 'queue' ? existing.item.id : undefined)
+                auditReceipt: auditReceipt(session, existing.kind === 'queue' ? 'QUEUE' : 'SEND', existing.kind === 'queue' ? existing.item.id : existing.run.id, existing.kind === 'queue' ? existing.item.id : undefined)
             };
-        const goalMessage = internalGoal || internalSchedule
+        const goalMessage = internalGoal || internalSchedule || internalRestore
             ? undefined
             : this.options.goalMessage(session, content, requestedIntent);
         const runnerContent = goalMessage?.runnerContent ?? internalRunnerContent;
@@ -128,23 +153,35 @@ export class SessionMessageService {
         const operation = (async () => {
             const acceptedSession = accepted.session;
             const session = this.options.runtime.getAgentSession(acceptedSession.id) ?? acceptedSession;
-            const runId = randomUUID();
+            const runId = internalRestore && typeof input.__queueItemId === 'string'
+                ? input.__queueItemId
+                : randomUUID();
             const queueBeforeCreate = this.options.runtime.sessionQueue(session.id);
             const active = this.options.runtime.activeSessionRun(session.id);
             if (internalSchedule && (active !== undefined || queueBeforeCreate.itemIds.length > 0))
                 throw new Error('SCHEDULE_SESSION_BUSY');
             const replaceCurrentRun = intent === 'REPLACE_CURRENT' ? active : undefined;
-            const created = this.options.coordinator.accept({
+            const acceptedMessage = {
                 runId,
                 sessionId: session.id,
                 clientMessageId,
                 content: publicContent,
                 ...(internalSchedule ? { source: 'SCHEDULED' } : {}),
+                ...(input.__suppressNotifications === true ? { suppressNotifications: true } : {}),
                 ...(Number.isSafeInteger(input.__requestUserId)
                     ? { initiatedByUserId: input.__requestUserId }
                     : {}),
                 ...(inlineAttachments.length === 0 ? {} : { attachments: inlineAttachments })
-            }, secretEnvironment);
+            };
+            const created = internalRestore
+                ? {
+                    run: undefined,
+                    queueItem: this.options.runtime.createQueueItem({
+                        ...acceptedMessage,
+                        queueItemId: runId
+                    }).item
+                }
+                : this.options.coordinator.accept(acceptedMessage, secretEnvironment);
             const submissionId = created.queueItem?.id ?? created.run.id;
             const sessionForPresentation = input.__goal === true
                 ? session
@@ -193,6 +230,13 @@ export class SessionMessageService {
                     else
                         this.options.runtime.updateQueueItemAttachments(created.queueItem.id, attachments, displayInput);
                     this.options.coordinator.prepare(submissionId, {
+                        restartMessage: {
+                            content,
+                            attachments,
+                            ...(Number.isSafeInteger(input.__requestUserId)
+                                ? { initiatedByUserId: input.__requestUserId }
+                                : {})
+                        },
                         ...(input.__usageGrant === undefined
                             ? {}
                             : { usageGrant: modelUsageGrantSchema.parse(input.__usageGrant) }),
@@ -235,12 +279,14 @@ export class SessionMessageService {
                         !this.options.prepareGoalInsertion(session.id, submissionId, goalMessage.goal))
                         throw new Error('GOAL_REVISION_STALE');
                     this.options.attachments.retainSessionFiles(currentSession.id, submissionId);
-                    const delivery = this.options.coordinator.settle({
-                        submissionId,
-                        intent,
-                        queueBefore: queueBeforeCreate,
-                        ...(replaceCurrentRun === undefined ? {} : { activeRunId: replaceCurrentRun.id })
-                    });
+                    const delivery = internalRestore
+                        ? 'QUEUED'
+                        : this.options.coordinator.settle({
+                            submissionId,
+                            intent,
+                            queueBefore: queueBeforeCreate,
+                            ...(replaceCurrentRun === undefined ? {} : { activeRunId: replaceCurrentRun.id })
+                        });
                     reservation?.commit((directories) => this.options.attachments.adoptSessionFiles(currentSession.id, submissionId, directories, currentSession.workspaceId, attachmentPaths));
                     this.options.attachments.acceptSessionInput(currentSession.id);
                     return delivery;
@@ -263,7 +309,7 @@ export class SessionMessageService {
                 ...(created.queueItem === undefined ? {} : { queueItemId: created.queueItem.id }),
                 delivery,
                 idempotent: false,
-                auditReceipt: auditReceipt(sessionForPresentation, intent === 'QUEUE' ? 'QUEUE' : intent === 'REPLACE_CURRENT' ? 'REPLACE_CURRENT' : 'SEND', created.run.id, created.queueItem?.id)
+                auditReceipt: auditReceipt(sessionForPresentation, intent === 'QUEUE' ? 'QUEUE' : intent === 'REPLACE_CURRENT' ? 'REPLACE_CURRENT' : 'SEND', created.run?.id ?? submissionId, created.queueItem?.id)
             };
         })();
         this.pendingMessages.set(pendingKey, operation);

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

@@ -12,6 +12,7 @@ export class SessionPresentationService {
                 session = {
                     ...session,
                     sessionPrompt: metadata.sessionPrompt ?? null,
+                    parentSessionId: metadata.parentSessionId ?? session.parentSessionId ?? null,
                     pinnedAt: metadata.pinnedAt,
                     pinOrder: metadata.pinOrder
                 };
@@ -24,6 +25,7 @@ export class SessionPresentationService {
         });
         return {
             ...session,
+            parentSessionId: session.parentSessionId ?? null,
             ...presentation,
             runtime: {
                 ...presentation.runtime,