@myagentroam/node 0.9.122 → 0.9.125

package/dist/codex-app-server.js

@@ -1,10 +1,4 @@
 import { spawn, spawnSync } from 'node:child_process';
-import { randomUUID } from 'node:crypto';
-import { existsSync } from 'node:fs';
-import { unlink } from 'node:fs/promises';
-import { connect } from 'node:net';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
 import { createInterface } from 'node:readline';
 import { minimalRunnerEnvironment, platformCliInvocation, runRunnerProbe } from './operational.js';
 const REQUEST_TIMEOUT_MS = 15_000;
@@ -45,15 +39,13 @@ export function isCodexRolloutMissingError(error) {
             /^thread not loaded:\s*/i.test(error.rpcMessage)));
 }
 /**
- * Local JSON-RPC client for a Node-supervised Codex App Server. Linux/macOS
- * use a private Unix socket by default; Windows uses stdio. Neither is exposed
- * to MAR Server or the browser.
+ * Local JSON-RPC client for a Node-supervised Codex App Server over stdio.
+ * The transport is not exposed to MAR Server or the browser.
  */
 export class CodexAppServerClient {
     options;
     child;
     transport;
-    socketPath;
     nextId = 1;
     pending = new Map();
     pendingDrainWaiters = new Set();
@@ -105,43 +97,15 @@ export class CodexAppServerClient {
     }
     async startManaged() {
         const command = this.options.command ?? 'codex';
-        const mode = this.transportMode();
-        this.socketPath =
-            mode === 'unix' ? (this.options.socketPath ?? privateSocketPath()) : undefined;
-        const baseArgs = this.options.args ?? ['app-server'];
-        const args = [
-            ...baseArgs,
-            ...(mode === 'unix' ? ['--listen', `unix://${this.socketPath}`] : [])
-        ];
+        const args = this.options.args ?? ['app-server'];
         const spawnProcess = this.options.spawnProcess ?? defaultSpawn;
-        let child = spawnProcess(command, args, {
+        const child = spawnProcess(command, args, {
             ...(this.options.cwd === undefined ? {} : { cwd: this.options.cwd }),
             env: { ...minimalRunnerEnvironment(), ...this.environment }
         });
         this.child = child;
-        let socket;
-        if (mode === 'unix') {
-            try {
-                socket = await connectUnix(this.socketPath, (this.options.transport ?? 'auto') === 'auto'
-                    ? Math.min(this.options.timeoutMs ?? REQUEST_TIMEOUT_MS, 1_000)
-                    : (this.options.timeoutMs ?? REQUEST_TIMEOUT_MS));
-            }
-            catch (error) {
-                if ((this.options.transport ?? 'auto') !== 'auto')
-                    throw error;
-                child.kill();
-                if (this.socketPath !== undefined && existsSync(this.socketPath))
-                    await unlink(this.socketPath);
-                this.socketPath = undefined;
-                child = spawnProcess(command, baseArgs, {
-                    ...(this.options.cwd === undefined ? {} : { cwd: this.options.cwd }),
-                    env: { ...minimalRunnerEnvironment(), ...this.environment }
-                });
-                this.child = child;
-            }
-        }
-        this.transport = socket ?? stdioTransport(child);
-        const lines = createInterface({ input: socket ?? child.stdout });
+        this.transport = stdioTransport(child);
+        const lines = createInterface({ input: child.stdout });
         lines.on('line', (line) => this.handleLine(line));
         const managedChild = child;
         child.once('error', (error) => {
@@ -180,9 +144,6 @@ export class CodexAppServerClient {
         this.transport = undefined;
         this.child?.kill();
         this.child = undefined;
-        if (this.socketPath !== undefined && existsSync(this.socketPath))
-            void unlink(this.socketPath);
-        this.socketPath = undefined;
         this.failAll(new Error('CODEX_APP_SERVER_STOPPED'));
     }
     onNotification(listener) {
@@ -331,15 +292,6 @@ export class CodexAppServerClient {
         }
         this.resolvePendingDrain();
     }
-    transportMode() {
-        const requested = this.options.transport ?? 'auto';
-        if (requested === 'auto')
-            return process.platform === 'linux' || process.platform === 'darwin' ? 'unix' : 'stdio';
-        if (requested === 'unix' && process.platform !== 'linux' && process.platform !== 'darwin') {
-            throw new Error('CODEX_UNIX_SOCKET_PLATFORM_UNSUPPORTED');
-        }
-        return requested;
-    }
 }
 function codexThreadConfiguration(cwd, configuration) {
     return {
@@ -472,28 +424,3 @@ function stdioTransport(child) {
         destroy: () => child.stdout.destroy()
     };
 }
-export function privateSocketPath(directory = tmpdir(), processId = process.pid, entropy = randomUUID()) {
-    // macOS has a shorter Unix-domain socket pathname limit than Linux, and its
-    // per-user TMPDIR is comparatively long. The process ID plus 64 random bits
-    // keeps concurrent sockets distinct while leaving room for that directory.
-    return join(directory, `m-${processId}-${entropy.replaceAll('-', '').slice(0, 16)}.sock`);
-}
-function connectUnix(socketPath, timeoutMs) {
-    return new Promise((resolve, reject) => {
-        const deadline = Date.now() + timeoutMs;
-        const attempt = () => {
-            const socket = connect(socketPath);
-            const retry = (error) => {
-                socket.destroy();
-                if (Date.now() >= deadline) {
-                    reject(new Error(`CODEX_UNIX_SOCKET_CONNECT_FAILED:${error.message}`));
-                    return;
-                }
-                setTimeout(attempt, 25);
-            };
-            socket.once('connect', () => resolve(socket));
-            socket.once('error', retry);
-        };
-        attempt();
-    });
-}

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);