@openchambery/web 1.19.22-beta.1 → 2.0.0-beta.3

package/server/lib/permission-auto-accept/runtime.test.js

@@ -31,6 +31,18 @@ const flush = async () => {
 };
 
 describe('permission auto-accept runtime', () => {
+  it('approves a session with no explicit policy', async () => {
+    const fetchImpl = vi.fn(async (url, init = {}) => {
+      const path = new URL(url).pathname;
+      if (path === '/session/root') return Response.json({ id: 'root' });
+      if (init.method === 'POST') return Response.json({});
+      return new Response('', { status: 404 });
+    });
+    const { runtime } = createRuntime({ fetchImpl });
+    await expect(runtime.processPermission({ id: 'perm', sessionID: 'root' }, '/project')).resolves.toBe(true);
+    expect(fetchImpl.mock.calls.some(([url, init]) => new URL(url).pathname === '/session/root/permission/perm/reply' && JSON.parse(init.body).decision === 'always')).toBe(true);
+  });
+
   it('persists explicit session policies across runtime restarts', async () => {
     const first = createRuntime();
     await first.runtime.setSessionPolicy('root', true);
@@ -55,7 +67,7 @@ describe('permission auto-accept runtime', () => {
   it('fetches missing subagent lineage before replying', async () => {
     const fetchImpl = vi.fn(async (url, init = {}) => {
       const path = new URL(url).pathname;
-      if (path === '/permission') return new Response('[]');
+      if (path === '/permission/request') return new Response('[]');
       if (path === '/session/child') return Response.json({ id: 'child', parentID: 'root', directory: '/project' });
       if (init.method === 'POST') return Response.json({});
       return new Response('', { status: 404 });
@@ -65,15 +77,15 @@ describe('permission auto-accept runtime', () => {
       fetchImpl,
     });
     await expect(runtime.processPermission({ id: 'perm', sessionID: 'child' }, '/project')).resolves.toBe(true);
-    expect(fetchImpl.mock.calls.some(([url, init]) => new URL(url).pathname === '/permission/perm/reply' && init.method === 'POST')).toBe(true);
+    expect(fetchImpl.mock.calls.some(([url, init]) => new URL(url).pathname === '/session/child/permission/perm/reply' && init.method === 'POST' && JSON.parse(init.body).decision === 'always')).toBe(true);
   });
 
   it('retries a transient reply failure and deduplicates concurrent events', async () => {
     let replyAttempts = 0;
     const fetchImpl = vi.fn(async (url, init = {}) => {
       const path = new URL(url).pathname;
-      if (path === '/permission') return new Response('[]');
-      if (path === '/permission/perm/reply' && init.method === 'POST') {
+      if (path === '/permission/request') return new Response('[]');
+      if (path === '/session/root/permission/perm/reply' && init.method === 'POST') {
         replyAttempts += 1;
         return replyAttempts === 1 ? new Response('', { status: 503 }) : Response.json({});
       }
@@ -94,8 +106,8 @@ describe('permission auto-accept runtime', () => {
   it('reconciles pending permissions after reconnect', async () => {
     const fetchImpl = vi.fn(async (url, init = {}) => {
       const path = new URL(url).pathname;
-      if (path === '/permission') return Response.json([{ id: 'pending', sessionID: 'root' }]);
-      if (path === '/permission/pending/reply' && init.method === 'POST') return Response.json({});
+      if (path === '/permission/request') return Response.json([{ id: 'pending', sessionID: 'root' }]);
+      if (path === '/session/root/permission/pending/reply' && init.method === 'POST') return Response.json({});
       return Response.json({ id: 'root' });
     });
     const { connect } = createRuntime({
@@ -104,14 +116,14 @@ describe('permission auto-accept runtime', () => {
     });
     connect();
     await flush();
-    expect(fetchImpl.mock.calls.some(([url]) => new URL(url).pathname === '/permission/pending/reply')).toBe(true);
+    expect(fetchImpl.mock.calls.some(([url]) => new URL(url).pathname === '/session/root/permission/pending/reply')).toBe(true);
   });
 
   it('accepts existing pending permissions when a session policy is enabled', async () => {
     const fetchImpl = vi.fn(async (url, init = {}) => {
       const parsed = new URL(url);
       const path = parsed.pathname;
-      if (path === '/permission') {
+      if (path === '/permission/request') {
         return parsed.searchParams.get('directory') === '/project'
           ? Response.json([
             { id: 'root-pending', sessionID: 'root' },
@@ -119,19 +131,22 @@ describe('permission auto-accept runtime', () => {
           ])
           : Response.json([]);
       }
-      if (path === '/permission/root-pending/reply' && init.method === 'POST') return Response.json({});
+      if (init.method === 'POST' && path.endsWith('/reply')) return Response.json({});
       if (path === '/session/other') return Response.json({ id: 'other' });
       return new Response('', { status: 404 });
     });
-    const { runtime } = createRuntime({ fetchImpl });
+    const { runtime } = createRuntime({
+      stored: { permissionAutoAccept: { sessions: { other: false } } },
+      fetchImpl,
+    });
 
     await runtime.setSessionPolicy('root', true, '/project');
 
     const replyPaths = fetchImpl.mock.calls
       .filter(([, init]) => init?.method === 'POST')
       .map(([url]) => new URL(url).pathname);
-    expect(replyPaths).toEqual(['/permission/root-pending/reply']);
+    expect(replyPaths).toEqual(['/session/root/permission/root-pending/reply']);
     expect(fetchImpl.mock.calls.some(([url]) => new URL(url).searchParams.get('directory') === '/project')).toBe(true);
-    expect(await runtime.load()).toEqual({ sessions: { root: true } });
+    expect(await runtime.load()).toEqual({ sessions: { other: false, root: true } });
   });
 });

package/server/lib/relay/reasoning-projection.e2e.test.ts

@@ -147,7 +147,11 @@ const startFakeOpenCode = async (): Promise<{
     next();
   });
 
-  app.get('/global/event', (req, res) => {
+  // Production proxy forwards official v2 paths with `/api` restored
+  // (`toUpstreamOpenCodeApiPath`). Host mounts both `/api/global/event` and
+  // `/api/event`; fake upstream must match those upstream targets — not the
+  // pre-v2 bare `/global/event` or `/event`.
+  const writeSseFixture = (res: express.Response) => {
     res.writeHead(200, {
       'content-type': 'text/event-stream; charset=utf-8',
       'cache-control': 'no-cache',
@@ -243,9 +247,16 @@ const startFakeOpenCode = async (): Promise<{
     );
 
     res.end();
+  };
+
+  app.get('/api/global/event', (_req, res) => {
+    writeSseFixture(res);
+  });
+  app.get('/api/event', (_req, res) => {
+    writeSseFixture(res);
   });
 
-  app.get('/session/:sessionID/message', (req, res) => {
+  app.get('/api/session/:sessionID/message', (_req, res) => {
     res.json([
       {
         info: {
@@ -513,11 +524,15 @@ describe('relay reasoning projection e2e (Host filter over private relay)', () =
       for (const url of upstream.observation.urls) {
         expect(url).not.toContain('includeReasoning');
       }
-      // Sanity: upstream still saw the event + message routes.
-      expect(upstream.observation.urls.some((u) => u.includes('/global/event'))).toBe(true);
-      expect(upstream.observation.urls.some((u) => u.includes('/session/ses_1/message'))).toBe(
-        true,
-      );
+      // Sanity: upstream still saw official v2 event + message routes.
+      expect(
+        upstream.observation.urls.some(
+          (u) => u.includes('/api/global/event') || u.includes('/api/event'),
+        ),
+      ).toBe(true);
+      expect(
+        upstream.observation.urls.some((u) => u.includes('/api/session/ses_1/message')),
+      ).toBe(true);
 
       // Unauthenticated tunnel request still hits real auth gate (not open).
       const denied = await client.fetch('/api/global/event?includeReasoning=false', {

package/server/lib/scheduled-tasks/DOCUMENTATION.md

@@ -15,7 +15,7 @@ Server-owned scheduled task runtime and routes for OpenChamber-only automation.
   - Next-run computation (daily/weekly/cron compatibility)
   - Timer scheduling and queueing
   - Concurrency controls
-  - Session create → archive → goal/prompt/command execution
+  - Session create → goal/prompt/command execution
   - Emits OpenChamber task-run events
   - Isolates project sync failures, retries each failed project up to three times,
     and clears pending retries during shutdown
@@ -69,6 +69,14 @@ Server-owned scheduled task runtime and routes for OpenChamber-only automation.
   - `runNow(projectId, taskId)`
   - `observeSessionEvent(event)`
 
+Isolation dependencies (required for sidebar hide):
+
+- `persistSessionMetadata(sessionID, patch)` — Host store write. Missing
+  persist refuses the run **before** `session.create`. Persist failure after
+  create fails the run before prompt.
+- `onSystemSessionPersisted({ sessionID, directory, metadata })` — drop the
+  session from the sidebar index immediately after Host commit.
+
 Dependencies include optional `runHistoryStore` with:
 
 - `startRun(record)`
@@ -186,44 +194,55 @@ Every actual run (timer or manual):
 4. Create an OpenCode session with:
    - title: `[Scheduled] ${taskName} yyyy-LL-dd HH:mm` (total length ≤ 120)
    - metadata: `openchamber.scheduledTask = { projectID, taskID, runID, name }`
-   - SDK/HTTP calls receive `{ signal }` as the second request-options argument
-     (`client.session.create(params, { signal })`, same for `update` /
-     `command` / `command.list`; raw `fetch` for goal PATCH and `prompt_async`
-     pass `signal` in `RequestInit`).
-5. `attachSession(runID, sessionID)` immediately after create.
-6. Archive the session via SDK `client.session.update({ sessionID, directory, time: { archived } })`.
-   - 404 receives one short bounded retry (also signal-aware); other failures
-     abort without prompt.
-   - If attach fails, the runtime still attempts archive, then fails the run.
- 7. Only after a successful archive: goal metadata PATCH (preserving the
-    `scheduledTask` marker together with `goal`), then command or `prompt_async`.
-    Non-cancellable async gaps (small-model distill, objective file write) check
-    `signal.throwIfAborted()` before continuing so a timed-out run never prompts.
-    **Admission is not completion:** `prompt_async` / command return when the
+    - SDK/HTTP calls receive `{ signal }` as the second request-options argument
+      (`client.session.create(params, { signal })`, same for `prompt` /
+      `command` / `command.list`; raw `fetch` for goal PATCH
+      pass `signal` in `RequestInit`).
+ 5. `attachSession(runID, sessionID)` immediately after create.
+    - If attach fails, the runtime fails the run without prompting.
+  6. When `goalEnabled`: refuse before OpenCode ready / session create if
+      `persistSessionGoal` is not injected; otherwise write objective file,
+      persist an active goal into the Host session-metadata store, optionally
+      notify `onGoalPersisted` to arm the goal loop, then command or
+      `session.prompt`. Non-cancellable async gaps (small-model distill,
+      objective file write) check `signal.throwIfAborted()` before continuing so
+      a timed-out run never prompts.
+    **Admission is not completion:** `session.prompt` / command return when the
     turn is accepted, not when the agent finishes.
- 8. Wait for the real session outcome (bounded by the same watchdog):
-    - Poll `session.status` + `session.messages` until the session is idle and
-      the tail is a settled assistant turn (completed, or incomplete-but-stable
-      while idle). Assistant `error` (including abort) finalizes as `error`.
-    - Goal-enabled runs poll `session.get` for terminal goal status
-      (`complete` → success; `blocked` / `budgetLimited` → error) and do not
-      finish on the first idle between goal turns.
-    - `durationMs` / `finishedAt` are wall-clock from run start through this
-      settlement — not the prompt admission latency.
- 9. On watchdog timeout after a session exists: immediately throw the canonical
+  7. Wait for the real session outcome (bounded by the same watchdog):
+     - Poll `session.active` + `message.list` until the session is idle and
+       the **latest-side** message page settles. Settlement always uses
+       `message.list({ limit: 50, order: 'desc' })` (newest first) — never
+       `order: 'asc'` page-0 + `at(-1)`, which reads an old page once the
+       session exceeds the limit.
+     - Real terminal success requires an assistant tail with `time.completed`
+       and finish not `tool-calls` (prefer `finish: 'stop'`). `finish:
+       'tool-calls'`, incomplete assistants (no `time.completed`), and
+       non-assistant tails such as `model-switched` never succeed — including
+       after multiple incomplete idle probes.
+     - `session.active` / `message.list` failures stay **unknown** (keep
+       polling under the watchdog); they never masquerade as idle success.
+     - Assistant `error` (and terminal finish `error` / `length` /
+       `content-filter`) finalizes as `error`.
+      - Goal-enabled runs: settle via Host goal terminal status when the store
+        seam is available (`readSessionMetadata` preferred over OpenCode
+        `session.get`). Store read failure is never empty-goal success.
+     - `durationMs` / `finishedAt` are wall-clock from run start through this
+       settlement — not the prompt admission latency.
+ 8. On watchdog timeout after a session exists: immediately throw the canonical
     `schedule run timed out` without awaiting non-cancellable helper work. A
     once-only abort listener registered after session create starts best-effort
-    `client.session.abort({ sessionID, directory })` as soon as the watchdog
-    aborts the signal (or right after create if the signal already aborted).
-    Abort failures must not replace the timeout error. Successful runs and
-    ordinary non-timeout failures never call session abort.
- 10. Finalize history with the ultimate run status (timeout → `error` with
+     `client.session.interrupt({ sessionID, continue: false })` as soon as the watchdog
+     aborts the signal (or right after create if the signal already aborted).
+     Interrupt failures must not replace the timeout error. Successful runs and
+     ordinary non-timeout failures never call session interrupt.
+ 9. Finalize history with the ultimate run status (timeout → `error` with
     `schedule run timed out`; assistant/goal failure → `error` with the
     recorded reason). An already-attached `session_id` remains on the history
     row so the session stays openable from history. Task state persistence
     failures also finalize history as `error`. A failed history finalize
     returns error and may leave a `running` row for next-start convergence.
-  11. `lastSessionId` is written on the task state whenever the run has a
+ 10. `lastSessionId` is written on the task state whenever the run has a
      session (success or error). If the run has no session, omit
      `lastSessionId` from the patch so a previous value is preserved. Full
      association still lives in the history table; history rows are not
@@ -239,14 +258,35 @@ that same history session. `observeSessionEvent` corrects **only task state**
 
 - `session.status` busy/retry while `lastStatus` is `error` or `success` →
   `lastStatus` `running`, clear `lastError`, keep/set `lastSessionId`
-- later `session.idle` (or idle `session.status`) with a success snapshot →
-  `lastStatus` `success`
+- later `session.idle` (or idle `session.status`) with a success snapshot from
+  `session.active` + latest-side `message.list` → `lastStatus` `success`
 - do not change `lastRunAt` / `lastDurationMs` / `nextRunAt`
+- history rows are never rewritten; `finishRun` is not called again
 
 A live run (`runningTaskKeys`) owns settlement; the observer is a no-op while
 the task is in `runningTaskKeys`. Idle correction is a no-op if `lastStatus`
-is already `success`, or if the snapshot is still error/busy/unknown. Observer
-failures are logged and must not throw out of the event bus.
+is already `success`, or if the snapshot is still error/busy/unknown
+(`session.active` failure and goal-unsupported goal tasks stay unknown).
+Observer failures are logged and must not throw out of the event bus.
+
+## Goal safety gating
+
+Session goal Host state is advertised by
+`packages/web/server/lib/session-goal/capability.js` as `{ supported: true }`.
+Goal records live in the OpenChamber session-metadata store (same seam as
+manual UI / `session-goal` runtime). Scheduled runs inject
+`persistSessionGoal`, `readSessionMetadata`, and optional `onGoalPersisted`
+from `server/index.js`.
+
+| Path | Behavior |
+|---|---|
+| `PUT` scheduled task / managed-tool create·update with `execution.goalEnabled` | Allowed when capability supported |
+| Existing `goalEnabled` task due or manual run | Requires `persistSessionGoal`; without it fail **before** OpenCode ready / session create / objective write / prompt; with it write objective + active goal then prompt |
+| Ordinary non-goal task | Unchanged |
+| Post-run observer on a goal-enabled task | Prefer Host store goal terminal status; never invent success from assistant-tail idle alone when goal is active |
+
+Do not treat objective-file hints or first-turn assistant idle as a registered
+goal success without a store-backed goal record.
 
 Run start also emits `scheduled-task-ran` with `status: running` as soon as
 task state is persisted, so the outer task list can show in-progress before
@@ -255,21 +295,21 @@ the session is attached.
 ## Watchdog cancel / upstream abort
 
 - Timeout path: abort the per-run signal → cancel in-flight cancellable
-  SDK/HTTP → start best-effort OpenCode `session.abort` via the create-time
+  SDK/HTTP → start best-effort OpenCode `session.interrupt` via the create-time
   abort listener (independent of whether the current await is cancellable) →
   **do not wait** for non-cancellable helpers (small-model distill /
   `writeObjective`) to finish → history and task state finalize as `error`
   with `schedule run timed out` within the watchdog bound. The detached
   `runPromise` is settled with a catch so late rejections are not unhandled.
 - When uncancellable helper work eventually finishes, post-await
-  `throwIfAborted` gates stop goal PATCH / command / `prompt_async`.
-- Non-timeout failures: no timeout abort; no forced `session.abort` from the
+  `throwIfAborted` gates stop goal PATCH / command / `session.prompt`.
+- Non-timeout failures: no timeout abort; no forced `session.interrupt` from the
   watchdog.
 - Runtime `stop()` clears timers, project-sync retries, and the queue only; it
   does not abort in-flight run controllers.
 - Remaining non-cancellable edges: work already fully admitted and completed
   HTTP-wise before timeout cannot be rolled back by aborting the HTTP request
-  alone; `session.abort` is the upstream stop for admitted command/prompt
+  alone; `session.interrupt` is the upstream stop for admitted command/prompt
   execution. Small-model distillation and objective file writes are not passed
   a signal; the watchdog does not await them, and abort gates block later
   stages after they complete.

package/server/lib/scheduled-tasks/managed-tool-route.js

@@ -1,3 +1,8 @@
+import {
+  getSessionGoalCapability,
+  isSessionGoalSupported,
+  sessionGoalUnavailableMessage,
+} from '../session-goal/capability.js';
 import { MANAGED_SCHEDULED_TASK_TOOL_PATH } from './managed-tool-contract.js';
 
 const MAX_ID_LENGTH = 512;
@@ -263,6 +268,17 @@ export const registerScheduledTaskToolRoute = (app, dependencies) => {
         : new Set(['taskId', 'name', 'enabled', 'schedule', 'execution']), 'input');
       validateTaskInputFields(input);
 
+      const refuseGoalExecution = (execution) => {
+        if (execution?.goalEnabled !== true || isSessionGoalSupported()) {
+          return null;
+        }
+        const capability = getSessionGoalCapability();
+        const error = new Error(sessionGoalUnavailableMessage(capability));
+        error.statusCode = 501;
+        error.capability = capability;
+        return error;
+      };
+
       if (operation === 'update') {
         const patch = {
           ...(input.name === undefined ? {} : { name: input.name }),
@@ -270,6 +286,8 @@ export const registerScheduledTaskToolRoute = (app, dependencies) => {
           ...(input.schedule === undefined ? {} : { schedule: input.schedule }),
           ...(input.execution === undefined ? {} : { execution: input.execution }),
         };
+        const goalRefusal = refuseGoalExecution(patch.execution);
+        if (goalRefusal) throw goalRefusal;
         const patched = await projectConfigRuntime.patchScheduledTask(project.id, taskID, patch);
         if (!patched?.task) return res.status(404).json({ error: 'Schedule not found' });
         const schedulerSynced = await syncAfterMutation(project.id, operation);
@@ -285,6 +303,8 @@ export const registerScheduledTaskToolRoute = (app, dependencies) => {
       if (operation === 'create' && (!execution.providerID || !execution.modelID)) {
         throw new Error('execution.providerID and execution.modelID are required from the user message or input');
       }
+      const goalRefusal = refuseGoalExecution(execution);
+      if (goalRefusal) throw goalRefusal;
       const taskInput = {
         ...(input.name === undefined ? {} : { name: input.name }),
         ...(input.enabled === undefined ? {} : { enabled: input.enabled }),
@@ -296,7 +316,17 @@ export const registerScheduledTaskToolRoute = (app, dependencies) => {
       return res.status(201).json({ projectId: project.id, created: upserted.created, task: upserted.task, tasks: upserted.tasks, schedulerSynced });
     } catch (error) {
       const statusCode = error?.statusCode || (isValidationError(error?.message || '') ? 400 : 500);
-      if (statusCode >= 500) logger.error?.('[ScheduledTaskTool] request failed', { operation: req.body?.operation, statusCode });
+      if (statusCode >= 500 && statusCode !== 501) {
+        logger.error?.('[ScheduledTaskTool] request failed', { operation: req.body?.operation, statusCode });
+      }
+      if (statusCode === 501) {
+        const capability = error?.capability || getSessionGoalCapability();
+        return res.status(501).json({
+          error: error?.message || sessionGoalUnavailableMessage(capability),
+          reason: capability.reason,
+          capability,
+        });
+      }
       return res.status(statusCode).json({ error: statusCode >= 500 ? 'Failed to manage schedule' : (error?.message || 'Invalid schedule request') });
     }
   });

package/server/lib/scheduled-tasks/managed-tool-route.test.js

@@ -265,4 +265,27 @@ describe('managed scheduled task tool route', () => {
       expect(oversized.status).toBe(413);
     } finally { fixture.restore(); }
   });
+
+  it('allows create/update with goalEnabled when Host goal state is supported', async () => {
+    const fixture = createApp();
+    try {
+      const created = await request(fixture.app).post(MANAGED_SCHEDULED_TASK_TOOL_PATH).send(body('create', {
+        name: 'Goal task',
+        schedule: { kind: 'daily', time: '10:00', timezone: 'UTC' },
+        execution: { prompt: 'review', goalEnabled: true },
+      }));
+      expect(created.status).toBe(201);
+      expect(fixture.projectConfigRuntime.upsertScheduledTask).toHaveBeenCalled();
+      expect(fixture.projectConfigRuntime.upsertScheduledTask.mock.calls[0][1]).toMatchObject({
+        execution: expect.objectContaining({ goalEnabled: true }),
+      });
+
+      const updated = await request(fixture.app).post(MANAGED_SCHEDULED_TASK_TOOL_PATH).send(body('update', {
+        taskId: 'task_1',
+        execution: { goalEnabled: true },
+      }));
+      expect(updated.status).toBe(200);
+      expect(fixture.projectConfigRuntime.patchScheduledTask).toHaveBeenCalled();
+    } finally { fixture.restore(); }
+  });
 });

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

@@ -1,3 +1,9 @@
+import {
+  getSessionGoalCapability,
+  isSessionGoalSupported,
+  sessionGoalUnavailableMessage,
+} from '../session-goal/capability.js';
+
 const asNonEmptyString = (value) => {
   if (typeof value !== 'string') {
     return null;
@@ -6,6 +12,22 @@ const asNonEmptyString = (value) => {
   return trimmed.length > 0 ? trimmed : null;
 };
 
+/** Reject create/edit that enables goal when Host goal state is unavailable. */
+const rejectUnsupportedGoalExecution = (taskInput) => {
+  if (taskInput?.execution?.goalEnabled !== true) {
+    return null;
+  }
+  if (isSessionGoalSupported()) {
+    return null;
+  }
+  const capability = getSessionGoalCapability();
+  return {
+    error: sessionGoalUnavailableMessage(capability),
+    reason: capability.reason,
+    capability,
+  };
+};
+
 const parseProjectID = (req) => asNonEmptyString(req?.params?.projectId);
 const parseTaskID = (req) => asNonEmptyString(req?.params?.taskId);
 
@@ -182,6 +204,11 @@ export const registerScheduledTaskRoutes = (app, dependencies) => {
         return res.status(404).json({ error: 'Project not found' });
       }
 
+      const goalRefusal = rejectUnsupportedGoalExecution(taskInput);
+      if (goalRefusal) {
+        return res.status(501).json(goalRefusal);
+      }
+
       const upserted = await projectConfigRuntime.upsertScheduledTask(projectID, taskInput);
       const schedulerSynced = await syncAfterMutation(projectID);
 

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

@@ -359,4 +359,98 @@ describe('scheduled task mutation routes', () => {
     await Promise.resolve();
     expect(scheduledTasksRuntime.syncProject).toHaveBeenCalledTimes(4);
   });
+
+  it('allows create/edit with goalEnabled when Host goal state is supported', async () => {
+    const savedTask = {
+      id: 'goal-task',
+      name: 'Goal task',
+      execution: { prompt: 'do the work', goalEnabled: true },
+    };
+    const projectConfigRuntime = {
+      upsertScheduledTask: vi.fn(async () => ({ task: savedTask, tasks: [savedTask], created: true })),
+      deleteScheduledTask: vi.fn(),
+      listScheduledTasks: vi.fn(),
+    };
+    const routes = registerMutationRoutes({
+      projectConfigRuntime,
+      scheduledTasksRuntime: { syncProject: vi.fn(async () => {}) },
+      scheduleSyncRetry: vi.fn(),
+    });
+
+    const created = createResponse();
+    await routes.put({
+      params: { projectId: 'project-a' },
+      body: {
+        task: {
+          name: 'Goal task',
+          execution: {
+            prompt: 'do the work',
+            providerID: 'openai',
+            modelID: 'gpt',
+            goalEnabled: true,
+          },
+        },
+      },
+    }, created);
+
+    expect(created.statusCode).toBe(200);
+    expect(projectConfigRuntime.upsertScheduledTask).toHaveBeenCalledTimes(1);
+    expect(projectConfigRuntime.upsertScheduledTask.mock.calls[0][1]).toMatchObject({
+      execution: expect.objectContaining({ goalEnabled: true }),
+    });
+
+    const updatedTask = { ...savedTask, id: 'existing', name: 'Existing' };
+    projectConfigRuntime.upsertScheduledTask.mockResolvedValueOnce({
+      task: updatedTask,
+      tasks: [updatedTask],
+      created: false,
+    });
+    const updated = createResponse();
+    await routes.put({
+      params: { projectId: 'project-a' },
+      body: {
+        task: {
+          id: 'existing',
+          name: 'Existing',
+          execution: {
+            prompt: 'do the work',
+            providerID: 'openai',
+            modelID: 'gpt',
+            goalEnabled: true,
+          },
+        },
+      },
+    }, updated);
+
+    expect(updated.statusCode).toBe(200);
+    expect(projectConfigRuntime.upsertScheduledTask).toHaveBeenCalledTimes(2);
+  });
+
+  it('allows ordinary non-goal task create when goal is unsupported', async () => {
+    const savedTask = { id: 'plain', name: 'Plain' };
+    const projectConfigRuntime = {
+      upsertScheduledTask: vi.fn(async () => ({ task: savedTask, tasks: [savedTask], created: true })),
+      deleteScheduledTask: vi.fn(),
+      listScheduledTasks: vi.fn(),
+    };
+    const routes = registerMutationRoutes({
+      projectConfigRuntime,
+      scheduledTasksRuntime: { syncProject: vi.fn(async () => {}) },
+      scheduleSyncRetry: vi.fn(),
+    });
+
+    const response = createResponse();
+    await routes.put({
+      params: { projectId: 'project-a' },
+      body: {
+        task: {
+          name: 'Plain',
+          execution: { prompt: 'hello', providerID: 'openai', modelID: 'gpt' },
+        },
+      },
+    }, response);
+
+    expect(response.statusCode).toBe(200);
+    expect(projectConfigRuntime.upsertScheduledTask).toHaveBeenCalledTimes(1);
+  });
 });