@myagentroam/node 0.10.35 → 0.10.37

package/dist/connector.js

@@ -68,7 +68,9 @@ import { composerResourceInputTags } from './service/composer-message-input.js';
 import { SessionScheduleService } from './service/session-schedule-service.js';
 import { ScheduledSessionCoordinator } from './service/scheduled-session-coordinator.js';
 import { ScheduledSessionStore } from './service/scheduled-session-store.js';
-import { ScheduledRunAuthorizationControl } from './service/scheduled-run-authorization-control.js';
+import { RunAuthorizationControl } from './service/run-authorization-control.js';
+import { PlannedRestartHandoff } from './service/planned-restart-handoff.js';
+import { RestartSessionRestorer } from './service/restart-session-restorer.js';
 import { ScheduledTaskMcpServer } from './service/scheduled-task-mcp-server.js';
 import { MailNotificationControl } from './service/mail-notification-control.js';
 import { MailNotificationMcpServer, resolveMailNotificationCapability } from './service/mail-notification-mcp-server.js';
@@ -169,6 +171,9 @@ export class NodeConnector {
     controlChannel;
     controlMessages;
     scheduledRunAuthorization;
+    restartAuthorization;
+    restartHandoff;
+    inFlightOperations = new Set();
     mailNotificationControl = new MailNotificationControl((envelope) => this.sendEnvelope(envelope));
     scheduledSessions;
     nodeRequests;
@@ -397,6 +402,8 @@ export class NodeConnector {
             this.goalRuntime.get(sessionId)?.status === 'active',
         executionTerminating: (executionId, status, permissionStop) => {
             this.gitOperationService.executionFinished(executionId);
+            if (this.stopped)
+                return;
             const pending = this.continuousRunCoordinator.pending(executionId);
             if (pending?.goal === undefined)
                 return;
@@ -779,7 +786,8 @@ export class NodeConnector {
             goal: (sessionId) => this.goalRuntime.get(sessionId),
             runtime: this.runtime,
             runners: this.runners,
-            resolve: (sessionId) => this.nativeSessionProjectionService.resolve(sessionId),
+            resolve: (sessionId, registeredOnly) => this.nativeSessionProjectionService.resolve(sessionId, registeredOnly),
+            similar: (sessionId, workspaceId) => this.nativeSessionProjectionService.similarSessionDetails(sessionId, workspaceId),
             present: (session) => this.sessionPresentationService.present(session),
             history: (session, input) => this.conversationHistoryService.read(session, input),
             segments: (session, input) => this.conversationSegmentService.read(session, input),
@@ -937,6 +945,7 @@ export class NodeConnector {
         });
         this.workspaceQueueWorkbenchService = new WorkspaceQueueWorkbenchService({
             runtime: this.runtime,
+            resolve: (sessionId, registeredOnly) => this.nativeSessionProjectionService.resolve(sessionId, registeredOnly),
             coordinator: this.continuousRunCoordinator,
             emit: (workspaceId, sessionId) => this.runEventBridge.emitQueue(workspaceId, sessionId),
             prepareInput: (runner, input, collaborationMode) => this.runners.require(runner).prepareMessageInput(input, collaborationMode)
@@ -947,15 +956,18 @@ export class NodeConnector {
                 void this.runAttachmentService.releaseSession(sessionId);
             },
             persist: (session, nativeSessionId) => {
-                if (session.model === null || session.effort === null || session.access === null)
-                    return;
                 this.database?.saveNativeSessionMetadata({
+                    ...(session.parentSessionId == null ? {} : { parentSessionId: session.parentSessionId }),
                     runner: session.runner,
                     externalSessionId: nativeSessionId,
                     workspaceId: session.workspaceId,
-                    model: session.model,
-                    effort: session.effort,
-                    access: session.access
+                    ...(session.model === null ? {} : { model: session.model }),
+                    ...(session.effort === null ? {} : { effort: session.effort }),
+                    ...(session.access === null ? {} : { access: session.access }),
+                    ...(session.customTitle === null ? {} : { customTitle: session.customTitle }),
+                    ...(session.runnerTitle === null
+                        ? {}
+                        : { runnerTitle: session.runnerTitle.slice(0, 160) })
                 });
             },
             migrateCommands: (previousId, nextId) => this.commandStates.promoteSessionIdentity(previousId, nextId),
@@ -1073,7 +1085,7 @@ export class NodeConnector {
                     goalAccessChanged: prepared.changed
                 };
             },
-            goal: async ({ session, objective, initiatedByUserId, secretEnvironment, personalInstructions, marAgentModel, marAgentModels, marAgentCompact, marAgentRuntimeScopeId, usageGrant }) => {
+            goal: async ({ session, objective, initiatedByUserId, suppressNotifications, secretEnvironment, personalInstructions, marAgentModel, marAgentModels, marAgentCompact, marAgentRuntimeScopeId, usageGrant }) => {
                 this.invalidateGoalContinuation(session.id);
                 const prepared = this.prepareGoalSession(session);
                 const goalSession = prepared.session;
@@ -1093,6 +1105,7 @@ export class NodeConnector {
                         objective: goal.objective,
                         deliveryIntent: replacing ? 'REPLACE_CURRENT' : 'SEND',
                         goal: goalRef,
+                        ...(suppressNotifications === true ? { suppressNotifications: true } : {}),
                         ...(usageGrant === undefined ? {} : { usageGrant }),
                         ...(initiatedByUserId === undefined ? {} : { initiatedByUserId }),
                         secretEnvironment,
@@ -1190,6 +1203,31 @@ export class NodeConnector {
             },
             goalPreparationFailed: (session, goal, activated) => this.handleGoalPreparationFailed(session, goal, activated)
         });
+        const inputState = (entry, message) => this.marAgentClient.restartInputState(entry.session.id, message.clientMessageId);
+        const restorer = new RestartSessionRestorer({
+            runtime: this.runtime,
+            goals: this.goalRuntime,
+            commands: this.commandStates,
+            coordinator: this.continuousRunCoordinator,
+            messages: this.sessionMessageService,
+            resolve: (id) => this.externalSessionResumeService.resolveForMessage(id),
+            authorize: (request) => this.restartAuthorization.authorize(request),
+            inputState,
+            withGrant: (context, work) => this.modelUsage.withGrant(context.usageGrant, work),
+            publishGoal: (session, goal) => this.publishGoalState(session, goal),
+            publishQueue: (session) => this.continuousRunCoordinator.publish(session.id)
+        });
+        this.restartHandoff = new PlannedRestartHandoff({
+            directory: () => nodeDataDirectory(this.config, this.configPath),
+            identity: () => ({ nodeId: this.config.nodeId, serverUrl: this.config.serverUrl }),
+            runtime: this.runtime,
+            coordinator: this.continuousRunCoordinator,
+            goals: this.goalRuntime,
+            commandActive: (id, command) => this.commandStates.get(id, command)?.active === true,
+            inputState,
+            restore: (entry, id) => restorer.restore(entry, id),
+            diagnose: (code, sessionId) => nodeLog('node.restart.diagnostic', { code, sessionId })
+        });
         this.sessionCatalogService = new SessionCatalogService({
             database: () => {
                 if (this.database === undefined)
@@ -1216,6 +1254,7 @@ export class NodeConnector {
             refreshActivity: (session) => this.conversationHistoryService.refreshExternalActivity(session),
             externalActivity: (sessionId) => this.sessionState.externalActivity.get(sessionId),
             isWatching: (sessionId) => this.nativeSessionWatchService.isWatching(sessionId),
+            isRecovering: (sessionId) => this.restartHandoff.blocks(sessionId),
             history: (session, input) => this.conversationHistoryService.read(session, input),
             invalidateHistory: (sessionId, workspaceId) => {
                 this.nativeSessionWatchService.invalidate(sessionId);
@@ -1323,10 +1362,11 @@ export class NodeConnector {
             onClose: (code, reason) => {
                 this.promptCompletion?.disconnect();
                 this.usageOutbox?.disconnected();
-                this.directTransferService?.close();
+                this.directTransferService?.close('DIRECT_TRANSFER_CONTROL_UNAVAILABLE');
                 this.runtimeCredentials.disconnected();
                 this.chatgptLogins.close();
                 this.scheduledRunAuthorization.disconnected();
+                this.restartAuthorization.disconnected();
                 this.mailNotificationControl.disconnected();
                 this.mailNotificationMcpServer.revokeAll();
                 this.terminalChannel.disconnect();
@@ -1364,7 +1404,8 @@ export class NodeConnector {
             inspectWorkspace: (envelope) => this.workspaceCoordinator.inspect(envelope),
             handleNodeRequest: (envelope) => this.nodeRequests.handle(envelope),
             handleRuntimeCredentialResponse: (envelope) => this.runtimeCredentials.handle(envelope),
-            handleScheduledRunAuthorizeResponse: (envelope) => this.scheduledRunAuthorization.handle(envelope),
+            handleScheduledRunAuthorizeResponse: (envelope) => this.scheduledRunAuthorization.handle(envelope) ||
+                this.restartAuthorization.handle(envelope),
             handleMailNotificationResponse: (envelope) => this.mailNotificationControl.handle(envelope),
             handleDirectTransfer: (envelope) => this.handleDirectTransfer(envelope),
             handleTerminalDirect: (envelope) => this.handleTerminalDirect(envelope),
@@ -1435,6 +1476,10 @@ export class NodeConnector {
             onConnected: () => {
                 this.runtimeCredentials.connected();
                 this.scheduledRunAuthorization.connected();
+                this.scheduledSessions.connected();
+                this.restartAuthorization.connected();
+                if (!this.stopped)
+                    void this.restartHandoff.recover();
                 this.mailNotificationControl.connected();
                 this.recentRunProjectionService.publishSnapshot();
             }
@@ -1444,10 +1489,13 @@ export class NodeConnector {
                 throw new Error('NODE_DATABASE_UNAVAILABLE');
             return this.database;
         };
-        this.scheduledRunAuthorization = new ScheduledRunAuthorizationControl((envelope) => this.controlChannel.sendEnvelope(envelope));
+        this.scheduledRunAuthorization = new RunAuthorizationControl((envelope) => this.controlChannel.sendEnvelope(envelope));
+        this.restartAuthorization = new RunAuthorizationControl((envelope) => this.controlChannel.sendEnvelope(envelope), 'restart');
         this.scheduledSessions = new ScheduledSessionCoordinator({
             store: () => new ScheduledSessionStore(requireDatabase().raw),
-            busy: (task) => this.runtime.activeSessionRun(task.sessionId) !== undefined ||
+            busy: (task) => this.stopped ||
+                this.restartHandoff.blocks(task.sessionId) ||
+                this.runtime.activeSessionRun(task.sessionId) !== undefined ||
                 this.runtime.sessionQueue(task.sessionId).itemIds.length > 0,
             authorize: async (task, occurrenceId) => {
                 const session = this.runtime.getAgentSession(task.sessionId) ??
@@ -1800,6 +1848,8 @@ export class NodeConnector {
             await this.stopping;
         this.stopping = undefined;
         this.stopped = false;
+        this.continuousRunCoordinator.resumeScheduling();
+        this.sessionMessageService.setAccepting(true);
         this.config ??= await loadNodeConfig(this.configPath);
         this.promptCompletion.initializeJournal(nodeDataDirectory(this.config, this.configPath));
         await this.upgradeCoordinator.loadResult(resolve(dirname(nodeDatabasePath(this.config, this.configPath)), 'upgrade-result.json'));
@@ -1816,6 +1866,8 @@ export class NodeConnector {
         });
         this.usageOutbox.recoverInterrupted();
         this.database.closeRunningTerminalSessions();
+        await this.restartHandoff.load();
+        this.scheduledSessions.recoverInterrupted();
         this.scheduledSessions.start();
         await this.initializeConversationHosting();
         this.computerUseEnablement.initialize();
@@ -1838,6 +1890,7 @@ export class NodeConnector {
                     const upload = await this.workspaceUploadService.createDirect(workspace, {
                         path: descriptor.resource.path,
                         size: descriptor.size,
+                        sha256: descriptor.sha256,
                         overwrite: descriptor.overwrite === true,
                         ...(descriptor.composerAttachment === undefined
                             ? {}
@@ -1846,7 +1899,7 @@ export class NodeConnector {
                     return {
                         offset: upload.receivedBytes,
                         write: (bytes) => this.workspaceUploadService.writeDirect(upload.uploadId, bytes),
-                        complete: (size) => this.workspaceUploadService.completeDirect(upload.uploadId, size),
+                        complete: (size, signal) => this.workspaceUploadService.completeDirect(upload.uploadId, size, signal),
                         cancel: () => this.workspaceUploadService.cancel(upload.uploadId)
                     };
                 },
@@ -2141,10 +2194,32 @@ export class NodeConnector {
             closeInput: '/goal --clear'
         };
     }
-    stop() {
+    stop(options = {}) {
         if (this.stopping !== undefined)
             return this.stopping;
         this.stopped = true;
+        this.continuousRunCoordinator.suspend();
+        this.scheduledSessions.stop();
+        this.stopping = (async () => {
+            let snapshot;
+            try {
+                // In-flight recovery must rebuild accepted inputs before preparation closes.
+                await this.restartHandoff.wait();
+                this.sessionMessageService.setAccepting(false);
+                await Promise.allSettled([...this.inFlightOperations]);
+                await this.sessionMessageService.drain();
+                if (options.handoff && this.config?.nodeId)
+                    snapshot = this.restartHandoff.capture();
+            }
+            finally {
+                await this.disposeRuntime();
+            }
+            if (snapshot !== undefined)
+                await this.restartHandoff.publish(snapshot);
+        })();
+        return this.stopping;
+    }
+    disposeRuntime() {
         this.recentRunProjectionService.dispose();
         this.upgradeCoordinator.stop();
         this.connectionLifecycle.stop();
@@ -2202,6 +2277,7 @@ export class NodeConnector {
         this.chatgptLogins.close();
         this.scheduledSessions.stop();
         this.scheduledRunAuthorization.close();
+        this.restartAuthorization.close();
         this.mailNotificationControl.close();
         const mailMcpDrain = this.mailNotificationMcpServer.close();
         const webToolDrain = this.webToolService.close();
@@ -2220,21 +2296,24 @@ export class NodeConnector {
             mailMcpDrain,
             webToolDrain
         ]);
-        this.stopping = (async () => {
+        return (async () => {
+            let failed;
             try {
                 await conversationHostingMaintenanceDrain;
             }
             finally {
                 await hostedConversationRuntime?.dispose().catch(() => undefined);
-                await drains;
+                const results = await drains;
                 await this.gitExecutionService?.close();
                 this.usageOutbox?.disconnected();
                 this.usageOutbox = undefined;
                 this.modelUsage.clear();
                 database?.close();
+                failed = results.find((result) => result.status === 'rejected');
             }
+            if (failed !== undefined)
+                throw failed.reason;
         })();
-        return this.stopping;
     }
     /** @internal Thin compatibility delegates; all behavior remains in the extracted services. */
     handleMessage = (raw) => this.controlMessages.handle(raw);
@@ -2375,12 +2454,30 @@ export class NodeConnector {
     startCapabilityRefresh = () => this.connectionLifecycle.startCapabilityRefresh();
     refreshCapabilities = () => this.connectionLifecycle.refreshCapabilities();
     async executeNodeOperation(operation, data) {
+        if (this.stopped)
+            throw new Error('NODE_STOPPED');
+        const input = isPlainRecord(data) ? data : {};
+        const sessionId = typeof input.sessionId === 'string' ? input.sessionId : undefined;
+        if (this.restartHandoff.blocksOperation(operation, input))
+            throw new Error('SESSION_RESTART_PENDING');
         if (this.database === undefined)
             throw new Error('NODE_DATABASE_UNAVAILABLE');
         if (this.upgradeCoordinator.blocks(operation))
             throw new Error('NODE_UPGRADE_PENDING');
         nodeLog('node.operation', { nodeId: this.config?.nodeId, operation });
-        return this.gitOperationService.execute(operation, data, (input) => this.operationRouter.execute(operation, input));
+        const task = this.gitOperationService.execute(operation, data, (input) => this.operationRouter.execute(operation, input));
+        this.inFlightOperations.add(task);
+        try {
+            const result = await task;
+            if ((operation === 'session.command.execute' || operation === 'session.message') &&
+                sessionId !== undefined &&
+                Number.isSafeInteger(input.__requestUserId))
+                this.restartHandoff.rememberUser(sessionId, input.__requestUserId);
+            return result;
+        }
+        finally {
+            this.inFlightOperations.delete(task);
+        }
     }
     gitExecution() {
         this.gitExecutionService ??= new GitExecutionService({

package/dist/database.js

@@ -1,5 +1,7 @@
 import { NODE_SCHEMA_MIGRATION_V17 } from './migrations/v017.js';
 import { NODE_SCHEMA_MIGRATION_V18 } from './migrations/v018.js';
+import { NODE_SCHEMA_MIGRATION_V19 } from './migrations/v019.js';
+import { NODE_SCHEMA_MIGRATION_V20 } from './migrations/v020.js';
 import { normalizeSessionPrompt } from './util/personal-instructions.js';
 import { randomUUID } from 'node:crypto';
 import { closeSync, existsSync, mkdirSync, openSync, rmSync } from 'node:fs';
@@ -19,7 +21,9 @@ export const NODE_SCHEMA_MIGRATIONS = [
     NODE_SCHEMA_MIGRATION_V15,
     NODE_SCHEMA_MIGRATION_V16,
     NODE_SCHEMA_MIGRATION_V17,
-    NODE_SCHEMA_MIGRATION_V18
+    NODE_SCHEMA_MIGRATION_V18,
+    NODE_SCHEMA_MIGRATION_V19,
+    NODE_SCHEMA_MIGRATION_V20
 ];
 const LEGACY_NODE_SCHEMA_V12 = NODE_SCHEMA_VERSION_V13 - 1;
 const OBSOLETE_NODE_SCHEMA_V16 = 16;
@@ -288,8 +292,10 @@ export class NodeDatabase {
         const model = input.model === undefined ? (current?.model ?? null) : input.model;
         const effort = input.effort === undefined ? (current?.effort ?? null) : input.effort;
         const access = input.access === undefined ? (current?.access ?? null) : input.access;
+        const parentSessionId = current?.parentSessionId ?? input.parentSessionId ?? null;
         const metadata = JSON.stringify({
             version: 1,
+            parentSessionId,
             customTitle,
             sessionPrompt,
             runnerTitle,
@@ -328,6 +334,7 @@ export class NodeDatabase {
         }
         return {
             customTitle,
+            parentSessionId,
             sessionPrompt,
             runnerTitle,
             runnerTitlePending,
@@ -341,17 +348,13 @@ export class NodeDatabase {
     listSessionRecords(workspaceId) {
         return this.raw
             .prepare('SELECT id, workspace_id, runner, pin_order, metadata FROM agent_sessions WHERE workspace_id = ? ORDER BY pin_order IS NULL, pin_order, id')
-            .all(workspaceId).map((row) => ({
-            id: stringValue(row, 'id'),
-            workspaceId: stringValue(row, 'workspace_id'),
-            runner: stringValue(row, 'runner'),
-            pinOrder: nullableNumber(row, 'pin_order'),
-            metadata: {
-                ...sessionMetadata(row),
-                pinnedAt: row['pin_order'] === null ? null : 1,
-                pinOrder: nullableNumber(row, 'pin_order')
-            }
-        }));
+            .all(workspaceId).map(sessionRecord);
+    }
+    getSessionRecord(sessionId) {
+        const row = this.raw
+            .prepare('SELECT id, workspace_id, runner, pin_order, metadata FROM agent_sessions WHERE id = ?')
+            .get(sessionId);
+        return row === undefined ? undefined : sessionRecord(row);
     }
     movePinnedSession(sessionId, direction) {
         const current = this.raw
@@ -565,6 +568,19 @@ function mcpInstallation(row) {
         installedAt: numberValue(row, 'installed_at')
     };
 }
+function sessionRecord(row) {
+    return {
+        id: stringValue(row, 'id'),
+        workspaceId: stringValue(row, 'workspace_id'),
+        runner: stringValue(row, 'runner'),
+        pinOrder: nullableNumber(row, 'pin_order'),
+        metadata: {
+            ...sessionMetadata(row),
+            pinnedAt: row['pin_order'] === null ? null : 1,
+            pinOrder: nullableNumber(row, 'pin_order')
+        }
+    };
+}
 function sessionMetadata(row) {
     const raw = JSON.parse(stringValue(row, 'metadata'));
     if (raw['version'] !== 1)
@@ -572,6 +588,7 @@ function sessionMetadata(row) {
     const value = (key) => typeof raw[key] === 'string' ? raw[key] : null;
     return {
         customTitle: value('customTitle'),
+        parentSessionId: value('parentSessionId'),
         sessionPrompt: value('sessionPrompt'),
         runnerTitle: value('runnerTitle'),
         runnerTitlePending: raw['runnerTitlePending'] === true,

package/dist/main.js

@@ -7,6 +7,7 @@ import { getNodeHealth } from './health.js';
 import { browserCachePath, removeServiceDefinition, writeServiceDefinition } from './service.js';
 import { superviseNode } from './supervisor.js';
 import { configureNodeLog } from './rotating-log.js';
+import { nodeLog } from './operational.js';
 const [command = 'status', ...args] = process.argv.slice(2);
 const config = readOption(args, '--config') ?? nodeConfigPath();
 const output = readOption(args, '--output') ?? defaultServicePath();
@@ -17,11 +18,26 @@ if (command === 'run') {
     const { NodeConnector } = await import('./connector.js');
     configureNodeLog(nodeDataDirectory(await loadNodeConfig(config), config));
     const connector = new NodeConnector({ configPath: config });
+    let shuttingDown = false;
     const shutdown = () => {
-        void connector.stop().finally(() => process.exit(0));
+        if (shuttingDown)
+            return;
+        shuttingDown = true;
+        const deadline = setTimeout(() => {
+            nodeLog('node.restart.diagnostic', { code: 'RESTART_HANDOFF_SHUTDOWN_TIMEOUT' });
+            process.exit(1);
+        }, 25_000);
+        void connector.stop({ handoff: true }).then(() => {
+            clearTimeout(deadline);
+            process.exit(0);
+        }, () => {
+            clearTimeout(deadline);
+            nodeLog('node.restart.diagnostic', { code: 'RESTART_HANDOFF_SHUTDOWN_FAILED' });
+            process.exit(1);
+        });
     };
     for (const signal of ['SIGINT', 'SIGTERM']) {
-        process.once(signal, shutdown);
+        process.on(signal, shutdown);
     }
     await connector.start();
 }

package/dist/migrations/v019.js

@@ -0,0 +1,9 @@
+import { NODE_SCHEMA_MIGRATION_V18 } from './v018.js';
+export const NODE_SCHEMA_MIGRATION_V19 = {
+    version: 19,
+    sql: `UPDATE agent_sessions
+    SET metadata = json_set(metadata, '$.parentSessionId', NULL)
+    WHERE json_type(metadata, '$.parentSessionId') IS NULL;`,
+    preflight: (database) => NODE_SCHEMA_MIGRATION_V18.assert(database),
+    assert: (database) => NODE_SCHEMA_MIGRATION_V18.assert(database)
+};

package/dist/migrations/v020.js

@@ -0,0 +1,46 @@
+import { DatabaseSync } from 'node:sqlite';
+import { NODE_SCHEMA_V13 } from './v013.js';
+import { NODE_SCHEMA_MIGRATION_V14 } from './v014.js';
+import { NODE_SCHEMA_MIGRATION_V15 } from './v015.js';
+import { NODE_SCHEMA_MIGRATION_V16 } from './v016.js';
+import { NODE_SCHEMA_MIGRATION_V17 } from './v017.js';
+import { NODE_SCHEMA_MIGRATION_V18 } from './v018.js';
+import { NODE_SCHEMA_MIGRATION_V19 } from './v019.js';
+const sql = `CREATE INDEX scheduled_session_occurrences_unfinished
+  ON scheduled_session_occurrences(status) WHERE status IN ('CLAIMED','SUBMITTED');`;
+export const NODE_SCHEMA_MIGRATION_V20 = {
+    version: 20,
+    sql,
+    preflight: (database) => NODE_SCHEMA_MIGRATION_V19.assert(database),
+    assert(database) {
+        const reference = new DatabaseSync(':memory:');
+        try {
+            reference.exec(NODE_SCHEMA_V13);
+            for (const migration of [
+                NODE_SCHEMA_MIGRATION_V14,
+                NODE_SCHEMA_MIGRATION_V15,
+                NODE_SCHEMA_MIGRATION_V16,
+                NODE_SCHEMA_MIGRATION_V17,
+                NODE_SCHEMA_MIGRATION_V18,
+                NODE_SCHEMA_MIGRATION_V19
+            ])
+                reference.exec(migration.sql);
+            reference.exec(sql);
+            const schema = (db) => db
+                .prepare("SELECT type,name,sql FROM sqlite_master WHERE sql IS NOT NULL AND name NOT LIKE 'sqlite_%' ORDER BY type,name")
+                .all()
+                .map((row) => [
+                row.type,
+                row.name,
+                row.name === 'node_schema_migrations'
+                    ? String(row.sql).replace(/\s+/g, '')
+                    : String(row.sql).replace(/\s+/g, ' ').trim()
+            ]);
+            if (JSON.stringify(schema(reference)) !== JSON.stringify(schema(database)))
+                throw new Error('NODE_DATABASE_SCHEMA_INVALID:scheduled_session_occurrences_unfinished');
+        }
+        finally {
+            reference.close();
+        }
+    }
+};

package/dist/runner/mar-agent/computer-use-probe.js

@@ -0,0 +1,126 @@
+/** Read-only platform evidence; never inject input or replace clipboard contents. */
+export const PYTHON_PROBE_SOURCE = String.raw `
+import ctypes
+import json
+import os
+import shutil
+import subprocess
+import sys
+
+result = dict(supportsScreenshot=False, supportsPrimaryDisplay=False,
+              supportsInput=False, supportsUnicodePaste=False,
+              reasonCode="COMPUTER_RUNTIME_UNAVAILABLE")
+
+def signature(library, name, arguments, returns):
+    function = getattr(library, name)
+    function.argtypes = arguments
+    function.restype = returns
+    return function
+
+def windows_desktop():
+    user = ctypes.WinDLL("user32", use_last_error=True)
+    kernel = ctypes.WinDLL("kernel32", use_last_error=True)
+    handle, integer = ctypes.c_void_p, ctypes.c_uint32
+    open_desktop = signature(user, "OpenInputDesktop", [integer, ctypes.c_int, integer], handle)
+    close_desktop = signature(user, "CloseDesktop", [handle], ctypes.c_int)
+    thread_id = signature(kernel, "GetCurrentThreadId", [], integer)
+    thread_desktop = signature(user, "GetThreadDesktop", [integer], handle)
+    station = signature(user, "GetProcessWindowStation", [], handle)
+    information = signature(user, "GetUserObjectInformationW",
+                            [handle, ctypes.c_int, handle, integer, handle], ctypes.c_int)
+    def name(object_handle):
+        buffer = ctypes.create_unicode_buffer(256)
+        needed = integer()
+        if not information(object_handle, 2, buffer, ctypes.sizeof(buffer), ctypes.byref(needed)):
+            return None
+        return buffer.value
+    # DESKTOP_READOBJECTS | DESKTOP_WRITEOBJECTS. Do not switch or attach desktops.
+    desktop = open_desktop(0, False, 0x0001 | 0x0080)
+    if not desktop:
+        return False
+    try:
+        desktop_name = name(desktop)
+        return (name(station()) == "WinSta0" and desktop_name is not None
+                and desktop_name == name(thread_desktop(thread_id())))
+    finally:
+        close_desktop(desktop)
+
+def input_supported(gui):
+    if sys.platform == "win32":
+        return windows_desktop()
+    if sys.platform == "darwin":
+        services = ctypes.CDLL("/System/Library/Frameworks/ApplicationServices.framework/ApplicationServices")
+        graphics = ctypes.CDLL("/System/Library/Frameworks/CoreGraphics.framework/CoreGraphics")
+        trusted = signature(services, "AXIsProcessTrusted", [], ctypes.c_bool)
+        post_access = signature(graphics, "CGPreflightPostEventAccess", [], ctypes.c_bool)
+        return bool(trusted() and post_access())
+    if sys.platform == "linux":
+        display = gui._pyautogui_x11._display
+        if not display.has_extension("XTEST"):
+            return False
+        display.xtest_get_version(2, 2)
+        return True
+    return False
+
+def clipboard_supported():
+    import pyperclip
+    copy, paste = pyperclip.determine_clipboard()
+    if not callable(copy) or not callable(paste) or not copy or not paste:
+        return False
+    names = (getattr(copy, "__name__", ""), getattr(paste, "__name__", ""))
+    if sys.platform == "win32" and names == ("copy_windows", "paste_windows"):
+        user = ctypes.WinDLL("user32", use_last_error=True)
+        open_clipboard = signature(user, "OpenClipboard", [ctypes.c_void_p], ctypes.c_int)
+        close_clipboard = signature(user, "CloseClipboard", [], ctypes.c_int)
+        if not open_clipboard(None):
+            return False
+        # Opening and closing does not empty, read, or take ownership of the clipboard.
+        return bool(close_clipboard())
+    if sys.platform == "darwin":
+        import AppKit
+        board = AppKit.NSPasteboard.generalPasteboard()
+        if board is None:
+            return False
+        # Newer systems expose pasteboard policy. Do not provoke an access prompt.
+        if hasattr(board, "accessBehavior"):
+            allowed = getattr(AppKit, "NSPasteboardAccessBehaviorAlwaysAllow", None)
+            if allowed is None or board.accessBehavior() != allowed:
+                return False
+        if names == ("copy_osx_pyobjc", "paste_osx_pyobjc"):
+            return True
+        return (names == ("copy_osx_pbcopy", "paste_osx_pbcopy")
+                and shutil.which("pbcopy") is not None and shutil.which("pbpaste") is not None)
+    if sys.platform == "linux":
+        commands = {("copy_xclip", "paste_xclip"): ["xclip", "-version"],
+                    ("copy_xsel", "paste_xsel"): ["xsel", "--version"]}
+        command = commands.get(names)
+        executable = shutil.which(command[0]) if command is not None else None
+        if executable is None:
+            return False
+        # X11 access was established above. Verify the selected backend can run,
+        # without consuming a one-shot selection or requesting clipboard contents.
+        subprocess.run([executable, *command[1:]], stdin=subprocess.DEVNULL,
+                       stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=True, timeout=2)
+        return True
+    return False
+
+try:
+    if sys.platform not in ("win32", "darwin", "linux") or (sys.platform == "linux" and
+            (not os.environ.get("DISPLAY") or os.environ.get("WAYLAND_DISPLAY"))):
+        result["reasonCode"] = "COMPUTER_DESKTOP_UNSUPPORTED"
+    else:
+        import pyautogui
+        image = pyautogui.screenshot()
+        if image.width > 0 and image.height > 0:
+            result["supportsScreenshot"] = result["supportsPrimaryDisplay"] = True
+            result["reasonCode"] = "COMPUTER_INPUT_PERMISSION_DENIED"
+            if input_supported(pyautogui):
+                result["supportsInput"] = True
+                result["reasonCode"] = "COMPUTER_RUNTIME_UNAVAILABLE"
+                if clipboard_supported():
+                    result["supportsUnicodePaste"] = True
+                    result["reasonCode"] = None
+except Exception:
+    pass
+print(json.dumps(result))
+`;