@openchambery/web 1.19.21-beta.1 → 2.0.0-beta.1

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