@vantran-se/openchamber-web 2.1.1 → 2.2.0

package/server/lib/message-queue/runtime.test.js

@@ -42,6 +42,7 @@ const createOpenCode = () => {
     sent: [],
     switched: [],
     failNext: null,
+    failStatus: 500,
     htmlNext: null,
   };
   // v2 wraps `/api/*` payloads in `{ location, data }`; a message page is
@@ -52,7 +53,7 @@ const createOpenCode = () => {
     const method = init.method ?? 'GET';
     if (state.failNext && state.failNext.test(pathname)) {
       state.failNext = null;
-      return new Response('boom', { status: 500 });
+      return new Response('boom', { status: state.failStatus });
     }
     if (method === 'POST' && state.htmlNext?.test(pathname)) {
       state.htmlNext = null;
@@ -80,7 +81,7 @@ const createOpenCode = () => {
   return { state, fetchImpl };
 };
 
-const createRuntime = ({ dataDir = makeDataDir(), openCode = createOpenCode(), knowledge = null, retryDelayMs, resolveAutoSelection, now } = {}) => {
+const createRuntime = ({ dataDir = makeDataDir(), openCode = createOpenCode(), knowledge = null, retryDelayMs, resolveAutoSelection, now, beforeScheduledTaskSend, onScheduledTaskResult } = {}) => {
   let eventHandler = () => {};
   let statusHandler = () => {};
   const broadcasts = [];
@@ -99,6 +100,8 @@ const createRuntime = ({ dataDir = makeDataDir(), openCode = createOpenCode(), k
     fetchImpl: openCode.fetchImpl,
     dispatchQuietMs: 0,
     abortHoldMs: 50,
+    beforeScheduledTaskSend,
+    onScheduledTaskResult,
   };
   if (retryDelayMs) options.retryDelayMs = retryDelayMs;
   if (resolveAutoSelection) options.resolveAutoSelection = resolveAutoSelection;
@@ -120,6 +123,173 @@ const settle = async (ms = 30) => {
   await new Promise((resolve) => setTimeout(resolve, ms));
 };
 
+describe('scheduled task items', () => {
+  const scheduled = (projectId = 'project-1', overrides = {}) => item({
+    scheduledTask: { projectId, taskId: 'task-1' }, sendConfig: {}, ...overrides,
+  });
+
+  it('deduplicates project and task across sessions, but not across projects', async () => {
+    const { runtime, openCode } = createRuntime();
+    openCode.state.active = { [SESSION]: { type: 'running' } };
+    await runtime.enqueue(SESSION, DIRECTORY, scheduled());
+    await expect(runtime.enqueue('ses_other', DIRECTORY, scheduled())).rejects.toMatchObject({ status: 409 });
+    await runtime.enqueue(SESSION, DIRECTORY, scheduled('project-2'));
+    expect(runtime.sessionSnapshot(SESSION).items).toHaveLength(2);
+    runtime.stop();
+    await runtime.flush();
+  });
+
+  it('inherits without a model POST and reports sent without waiting for completion', async () => {
+    const results = [];
+    const { runtime, openCode } = createRuntime({ onScheduledTaskResult: (task, status) => results.push({ task, status }) });
+    await runtime.enqueue(SESSION, DIRECTORY, scheduled());
+    await settle();
+    expect(openCode.state.switched).toEqual([]);
+    expect(openCode.state.sent).toHaveLength(1);
+    expect(openCode.state.sent[0].body).toEqual({ text: 'follow up' });
+    expect(runtime.sessionSnapshot(SESSION).items).toEqual([]);
+    expect(results).toEqual([{ task: { projectId: 'project-1', taskId: 'task-1' }, status: 'sent' }]);
+    runtime.stop();
+    await runtime.flush();
+  });
+
+  it('applies explicit selection and keeps the existing directory query', async () => {
+    const { runtime, openCode } = createRuntime();
+    await runtime.enqueue(SESSION, DIRECTORY, scheduled('project-1', { sendConfig: { providerID: 'openai', modelID: 'chosen', agent: 'plan' } }));
+    await settle();
+    expect(openCode.state.switched.map((entry) => entry.body)).toEqual([{ model: { providerID: 'openai', id: 'chosen' } }, { agent: 'plan' }]);
+    const promptCall = openCode.fetchImpl.mock.calls.find(([url]) => new URL(url).pathname.endsWith('/prompt'));
+    expect(new URL(promptCall[0]).searchParams.get('directory')).toBe(DIRECTORY);
+    runtime.stop();
+    await runtime.flush();
+  });
+
+  it('supports an agent override without switching the target model', async () => {
+    const { runtime, openCode } = createRuntime();
+    await runtime.enqueue(SESSION, DIRECTORY, scheduled('project-1', { sendConfig: { agent: 'plan' } }));
+    await settle();
+    expect(openCode.state.switched.map((entry) => entry.body)).toEqual([{ agent: 'plan' }]);
+    runtime.stop();
+    await runtime.flush();
+  });
+
+  it('keeps an agent-only override across persistence and restart', async () => {
+    const first = createRuntime();
+    first.openCode.state.active = { [SESSION]: { type: 'running' } };
+    await first.runtime.enqueue(SESSION, DIRECTORY, scheduled('project-1', { sendConfig: { agent: 'plan' } }));
+    first.runtime.stop();
+    await first.runtime.flush();
+    const second = createRuntime({ dataDir: first.dataDir });
+    await second.runtime.load();
+    expect(second.runtime.sessionSnapshot(SESSION).items[0].sendConfig).toEqual({ agent: 'plan' });
+    second.runtime.start();
+    await settle();
+    expect(second.openCode.state.switched.map((entry) => entry.body)).toEqual([{ agent: 'plan' }]);
+    expect(second.openCode.state.sent).toHaveLength(1);
+    second.runtime.stop();
+    await second.runtime.flush();
+  });
+
+  it.each([404, 409])('drops a target refusal %s without holding ordinary items behind it', async (statusCode) => {
+    const results = [];
+    const { runtime, openCode } = createRuntime({
+      beforeScheduledTaskSend: async () => { throw Object.assign(new Error('Scheduled target is unavailable'), { statusCode }); },
+      onScheduledTaskResult: (_task, status) => results.push(status),
+    });
+    await runtime.enqueue(SESSION, DIRECTORY, scheduled());
+    await runtime.enqueue(SESSION, DIRECTORY, item({ text: 'ordinary' }));
+    await settle();
+    expect(results).toEqual(['failed']);
+    expect(openCode.state.sent[0].body.text).toBe('ordinary');
+    runtime.stop();
+    await runtime.flush();
+  });
+
+  it.each([
+    { operation: 'prompt', status: 500 },
+    { operation: 'model', status: 500 },
+    { operation: 'model', status: 404 },
+    { operation: 'model', status: 409 },
+    { operation: 'target lookup', status: 503 },
+  ])('uses the ordinary retry policy for scheduled $operation failure $status', async ({ operation, status }) => {
+    const results = [];
+    let checks = 0;
+    const { runtime, openCode, emit } = createRuntime({
+      retryDelayMs: () => 100,
+      beforeScheduledTaskSend: async () => {
+        checks += 1;
+        if (operation === 'target lookup' && checks === 1) throw Object.assign(new Error('upstream unavailable'), { statusCode: 503 });
+      },
+      onScheduledTaskResult: (_task, status) => results.push(status),
+    });
+    runtime.start();
+    openCode.state.failStatus = status;
+    if (operation === 'prompt') openCode.state.failNext = /\/prompt$/;
+    if (operation === 'model') openCode.state.failNext = /\/model$/;
+    await runtime.enqueue(SESSION, DIRECTORY, operation === 'model'
+      ? scheduled('project-1', { sendConfig: { providerID: 'openai', modelID: 'chosen' } })
+      : scheduled());
+    await runtime.enqueue(SESSION, DIRECTORY, item({ text: 'ordinary' }));
+    await settle();
+    expect(runtime.sessionSnapshot(SESSION).items).toHaveLength(2);
+    expect(results).toEqual([]);
+    expect(openCode.state.sent).toEqual([]);
+    await expect(runtime.enqueue(SESSION, DIRECTORY, scheduled())).rejects.toMatchObject({ status: 409 });
+    await settle(130);
+    expect(checks).toBe(2);
+    expect(results).toEqual(['sent']);
+    expect(openCode.state.sent.map((entry) => entry.body.text)).toEqual(['follow up']);
+    emit({ type: 'session.status', properties: { sessionID: SESSION, status: { type: 'idle' } } });
+    await settle();
+    expect(openCode.state.sent.map((entry) => entry.body.text)).toEqual(['follow up', 'ordinary']);
+    runtime.stop();
+    await runtime.flush();
+  });
+
+  it('rejects scheduled takes, leaves them in bulk take, and allows reorder and remove', async () => {
+    const results = [];
+    const { runtime, openCode } = createRuntime({ onScheduledTaskResult: (task, status) => results.push({ task, status }) });
+    openCode.state.active = { [SESSION]: { type: 'running' } };
+    const first = await runtime.enqueue(SESSION, DIRECTORY, scheduled());
+    const ordinary = await runtime.enqueue(SESSION, DIRECTORY, item());
+    const second = await runtime.enqueue(SESSION, DIRECTORY, scheduled('project-1', { scheduledTask: { projectId: 'project-1', taskId: 'task-2' } }));
+    await runtime.reorder(SESSION, [second.itemId, ordinary.itemId, first.itemId]);
+    await expect(runtime.take(SESSION, first.itemId)).rejects.toMatchObject({ status: 409 });
+    expect((await runtime.takeAll(SESSION)).items.map((entry) => entry.id)).toEqual([ordinary.itemId]);
+    expect(runtime.sessionSnapshot(SESSION).items.map((entry) => entry.id)).toEqual([second.itemId, first.itemId]);
+    expect(results).toEqual([]);
+    await runtime.remove(SESSION, second.itemId);
+    expect(results).toEqual([{ task: { projectId: 'project-1', taskId: 'task-2' }, status: 'cancelled' }]);
+    runtime.stop();
+    await runtime.flush();
+  });
+
+  it('ignores creation-only policy fields on stored scheduled provenance', () => {
+    const parsed = parseQueuedItemInput(scheduled('project-1', {
+      scheduledTask: { projectId: 'project-1', taskId: 'task-1', goalEnabled: true, goalTokenBudget: 5000, permissionAutoAccept: true },
+    }));
+    expect(parsed.scheduledTask).toEqual({ projectId: 'project-1', taskId: 'task-1' });
+  });
+
+  it('cancels only the requested task and survives a restart with provenance', async () => {
+    const results = [];
+    const first = createRuntime({ onScheduledTaskResult: (_task, status) => results.push(status) });
+    first.openCode.state.active = { [SESSION]: { type: 'running' } };
+    await first.runtime.enqueue(SESSION, DIRECTORY, scheduled());
+    await first.runtime.enqueue(SESSION, DIRECTORY, item());
+    first.runtime.stop();
+    await first.runtime.flush();
+    const second = createRuntime({ dataDir: first.dataDir, onScheduledTaskResult: (_task, status) => results.push(status) });
+    await second.runtime.load();
+    expect(second.runtime.sessionSnapshot(SESSION).items[0].scheduledTask).toEqual({ projectId: 'project-1', taskId: 'task-1' });
+    await second.runtime.cancelScheduledTask('project-1', 'task-1');
+    expect(second.runtime.sessionSnapshot(SESSION).items).toHaveLength(1);
+    expect(results).toEqual(['cancelled']);
+    second.runtime.stop();
+    await second.runtime.flush();
+  });
+});
+
 describe('auto routing', () => {
   it('switches a queued prompt and a queued command onto the routed model and agent', async () => {
     const resolveAutoSelection = vi.fn(async ({ model }) => (model?.id === 'auto'

package/server/lib/notifications/apns-runtime.js

@@ -43,9 +43,8 @@ export const createApnsRuntime = (deps) => {
     http2,
     APNS_TOKENS_FILE_PATH,
     readSettingsFromDiskMigrated,
-    writeSettingsToDisk,
-    // Strict settings reader gating identity regeneration (see signing-key.js).
-    readSettingsStrict,
+    // Host relay identity keys, shared with the private relay (relay/key-store.js).
+    relayKeyStore,
   } = deps;
 
   let persistLock = Promise.resolve();
@@ -55,8 +54,8 @@ export const createApnsRuntime = (deps) => {
   let warnedUnconfigured = false;
 
   // ---------------------------------------------------------------------------
-  // Per-server relay signing identity (ECDSA P-256). Auto-generated + persisted in settings
-  // (mirrors getOrCreateVapidKeys). The relay derives serverId = SHA-256(publicKey), verifies
+  // Per-server relay signing identity (ECDSA P-256). Auto-generated + persisted by
+  // relay/key-store.js. The relay derives serverId = SHA-256(publicKey), verifies
   // each request's signature, and only delivers to tokens this server registered — so a leaked
   // device token alone can't be used to push. Zero-config: the keypair generates on first use.
   // ---------------------------------------------------------------------------
@@ -65,7 +64,7 @@ export const createApnsRuntime = (deps) => {
   // relay identity — same keypair, same storage, same serverId derivation).
   const getOrCreateRelayKeypair = async () => {
     if (cachedRelayKey) return cachedRelayKey;
-    cachedRelayKey = await getOrCreateRelaySigningKeypair({ crypto, readSettingsFromDiskMigrated, writeSettingsToDisk, readSettingsStrict });
+    cachedRelayKey = await getOrCreateRelaySigningKeypair({ crypto, relayKeyStore });
     return cachedRelayKey;
   };
 

package/server/lib/notifications/apns-runtime.test.js

@@ -28,9 +28,25 @@ const createMemoryFs = () => {
   };
 };
 
+// In-memory relay key store: the auto-generated signing keypair persists and
+// reads back; `generations` counts how many keypairs were minted.
+const makeMemoryKeyStore = () => {
+  const slots = {};
+  const store = {
+    generations: 0,
+    getOrCreate: async (slot, generate) => {
+      if (!slots[slot]) {
+        store.generations += 1;
+        slots[slot] = await generate();
+      }
+      return slots[slot];
+    },
+  };
+  return store;
+};
+
 const makeDeps = (overrides = {}) => {
-  // Stateful settings so the auto-generated relay signing keypair persists + reads back.
-  let settings = {};
+  const settings = {};
   return {
     fsPromises: createMemoryFs(),
     path: { dirname: () => '/tmp' },
@@ -38,7 +54,7 @@ const makeDeps = (overrides = {}) => {
     http2: { connect: vi.fn(() => { throw new Error('http2 must not be used in relay mode'); }) },
     APNS_TOKENS_FILE_PATH: '/tmp/apns-tokens.json',
     readSettingsFromDiskMigrated: vi.fn(async () => settings),
-    writeSettingsToDisk: vi.fn(async (next) => { settings = next; }),
+    relayKeyStore: makeMemoryKeyStore(),
     ...overrides,
   };
 };
@@ -144,7 +160,7 @@ describe('apns runtime relay mode (default)', () => {
     expect(keys.length).toBeGreaterThanOrEqual(2);
     expect(keys.every((k) => k.x === keys[0].x && k.y === keys[0].y)).toBe(true);
     // Keypair was generated + persisted exactly once.
-    expect(deps.writeSettingsToDisk).toHaveBeenCalledTimes(1);
+    expect(deps.relayKeyStore.generations).toBe(1);
   });
 
   it('honors an explicit sandbox environment override for every token', async () => {

package/server/lib/openchamber-control/DOCUMENTATION.md

@@ -13,8 +13,18 @@ other.
   scheduled-task action allowlist. `actions.js` marks CLI-only actions with
   `agentExposed: false` (currently `schedule.status`); the agent tool consumes
   the filtered `OPENCHAMBER_AGENT_TOOL_*` exports. `schedule.toggle` requires
-  the `disabled` boolean and replaces separate enable/disable actions;
+  the `disabled` boolean and replaces separate enable/disable actions; its
+  `enabled` is the saved state, never the requested one. Loop tasks and the
+  refusal to enable a repository loop are the scheduled-task service's rules
+  (`../scheduled-tasks/DOCUMENTATION.md`, *Local approval*).
   `schedule.list` also returns scheduler status as `scheduler`.
+  `schedule.update` patches a task in place: only the fields the call names
+  change, the id and run state stay, and a task driven by a loop file is
+  refused (the file is its source).
+  `schedule.create` and `schedule.update` accept `targetSessionId`, validated
+  by the scheduled-task service. An empty update clears the target. Create
+  without a model inherits the target selection; an explicit agent overrides
+  it. A task without a target still requires a model.
 - `routes.js` is the authenticated CLI HTTP adapter. It forwards one action,
   preserves service status and partial-result details, and propagates request
   cancellation.
@@ -53,6 +63,14 @@ other.
 - Send and fork dispatches without an explicit model/agent/variant reuse the
   target session's last user-message selection before falling back to the
   configured defaults; only session creation resolves defaults directly.
+- `session.create` with `pullRequest` passes the number, and `worktree` and
+  `branch` as folder and local-branch names, to the session service, which
+  creates the worktree through the injected `createChangeRequestWorktree`
+  (the Git routes' contributor pipeline) before any session exists. A
+  malformed number, or `startRef`/`setUpstream` beside it, is a 400; a
+  server without that pipeline answers 501 and never makes a plain branch
+  worktree instead; a provider or transfer refusal keeps its status and
+  message, and no session is created.
 - Default agents resolve from the owning project before global settings and
   OpenCode defaults. Directory-based requests identify the project before
   creating a worktree; existing linked worktrees resolve through Git's primary

package/server/lib/openchamber-control/actions.js

@@ -19,7 +19,8 @@ export const OPENCHAMBER_CONTROL_ACTION_DEFINITIONS = Object.freeze([
   { action: 'session.link', title: 'Link a change or issue to a session', description: 'Link a change under review (pull or merge request) or an issue, on any service, to a session; requires link, sessionId defaults to the current session. Each link is added beside the others; linking one that is already there updates its title instead of adding it twice. Links are only added; the user removes them' },
   { action: 'schedule.status', title: 'Check scheduler status', description: 'Check scheduler status; no parameters', agentExposed: false },
   { action: 'schedule.list', title: 'List scheduled tasks', description: 'List tasks and scheduler status; scope with projectId or directory' },
-  { action: 'schedule.create', title: 'Create a scheduled task', description: 'Create task; requires name, prompt, model, and one schedule selector' },
+  { action: 'schedule.create', title: 'Create a scheduled task', description: 'Create task; requires name, prompt, one schedule selector, and model unless targetSessionId is set. targetSessionId reuses a session; without model it keeps that session selection' },
+  { action: 'schedule.update', title: 'Change a scheduled task', description: 'Change taskId in place, keeping its id and run state; pass only what changes: name, prompt, model, variant, agent, targetSessionId (empty clears it), a schedule selector, timezone, disabled' },
   { action: 'schedule.run', title: 'Run a scheduled task', description: 'Run taskId; scope with projectId or directory' },
   { action: 'schedule.delete', title: 'Delete a scheduled task', description: 'Delete taskId; scope with projectId or directory' },
   { action: 'schedule.toggle', title: 'Enable or disable a scheduled task', description: 'Enable or disable taskId; requires the disabled boolean' },

package/server/lib/openchamber-control/service.js

@@ -1,3 +1,4 @@
+import { asNonEmptyString } from '../shared/guards.js';
 import path from 'node:path';
 import { OpenCode } from '@opencode/client';
 import { OpenChamberControlError, asControlError } from './error.js';
@@ -10,17 +11,12 @@ const WAIT_POLL_INTERVAL_MS = 500;
 // One service, both capabilities: which tool asked is the caller's concern.
 const CONTROL_ACTIONS = new Set(OPENCHAMBER_ALL_ACTIONS);
 const SCHEDULE_TASK_ID_ACTIONS = new Set([
+  'schedule.update',
   'schedule.run',
   'schedule.delete',
   'schedule.toggle',
 ]);
 
-const asNonEmptyString = (value) => {
-  if (typeof value !== 'string') return null;
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : null;
-};
-
 const positiveInteger = (value, fallback, field) => {
   if (value === undefined || value === null) return fallback;
   const number = Number(value);
@@ -120,7 +116,8 @@ const buildScheduledTask = (input) => {
   const prompt = asNonEmptyString(input.prompt);
   if (!name) throw new OpenChamberControlError('name is required', 400);
   if (!prompt) throw new OpenChamberControlError('prompt is required', 400);
-  const model = parseModel(input.model);
+  const targetSessionId = asNonEmptyString(input.targetSessionId);
+  const model = targetSessionId && input.model === undefined ? { useDefaults: !asNonEmptyString(input.agent) } : parseModel(input.model);
   const goalTokenBudget = input.goalTokenBudget;
   if (goalTokenBudget !== undefined && input.goal !== true) {
     throw new OpenChamberControlError('goalTokenBudget requires goal', 400);
@@ -128,7 +125,7 @@ const buildScheduledTask = (input) => {
   if (goalTokenBudget !== undefined && (!Number.isSafeInteger(goalTokenBudget) || goalTokenBudget < 1000 || goalTokenBudget > 100_000_000)) {
     throw new OpenChamberControlError('goalTokenBudget must be from 1000 to 100000000', 400);
   }
-  return {
+  const task = {
     name,
     enabled: input.disabled !== true,
     schedule: buildSchedule(input),
@@ -141,6 +138,70 @@ const buildScheduledTask = (input) => {
       ...(goalTokenBudget !== undefined ? { goalTokenBudget } : {}),
     },
   };
+  if (input.targetSessionId !== undefined) task.targetSessionId = targetSessionId ?? input.targetSessionId;
+  return task;
+};
+
+/**
+ * `schedule.update`: the stored task with only the fields the call names
+ * changed. The id and the run state stay, so history and references survive;
+ * the scheduler re-arms from the new schedule on save.
+ */
+const patchScheduledTask = (existing, input) => {
+  if (existing.loopFile) {
+    throw new OpenChamberControlError(`This task comes from ${existing.loopFile}; change that file instead`, 409);
+  }
+  const execution = { ...existing.execution };
+  if (input.prompt !== undefined) {
+    const prompt = asNonEmptyString(input.prompt);
+    if (!prompt) throw new OpenChamberControlError('prompt cannot be empty', 400);
+    execution.prompt = prompt;
+  }
+  if (input.model !== undefined) {
+    Object.assign(execution, parseModel(input.model));
+    // A thinking level belongs to the model it was chosen for.
+    delete execution.variant;
+    delete execution.useDefaults;
+  }
+  for (const field of ['variant', 'agent']) {
+    if (input[field] === undefined) continue;
+    const value = asNonEmptyString(input[field]);
+    if (value) execution[field] = value;
+    else delete execution[field];
+    if (field === 'agent' && value && (input.targetSessionId || existing.targetSessionId)) delete execution.useDefaults;
+  }
+  if (typeof input.goal === 'boolean') {
+    if (input.goal) execution.goalEnabled = true;
+    else {
+      delete execution.goalEnabled;
+      delete execution.goalTokenBudget;
+    }
+  }
+  if (input.goalTokenBudget !== undefined) {
+    if (!execution.goalEnabled) throw new OpenChamberControlError('goalTokenBudget requires goal', 400);
+    if (!Number.isSafeInteger(input.goalTokenBudget) || input.goalTokenBudget < 1000 || input.goalTokenBudget > 100_000_000) {
+      throw new OpenChamberControlError('goalTokenBudget must be from 1000 to 100000000', 400);
+    }
+    execution.goalTokenBudget = input.goalTokenBudget;
+  }
+  let name = existing.name;
+  if (input.name !== undefined) {
+    name = asNonEmptyString(input.name);
+    if (!name) throw new OpenChamberControlError('name cannot be empty', 400);
+  }
+  const replacesSchedule = ['daily', 'weekly', 'once', 'cron'].some((key) => asNonEmptyString(input[key]));
+  const timezone = asNonEmptyString(input.timezone);
+  const schedule = replacesSchedule
+    ? buildSchedule(input)
+    : (timezone ? { ...existing.schedule, timezone } : existing.schedule);
+  return {
+    id: existing.id,
+    targetSessionId: input.targetSessionId === undefined ? existing.targetSessionId : input.targetSessionId,
+    name,
+    enabled: typeof input.disabled === 'boolean' ? !input.disabled : existing.enabled,
+    schedule,
+    execution,
+  };
 };
 
 export const createOpenChamberControlService = (dependencies) => {
@@ -262,18 +323,36 @@ export const createOpenChamberControlService = (dependencies) => {
     return asPublicStatus(statuses[sessionID]);
   };
 
-  // `order: 'desc'` puts the newest messages in the limited page;
-  // extractTextMessages re-sorts them oldest-first for the caller.
+  // The message list is cursor-paginated and `order: 'desc'` puts the newest
+  // messages in the page, so a single call returns only the recent tail.
+  // `all: true` walks `cursor.next` until the history is exhausted; a bounded
+  // `limit` stops once enough text messages are collected. Later pages carry
+  // the order inside the cursor, and OpenCode rejects a cursor combined with
+  // `order`, so only the first page sends it. An empty page or a repeated
+  // cursor ends the walk. `extractTextMessages` sorts the gathered records
+  // oldest-first for the caller.
+  const MESSAGE_PAGE_LIMIT = 200;
   const sessionMessages = async (client, sessionID, role, limit) => {
     const fetchLimit = limit === undefined ? undefined : Math.max(100, limit * 4);
-    let response = await client.message.list({ sessionID, ...(fetchLimit ? { limit: fetchLimit, order: 'desc' } : {}) });
-    let raw = Array.isArray(response?.data) ? response.data : [];
-    let messages = extractTextMessages(raw, role);
-    if (limit !== undefined && messages.length < limit && raw.length >= fetchLimit) {
-      response = await client.message.list({ sessionID });
-      raw = Array.isArray(response?.data) ? response.data : [];
-      messages = extractTextMessages(raw, role);
+    const collected = [];
+    const seenCursors = new Set();
+    let cursor;
+    for (;;) {
+      const response = await client.message.list({
+        sessionID,
+        limit: fetchLimit ?? MESSAGE_PAGE_LIMIT,
+        ...(cursor ? { cursor } : fetchLimit ? { order: 'desc' } : {}),
+      });
+      const raw = Array.isArray(response?.data) ? response.data : [];
+      collected.push(...raw);
+      const next = asNonEmptyString(response?.cursor?.next);
+      if (!next || raw.length === 0 || seenCursors.has(next)) break;
+      // A bounded read only needs enough pages to project `limit` text messages.
+      if (limit !== undefined && extractTextMessages(collected, role).length >= limit) break;
+      seenCursors.add(next);
+      cursor = next;
     }
+    const messages = extractTextMessages(collected, role);
     return limit === undefined ? messages : messages.slice(-limit);
   };
 
@@ -368,6 +447,10 @@ export const createOpenChamberControlService = (dependencies) => {
     if (input.timeout !== undefined && input.wait !== true) throw new OpenChamberControlError('timeout requires wait', 400);
     if (input.lastAssistant === true && input.wait !== true) throw new OpenChamberControlError('lastAssistant requires wait', 400);
     assertSingleScope(input);
+    // Only a new session gets a worktree; elsewhere the number would be ignored.
+    if (input.pullRequest !== undefined && action !== 'session.create') {
+      throw new OpenChamberControlError('pullRequest applies only to session.create', 400);
+    }
     const sessionID = asNonEmptyString(input.sessionId);
     const parentSessionID = asNonEmptyString(contextSessionId);
     const returnResult = input.returnResult === true;
@@ -395,6 +478,16 @@ export const createOpenChamberControlService = (dependencies) => {
       ...(typeof input.setUpstream === 'boolean' ? { setUpstream: input.setUpstream } : {}),
       ...(asNonEmptyString(input.messageId) ? { messageId: input.messageId.trim() } : {}),
     };
+    // A pull request makes a worktree of its own, so its branch name (and a
+    // start ref the session service refuses) travel without a worktree name.
+    if (input.pullRequest !== undefined) {
+      payload.pullRequest = input.pullRequest;
+      if (!payload.worktree) {
+        payload.worktree = {};
+        if (asNonEmptyString(input.branch)) payload.worktree.branchName = input.branch.trim();
+        if (asNonEmptyString(input.startRef)) payload.worktree.startRef = input.startRef.trim();
+      }
+    }
     const startedAt = now();
     let result;
     if (action === 'session.create') {
@@ -488,7 +581,6 @@ export const createOpenChamberControlService = (dependencies) => {
       parameters.url = parsed.toString();
     }
 
-
     if (action === 'browser.click') {
       const selector = asNonEmptyString(input.selector);
       const text = asNonEmptyString(input.text);
@@ -648,6 +740,12 @@ export const createOpenChamberControlService = (dependencies) => {
             const result = await scheduledTaskService.upsert(projectID, buildScheduledTask(input));
             return { task: result.task, created: result.created };
           }
+          case 'schedule.update': {
+            const existing = (await scheduledTaskService.list(projectID)).find((task) => task.id === taskID);
+            if (!existing) throw new OpenChamberControlError(`Scheduled task not found: ${taskID}`, 404);
+            const result = await scheduledTaskService.upsert(projectID, patchScheduledTask(existing, input));
+            return { task: result.task, updated: true };
+          }
           case 'schedule.run':
             return scheduledTaskService.run(projectID, taskID);
           case 'schedule.delete':
@@ -656,8 +754,9 @@ export const createOpenChamberControlService = (dependencies) => {
             if (typeof input.disabled !== 'boolean') {
               throw new OpenChamberControlError('disabled is required for schedule.toggle', 400);
             }
-            const enabled = input.disabled === false;
-            return { task: await scheduledTaskService.setEnabled(projectID, taskID, enabled), enabled };
+            const task = await scheduledTaskService.setEnabled(projectID, taskID, input.disabled === false);
+            // What was saved, which is what the scheduler acts on.
+            return { task, enabled: task?.enabled === true };
           }
         }
       }