@myagentroam/node 0.9.124 → 0.9.126

package/dist/codex-app-server.js

@@ -139,6 +139,36 @@ export class CodexAppServerClient {
         this.lifecycleRevision += 1;
         this.stopManaged();
     }
+    async stopAndWait() {
+        const child = this.child;
+        if (child === undefined) {
+            this.stop();
+            return;
+        }
+        const exited = new Promise((resolve, reject) => {
+            if (child.exitCode !== null || child.signalCode !== null)
+                resolve();
+            else {
+                let forcedTimeout;
+                const onExit = () => {
+                    clearTimeout(timeout);
+                    if (forcedTimeout !== undefined)
+                        clearTimeout(forcedTimeout);
+                    resolve();
+                };
+                const timeout = setTimeout(() => {
+                    child.kill('SIGKILL');
+                    forcedTimeout = setTimeout(() => {
+                        child.off('exit', onExit);
+                        reject(new Error('CODEX_APP_SERVER_STOP_TIMEOUT'));
+                    }, 2_000);
+                }, 2_000);
+                child.once('exit', onExit);
+            }
+        });
+        this.stop();
+        await exited;
+    }
     stopManaged() {
         this.transport?.destroy();
         this.transport = undefined;

package/dist/connector.js

@@ -61,6 +61,11 @@ import { RunnerInteractionService } from './service/runner-interaction-service.j
 import { SessionLifecycleService } from './service/session-lifecycle-service.js';
 import { ExternalSessionResumeService } from './service/external-session-resume-service.js';
 import { SessionMessageService } from './service/session-message-service.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 { ScheduledTaskMcpServer } from './service/scheduled-task-mcp-server.js';
 import { SessionCatalogService } from './service/session-catalog-service.js';
 import { SessionCommandService } from './service/session-command-service.js';
 import { SessionPresentationService } from './service/session-presentation-service.js';
@@ -151,6 +156,8 @@ export class NodeConnector {
     nodeGeneration = crypto.randomUUID().replace(/-/g, '');
     controlChannel;
     controlMessages;
+    scheduledRunAuthorization;
+    scheduledSessions;
     nodeRequests;
     connectionLifecycle;
     runtimeCredentials = new RuntimeCredentialControlService({
@@ -253,6 +260,7 @@ export class NodeConnector {
     goalSubmissionAttempts = new Map();
     goalContinuationEpochs = new Map();
     goalExecutionProgress = new Set();
+    sessionScheduleService;
     goalMcpServer = new GoalMcpServer(this.goalRuntime, (sessionId) => {
         const goal = this.goalRuntime.get(sessionId);
         const session = this.runtime.getAgentSession(sessionId);
@@ -264,6 +272,22 @@ export class NodeConnector {
         }
         this.publishGoalState(session, goal);
     });
+    scheduledTaskMcpServer = new ScheduledTaskMcpServer(() => {
+        if (this.database === undefined)
+            throw new Error('NODE_DATABASE_UNAVAILABLE');
+        return new ScheduledSessionStore(this.database.raw);
+    }, (sessionId) => {
+        const session = this.runtime.getAgentSession(sessionId);
+        if (session !== undefined)
+            this.emitSessionWorkbenchEvent({
+                session: this.sessionPresentationService.present(session)
+            });
+        this.scheduledSessions.changed();
+    }, (sessionId, proposalId) => this.emitScheduledProposalNotification(sessionId, proposalId), (input) => {
+        if (this.sessionScheduleService === undefined)
+            throw new Error('SCHEDULE_SERVICE_UNAVAILABLE');
+        return this.sessionScheduleService.createFromMcp(input);
+    }, (sessionId) => this.runtime.getAgentSession(sessionId)?.externalSessionId ?? sessionId);
     runnerUsageReader;
     terminalManager;
     upgradeCoordinator;
@@ -314,6 +338,17 @@ export class NodeConnector {
         expireImages: (runId) => this.runAttachmentService.expire(runId),
         scheduleContextRefresh: (sessionId) => this.sessionContextService.schedule(sessionId),
         refreshWorkspaceSessions: (workspaceId) => this.workspaceWorkbenchService.ensureTopicSnapshot(workspaceId, 'sessions'),
+        onTerminalRun: (run, status) => {
+            if (run.source !== 'SCHEDULED' || this.database === undefined)
+                return;
+            const store = new ScheduledSessionStore(this.database.raw);
+            store.finish(run.clientMessageId, status === 'SUCCEEDED' ? 'SUCCEEDED' : 'FAILED', status === 'SUCCEEDED' ? undefined : `SCHEDULE_RUN_${status}`, run.id);
+            if (status !== 'SUCCEEDED') {
+                const task = store.get(run.sessionId);
+                if (task !== undefined)
+                    this.emitScheduledNotification(task, run.clientMessageId, `SCHEDULE_RUN_${status}`, 'FAILED');
+            }
+        },
         dispatchQueue: async (sessionId, delayMs = 0) => {
             if (this.upgradeCoordinator.pending())
                 return;
@@ -386,6 +421,7 @@ export class NodeConnector {
         releaseExecution: (executionId) => {
             this.goalExecutionProgress.delete(executionId);
             this.goalMcpServer.revoke(executionId);
+            this.scheduledTaskMcpServer.revoke(executionId);
             this.continuousRunCoordinator.remove(executionId);
         }
     });
@@ -463,7 +499,7 @@ export class NodeConnector {
             options.fakeRunner === undefined ? undefined : new FakeTestRunner(options.fakeRunner);
         this.fakeScript = options.fakeScript;
         this.runAttachmentService = new RunAttachmentService((session) => this.runners.require(session.runner).nativeImageRoots(session));
-        this.codexClient = new CodexRunner(options.codexClient, options.codexProfileClientFactory);
+        this.codexClient = new CodexRunner(options.codexClient, options.codexProfileClientFactory, options.codexRunClientFactory);
         this.codexRunController = new CodexManagedRunController(this.codexClient, {
             available: () => this.capabilities.codex.available,
             intercepted: () => this.fakeRunner !== undefined,
@@ -483,7 +519,7 @@ export class NodeConnector {
             emit: (runId, eventType, payload, status) => this.runEventBridge.emitRun(runId, eventType, payload, status),
             cancel: (runId, threadId, turnId, cwd, status) => this.runnerInteractionService.cancelCodexTurn(runId, threadId, turnId, cwd, status),
             createApproval: (input) => this.runtime.createApproval(input),
-            publishApproval: (input) => this.runEventBridge.publishApproval(input),
+            publishApproval: (input) => this.publishApprovalForRun(input),
             emitItem: (runId, item) => this.emitConversationItem(runId, item),
             appendImages: (runId, images) => this.runAttachmentService.append(runId, images.filter(isRunnerImageAttachment)),
             syncTitle: (sessionId, nativeSessionId, cwd) => this.managedRunnerSessions.refreshTitle(sessionId, nativeSessionId, cwd),
@@ -574,7 +610,7 @@ export class NodeConnector {
             expireApproval: (approvalId) => {
                 this.runtime.expireApproval(approvalId);
             },
-            publishApproval: (input) => this.runEventBridge.publishApproval(input),
+            publishApproval: (input) => this.publishApprovalForRun(input),
             commandState: (sessionId, commandId) => this.commandStates.get(sessionId, commandId),
             setCommandState: (sessionId, state) => this.commandStates.set(sessionId, state),
             clearCommandState: (sessionId, commandId) => this.commandStates.clear(sessionId, commandId),
@@ -622,7 +658,7 @@ export class NodeConnector {
             emitRun: (runId, eventType, payload, status) => this.runEventBridge.emitRun(runId, eventType, payload, status),
             emitItem: (runId, item) => this.emitConversationItem(runId, item),
             approvalTimeoutMs: this.claudeApprovalTimeoutMs,
-            publishApproval: (input) => this.runEventBridge.publishApproval(input)
+            publishApproval: (input) => this.publishApprovalForRun(input)
         });
         this.runnerChannelMessages = new RunnerChannelMessageService({
             interactions: this.runnerInteractionService,
@@ -763,6 +799,38 @@ export class NodeConnector {
                     },
                     secrets: resolved.secrets
                 };
+            },
+            scheduledMcp: async (input) => {
+                if (this.database === undefined)
+                    return undefined;
+                const task = new ScheduledSessionStore(this.database.raw).get(input.sessionId);
+                const run = this.runtime.getRun(input.runId);
+                if (run?.initiatedByUserId === undefined)
+                    return undefined;
+                const resolved = await this.scheduledTaskMcpServer.installation({
+                    executionId: input.runId,
+                    sessionId: input.sessionId,
+                    workspaceId: input.workspaceId,
+                    ...(task === undefined ? {} : { taskId: task.id, revision: task.revision }),
+                    actorUserId: run.initiatedByUserId,
+                    readonly: run.source === 'SCHEDULED'
+                });
+                return {
+                    installation: {
+                        targetKind: 'WORKSPACE',
+                        targetId: input.workspaceId,
+                        catalogEntryId: 'mar-internal-schedule',
+                        serverName: 'mar_schedule',
+                        displayName: 'MAR scheduled task',
+                        version: '1.0.0',
+                        enabled: true,
+                        runtime: { transport: 'HTTP', url: 'https://127.0.0.1.invalid/mcp', headers: {} },
+                        configuration: resolved.installation,
+                        installedAt: Date.now(),
+                        ...resolved.installation
+                    },
+                    secrets: resolved.secrets
+                };
             }
         });
         this.workspaceQueueWorkbenchService = new WorkspaceQueueWorkbenchService({
@@ -1077,7 +1145,7 @@ export class NodeConnector {
                 runtime: this.runtime,
                 state: this.runState,
                 emitRun: (runId, type, payload, status) => this.runEventBridge.emitRun(runId, type, payload, status),
-                publishApproval: (input) => this.runEventBridge.publishApproval(input),
+                publishApproval: (input) => this.publishApprovalForRun(input),
                 disconnect: () => this.controlChannel.close(4010, 'FAKE_RUNNER_DISCONNECT')
             });
         this.fakeRunner?.bindControl({
@@ -1122,6 +1190,7 @@ export class NodeConnector {
             onClose: (code, reason) => {
                 this.directTransferService?.close();
                 this.runtimeCredentials.disconnected();
+                this.scheduledRunAuthorization.disconnected();
                 this.terminalChannel.disconnect();
                 if (code === 4000 && reason === 'NODE_CONNECTION_REPLACED')
                     nodeLog('node.connection.replaced', {
@@ -1139,6 +1208,7 @@ 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),
             handleDirectTransfer: (envelope) => this.handleDirectTransfer(envelope),
             handleTerminalDirect: (envelope) => this.handleTerminalDirect(envelope),
             reconcileRuns: (envelope) => this.runEventBridge.reconcile(envelope),
@@ -1200,6 +1270,7 @@ export class NodeConnector {
             },
             onConnected: () => {
                 this.runtimeCredentials.connected();
+                this.scheduledRunAuthorization.connected();
                 this.recentRunProjectionService.publishSnapshot();
             }
         });
@@ -1208,6 +1279,46 @@ export class NodeConnector {
                 throw new Error('NODE_DATABASE_UNAVAILABLE');
             return this.database;
         };
+        this.scheduledRunAuthorization = new ScheduledRunAuthorizationControl((envelope) => this.controlChannel.sendEnvelope(envelope));
+        this.scheduledSessions = new ScheduledSessionCoordinator({
+            store: () => new ScheduledSessionStore(requireDatabase().raw),
+            busy: (task) => 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) ??
+                    (await this.nativeSessionProjectionService.resolveCurrent(task.sessionId));
+                if (session === undefined ||
+                    session.workspaceId !== task.workspaceId ||
+                    session.runner !== task.runner)
+                    throw new Error('SCHEDULE_SESSION_NOT_FOUND');
+                const configuration = this.nativeSessionProjectionService.resumedConfiguration(session);
+                return this.scheduledRunAuthorization.authorize({
+                    taskId: task.id,
+                    revision: task.revision,
+                    occurrenceId,
+                    sessionId: task.sessionId,
+                    workspaceId: task.workspaceId,
+                    ownerUserId: task.ownerUserId,
+                    runner: task.runner,
+                    model: configuration.model
+                });
+            },
+            submit: async (task, occurrenceId, context) => {
+                const result = (await this.sessionMessageService.submitScheduled({
+                    sessionId: task.sessionId,
+                    occurrenceId,
+                    objective: task.objective,
+                    initiatedByUserId: task.ownerUserId,
+                    secretEnvironment: context.secretEnvironment,
+                    personalInstructions: context.personalInstructions,
+                    marAgentModel: context.marAgentModel,
+                    marAgentModels: context.marAgentModels,
+                    marAgentRuntimeScopeId: context.marAgentRuntimeScopeId
+                }));
+                return { runId: result.run.id };
+            },
+            notify: (task, occurrenceId, code, status) => this.emitScheduledNotification(task, occurrenceId, code, status)
+        });
         this.runnerService = new RunnerService(requireDatabase, () => this.capabilities, this.runners, this.runnerUsageReader);
         this.workbenchManifestService = new WorkbenchManifestService({
             capabilities: () => this.capabilities,
@@ -1273,6 +1384,23 @@ export class NodeConnector {
         this.operationRouter.registerAll(this.nativeSessionWatchService.operations());
         this.operationRouter.registerAll(this.sessionQueryService.operations());
         this.operationRouter.registerAll(this.sessionLifecycleService.operations());
+        this.sessionScheduleService = new SessionScheduleService({
+            database: requireDatabase,
+            runtime: this.runtime,
+            projection: this.nativeSessionProjectionService,
+            awaitNativeSessionId: (sessionId) => {
+                const nativeId = this.runtime.getAgentSession(sessionId)?.externalSessionId;
+                return nativeId === null || nativeId === undefined
+                    ? this.sessionIdentityService.wait(sessionId)
+                    : Promise.resolve(nativeId);
+            },
+            present: (session) => this.sessionPresentationService.present(session),
+            emitSession: (session) => this.emitSessionWorkbenchEvent({
+                session: this.sessionPresentationService.present(session)
+            }),
+            changed: () => this.scheduledSessions.changed()
+        });
+        this.operationRouter.registerAll(this.sessionScheduleService.operations());
         this.operationRouter.registerAll(this.sessionMessageService.operations());
         this.operationRouter.registerAll(this.sessionCatalogService.operations());
         this.operationRouter.registerAll(this.sessionCommandService.operations());
@@ -1453,6 +1581,7 @@ export class NodeConnector {
         await assertLocalSqlitePath(nodeDatabasePath(this.config, this.configPath));
         this.database ??= new NodeDatabase(nodeDatabasePath(this.config, this.configPath), () => this.config?.nodeId ?? 'unregistered');
         this.database.closeRunningTerminalSessions();
+        this.scheduledSessions.start();
         await this.initializeConversationHosting();
         this.computerUseEnablement.initialize();
         this.directTransferService ??= this.createDirectTransferService();
@@ -1786,11 +1915,14 @@ export class NodeConnector {
         this.workspaceChangeService.clear();
         const runnerDrain = this.runners.stop();
         const goalMcpDrain = this.goalMcpServer.close();
+        const scheduledMcpDrain = this.scheduledTaskMcpServer.close();
         // close() transitions metadata before awaiting process-tree termination,
         // so the lifecycle is persisted before this synchronous shutdown returns.
         const terminalDrain = this.terminalManager.shutdown();
         this.terminalChannel.stop();
         this.runtimeCredentials.close();
+        this.scheduledSessions.stop();
+        this.scheduledRunAuthorization.close();
         this.directTransferService?.dispose();
         this.directTransferService = undefined;
         this.controlChannel.stop();
@@ -1801,7 +1933,8 @@ export class NodeConnector {
             runnerDrain,
             terminalDrain,
             uploadDrain,
-            goalMcpDrain
+            goalMcpDrain,
+            scheduledMcpDrain
         ]);
         this.stopping = (async () => {
             try {
@@ -1818,6 +1951,84 @@ export class NodeConnector {
     }
     /** @internal Thin compatibility delegates; all behavior remains in the extracted services. */
     handleMessage = (raw) => this.controlMessages.handle(raw);
+    publishApprovalForRun = (input) => {
+        const run = this.runtime.getRun(this.runtime.canonicalRunId(input.runId));
+        if (run?.source !== 'SCHEDULED') {
+            this.runEventBridge.publishApproval(input);
+            return;
+        }
+        this.runEventBridge.emitRun(input.runId, 'approval.request', input);
+        queueMicrotask(() => {
+            try {
+                this.runtime.decideApproval(input.approvalId, 'APPROVED');
+                this.runEventBridge.emitRun(input.runId, 'approval.decided', {
+                    approvalId: input.approvalId,
+                    decision: 'APPROVED',
+                    source: 'SCHEDULED'
+                });
+                this.runners.decideApproval({
+                    runId: input.runId,
+                    approvalId: input.approvalId,
+                    decision: 'APPROVED'
+                });
+            }
+            catch {
+                // A cancelled execution cannot receive an approval after its pending request expires.
+            }
+        });
+    };
+    emitScheduledNotification = (task, occurrenceId, code, status) => {
+        const occurredAt = Date.now();
+        const session = this.runtime.getAgentSession(task.sessionId);
+        this.emitWorkbenchEvent('conversation', {
+            event: {
+                runId: occurrenceId,
+                sequence: 1,
+                eventType: 'notification',
+                payload: {
+                    targetType: 'WORKSPACE_SESSION',
+                    userId: task.ownerUserId,
+                    workspaceId: task.workspaceId,
+                    sessionId: task.sessionId,
+                    sessionTitle: session?.customTitle ?? session?.runnerTitle ?? task.sessionId,
+                    runId: occurrenceId,
+                    notificationId: `schedule:${task.id}:${occurrenceId}`,
+                    kind: status === 'FAILED' ? 'SCHEDULE_FAILED' : 'SCHEDULE_SKIPPED',
+                    code,
+                    occurredAt
+                },
+                createdAt: occurredAt
+            }
+        });
+    };
+    emitScheduledProposalNotification = (sessionId, proposalId) => {
+        if (this.database === undefined)
+            return;
+        const task = new ScheduledSessionStore(this.database.raw).get(sessionId);
+        if (task === undefined)
+            return;
+        const occurredAt = Date.now();
+        const session = this.runtime.getAgentSession(sessionId);
+        this.emitWorkbenchEvent('conversation', {
+            event: {
+                runId: proposalId,
+                sequence: 1,
+                eventType: 'notification',
+                payload: {
+                    targetType: 'WORKSPACE_SESSION',
+                    userId: task.ownerUserId,
+                    workspaceId: task.workspaceId,
+                    sessionId,
+                    sessionTitle: session?.customTitle ?? session?.runnerTitle ?? sessionId,
+                    runId: proposalId,
+                    notificationId: `schedule-proposal:${task.id}:${proposalId}`,
+                    kind: 'SCHEDULE_PROPOSAL',
+                    occurredAt
+                },
+                createdAt: occurredAt
+            }
+        });
+    };
     emitRunEvent = (runId, eventType, payload, status) => this.runEventBridge.emitRun(runId, eventType, payload, status);
     emitConversationItem = (runId, item) => {
         if (this.continuousRunCoordinator.pending(runId)?.goal !== undefined &&

package/dist/database.js

@@ -5,8 +5,9 @@ import { DatabaseSync } from 'node:sqlite';
 import { runnerDefaultConfigurationSchema } from '@myagentroam/protocol';
 import { mcpCatalogEntrySchema, mcpInstallationConfigurationSchema, mcpRuntimeDescriptorSchema } from '@myagentroam/protocol';
 import { assertNodeSchemaV13, NODE_SCHEMA_V13, NODE_SCHEMA_VERSION_V13 } from './migrations/v013.js';
+import { NODE_SCHEMA_MIGRATION_V14 } from './migrations/v014.js';
 // Future released migrations must be contiguous, immutable and begin at v14; Demo is excluded.
-export const NODE_SCHEMA_MIGRATIONS = [];
+export const NODE_SCHEMA_MIGRATIONS = [NODE_SCHEMA_MIGRATION_V14];
 const LEGACY_NODE_SCHEMA_V12 = NODE_SCHEMA_VERSION_V13 - 1;
 export class NodeDatabase {
     now;

package/dist/migrations/v014.js

@@ -0,0 +1,107 @@
+export const NODE_SCHEMA_MIGRATION_V14 = {
+    version: 14,
+    sql: `CREATE TABLE scheduled_session_tasks (
+    id TEXT PRIMARY KEY,
+    session_id TEXT NOT NULL UNIQUE REFERENCES agent_sessions(id) ON DELETE CASCADE,
+    workspace_id TEXT NOT NULL REFERENCES workspaces(id) ON DELETE CASCADE,
+    runner TEXT NOT NULL CHECK (runner IN ('mar-agent','codex','claude-code','opencode')),
+    owner_user_id INTEGER NOT NULL CHECK (owner_user_id > 0),
+    objective TEXT NOT NULL CHECK (length(objective) BETWEEN 1 AND 20000),
+    cron TEXT NOT NULL,
+    timezone TEXT NOT NULL,
+    enabled INTEGER NOT NULL CHECK (enabled IN (0,1)),
+    revision INTEGER NOT NULL CHECK (revision > 0),
+    next_run_at INTEGER CHECK (next_run_at IS NULL OR next_run_at >= 0),
+    created_at INTEGER NOT NULL CHECK (created_at >= 0),
+    updated_at INTEGER NOT NULL CHECK (updated_at >= 0)
+  ) STRICT;
+  CREATE INDEX scheduled_session_tasks_due
+    ON scheduled_session_tasks(enabled, next_run_at);
+  CREATE TABLE scheduled_session_occurrences (
+    id TEXT PRIMARY KEY,
+    task_id TEXT NOT NULL REFERENCES scheduled_session_tasks(id) ON DELETE CASCADE,
+    due_at INTEGER NOT NULL CHECK (due_at >= 0),
+    status TEXT NOT NULL CHECK (status IN ('CLAIMED','SUBMITTED','SUCCEEDED','SKIPPED','FAILED')),
+    code TEXT,
+    run_id TEXT,
+    created_at INTEGER NOT NULL CHECK (created_at >= 0),
+    updated_at INTEGER NOT NULL CHECK (updated_at >= 0),
+    UNIQUE(task_id, due_at)
+  ) STRICT;
+  CREATE INDEX scheduled_session_occurrences_recent
+    ON scheduled_session_occurrences(task_id, due_at DESC);
+  CREATE TABLE scheduled_session_proposals (
+    id TEXT PRIMARY KEY,
+    task_id TEXT NOT NULL REFERENCES scheduled_session_tasks(id) ON DELETE CASCADE,
+    proposed_by_user_id INTEGER NOT NULL CHECK (proposed_by_user_id > 0),
+    base_revision INTEGER NOT NULL CHECK (base_revision > 0),
+    objective TEXT CHECK (objective IS NULL OR length(objective) BETWEEN 1 AND 20000),
+    cron TEXT,
+    timezone TEXT,
+    status TEXT NOT NULL CHECK (status IN ('PENDING','ACCEPTED','REJECTED','STALE')),
+    created_at INTEGER NOT NULL CHECK (created_at >= 0),
+    resolved_at INTEGER
+  ) STRICT;
+  CREATE INDEX scheduled_session_proposals_pending
+    ON scheduled_session_proposals(task_id, status, created_at DESC);`,
+    assert(database) {
+        const tables = {
+            scheduled_session_tasks: [
+                'id',
+                'session_id',
+                'workspace_id',
+                'runner',
+                'owner_user_id',
+                'objective',
+                'cron',
+                'timezone',
+                'enabled',
+                'revision',
+                'next_run_at',
+                'created_at',
+                'updated_at'
+            ],
+            scheduled_session_occurrences: [
+                'id',
+                'task_id',
+                'due_at',
+                'status',
+                'code',
+                'run_id',
+                'created_at',
+                'updated_at'
+            ],
+            scheduled_session_proposals: [
+                'id',
+                'task_id',
+                'proposed_by_user_id',
+                'base_revision',
+                'objective',
+                'cron',
+                'timezone',
+                'status',
+                'created_at',
+                'resolved_at'
+            ]
+        };
+        for (const [table, required] of Object.entries(tables)) {
+            const row = database
+                .prepare("SELECT sql FROM sqlite_master WHERE type='table' AND name=?")
+                .get(table);
+            const columns = new Set(database.prepare(`PRAGMA table_info(${table})`).all().map((column) => column.name));
+            if (row === undefined ||
+                !row.sql.endsWith('STRICT') ||
+                required.some((column) => !columns.has(column)))
+                throw new Error('NODE_DATABASE_SCHEMA_INVALID');
+        }
+        for (const name of [
+            'scheduled_session_tasks_due',
+            'scheduled_session_occurrences_recent',
+            'scheduled_session_proposals_pending'
+        ])
+            if (database
+                .prepare("SELECT name FROM sqlite_master WHERE type='index' AND name=?")
+                .get(name) === undefined)
+                throw new Error('NODE_DATABASE_SCHEMA_INVALID');
+    }
+};

package/dist/runner/abstract-runner.js

@@ -173,7 +173,7 @@ function resolvedMcpServers(raw, secrets) {
         const record = value;
         if (typeof record['serverName'] !== 'string' || record['enabled'] !== true)
             continue;
-        if (record['__marGoal'] === true &&
+        if ((record['__marGoal'] === true || record['__marScheduled'] === true) &&
             typeof record['command'] === 'string' &&
             Array.isArray(record['args']) &&
             record['args'].every((value) => typeof value === 'string') &&
@@ -186,10 +186,16 @@ function resolvedMcpServers(raw, secrets) {
                 transport: 'STDIO',
                 command: record['command'],
                 args: record['args'],
-                environment: {
-                    MAR_GOAL_MCP_ENDPOINT: record['endpoint'],
-                    MAR_GOAL_MCP_TOKEN: secrets[record['secretName']]
-                }
+                environment: record['__marGoal'] === true
+                    ? {
+                        MAR_GOAL_MCP_ENDPOINT: record['endpoint'],
+                        MAR_GOAL_MCP_TOKEN: secrets[record['secretName']]
+                    }
+                    : {
+                        MAR_SCHEDULE_MCP_ENDPOINT: record['endpoint'],
+                        MAR_SCHEDULE_MCP_TOKEN: secrets[record['secretName']],
+                        MAR_SCHEDULE_MCP_READ_ONLY: record['readOnly'] === true ? '1' : '0'
+                    }
             });
             continue;
         }

package/dist/runner/claude-code-runner.js

@@ -230,6 +230,9 @@ export class ClaudeCodeRunner extends AbstractRunner {
                 externalSessionId: item.externalSessionId,
                 cwd: item.cwd,
                 ...(item.title === undefined ? {} : { title: item.title }),
+                ...('titleOrigin' in item && item.titleOrigin !== undefined
+                    ? { titleOrigin: item.titleOrigin }
+                    : {}),
                 ...(isNativeHistory(item) ? { lastActivityAt: latestNativeActivity(item) } : {})
             });
             const index = sessions.findIndex((candidate) => candidate.id === session.id);