@myagentroam/node 0.10.34 → 0.10.36

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

@@ -10,9 +10,25 @@ export class ContinuousRunCoordinator {
     startedExecutions = new Set();
     scheduledSessions = new Map();
     immediateQueueItems = new Set();
+    suspended = false;
     constructor(options) {
         this.options = options;
     }
+    suspend() {
+        this.suspended = true;
+        for (const timer of this.scheduledSessions.values())
+            clearTimeout(timer);
+        this.scheduledSessions.clear();
+    }
+    resumeScheduling() {
+        this.suspended = false;
+    }
+    isImmediate(itemId) {
+        return this.immediateQueueItems.has(itemId);
+    }
+    restoreImmediate(itemId) {
+        this.immediateQueueItems.add(itemId);
+    }
     accept(message, environment = {}) {
         const release = this.options.retainEnvironment?.(environment);
         let retained = false;
@@ -31,6 +47,7 @@ export class ContinuousRunCoordinator {
                 sessionId: message.sessionId,
                 clientMessageId: message.clientMessageId,
                 content: message.content,
+                ...(message.suppressNotifications === true ? { suppressNotifications: true } : {}),
                 ...(message.initiatedByUserId === undefined
                     ? {}
                     : { initiatedByUserId: message.initiatedByUserId }),
@@ -186,6 +203,14 @@ export class ContinuousRunCoordinator {
         const resources = prepareComposerResourceInput(input, pending.cwd, pending.workspacePath ?? pending.cwd);
         this.preparedInputs.set(itemId, {
             ...pending,
+            ...(pending.restartMessage === undefined
+                ? {}
+                : {
+                    restartMessage: {
+                        ...pending.restartMessage,
+                        content: this.options.runtime.getQueueItem(itemId)?.content ?? input
+                    }
+                }),
             input: withNonImageAttachmentPrompt(resources, pending.attachmentPaths, pending.attachmentFiles)
         });
     }
@@ -238,6 +263,8 @@ export class ContinuousRunCoordinator {
         this.startIdleQueue(sessionId);
     }
     schedule(sessionId, delayMs = 0) {
+        if (this.suspended)
+            return;
         if (this.scheduledSessions.has(sessionId))
             return;
         const timer = setTimeout(() => {
@@ -256,6 +283,8 @@ export class ContinuousRunCoordinator {
         this.schedule(sessionId);
     }
     async dispatch(sessionId) {
+        if (this.suspended || this.options.stopped())
+            return;
         const active = this.options.runtime.activeSessionRun(sessionId);
         if (active === undefined)
             return;
@@ -323,6 +352,8 @@ export class ContinuousRunCoordinator {
             const goalMcp = pending.goal === undefined ? undefined : await this.options.goalMcp?.(executionInput);
             const scheduledMcp = await this.options.scheduledMcp?.(executionInput);
             const mailMcp = await this.options.mailMcp?.(executionInput);
+            if (this.suspended || this.options.stopped())
+                return;
             if (!this.goalCurrent(pending)) {
                 this.dispatchedExecutions.delete(executionId);
                 this.rejectStaleGoal(executionId);

package/dist/service/direct-transfer-service.js

@@ -77,12 +77,12 @@ export class DirectTransferService {
     handleTerminal(value) {
         return this.terminalDirect?.handle(value, (id) => this.transports.get(id)?.peer) ?? false;
     }
-    close() {
+    close(code = 'DIRECT_NODE_STOPPED') {
         this.terminalDirect?.close();
         for (const transfer of [...this.transfers.values()])
-            void this.removeTransfer(transfer, 'DIRECT_NODE_STOPPED');
+            void this.removeTransfer(transfer, code);
         for (const transport of [...this.transports.values()])
-            this.removeTransport(transport, 'DIRECT_NODE_STOPPED');
+            this.removeTransport(transport, code);
     }
     dispose() {
         if (this.disposed)
@@ -215,6 +215,7 @@ export class DirectTransferService {
             uploadCommitted: false,
             opened: false,
             processing: Promise.resolve(),
+            controller: new AbortController(),
             lastLeaseAliveAt: this.now(),
             leaseExpiresAt: command.expiresAt,
             leaseTimer: undefined
@@ -267,10 +268,11 @@ export class DirectTransferService {
                     channel.close();
                 return;
             }
+            const pendingTransfer = this.transfers.get(openFrameSessionId(event.data) ?? '');
             void this.openChannel(transport, channel, event.data).catch((error) => {
                 channel.close();
                 const id = openFrameSessionId(event.data);
-                if (id !== undefined)
+                if (id !== undefined && this.transfers.get(id) === pendingTransfer)
                     this.fail(id, errorCode(error), errorMessage(error));
             });
         };
@@ -294,16 +296,25 @@ export class DirectTransferService {
         transfer.opened = true;
         channel.onmessage = (event) => {
             transfer.processing = transfer.processing
-                .then(() => this.channelMessage(transfer, event.data))
-                .catch((error) => this.fail(transfer.command.directSessionId, errorCode(error), errorMessage(error)));
+                .then(() => {
+                if (this.current(transfer))
+                    return this.channelMessage(transfer, event.data);
+            })
+                .catch((error) => {
+                if (this.current(transfer))
+                    this.fail(transfer.command.directSessionId, errorCode(error), errorMessage(error));
+            });
         };
         channel.onclose = () => {
             if (this.transfers.get(transfer.command.directSessionId) === transfer)
                 void this.removeTransfer(transfer, 'DIRECT_CHANNEL_CLOSED');
         };
-        await this.open(transfer);
+        transfer.processing = this.open(transfer);
+        await transfer.processing;
     }
     async channelMessage(transfer, data) {
+        if (!this.current(transfer))
+            return;
         const descriptor = transfer.command.transfer;
         const expectedSize = transferredSize(descriptor);
         if (descriptor.direction === 'DOWNLOAD') {
@@ -326,8 +337,10 @@ export class DirectTransferService {
                 throw new Error('DIRECT_FRAME_INVALID');
             if (control.size !== descriptor.size)
                 throw new Error('DIRECT_INTEGRITY_FAILED');
-            await transfer.upload.complete(control.size);
+            await transfer.upload.complete(control.size, transfer.controller.signal);
             transfer.uploadCommitted = true;
+            if (!this.current(transfer))
+                return;
             this.emit(transfer.command.directSessionId, {
                 type: 'direct.complete',
                 directSessionId: transfer.command.directSessionId,
@@ -340,6 +353,8 @@ export class DirectTransferService {
         if (bytes.byteLength === 0 || bytes.byteLength > 256 * 1024 || transfer.upload === undefined)
             throw new Error('DIRECT_CHUNK_INVALID');
         const offset = await transfer.upload.write(bytes);
+        if (!this.current(transfer))
+            return;
         transfer.channel?.send(JSON.stringify({ type: 'ACK', offset }));
     }
     async open(transfer) {
@@ -348,6 +363,11 @@ export class DirectTransferService {
             if (this.options.openUpload === undefined)
                 throw new Error('DIRECT_UPLOAD_UNAVAILABLE');
             transfer.upload = await this.options.openUpload(descriptor);
+            if (!this.current(transfer)) {
+                if (!transfer.preserveUpload)
+                    await this.cancelUpload(transfer);
+                return;
+            }
             transfer.channel?.send(JSON.stringify({ type: 'ACK', offset: transfer.upload.offset }));
             this.emit(transfer.command.directSessionId, {
                 type: 'direct.opened',
@@ -359,6 +379,8 @@ export class DirectTransferService {
         if (this.options.openDownload === undefined)
             throw new Error('DIRECT_DOWNLOAD_UNAVAILABLE');
         const source = await this.options.openDownload(descriptor);
+        if (!this.current(transfer))
+            return;
         const expectedSize = transferredSize(descriptor);
         transfer.channel?.send(JSON.stringify({ type: 'ACK', offset: source.offset }));
         this.emit(transfer.command.directSessionId, {
@@ -444,12 +466,20 @@ export class DirectTransferService {
             });
     }
     async removeTransfer(transfer, code) {
-        if (!this.transfers.delete(transfer.command.directSessionId))
+        if (!this.current(transfer))
             return;
+        this.transfers.delete(transfer.command.directSessionId);
         clearInterval(transfer.leaseTimer);
-        if (!transfer.uploadCommitted)
-            await transfer.upload?.cancel().catch(() => undefined);
+        const preserveWorkspaceUpload = transfer.command.transfer.direction === 'UPLOAD' &&
+            transfer.command.transfer.composerAttachment === undefined &&
+            (code === 'DIRECT_CHANNEL_CLOSED' ||
+                code === 'DIRECT_CONNECTION_FAILED' ||
+                code === 'DIRECT_TRANSFER_CONTROL_UNAVAILABLE');
+        transfer.preserveUpload = preserveWorkspaceUpload;
+        transfer.controller.abort();
         transfer.channel?.close();
+        if (!transfer.uploadCommitted && !preserveWorkspaceUpload)
+            await this.cancelUpload(transfer);
         if (code !== undefined)
             this.options.send('direct.error', {
                 type: 'direct.error',
@@ -458,6 +488,23 @@ export class DirectTransferService {
                 message: directErrorMessage(code)
             });
     }
+    current(transfer) {
+        return (this.transfers.get(transfer.command.directSessionId) === transfer &&
+            !transfer.controller.signal.aborted);
+    }
+    async cancelUpload(transfer) {
+        if (transfer.upload === undefined)
+            return;
+        transfer.cleanup ??= transfer.upload.cancel().catch(() => {
+            this.options.send('direct.error', {
+                type: 'direct.error',
+                directSessionId: transfer.command.directSessionId,
+                code: 'DIRECT_UPLOAD_CLEANUP_FAILED',
+                message: 'Temporary upload cleanup could not be completed.'
+            });
+        });
+        await transfer.cleanup;
+    }
 }
 function transferredSize(descriptor) {
     return descriptor.direction === 'DOWNLOAD' && descriptor.range !== undefined

package/dist/service/external-session-resume-service.js

@@ -70,7 +70,8 @@ export class ExternalSessionResumeService {
                         access: configuration.access,
                         ...(session.runnerTitle === null ? {} : { title: session.runnerTitle }),
                         ...(session.customTitle === null ? {} : { customTitle: session.customTitle }),
-                        sessionPrompt: session.sessionPrompt ?? null
+                        sessionPrompt: session.sessionPrompt ?? null,
+                        parentSessionId: session.parentSessionId ?? null
                     });
                 },
                 workspacePath: this.options.workspacePath,

package/dist/service/goal-runtime.js

@@ -31,6 +31,8 @@ export function stripGoalStartPrompt(text) {
     return close === -1 ? '' : text.slice(close + tags.close.length).trimStart();
 }
 export function publicGoalHistoryText(text) {
+    if (parseComposerTags(text)[0]?.kind === 'mar_restart')
+        return serializeComposerTag('mar_restart', {});
     const tags = goalPromptTags(text);
     if (tags === undefined)
         return text;
@@ -61,6 +63,17 @@ export class GoalRuntime {
     get(sessionId) {
         return this.goals.get(sessionId);
     }
+    restartState(sessionId) {
+        const goal = this.goals.get(sessionId);
+        return goal === undefined
+            ? undefined
+            : { goal: { ...goal }, executionFailures: this.executionFailures.get(sessionId) ?? 0 };
+    }
+    restoreRestartState(state) {
+        this.goals.set(state.goal.sessionId, { ...state.goal });
+        this.executionFailures.set(state.goal.sessionId, state.executionFailures);
+        this.changed(state.goal);
+    }
     migrateSession(previousId, nextId) {
         if (previousId === nextId)
             return;

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();
+}