@myagentroam/node 0.9.122 → 0.9.125

package/dist/service/scheduled-session-store.js

@@ -0,0 +1,234 @@
+import { randomUUID } from 'node:crypto';
+import { assertScheduleTimezone, nextScheduledAt, parseScheduledCron } from './scheduled-session-recurrence.js';
+export class ScheduledSessionStore {
+    database;
+    now;
+    constructor(database, now = Date.now) {
+        this.database = database;
+        this.now = now;
+    }
+    get(sessionId) {
+        const row = this.database
+            .prepare('SELECT * FROM scheduled_session_tasks WHERE session_id=?')
+            .get(sessionId);
+        return row === undefined ? undefined : taskFromRow(row);
+    }
+    getById(taskId) {
+        const row = this.database
+            .prepare('SELECT * FROM scheduled_session_tasks WHERE id=?')
+            .get(taskId);
+        return row === undefined ? undefined : taskFromRow(row);
+    }
+    listDue(at = this.now()) {
+        return this.database
+            .prepare('SELECT * FROM scheduled_session_tasks WHERE enabled=1 AND next_run_at<=? ORDER BY next_run_at,id')
+            .all(at).map(taskFromRow);
+    }
+    nextDueAt() {
+        const row = this.database
+            .prepare('SELECT MIN(next_run_at) AS value FROM scheduled_session_tasks WHERE enabled=1')
+            .get();
+        return typeof row['value'] === 'number' ? row['value'] : null;
+    }
+    create(input) {
+        validate(input.objective, input.cron, input.timezone);
+        if (!Number.isSafeInteger(input.ownerUserId) || input.ownerUserId < 1)
+            throw new Error('SCHEDULE_OWNER_INVALID');
+        const now = this.now();
+        const task = {
+            sessionId: input.sessionId,
+            workspaceId: input.workspaceId,
+            runner: input.runner,
+            ownerUserId: input.ownerUserId,
+            cron: input.cron,
+            timezone: input.timezone,
+            objective: input.objective.trim(),
+            id: randomUUID(),
+            enabled: input.enabled !== false,
+            revision: 1,
+            nextRunAt: input.enabled === false ? null : nextScheduledAt(input.cron, input.timezone, now),
+            createdAt: now,
+            updatedAt: now
+        };
+        this.database
+            .prepare(`INSERT INTO scheduled_session_tasks
+        (id,session_id,workspace_id,runner,owner_user_id,objective,cron,timezone,enabled,revision,next_run_at,created_at,updated_at)
+        VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?)`)
+            .run(task.id, task.sessionId, task.workspaceId, task.runner, task.ownerUserId, task.objective, task.cron, task.timezone, task.enabled ? 1 : 0, 1, task.nextRunAt, now, now);
+        return task;
+    }
+    update(sessionId, expectedRevision, patch) {
+        const current = this.get(sessionId);
+        if (current === undefined)
+            throw new Error('SCHEDULE_NOT_FOUND');
+        if (current.revision !== expectedRevision)
+            throw new Error('SCHEDULE_REVISION_CONFLICT');
+        const objective = patch.objective ?? current.objective;
+        const cron = patch.cron ?? current.cron;
+        const timezone = patch.timezone ?? current.timezone;
+        validate(objective, cron, timezone);
+        const enabled = patch.enabled ?? current.enabled;
+        const nextRunAt = enabled
+            ? patch.enabled === true || patch.cron !== undefined || patch.timezone !== undefined
+                ? nextScheduledAt(cron, timezone, this.now())
+                : current.nextRunAt
+            : null;
+        const now = this.now();
+        const result = this.database
+            .prepare(`UPDATE scheduled_session_tasks SET objective=?,cron=?,timezone=?,enabled=?,revision=?,next_run_at=?,updated_at=?
+        WHERE session_id=? AND revision=?`)
+            .run(objective.trim(), cron, timezone, enabled ? 1 : 0, expectedRevision + 1, nextRunAt, now, sessionId, expectedRevision);
+        if (result.changes !== 1)
+            throw new Error('SCHEDULE_REVISION_CONFLICT');
+        this.database
+            .prepare(`UPDATE scheduled_session_proposals SET status='STALE',resolved_at=?
+      WHERE task_id=? AND status='PENDING' AND base_revision<?`)
+            .run(now, current.id, expectedRevision + 1);
+        this.database
+            .prepare("DELETE FROM scheduled_session_proposals WHERE task_id=? AND status='STALE'")
+            .run(current.id);
+        return this.get(sessionId);
+    }
+    remove(sessionId, expectedRevision) {
+        const result = this.database
+            .prepare('DELETE FROM scheduled_session_tasks WHERE session_id=? AND revision=?')
+            .run(sessionId, expectedRevision);
+        if (result.changes !== 1)
+            throw new Error('SCHEDULE_REVISION_CONFLICT');
+    }
+    claim(sessionId, dueAt, expectedRevision) {
+        const current = this.get(sessionId);
+        if (current === undefined ||
+            !current.enabled ||
+            current.revision !== expectedRevision ||
+            current.nextRunAt !== dueAt)
+            return undefined;
+        const next = nextScheduledAt(current.cron, current.timezone, Math.max(this.now(), dueAt));
+        const id = `${current.id}:${dueAt}`;
+        this.database.exec('BEGIN IMMEDIATE');
+        try {
+            const result = this.database
+                .prepare('UPDATE scheduled_session_tasks SET next_run_at=?,updated_at=? WHERE id=? AND revision=? AND next_run_at=?')
+                .run(next, this.now(), current.id, expectedRevision, dueAt);
+            if (result.changes !== 1) {
+                this.database.exec('ROLLBACK');
+                return undefined;
+            }
+            this.database
+                .prepare(`INSERT INTO scheduled_session_occurrences
+          (id,task_id,due_at,status,created_at,updated_at) VALUES (?,?,?,'CLAIMED',?,?)`)
+                .run(id, current.id, dueAt, this.now(), this.now());
+            this.database.exec('COMMIT');
+            return id;
+        }
+        catch (error) {
+            this.database.exec('ROLLBACK');
+            throw error;
+        }
+    }
+    finish(occurrenceId, status, code, runId) {
+        const result = this.database
+            .prepare(`UPDATE scheduled_session_occurrences SET status=?,code=?,run_id=?,updated_at=?
+        WHERE id=? AND status IN ('CLAIMED','SUBMITTED')`)
+            .run(status, code ?? null, runId ?? null, this.now(), occurrenceId);
+        if (result.changes === 0 || status === 'SUBMITTED')
+            return;
+        this.database
+            .prepare(`DELETE FROM scheduled_session_occurrences
+      WHERE task_id=(SELECT task_id FROM scheduled_session_occurrences WHERE id=?)
+        AND status NOT IN ('CLAIMED','SUBMITTED')
+        AND id NOT IN (SELECT id FROM scheduled_session_occurrences
+          WHERE task_id=(SELECT task_id FROM scheduled_session_occurrences WHERE id=?)
+            AND status NOT IN ('CLAIMED','SUBMITTED') ORDER BY due_at DESC LIMIT 100)`)
+            .run(occurrenceId, occurrenceId);
+    }
+    recent(taskId, limit = 20) {
+        return this.database
+            .prepare('SELECT * FROM scheduled_session_occurrences WHERE task_id=? ORDER BY due_at DESC LIMIT ?')
+            .all(taskId, Math.max(1, Math.min(limit, 100)));
+    }
+    pendingProposals(taskId) {
+        return this.database
+            .prepare(`SELECT * FROM scheduled_session_proposals
+      WHERE task_id=? AND status='PENDING' ORDER BY created_at DESC LIMIT 50`)
+            .all(taskId);
+    }
+    propose(task, actorUserId, patch) {
+        if (!Number.isSafeInteger(actorUserId) || actorUserId < 1 || actorUserId === task.ownerUserId)
+            throw new Error('SCHEDULE_PROPOSAL_INVALID');
+        if (patch.objective === undefined && patch.cron === undefined && patch.timezone === undefined)
+            throw new Error('SCHEDULE_PROPOSAL_INVALID');
+        validate(patch.objective ?? task.objective, patch.cron ?? task.cron, patch.timezone ?? task.timezone);
+        const pending = this.database
+            .prepare("SELECT COUNT(*) AS count FROM scheduled_session_proposals WHERE task_id=? AND status='PENDING'")
+            .get(task.id);
+        if (pending.count >= 50)
+            throw new Error('SCHEDULE_PROPOSAL_LIMIT');
+        const id = randomUUID();
+        this.database
+            .prepare(`INSERT INTO scheduled_session_proposals
+      (id,task_id,proposed_by_user_id,base_revision,objective,cron,timezone,status,created_at)
+      VALUES (?,?,?,?,?,?,?,'PENDING',?)`)
+            .run(id, task.id, actorUserId, task.revision, patch.objective ?? null, patch.cron ?? null, patch.timezone ?? null, this.now());
+        return id;
+    }
+    resolveProposal(sessionId, proposalId, ownerUserId, accept) {
+        const task = this.get(sessionId);
+        if (task === undefined)
+            throw new Error('SCHEDULE_NOT_FOUND');
+        if (task.ownerUserId !== ownerUserId)
+            throw new Error('SCHEDULE_OWNER_REQUIRED');
+        const proposal = this.database
+            .prepare('SELECT * FROM scheduled_session_proposals WHERE id=? AND task_id=?')
+            .get(proposalId, task.id);
+        if (proposal === undefined || proposal['status'] !== 'PENDING')
+            throw new Error('SCHEDULE_PROPOSAL_NOT_FOUND');
+        if (proposal['base_revision'] !== task.revision)
+            throw new Error('SCHEDULE_REVISION_CONFLICT');
+        this.database.exec('BEGIN IMMEDIATE');
+        try {
+            const updated = accept
+                ? this.update(sessionId, task.revision, {
+                    ...(proposal['objective'] === null
+                        ? {}
+                        : { objective: proposal['objective'] }),
+                    ...(proposal['cron'] === null ? {} : { cron: proposal['cron'] }),
+                    ...(proposal['timezone'] === null ? {} : { timezone: proposal['timezone'] })
+                })
+                : task;
+            this.database
+                .prepare('UPDATE scheduled_session_proposals SET status=?,resolved_at=? WHERE id=?')
+                .run(accept ? 'ACCEPTED' : 'REJECTED', this.now(), proposalId);
+            this.database.prepare('DELETE FROM scheduled_session_proposals WHERE id=?').run(proposalId);
+            this.database.exec('COMMIT');
+            return updated;
+        }
+        catch (error) {
+            this.database.exec('ROLLBACK');
+            throw error;
+        }
+    }
+}
+function validate(objective, cron, timezone) {
+    if (objective.trim().length < 1 || objective.trim().length > 20_000)
+        throw new Error('SCHEDULE_OBJECTIVE_INVALID');
+    parseScheduledCron(cron);
+    assertScheduleTimezone(timezone);
+}
+function taskFromRow(row) {
+    return {
+        id: row['id'],
+        sessionId: row['session_id'],
+        workspaceId: row['workspace_id'],
+        runner: row['runner'],
+        ownerUserId: Number(row['owner_user_id']),
+        objective: row['objective'],
+        cron: row['cron'],
+        timezone: row['timezone'],
+        enabled: row['enabled'] === 1,
+        revision: Number(row['revision']),
+        nextRunAt: row['next_run_at'] === null ? null : Number(row['next_run_at']),
+        createdAt: Number(row['created_at']),
+        updatedAt: Number(row['updated_at'])
+    };
+}

package/dist/service/scheduled-task-mcp-server.js

@@ -0,0 +1,179 @@
+import { randomBytes, randomUUID } from 'node:crypto';
+import { existsSync } from 'node:fs';
+import { unlink } from 'node:fs/promises';
+import { createServer } from 'node:net';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+export class ScheduledTaskMcpServer {
+    store;
+    changed;
+    proposed;
+    create;
+    resolveSessionId;
+    #capabilities = new Map();
+    #sockets = new Set();
+    #endpoint = process.platform === 'win32'
+        ? `\\\\.\\pipe\\mar-schedule-${process.pid}-${randomUUID()}`
+        : join(tmpdir(), `mar-schedule-${process.pid}-${randomUUID()}.sock`);
+    #listening;
+    constructor(store, changed, proposed, create, resolveSessionId) {
+        this.store = store;
+        this.changed = changed;
+        this.proposed = proposed;
+        this.create = create;
+        this.resolveSessionId = resolveSessionId;
+    }
+    async installation(capability) {
+        await this.#listen();
+        const token = randomBytes(32).toString('base64url');
+        const secretName = `MAR_SCHEDULE_MCP_${randomBytes(16).toString('hex').toUpperCase()}`;
+        this.#capabilities.set(token, capability);
+        return {
+            installation: {
+                __marScheduled: true,
+                serverName: 'mar_schedule',
+                enabled: true,
+                command: process.execPath,
+                args: scheduledMcpStdioArgs(),
+                endpoint: this.#endpoint,
+                secretName,
+                readOnly: capability.readonly
+            },
+            secrets: { [secretName]: token }
+        };
+    }
+    revoke(executionId) {
+        for (const [token, capability] of this.#capabilities)
+            if (capability.executionId === executionId)
+                this.#capabilities.delete(token);
+    }
+    async close() {
+        if (this.#listening === undefined)
+            return;
+        const server = await this.#listening;
+        this.#capabilities.clear();
+        const closed = new Promise((resolve, reject) => server.close((error) => (error === undefined ? resolve() : reject(error))));
+        for (const socket of this.#sockets)
+            socket.destroy();
+        await closed;
+        if (process.platform !== 'win32')
+            await unlink(this.#endpoint).catch(() => undefined);
+    }
+    #listen() {
+        this.#listening ??= new Promise((resolve, reject) => {
+            const server = createServer((socket) => this.#handle(socket));
+            server.once('error', reject);
+            server.listen(this.#endpoint, () => resolve(server));
+        });
+        return this.#listening;
+    }
+    #handle(socket) {
+        this.#sockets.add(socket);
+        socket.once('close', () => this.#sockets.delete(socket));
+        let body = '';
+        socket.setEncoding('utf8');
+        socket.on('data', (chunk) => {
+            body += chunk;
+            if (body.length > 64_000) {
+                socket.destroy();
+                return;
+            }
+            if (body.includes('\n'))
+                void this.#respond(socket, body.slice(0, body.indexOf('\n')));
+        });
+    }
+    async #respond(socket, body) {
+        try {
+            const request = JSON.parse(body);
+            const capability = typeof request.token === 'string' ? this.#capabilities.get(request.token) : undefined;
+            if (capability === undefined)
+                throw new Error('SCHEDULE_CAPABILITY_INVALID');
+            const sessionId = this.resolveSessionId?.(capability.sessionId) ?? capability.sessionId;
+            const task = this.store().get(sessionId);
+            if ((task === undefined && capability.taskId !== undefined) ||
+                (task !== undefined &&
+                    (task.id !== capability.taskId || task.revision !== capability.revision)))
+                throw new Error('SCHEDULE_CAPABILITY_STALE');
+            if (request.tool === 'mar_get_scheduled_task') {
+                socket.end(`${JSON.stringify({ result: task ?? null })}\n`);
+                return;
+            }
+            if (request.tool === 'mar_create_scheduled_task') {
+                if (capability.readonly)
+                    throw new Error('SCHEDULE_READ_ONLY');
+                if (task !== undefined)
+                    throw new Error('SCHEDULE_ALREADY_EXISTS');
+                const args = record(request.arguments);
+                if (typeof args.objective !== 'string' ||
+                    typeof args.cron !== 'string' ||
+                    capability.workspaceId === undefined ||
+                    this.create === undefined)
+                    throw new Error('SCHEDULE_INVALID');
+                const created = await this.create({
+                    sessionId: capability.sessionId,
+                    workspaceId: capability.workspaceId,
+                    actorUserId: capability.actorUserId,
+                    objective: args.objective,
+                    cron: args.cron
+                });
+                this.#capabilities.set(request.token, {
+                    ...capability,
+                    sessionId: created.sessionId,
+                    taskId: created.id,
+                    revision: created.revision
+                });
+                socket.end(`${JSON.stringify({ result: created })}\n`);
+                return;
+            }
+            if (request.tool !== 'mar_update_scheduled_task')
+                throw new Error('SCHEDULE_TOOL_INVALID');
+            if (capability.readonly)
+                throw new Error('SCHEDULE_READ_ONLY');
+            if (task === undefined)
+                throw new Error('SCHEDULE_NOT_FOUND');
+            const args = record(request.arguments);
+            const objective = args.objective;
+            const cron = args.cron;
+            if ((objective !== undefined && typeof objective !== 'string') ||
+                (cron !== undefined && typeof cron !== 'string') ||
+                (objective === undefined && cron === undefined))
+                throw new Error('SCHEDULE_UPDATE_INVALID');
+            const patch = {
+                ...(objective === undefined ? {} : { objective: objective }),
+                ...(cron === undefined ? {} : { cron: cron })
+            };
+            if (capability.actorUserId === task.ownerUserId) {
+                const updated = this.store().update(task.sessionId, task.revision, patch);
+                this.#capabilities.set(request.token, {
+                    ...capability,
+                    revision: updated.revision
+                });
+                this.changed(task.sessionId);
+                socket.end(`${JSON.stringify({ result: updated })}\n`);
+            }
+            else {
+                const proposalId = this.store().propose(task, capability.actorUserId, patch);
+                this.proposed(task.sessionId, proposalId);
+                socket.end(`${JSON.stringify({ result: { proposalId, status: 'PENDING' } })}\n`);
+            }
+        }
+        catch (error) {
+            socket.end(`${JSON.stringify({ error: error instanceof Error ? error.message : 'SCHEDULE_IPC_FAILED' })}\n`);
+        }
+    }
+}
+function record(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : {};
+}
+function scheduledMcpStdioArgs() {
+    const javascript = fileURLToPath(new URL('./scheduled-task-mcp-stdio.js', import.meta.url));
+    if (existsSync(javascript))
+        return [javascript];
+    const typescript = fileURLToPath(new URL('./scheduled-task-mcp-stdio.ts', import.meta.url));
+    if (!existsSync(typescript))
+        throw new Error('SCHEDULE_MCP_STDIO_ENTRY_UNAVAILABLE');
+    return ['--import', import.meta.resolve('tsx'), typescript];
+}

package/dist/service/scheduled-task-mcp-stdio.js

@@ -0,0 +1,63 @@
+import { connect } from 'node:net';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+const endpoint = process.env['MAR_SCHEDULE_MCP_ENDPOINT'];
+const token = process.env['MAR_SCHEDULE_MCP_TOKEN'];
+if (endpoint === undefined || token === undefined)
+    throw new Error('SCHEDULE_CAPABILITY_INVALID');
+const server = new McpServer({ name: 'mar_schedule', version: '1.0.0' });
+server.registerTool('mar_get_scheduled_task', {
+    description: 'Read the MAR scheduled task for this MAR-managed Workspace conversation, or null if none exists.'
+}, async () => result(await request('mar_get_scheduled_task', {})));
+if (process.env['MAR_SCHEDULE_MCP_READ_ONLY'] !== '1') {
+    server.registerTool('mar_create_scheduled_task', {
+        description: 'Create a MAR scheduled task for this MAR-managed Workspace conversation. MAR runs it in this conversation using the connected Node time zone.',
+        inputSchema: {
+            objective: z.string().min(1).max(20_000).describe('Prompt to run at each trigger.'),
+            cron: z
+                .string()
+                .min(9)
+                .max(64)
+                .describe('Five-field cron expression interpreted in the connected MAR Node time zone.')
+        }
+    }, async (args) => result(await request('mar_create_scheduled_task', args)));
+    server.registerTool('mar_update_scheduled_task', {
+        description: 'Update the MAR scheduled task for this MAR-managed Workspace conversation. Its cron expression uses the connected Node time zone.',
+        inputSchema: {
+            objective: z.string().min(1).max(20_000).describe('Replacement prompt.').optional(),
+            cron: z
+                .string()
+                .min(9)
+                .max(64)
+                .describe('Replacement five-field cron expression in the connected MAR Node time zone.')
+                .optional()
+        }
+    }, async (args) => result(await request('mar_update_scheduled_task', args)));
+}
+await server.connect(new StdioServerTransport());
+function request(tool, args) {
+    return new Promise((resolve, reject) => {
+        const socket = connect(endpoint);
+        let body = '';
+        socket.setEncoding('utf8');
+        socket.once('connect', () => socket.end(`${JSON.stringify({ token, tool, arguments: args })}\n`));
+        socket.on('data', (chunk) => (body += chunk));
+        socket.once('error', reject);
+        socket.once('end', () => {
+            try {
+                const payload = JSON.parse(body);
+                if (payload.error !== undefined)
+                    reject(new Error(payload.error));
+                else
+                    resolve(payload.result);
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    });
+}
+function result(value) {
+    return { content: [{ type: 'text', text: JSON.stringify(value) }] };
+}

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

@@ -38,7 +38,9 @@ export class SessionCatalogService {
                 source?.runnerTitle === undefined ||
                 source.runnerTitle === null
                 ? session
-                : this.options.runtime.setRunnerTitleFromNative(session.id, source.runnerTitle);
+                : source.titleSource === 'AUTO'
+                    ? this.options.runtime.setTemporaryTitleIfMissing(session.id, source.runnerTitle)
+                    : this.options.runtime.setRunnerTitleFromNative(session.id, source.runnerTitle);
             return this.options.present(source === undefined
                 ? synchronized
                 : {

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

@@ -1,6 +1,7 @@
 import { validSessionEffort, validSessionOption, validSessionTitle } from '../util/node-operation-parsers.js';
 import { isPlainRecord } from '../util/node-operation-parsers.js';
 import { parseSecretEnvironment } from '../util/secret-environment.js';
+import { ScheduledSessionStore } from './scheduled-session-store.js';
 export class SessionLifecycleService {
     options;
     starts = new Map();
@@ -34,6 +35,11 @@ export class SessionLifecycleService {
             (await this.options.projection.createMetadataProjection(input.sessionId));
         if (current === undefined)
             throw new Error('SESSION_NOT_FOUND');
+        if (input.pinned === false) {
+            const task = new ScheduledSessionStore(this.options.database().raw).get(current.externalSessionId ?? current.id);
+            if (task?.enabled === true)
+                throw new Error('SCHEDULE_PIN_REQUIRED');
+        }
         const nativeCodexRename = this.options.runners.require(current.runner).usesRunnerTitleForRename() &&
             current.externalSessionId !== null &&
             input.customTitle !== undefined;

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

@@ -5,6 +5,7 @@ import { personalInstructionsForRunner } from '../util/personal-instructions.js'
 import { safeErrorCode } from '../util/safe-error.js';
 import { publicGoalStartText } from './goal-runtime.js';
 const INTERNAL_GOAL = Symbol('internalGoal');
+const INTERNAL_SCHEDULE = Symbol('internalSchedule');
 export class SessionMessageService {
     options;
     pendingMessages = new Map();
@@ -37,6 +38,22 @@ export class SessionMessageService {
             marAgentRuntimeScopeId: input.marAgentRuntimeScopeId
         });
     }
+    submitScheduled(input) {
+        return this.message({
+            [INTERNAL_SCHEDULE]: true,
+            sessionId: input.sessionId,
+            clientMessageId: input.occurrenceId,
+            content: input.objective,
+            __runnerContent: `Scheduled task execution:\n${input.objective}`,
+            __requestUserId: input.initiatedByUserId,
+            deliveryIntent: 'SEND',
+            secretEnvironment: input.secretEnvironment,
+            personalInstructions: input.personalInstructions,
+            marAgentModel: input.marAgentModel,
+            marAgentModels: input.marAgentModels,
+            marAgentRuntimeScopeId: input.marAgentRuntimeScopeId
+        });
+    }
     async message(input) {
         if (typeof input.sessionId !== 'string' ||
             typeof input.clientMessageId !== 'string' ||
@@ -47,7 +64,10 @@ export class SessionMessageService {
         const clientMessageId = input.clientMessageId;
         const content = input.content;
         const internalGoal = input[INTERNAL_GOAL] === true;
-        const internalRunnerContent = internalGoal && typeof input.__runnerContent === 'string' ? input.__runnerContent : content;
+        const internalSchedule = input[INTERNAL_SCHEDULE] === true;
+        const internalRunnerContent = (internalGoal || internalSchedule) && typeof input.__runnerContent === 'string'
+            ? input.__runnerContent
+            : content;
         const inlineAttachments = parseMessageAttachments(input.attachments);
         const secretEnvironment = parseSecretEnvironment(input.secretEnvironment);
         const attachmentIds = parseComposerAttachmentIds(input.attachmentIds);
@@ -80,7 +100,7 @@ export class SessionMessageService {
                 idempotent: true,
                 auditReceipt: auditReceipt(session, existing.kind === 'queue' ? 'QUEUE' : 'SEND', existing.run.id, existing.kind === 'queue' ? existing.item.id : undefined)
             };
-        const goalMessage = internalGoal ? undefined : this.options.goalMessage(session, content);
+        const goalMessage = internalGoal || internalSchedule ? undefined : this.options.goalMessage(session, content);
         const runnerContent = goalMessage?.runnerContent ?? internalRunnerContent;
         const publicContent = goalMessage?.activated === true ? publicGoalStartText(content) : content;
         const intent = goalMessage === undefined ? requestedIntent : 'REPLACE_CURRENT';
@@ -90,12 +110,15 @@ export class SessionMessageService {
             const runId = randomUUID();
             const queueBeforeCreate = this.options.runtime.sessionQueue(session.id);
             const active = this.options.runtime.activeSessionRun(session.id);
+            if (internalSchedule && (active !== undefined || queueBeforeCreate.itemIds.length > 0))
+                throw new Error('SCHEDULE_SESSION_BUSY');
             const replaceCurrentRun = intent === 'REPLACE_CURRENT' ? active : undefined;
             const created = this.options.coordinator.accept({
                 runId,
                 sessionId: session.id,
                 clientMessageId,
                 content: publicContent,
+                ...(internalSchedule ? { source: 'SCHEDULED' } : {}),
                 ...(Number.isSafeInteger(input.__requestUserId)
                     ? { initiatedByUserId: input.__requestUserId }
                     : {}),

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

@@ -1,3 +1,4 @@
+import { ScheduledSessionStore } from './scheduled-session-store.js';
 export class SessionPresentationService {
     options;
     constructor(options) {
@@ -18,7 +19,21 @@ export class SessionPresentationService {
         });
         return {
             ...session,
-            ...presentation
+            ...presentation,
+            runtime: {
+                ...presentation.runtime,
+                capabilities: session.externalSessionId !== null && database !== undefined
+                    ? [...presentation.runtime.capabilities, 'session.schedule']
+                    : presentation.runtime.capabilities
+            },
+            schedule: database === undefined
+                ? null
+                : (() => {
+                    const task = new ScheduledSessionStore(database.raw).get(session.externalSessionId ?? session.id);
+                    return task === undefined
+                        ? null
+                        : { enabled: task.enabled, nextRunAt: task.nextRunAt };
+                })()
         };
     }
     presentDiscovered(sessions) {
@@ -28,7 +43,9 @@ export class SessionPresentationService {
                 return this.present(session);
             const synchronized = session.runnerTitle === null
                 ? projected
-                : this.options.runtime.setRunnerTitleFromNative(projected.id, session.runnerTitle);
+                : session.titleSource === 'AUTO'
+                    ? this.options.runtime.setTemporaryTitleIfMissing(projected.id, session.runnerTitle)
+                    : this.options.runtime.setRunnerTitleFromNative(projected.id, session.runnerTitle);
             return this.present({
                 ...synchronized,
                 lastActivityAt: latestSessionActivityAt(synchronized.lastActivityAt, session.lastActivityAt)