@vantran-se/openchamber-web 2.1.1 → 2.2.0

package/server/lib/scheduled-tasks/existing-session.test.js

@@ -0,0 +1,350 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { OpenCode } from '@opencode/client';
+import { createExistingSessionTasks } from './existing-session.js';
+import { createScheduledTaskService } from './service.js';
+import { registerScheduledTaskRoutes } from './routes.js';
+import { createScheduledTasksRuntime } from './runtime.js';
+
+afterEach(() => {
+  vi.unstubAllGlobals();
+  vi.useRealTimers();
+});
+
+const task = {
+  id: 'task-1', name: 'Repeat', enabled: true, targetSessionId: 'ses_target',
+  schedule: { kind: 'daily', time: '09:00' }, execution: { prompt: 'Follow up', useDefaults: true }, state: {},
+};
+
+const setup = (overrides = {}) => {
+  let stored = structuredClone(task);
+  const projectConfigRuntime = {
+    listScheduledTasks: async () => [stored],
+    updateScheduledTaskState: async (_project, _task, patch) => {
+      stored = { ...stored, state: { ...stored.state, ...patch } };
+      return { task: stored };
+    },
+    updateScheduledTaskStateIf: async (_project, _task, predicate, patch) => {
+      if (!predicate(stored)) return { task: stored, updated: false };
+      stored = { ...stored, state: { ...stored.state, ...patch } };
+      return { task: stored, updated: true };
+    },
+    upsertScheduledTask: async (_project, input) => {
+      stored = { ...stored, ...input };
+      return { task: stored };
+    },
+    deleteScheduledTask: async () => ({ deleted: true }),
+  };
+  const messageQueueRuntime = { enqueue: vi.fn(async () => {}), cancelScheduledTask: vi.fn(async () => {}) };
+  const runtime = createExistingSessionTasks({
+    projectConfigRuntime, messageQueueRuntime,
+    createClient: () => ({ session: { get: async ({ sessionID }) => ({ id: sessionID, location: { directory: '/repo' } }) } }),
+    listProjects: async () => [{ id: 'project-1', path: '/repo' }],
+    ...overrides,
+  });
+  return { runtime, projectConfigRuntime, messageQueueRuntime, stored: () => stored };
+};
+
+describe('existing session scheduling', () => {
+  it('the scheduler reuses a target without creating a chat or reading new-session defaults', async () => {
+    const { projectConfigRuntime, messageQueueRuntime } = setup();
+    const fetchImpl = vi.fn(async () => Response.json({ location: { directory: '/repo' }, data: { id: 'ses_target', location: { directory: '/repo' } } }));
+    vi.stubGlobal('fetch', fetchImpl);
+    const readSessionDefaults = vi.fn();
+    const createChatDirectory = vi.fn();
+    const scheduler = createScheduledTasksRuntime({
+      projectConfigRuntime, messageQueueRuntime,
+      listProjects: async () => [{ id: 'project-1', path: '/repo' }],
+      chatsScope: { id: 'project-1', root: '/repo', contains: () => true, createChatDirectory },
+      buildOpenCodeUrl: (route) => `http://opencode.test${route}`, getOpenCodeAuthHeaders: () => ({}),
+      readSessionDefaults,
+    });
+    await scheduler.syncProject('project-1');
+    expect(await scheduler.runNow('project-1', 'task-1')).toMatchObject({ ok: true, sessionID: 'ses_target' });
+    expect(createChatDirectory).not.toHaveBeenCalled();
+    expect(readSessionDefaults).not.toHaveBeenCalled();
+    expect(fetchImpl).toHaveBeenCalledOnce();
+    expect(new URL(fetchImpl.mock.calls[0][0]).pathname).toBe('/api/session/ses_target');
+  });
+  it('admits to the ordinary queue, records the target, then finishes at send', async () => {
+    const { runtime, messageQueueRuntime, stored } = setup();
+    const result = await runtime.run('project-1', { ...task, execution: { ...task.execution, providerID: 'old', modelID: 'old', agent: 'old' } }, 'manual');
+    expect(result).toMatchObject({ ok: true, sessionID: 'ses_target', directory: '/repo' });
+    expect(messageQueueRuntime.enqueue).toHaveBeenCalledWith('ses_target', '/repo', {
+      content: 'Follow up', text: 'Follow up', sendConfig: {}, scheduledTask: { projectId: 'project-1', taskId: 'task-1' },
+    });
+    expect(stored().state).toMatchObject({ lastStatus: 'queued', lastSessionId: 'ses_target' });
+    await runtime.result({ projectId: 'project-1', taskId: 'task-1' }, 'sent');
+    expect(stored().state.lastStatus).toBe('sent');
+  });
+
+  it('records a duplicate Run now as skipped with queued busy status', async () => {
+    const { runtime, messageQueueRuntime, stored } = setup();
+    messageQueueRuntime.enqueue.mockRejectedValue(Object.assign(new Error('task is already queued'), { status: 409 }));
+    expect(await runtime.run('project-1', task, 'manual')).toMatchObject({ ok: false, queued: true, statusCode: 409 });
+    expect(stored().state.lastStatus).toBe('skipped');
+    expect(messageQueueRuntime.cancelScheduledTask).not.toHaveBeenCalled();
+  });
+
+  it.each(['manual', 'scheduled'])('records a %s attempt that overlaps an admission before the final queued write', async (reason) => {
+    let releaseTarget;
+    const target = new Promise((resolve) => { releaseTarget = resolve; });
+    const { runtime, projectConfigRuntime, stored, messageQueueRuntime } = setup({
+      createClient: () => ({ session: { get: () => target } }),
+    });
+    const claim = vi.spyOn(projectConfigRuntime, 'updateScheduledTaskStateIf');
+    const first = runtime.run('project-1', task, 'manual');
+    expect(await runtime.run('project-1', task, reason, Date.now())).toMatchObject({ ok: false, queued: true });
+    expect(stored().state).toMatchObject({ lastStatus: 'skipped', lastError: 'task is already queued' });
+    expect(claim).not.toHaveBeenCalled();
+    releaseTarget({ id: 'ses_target', location: { directory: '/repo' } });
+    expect(await first).toMatchObject({ ok: true });
+    expect(stored().state).toMatchObject({ lastStatus: 'queued', lastSessionId: 'ses_target' });
+    expect(messageQueueRuntime.enqueue).toHaveBeenCalledOnce();
+  });
+
+  it.each(['manual', 'scheduled'])('returns queued busy when the %s overlap state write rejects', async (reason) => {
+    let releaseTarget;
+    const target = new Promise((resolve) => { releaseTarget = resolve; });
+    const { runtime, projectConfigRuntime, messageQueueRuntime } = setup({
+      createClient: () => ({ session: { get: () => target } }),
+    });
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    const first = runtime.run('project-1', task, 'manual');
+    const write = vi.spyOn(projectConfigRuntime, 'updateScheduledTaskState').mockRejectedValueOnce(new Error('project lock timeout'));
+    try {
+      await expect(runtime.run('project-1', task, reason, Date.now())).resolves.toMatchObject({
+        ok: false, queued: true, error: 'task is already queued',
+      });
+      expect(write).toHaveBeenCalledWith('project-1', task.id, expect.objectContaining({ lastStatus: 'skipped' }));
+      expect(warn).toHaveBeenCalledWith('[scheduled-tasks] admission failure state write failed:', 'project lock timeout');
+    } finally {
+      releaseTarget({ id: 'ses_target', location: { directory: '/repo' } });
+      await first;
+      warn.mockRestore();
+    }
+    expect(messageQueueRuntime.enqueue).toHaveBeenCalledOnce();
+    expect(messageQueueRuntime.cancelScheduledTask).not.toHaveBeenCalled();
+  });
+
+  it('keeps manual busy 409 and re-arms the scheduled timer when overlap state writes reject', async () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date('2026-10-07T08:00:00Z'));
+    const { projectConfigRuntime, messageQueueRuntime } = setup();
+    await projectConfigRuntime.upsertScheduledTask('project-1', {
+      ...task, schedule: { kind: 'daily', time: '08:01', timezone: 'UTC' },
+    });
+    let releaseAdmission;
+    let enteredAdmission;
+    const admission = new Promise((resolve) => { releaseAdmission = resolve; });
+    const entered = new Promise((resolve) => { enteredAdmission = resolve; });
+    messageQueueRuntime.enqueue.mockImplementationOnce(() => {
+      enteredAdmission();
+      return admission;
+    });
+    vi.stubGlobal('fetch', async () => Response.json({ data: { id: 'ses_target', location: { directory: '/repo' } } }));
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    const schedulerWarn = vi.fn();
+    const scheduler = createScheduledTasksRuntime({
+      projectConfigRuntime, messageQueueRuntime, logger: { warn: schedulerWarn },
+      listProjects: async () => [{ id: 'project-1', path: '/repo' }],
+      chatsScope: { id: 'project-1', root: '/repo', contains: () => true },
+      buildOpenCodeUrl: (route) => `http://opencode.test${route}`, getOpenCodeAuthHeaders: () => ({}),
+    });
+    const service = createScheduledTaskService({
+      projectConfigRuntime, scheduledTasksRuntime: scheduler,
+      readSettingsFromDiskMigrated: async () => ({ projects: [{ id: 'project-1', path: '/repo' }] }), sanitizeProjects: (projects) => projects,
+    });
+    const handlers = new Map();
+    const app = Object.fromEntries(['get', 'put', 'delete', 'patch', 'post'].map((method) => [method, (route, handler) => handlers.set(`${method}:${route}`, handler)]));
+    registerScheduledTaskRoutes(app, { scheduledTaskService: service });
+    let first;
+    try {
+      await scheduler.start();
+      first = scheduler.runNow('project-1', task.id);
+      await entered;
+      vi.spyOn(projectConfigRuntime, 'updateScheduledTaskState')
+        .mockRejectedValueOnce(new Error('disk write failed'))
+        .mockRejectedValueOnce(new Error('project lock timeout'));
+      const response = { statusCode: 200, body: null, status(code) { this.statusCode = code; return this; }, json(body) { this.body = body; return this; } };
+      await handlers.get('post:/api/projects/:projectId/scheduled-tasks/:taskId/run')({ params: { projectId: 'project-1', taskId: task.id } }, response);
+      expect(response.statusCode).toBe(409);
+      expect(response.body).toMatchObject({ busy: 'queued', error: 'task is already queued' });
+      await vi.advanceTimersByTimeAsync(65_000);
+      expect(warn).toHaveBeenCalledWith('[scheduled-tasks] admission failure state write failed:', 'project lock timeout');
+      expect(schedulerWarn).not.toHaveBeenCalled();
+      expect(vi.getTimerCount()).toBe(1);
+      expect(messageQueueRuntime.enqueue).toHaveBeenCalledOnce();
+      releaseAdmission();
+      await expect(first).resolves.toMatchObject({ ok: true });
+      await vi.advanceTimersByTimeAsync(24 * 60 * 60 * 1000);
+      expect(messageQueueRuntime.enqueue).toHaveBeenCalledTimes(2);
+      expect(schedulerWarn).not.toHaveBeenCalled();
+      expect(vi.getTimerCount()).toBe(1);
+    } finally {
+      releaseAdmission();
+      await first;
+      scheduler.stop();
+      warn.mockRestore();
+    }
+  });
+
+  it('ignores task goal and auto-accept options when reusing a target', async () => {
+    const { projectConfigRuntime, messageQueueRuntime } = setup();
+    const execution = { ...task.execution, goalEnabled: true, goalTokenBudget: 5000, permissionAutoAccept: true };
+    await projectConfigRuntime.upsertScheduledTask('project-1', { ...task, execution });
+    const fetchImpl = vi.fn(async () => Response.json({ data: { id: 'ses_target', location: { directory: '/repo' } } }));
+    vi.stubGlobal('fetch', fetchImpl);
+    const setSessionAutoAccept = vi.fn();
+    const persistSessionGoal = vi.fn();
+    const scheduler = createScheduledTasksRuntime({
+      projectConfigRuntime, messageQueueRuntime, setSessionAutoAccept, persistSessionGoal,
+      listProjects: async () => [{ id: 'project-1', path: '/repo' }],
+      chatsScope: { id: 'project-1', root: '/repo', contains: () => true },
+      buildOpenCodeUrl: (route) => `http://opencode.test${route}`, getOpenCodeAuthHeaders: () => ({}),
+    });
+    await scheduler.syncProject('project-1');
+    await scheduler.runNow('project-1', task.id);
+    const item = messageQueueRuntime.enqueue.mock.calls[0][2];
+    expect(item.scheduledTask).toEqual({ projectId: 'project-1', taskId: 'task-1' });
+    await scheduler.beforeScheduledTaskSend('ses_target', '/repo', item);
+    expect(setSessionAutoAccept).not.toHaveBeenCalled();
+    expect(persistSessionGoal).not.toHaveBeenCalled();
+    expect(fetchImpl.mock.calls.every(([, init]) => !init?.method || init.method === 'GET')).toBe(true);
+    expect(item.context).toBeUndefined();
+  });
+
+  it('Run now on a deleted target responds 404 with its message', async () => {
+    const { runtime, projectConfigRuntime } = setup({ createClient: () => OpenCode.make({ baseUrl: 'http://opencode.test', fetch: async () => Response.json({ name: 'NotFoundError', message: 'Not found' }, { status: 404 }) }) });
+    const scheduledTasksRuntime = { runNow: (project, id) => runtime.run(project, { ...task, id }, 'manual') };
+    const service = createScheduledTaskService({
+      projectConfigRuntime, scheduledTasksRuntime,
+      readSettingsFromDiskMigrated: async () => ({ projects: [{ id: 'project-1', path: '/repo' }] }), sanitizeProjects: (projects) => projects,
+    });
+    const handlers = new Map();
+    const app = Object.fromEntries(['get', 'put', 'delete', 'patch', 'post'].map((method) => [method, (route, handler) => handlers.set(`${method}:${route}`, handler)]));
+    registerScheduledTaskRoutes(app, { scheduledTaskService: service });
+    const response = { statusCode: 200, body: null, status(code) { this.statusCode = code; return this; }, json(body) { this.body = body; return this; } };
+    await handlers.get('post:/api/projects/:projectId/scheduled-tasks/:taskId/run')({ params: { projectId: 'project-1', taskId: task.id } }, response);
+    expect(response.statusCode).toBe(404);
+    expect(response.body.error).toBe('Scheduled target not found');
+  });
+
+  it('refuses archived and foreign targets and admits linked worktrees', async () => {
+    await expect(setup({ isSessionArchived: () => true }).runtime.validateTarget('project-1', 'ses_target')).rejects.toMatchObject({ statusCode: 409, message: 'Scheduled target is archived' });
+    const foreign = () => ({ session: { get: async () => ({ id: 'ses_target', location: { directory: '/worktree' } }) } });
+    await expect(setup({ createClient: foreign }).runtime.validateTarget('project-1', 'ses_target')).rejects.toMatchObject({ statusCode: 409 });
+    await expect(setup({ createClient: foreign, resolvePrimaryWorktreeRoot: async () => ({ root: '/repo' }) }).runtime.validateTarget('project-1', 'ses_target')).resolves.toMatchObject({ directory: '/worktree' });
+  });
+
+  it.each(['removed', 'retargeted', 'moved'])('refuses a %s target/task before send with 409', async (change) => {
+    let directory = '/repo';
+    const { runtime, projectConfigRuntime, messageQueueRuntime } = setup({
+      createClient: () => ({ session: { get: async () => ({ id: 'ses_target', location: { directory } }) } }),
+      resolvePrimaryWorktreeRoot: async () => ({ root: '/repo' }),
+    });
+    await runtime.run('project-1', task, 'manual');
+    if (change === 'removed') projectConfigRuntime.listScheduledTasks = async () => [];
+    if (change === 'retargeted') await projectConfigRuntime.upsertScheduledTask('project-1', { ...task, targetSessionId: 'ses_another' });
+    if (change === 'moved') directory = '/worktree';
+    await expect(runtime.beforeSend('ses_target', '/repo', messageQueueRuntime.enqueue.mock.calls[0][2])).rejects.toMatchObject({
+      statusCode: 409,
+      message: change === 'moved' ? 'Scheduled target moved' : 'Scheduled task target changed or was removed',
+    });
+  });
+
+  it('cancels waiting prompts on disable, retarget and delete', async () => {
+    for (const input of [{ ...task, enabled: false }, { ...task, targetSessionId: 'ses_another' }]) {
+      const { runtime, projectConfigRuntime, messageQueueRuntime } = setup();
+      const service = createScheduledTaskService({
+        projectConfigRuntime, scheduledTasksRuntime: { validateTarget: runtime.validateTarget, cancelWaitingPrompt: runtime.cancel, syncProject: async () => [] },
+        readSettingsFromDiskMigrated: async () => ({ projects: [{ id: 'project-1', path: '/repo' }] }), sanitizeProjects: (projects) => projects,
+      });
+      await service.upsert('project-1', input);
+      expect(messageQueueRuntime.cancelScheduledTask).toHaveBeenCalledWith('project-1', task.id);
+      await service.remove('project-1', task.id);
+      expect(messageQueueRuntime.cancelScheduledTask).toHaveBeenCalledTimes(2);
+    }
+  });
+
+  it.each([404, 409])('allows pausing and editing an unchanged stale target with refusal %s', async (statusCode) => {
+    const { projectConfigRuntime, stored } = setup();
+    const validateTarget = vi.fn(async () => { throw Object.assign(new Error('stale target'), { statusCode }); });
+    const service = createScheduledTaskService({
+      projectConfigRuntime,
+      scheduledTasksRuntime: { validateTarget, cancelWaitingPrompt: async () => {}, syncProject: () => projectConfigRuntime.listScheduledTasks() },
+      readSettingsFromDiskMigrated: async () => ({ projects: [{ id: 'project-1', path: '/repo' }] }), sanitizeProjects: (projects) => projects,
+    });
+    expect(await service.setEnabled('project-1', task.id, false)).toMatchObject({ enabled: false });
+    expect((await service.upsert('project-1', { ...stored(), name: 'Paused edit' })).task.name).toBe('Paused edit');
+    expect(validateTarget).not.toHaveBeenCalled();
+    await expect(service.setEnabled('project-1', task.id, true)).rejects.toMatchObject({ statusCode });
+    await expect(service.upsert('project-1', { ...stored(), targetSessionId: 'ses_another' })).rejects.toMatchObject({ statusCode });
+    expect(validateTarget).toHaveBeenCalledTimes(2);
+  });
+
+  it('keeps a waiting prompt when disabling or retargeting fails to save', async () => {
+    for (const input of [{ ...task, enabled: false }, { ...task, targetSessionId: 'ses_another' }]) {
+      const { runtime, projectConfigRuntime, messageQueueRuntime } = setup();
+      projectConfigRuntime.upsertScheduledTask = async () => { throw new Error('disk write failed'); };
+      const service = createScheduledTaskService({
+        projectConfigRuntime, scheduledTasksRuntime: { validateTarget: runtime.validateTarget, cancelWaitingPrompt: runtime.cancel, syncProject: async () => [] },
+        readSettingsFromDiskMigrated: async () => ({ projects: [{ id: 'project-1', path: '/repo' }] }), sanitizeProjects: (projects) => projects,
+      });
+      await expect(service.upsert('project-1', input)).rejects.toMatchObject({ statusCode: 500 });
+      expect(messageQueueRuntime.cancelScheduledTask).not.toHaveBeenCalled();
+    }
+  });
+
+  it('keeps a manually queued prompt when saving an already-paused task, but cancels on retarget', async () => {
+    const { runtime, projectConfigRuntime, messageQueueRuntime, stored } = setup();
+    await projectConfigRuntime.upsertScheduledTask('project-1', { ...task, enabled: false });
+    await runtime.run('project-1', stored(), 'manual');
+    const service = createScheduledTaskService({
+      projectConfigRuntime, scheduledTasksRuntime: { validateTarget: runtime.validateTarget, cancelWaitingPrompt: runtime.cancel, syncProject: () => projectConfigRuntime.listScheduledTasks() },
+      readSettingsFromDiskMigrated: async () => ({ projects: [{ id: 'project-1', path: '/repo' }] }), sanitizeProjects: (projects) => projects,
+    });
+    await service.upsert('project-1', { ...stored(), name: 'Paused edit' });
+    expect(stored().enabled).toBe(false);
+    expect(stored().state.lastStatus).toBe('queued');
+    expect(messageQueueRuntime.cancelScheduledTask).not.toHaveBeenCalled();
+    await service.upsert('project-1', { ...stored(), targetSessionId: 'ses_another' });
+    expect(messageQueueRuntime.cancelScheduledTask).toHaveBeenCalledWith('project-1', task.id);
+  });
+
+  it.each([
+    { missing: false, claimed: true, consumeFails: false },
+    { missing: true, claimed: true, consumeFails: false },
+    { missing: false, claimed: false, consumeFails: false },
+    { missing: false, claimed: true, consumeFails: true },
+  ])('consumes only a claimed once attempt, missing=$missing claimed=$claimed consumeFails=$consumeFails', async ({ missing, claimed, consumeFails }) => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date('2026-10-07T08:00:00Z'));
+    const { projectConfigRuntime, messageQueueRuntime, stored } = setup();
+    if (!claimed) projectConfigRuntime.updateScheduledTaskStateIf = async () => ({ task: stored(), updated: false });
+    await projectConfigRuntime.upsertScheduledTask('project-1', { ...task, schedule: { kind: 'once', date: '2026-10-07', time: '08:01', timezone: 'UTC' } });
+    if (consumeFails) projectConfigRuntime.upsertScheduledTask = async () => { throw new Error('disk write failed'); };
+    const warn = vi.fn();
+    vi.stubGlobal('fetch', async () => missing
+      ? Response.json({ name: 'NotFoundError', message: 'Not found' }, { status: 404 })
+      : Response.json({ data: { id: 'ses_target', location: { directory: '/repo' } } }));
+    const scheduler = createScheduledTasksRuntime({
+      projectConfigRuntime, messageQueueRuntime, logger: { warn },
+      listProjects: async () => [{ id: 'project-1', path: '/repo' }],
+      chatsScope: { id: 'project-1', root: '/repo', contains: () => true },
+      buildOpenCodeUrl: (route) => `http://opencode.test${route}`, getOpenCodeAuthHeaders: () => ({}),
+    });
+    try {
+      await scheduler.start();
+      await vi.advanceTimersByTimeAsync(65_000);
+      expect(stored().enabled).toBe(!claimed || consumeFails);
+      expect(scheduler.getStatus().enabledScheduledTasksCount).toBe(claimed && !consumeFails ? 0 : 1);
+      expect(stored().state.lastStatus).toBe(claimed ? (missing ? 'failed' : 'queued') : undefined);
+      expect(messageQueueRuntime.enqueue).toHaveBeenCalledTimes(claimed && !missing ? 1 : 0);
+      expect(messageQueueRuntime.cancelScheduledTask).not.toHaveBeenCalled();
+      if (consumeFails) expect(warn).toHaveBeenCalledWith('[ScheduledTasks] failed to consume one-time task', { projectID: 'project-1', taskID: task.id, error: 'disk write failed' });
+      else expect(warn).not.toHaveBeenCalled();
+    } finally {
+      scheduler.stop();
+    }
+  });
+});

package/server/lib/scheduled-tasks/loops.js

@@ -37,6 +37,7 @@
  * the markdown file; it continues to live in the project config/state store.
  */
 
+import { asNonEmptyString } from '../shared/guards.js';
 import { createHash } from 'crypto';
 import fs from 'fs';
 import os from 'os';
@@ -47,14 +48,6 @@ import { MAX_TASK_NAME_LENGTH } from '../projects/project-config.js';
 const LOOP_DIR_NAME = 'loops';
 const USER_LOOP_ROOT = () => path.join(os.homedir(), '.agents', LOOP_DIR_NAME);
 
-const asNonEmptyString = (value) => {
-  if (typeof value !== 'string') {
-    return null;
-  }
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : null;
-};
-
 /**
  * Split a `provider/model` string into its two parts. Splits on the first `/`
  * so model ids containing a slash (e.g. `openai/gpt-5`) still resolve.

package/server/lib/scheduled-tasks/routes.js

@@ -1,11 +1,5 @@
+import { asNonEmptyString } from '../shared/guards.js';
 import { randomUUID } from 'node:crypto';
-const asNonEmptyString = (value) => {
-  if (typeof value !== 'string') {
-    return null;
-  }
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : null;
-};
 
 const parseProjectID = (req) => asNonEmptyString(req?.params?.projectId);
 const parseTaskID = (req) => asNonEmptyString(req?.params?.taskId);
@@ -124,7 +118,13 @@ export const registerScheduledTaskRoutes = (app, dependencies) => {
     try {
       return res.json({ ok: true, ...await scheduledTaskService.run(projectID, taskID) });
     } catch (error) {
-      if (error?.statusCode) return res.status(error.statusCode).json({ error: error.message, ...(error.task ? { task: error.task } : {}) });
+      if (error?.statusCode) {
+        return res.status(error.statusCode).json({
+          error: error.message,
+          ...(error.task ? { task: error.task } : {}),
+          ...(error.busy ? { busy: error.busy } : {}),
+        });
+      }
       console.error('[ScheduledTasks] failed to run task:', error);
       return res.status(500).json({ error: 'Failed to run scheduled task' });
     }

package/server/lib/scheduled-tasks/runtime.js

@@ -5,6 +5,7 @@ import { expandSnippets } from '../opencode/snippets.js';
 import { buildGoalIntroText, createSessionGoal } from '../session-goal/create.js';
 import { discoverLoops } from './loops.js';
 import { assertOpenCodeApiResponse } from '../opencode/prompt-response.js';
+import { createExistingSessionTasks } from './existing-session.js';
 
 const DEFAULT_GLOBAL_CONCURRENCY = 4;
 const DEFAULT_PROJECT_CONCURRENCY = 2;
@@ -262,6 +263,12 @@ export const createScheduledTasksRuntime = (deps) => {
     // Chats scope (see chats-scope.js): scheduled like a project, but each run
     // opens a new chat directory and loop files are not discovered for it.
     chatsScope = null,
+    // The session defaults a task with `useDefaults` runs on:
+    // `(projectID) => { providerID, modelID, variant, agent }`, any of them null.
+    readSessionDefaults = null,
+    messageQueueRuntime,
+    resolvePrimaryWorktreeRoot,
+    isSessionArchived,
     logger = console,
     maxGlobalConcurrency = DEFAULT_GLOBAL_CONCURRENCY,
     maxProjectConcurrency = DEFAULT_PROJECT_CONCURRENCY,
@@ -284,6 +291,37 @@ export const createScheduledTasksRuntime = (deps) => {
     },
   });
 
+  const existingSessionTasks = messageQueueRuntime ? createExistingSessionTasks({
+    projectConfigRuntime, messageQueueRuntime, createClient: createScopedClient,
+    listProjects, chatsScope, resolvePrimaryWorktreeRoot, isSessionArchived, emitTaskRunEvent,
+  }) : null;
+
+  // A pinned task runs on what it stores; one that follows the session
+  // defaults reads them now, so changing a default reaches it on its next run.
+  const resolveRunSelection = async (projectID, task) => {
+    const execution = task.execution;
+    if (!execution.useDefaults) {
+      return {
+        providerID: execution.providerID ?? null,
+        modelID: execution.modelID ?? null,
+        variant: execution.variant ?? null,
+        agent: execution.agent ?? null,
+      };
+    }
+    try {
+      const defaults = typeof readSessionDefaults === 'function' ? await readSessionDefaults(projectID) : null;
+      return {
+        providerID: defaults?.providerID ?? null,
+        modelID: defaults?.modelID ?? null,
+        variant: defaults?.variant ?? null,
+        agent: defaults?.agent ?? null,
+      };
+    } catch (error) {
+      logger.warn?.('[scheduled-tasks] session defaults unavailable, using OpenCode defaults:', error?.message ?? error);
+      return { providerID: null, modelID: null, variant: null, agent: null };
+    }
+  };
+
   let started = false;
   const tasksByProject = new Map();
   const projectPathByID = new Map();
@@ -574,7 +612,7 @@ export const createScheduledTasksRuntime = (deps) => {
     await recordKnowledge(sessionID, projectPath, knowledge);
   };
 
-  const runTaskWithWatchdog = async (projectID, task, reason) => {
+  const runTaskWithWatchdog = async (projectID, task, reason, onSessionCreated) => {
     const startedAt = Date.now();
     const title = formatScheduledSessionTitle(task, startedAt);
     const projectPath = projectPathByID.get(projectID);
@@ -595,6 +633,7 @@ export const createScheduledTasksRuntime = (deps) => {
     const baseUrl = openCodeOrigin();
     const authHeaders = getOpenCodeAuthHeaders();
     const client = createScopedClient(directory);
+    const selection = await resolveRunSelection(projectID, task);
 
     // Agent, model and variant belong to the session in v2: a scheduled run
     // fixes them here instead of repeating them on every prompt.
@@ -603,13 +642,15 @@ export const createScheduledTasksRuntime = (deps) => {
       const session = await client.session.create({
         title,
         location: { directory },
-        metadata: { openchamber: { adopted: true } },
-        model: {
-          providerID: task.execution.providerID,
-          id: task.execution.modelID,
-          ...(task.execution.variant ? { variant: task.execution.variant } : {}),
-        },
-        ...(task.execution.agent ? { agent: task.execution.agent } : {}),
+        // No model or agent at all: OpenCode picks its own default.
+        ...(selection.providerID && selection.modelID ? {
+          model: {
+            providerID: selection.providerID,
+            id: selection.modelID,
+            ...(selection.variant ? { variant: selection.variant } : {}),
+          },
+        } : {}),
+        ...(selection.agent ? { agent: selection.agent } : {}),
       });
       sessionID = session?.id;
       if (!sessionID) {
@@ -622,6 +663,9 @@ export const createScheduledTasksRuntime = (deps) => {
       throw error;
     }
 
+    // Before the event, so a UI refreshing on it already sees the session.
+    await onSessionCreated?.(sessionID);
+
     try {
       emitTaskRunEvent?.({
         projectID,
@@ -658,8 +702,8 @@ export const createScheduledTasksRuntime = (deps) => {
         directory,
         objective: commandObjective ?? expandSnippets(task.execution.prompt, directory),
         tokenBudget: task.execution.goalTokenBudget,
-        providerID: task.execution.providerID,
-        modelID: task.execution.modelID,
+        providerID: selection.providerID ?? undefined,
+        modelID: selection.modelID ?? undefined,
         onWarning: (message, error) => console.warn(`[scheduled-tasks] ${message}:`, error?.message || error),
       });
     }
@@ -733,6 +777,27 @@ export const createScheduledTasksRuntime = (deps) => {
       return { ok: false, skipped: true };
     }
 
+    if (task.targetSessionId) {
+      if (!existingSessionTasks) return { ok: false, error: 'Existing-session scheduling is unavailable', statusCode: 503 };
+      const nextRunAt = computeNextRunAt(task, Math.max(Date.now(), (scheduledFor ?? 0) + 1));
+      const result = await existingSessionTasks.run(projectID, task, reason, scheduledFor, nextRunAt);
+      if (reason === 'scheduled') {
+        if (task.schedule.kind === 'once' && result.task && !result.skipped) {
+          try {
+            const consumed = await projectConfigRuntime.upsertScheduledTask(projectID, { ...result.task, enabled: false });
+            updateInMemoryTask(projectID, consumed.task);
+          } catch (consumeError) {
+            logger.warn?.('[ScheduledTasks] failed to consume one-time task', {
+              projectID,
+              taskID,
+              error: safeErrorMessage(consumeError),
+            });
+          }
+        } else scheduleFutureRun(projectID, taskID, nextRunAt);
+      }
+      return result;
+    }
+
     const taskKey = buildTaskKey(projectID, taskID);
     if (runningTaskKeys.has(taskKey)) {
       return { ok: false, running: true };
@@ -762,6 +827,8 @@ export const createScheduledTasksRuntime = (deps) => {
           lastRunAt: runStartedAt,
           lastStatus: 'running',
           lastError: undefined,
+          // Set again once this run creates its session.
+          lastSessionId: undefined,
           updatedAt: runStartedAt,
           // Always set nextRunAt so a past once-slot is cleared when there is
           // no following occurrence (omitting the key would leave the past value).
@@ -882,6 +949,7 @@ export const createScheduledTasksRuntime = (deps) => {
             lastRunAt: runStartedAt,
             lastStatus: 'running',
             lastError: undefined,
+            lastSessionId: undefined,
             updatedAt: runStartedAt,
           });
           if (startResult.task) {
@@ -903,9 +971,27 @@ export const createScheduledTasksRuntime = (deps) => {
       let sessionDirectory;
       let durationMs = 0;
       let errorMessage;
+      // Known as soon as the run creates its session, so a run that fails or
+      // times out afterwards still points at the session it left behind.
+      let createdSessionID;
+      const recordCreatedSession = async (id) => {
+        createdSessionID = id;
+        try {
+          const recorded = await projectConfigRuntime.updateScheduledTaskState(projectID, taskID, { lastSessionId: id });
+          if (recorded.task) {
+            updateInMemoryTask(projectID, recorded.task);
+          }
+        } catch (error) {
+          logger.warn?.('[ScheduledTasks] failed to record the run session', {
+            projectID,
+            taskID,
+            error: safeErrorMessage(error),
+          });
+        }
+      };
 
       try {
-        const runPromise = runTaskWithWatchdog(projectID, task, reason);
+        const runPromise = runTaskWithWatchdog(projectID, task, reason, recordCreatedSession);
         let timeoutID;
         const timeoutPromise = new Promise((_, reject) => {
           timeoutID = setTimeout(() => {
@@ -967,7 +1053,7 @@ export const createScheduledTasksRuntime = (deps) => {
         lastStatus: status,
         lastDurationMs: durationMs,
         lastError: status === 'error' ? errorMessage : undefined,
-        lastSessionId: status === 'success' ? sessionID : undefined,
+        lastSessionId: sessionID ?? createdSessionID,
         nextRunAt: Number.isFinite(nextRunAt) ? nextRunAt : undefined,
         updatedAt: finishedAt,
       };
@@ -1004,7 +1090,7 @@ export const createScheduledTasksRuntime = (deps) => {
             lastStatus: status,
             lastDurationMs: durationMs,
             lastError: status === 'error' ? errorMessage : undefined,
-            lastSessionId: status === 'success' ? sessionID : undefined,
+            lastSessionId: sessionID ?? createdSessionID,
             nextRunAt: Number.isFinite(nextRunAt) ? nextRunAt : undefined,
             updatedAt: finishedAt,
           },
@@ -1175,5 +1261,9 @@ export const createScheduledTasksRuntime = (deps) => {
     syncProject,
     runNow,
     getStatus,
+    validateTarget: (projectID, sessionID) => existingSessionTasks.validateTarget(projectID, sessionID),
+    beforeScheduledTaskSend: (sessionID, directory, item) => existingSessionTasks.beforeSend(sessionID, directory, item),
+    onScheduledTaskResult: (provenance, status, error) => existingSessionTasks.result(provenance, status, error),
+    cancelWaitingPrompt: (projectID, taskID) => existingSessionTasks?.cancel(projectID, taskID),
   };
 };