@openchambery/web 1.19.0 → 1.19.2-beta.1

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

@@ -305,6 +305,108 @@ const extractGoalFromSession = (session) => {
   };
 };
 
+/**
+ * Single-shot session outcome for post-run continuation (no polling).
+ * Goal-enabled: terminal complete → success; blocked/budgetLimited → error;
+ * otherwise not-yet-success. Non-goal: busy/retry, assistant error, or
+ * completed assistant; incomplete/empty tails are not treated as success.
+ */
+const snapshotSessionOutcome = async ({
+  client,
+  sessionID,
+  projectPath,
+  goalEnabled,
+  signal,
+}) => {
+  const requestOptions = signal ? { signal } : undefined;
+
+  if (goalEnabled && typeof client?.session?.get === 'function') {
+    try {
+      const sessionResult = await client.session.get({
+        sessionID,
+        directory: projectPath,
+      }, requestOptions);
+      if (!sessionResult?.error) {
+        const goal = extractGoalFromSession(sessionResult?.data);
+        if (goal && GOAL_TERMINAL_STATUSES.has(goal.status)) {
+          if (goal.status === 'complete') {
+            return { outcome: 'success' };
+          }
+          return {
+            outcome: 'error',
+            error: goal.note || `goal ${goal.status}`,
+          };
+        }
+      }
+    } catch (error) {
+      if (signal?.aborted) throw error;
+    }
+    return { outcome: 'busy' };
+  }
+
+  if (typeof client?.session?.status === 'function') {
+    try {
+      const statusResult = await client.session.status({
+        directory: projectPath,
+      }, requestOptions);
+      if (!statusResult?.error && statusResult?.data && typeof statusResult.data === 'object') {
+        const statusValue = statusResult.data[sessionID];
+        const type = statusValue?.type ?? statusValue?.status;
+        if (type === 'busy' || type === 'retry') {
+          return { outcome: 'busy' };
+        }
+      }
+    } catch (error) {
+      if (signal?.aborted) throw error;
+    }
+  }
+
+  if (typeof client?.session?.messages === 'function') {
+    try {
+      const messagesResult = await client.session.messages({
+        sessionID,
+        directory: projectPath,
+        limit: 50,
+      }, requestOptions);
+      if (!messagesResult?.error && Array.isArray(messagesResult?.data)) {
+        const lastInfo = readMessageInfo(messagesResult.data.at(-1));
+        if (lastInfo?.role === 'assistant') {
+          if (lastInfo.error) {
+            return {
+              outcome: 'error',
+              error: formatAssistantError(lastInfo.error),
+            };
+          }
+          if (lastInfo.time?.completed) {
+            return { outcome: 'success' };
+          }
+        }
+      }
+    } catch (error) {
+      if (signal?.aborted) throw error;
+    }
+  }
+
+  return { outcome: 'busy' };
+};
+
+const parseSessionEventIdle = (event) => {
+  const payload = event?.payload?.payload ?? event?.payload;
+  const properties = payload?.properties;
+  const sessionID = typeof properties?.sessionID === 'string' ? properties.sessionID : '';
+  if (!sessionID) {
+    return { idle: false, sessionID: '' };
+  }
+  if (payload?.type === 'session.idle') {
+    return { idle: true, sessionID };
+  }
+  if (payload?.type === 'session.status') {
+    const type = properties?.status?.type ?? properties?.info?.type;
+    return { idle: type === 'idle', sessionID };
+  }
+  return { idle: false, sessionID };
+};
+
 export const createScheduledTasksRuntime = (deps) => {
   const {
     projectConfigRuntime,
@@ -331,6 +433,34 @@ export const createScheduledTasksRuntime = (deps) => {
   const runningCountByProject = new Map();
   let runningGlobalCount = 0;
   const queue = [];
+  /** sessionID → { projectID, taskID } for post-run continuation correction. */
+  const lastSessionOwners = new Map();
+
+  const rememberLastSession = (projectID, task) => {
+    const sessionID = task?.state?.lastSessionId;
+    if (typeof sessionID !== 'string' || !sessionID || !task?.id) {
+      return;
+    }
+    lastSessionOwners.set(sessionID, { projectID, taskID: task.id });
+  };
+
+  const forgetLastSessionsForProject = (projectID) => {
+    for (const [sessionID, owner] of [...lastSessionOwners.entries()]) {
+      if (owner.projectID === projectID) {
+        lastSessionOwners.delete(sessionID);
+      }
+    }
+  };
+
+  const forgetLastSessionIfOwned = (projectID, taskID, sessionID) => {
+    if (typeof sessionID !== 'string' || !sessionID) {
+      return;
+    }
+    const owner = lastSessionOwners.get(sessionID);
+    if (owner?.projectID === projectID && owner?.taskID === taskID) {
+      lastSessionOwners.delete(sessionID);
+    }
+  };
 
   const clearTimerForKey = (taskKey) => {
     const timer = timersByTaskKey.get(taskKey);
@@ -361,9 +491,11 @@ export const createScheduledTasksRuntime = (deps) => {
 
   const setProjectTasks = (projectID, tasks) => {
     clearProjectTimers(projectID);
+    forgetLastSessionsForProject(projectID);
     const taskMap = new Map();
     for (const task of tasks) {
       taskMap.set(task.id, task);
+      rememberLastSession(projectID, task);
     }
     tasksByProject.set(projectID, taskMap);
   };
@@ -412,7 +544,14 @@ export const createScheduledTasksRuntime = (deps) => {
     if (!taskMap) {
       return;
     }
+    const previous = taskMap.get(nextTask.id);
+    const previousSessionID = previous?.state?.lastSessionId;
+    const nextSessionID = nextTask.state?.lastSessionId;
+    if (previousSessionID && previousSessionID !== nextSessionID) {
+      forgetLastSessionIfOwned(projectID, nextTask.id, previousSessionID);
+    }
     taskMap.set(nextTask.id, nextTask);
+    rememberLastSession(projectID, nextTask);
   };
 
   const syncTaskSchedule = async (projectID, task) => {
@@ -1278,14 +1417,17 @@ export const createScheduledTasksRuntime = (deps) => {
 
       const nextRunAt = computeNextRunAt(latestTask, finishedAt);
       try {
-        stateResult = await projectConfigRuntime.updateScheduledTaskState(projectID, taskID, {
+        const statePatch = {
           lastStatus: status,
           lastDurationMs: durationMs,
           lastError: status === 'error' ? errorMessage : undefined,
-          lastSessionId: status === 'success' ? sessionID : undefined,
           nextRunAt: Number.isFinite(nextRunAt) ? nextRunAt : undefined,
           updatedAt: finishedAt,
-        });
+        };
+        if (sessionID) {
+          statePatch.lastSessionId = sessionID;
+        }
+        stateResult = await projectConfigRuntime.updateScheduledTaskState(projectID, taskID, statePatch);
         if (stateResult.task) {
           updateInMemoryTask(projectID, stateResult.task);
           if (stateResult.task.enabled && Number.isFinite(stateResult.task.state?.nextRunAt)) {
@@ -1301,6 +1443,9 @@ export const createScheduledTasksRuntime = (deps) => {
           error: errorMessage,
         });
       }
+      if (sessionID) {
+        lastSessionOwners.set(sessionID, { projectID, taskID });
+      }
 
       // History final status reflects the ultimate run outcome, including
       // state-persistence failures. A failed finalize leaves the row running
@@ -1441,6 +1586,91 @@ export const createScheduledTasksRuntime = (deps) => {
     };
   };
 
+  const handleSessionIdleCorrection = async (event) => {
+    const { idle, sessionID } = parseSessionEventIdle(event);
+    if (!idle || !sessionID) {
+      return;
+    }
+
+    const owner = lastSessionOwners.get(sessionID);
+    if (!owner) {
+      return;
+    }
+
+    const { projectID, taskID } = owner;
+    const taskKey = buildTaskKey(projectID, taskID);
+    if (runningTaskKeys.has(taskKey)) {
+      return;
+    }
+
+    const task = tasksByProject.get(projectID)?.get(taskID);
+    const lastStatus = task?.state?.lastStatus;
+    if (lastStatus === 'success' || lastStatus === 'running') {
+      return;
+    }
+    if (lastStatus !== 'error') {
+      return;
+    }
+
+    const projectPath = projectPathByID.get(projectID) || await ensureProjectPath(projectID);
+    if (!projectPath) {
+      return;
+    }
+
+    const baseUrl = buildOpenCodeUrl('/', '').replace(/\/$/, '');
+    const authHeaders = getOpenCodeAuthHeaders();
+    const client = createOpencodeClient({
+      baseUrl,
+      headers: authHeaders,
+    });
+    const snapshot = await snapshotSessionOutcome({
+      client,
+      sessionID,
+      projectPath,
+      goalEnabled: Boolean(task.execution?.goalEnabled),
+    });
+    if (snapshot.outcome !== 'success') {
+      return;
+    }
+
+    if (runningTaskKeys.has(taskKey)) {
+      return;
+    }
+    const latest = tasksByProject.get(projectID)?.get(taskID);
+    if (latest?.state?.lastStatus !== 'error') {
+      return;
+    }
+
+    const stateResult = await projectConfigRuntime.updateScheduledTaskState(projectID, taskID, {
+      lastStatus: 'success',
+      lastError: undefined,
+      lastSessionId: sessionID,
+      updatedAt: Date.now(),
+    });
+    if (stateResult.task) {
+      updateInMemoryTask(projectID, stateResult.task);
+    }
+
+    try {
+      emitTaskRunEvent?.({
+        projectID,
+        taskID,
+        ranAt: Date.now(),
+        status: 'success',
+        sessionID,
+      });
+    } catch {
+    }
+  };
+
+  const observeSessionEvent = (event) => {
+    return handleSessionIdleCorrection(event).catch((error) => {
+      logger.warn?.('[ScheduledTasks] observeSessionEvent failed', {
+        error: safeErrorMessage(error),
+      });
+    });
+  };
+
   return {
     start,
     stop,
@@ -1448,5 +1678,6 @@ export const createScheduledTasksRuntime = (deps) => {
     syncProject,
     runNow,
     getStatus,
+    observeSessionEvent,
   };
 };

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

@@ -993,4 +993,225 @@ describe('scheduled-tasks run history and session lifecycle', () => {
 
     vi.unstubAllGlobals();
   });
+
+  it('persists lastSessionId when an error run still created a session', async () => {
+    const history = createHistoryStore();
+    createSuccessfulClient({ settlement: 'assistant-error' });
+    const fetchMock = vi.fn(async (url) => {
+      if (String(url).includes('prompt_async')) {
+        return { ok: true, text: async () => '' };
+      }
+      throw new Error(`unexpected fetch ${url}`);
+    });
+    vi.stubGlobal('fetch', fetchMock);
+
+    const updateScheduledTaskState = vi.fn(async (_projectID, _taskID, state) => ({
+      task: { ...scheduledTask, state: { ...scheduledTask.state, ...state } },
+    }));
+    const runtime = createRuntime(updateScheduledTaskState, {
+      runHistoryStore: history,
+      waitForOpenCodeReady: vi.fn(async () => {}),
+    });
+    await runtime.syncProject('project-1');
+    const result = await runtime.runNow('project-1', 'task-1');
+
+    expect(result.ok).toBe(false);
+    expect(result.status).toBe('error');
+    const finalPatch = updateScheduledTaskState.mock.calls.at(-1)[2];
+    expect(finalPatch.lastStatus).toBe('error');
+    expect(finalPatch.lastSessionId).toBe('ses_1');
+
+    vi.unstubAllGlobals();
+  });
+
+  it('omits lastSessionId from the final patch when the failed run has no session', async () => {
+    const updateScheduledTaskState = vi.fn(async (_projectID, _taskID, state) => ({
+      task: { ...scheduledTask, state: { ...scheduledTask.state, ...state } },
+    }));
+    const runtime = createRuntime(updateScheduledTaskState);
+    await runtime.syncProject('project-1');
+    const result = await runtime.runNow('project-1', 'task-1');
+
+    expect(result.ok).toBe(false);
+    expect(result.status).toBe('error');
+    const finalPatch = updateScheduledTaskState.mock.calls.at(-1)[2];
+    expect(finalPatch.lastStatus).toBe('error');
+    expect(Object.hasOwn(finalPatch, 'lastSessionId')).toBe(false);
+  });
+
+  it('corrects lastStatus error → success on idle after a continuation, without rewriting history', async () => {
+    const history = createHistoryStore();
+    const client = createSuccessfulClient({ settlement: 'assistant-error' });
+    const fetchMock = vi.fn(async (url) => {
+      if (String(url).includes('prompt_async')) {
+        return { ok: true, text: async () => '' };
+      }
+      throw new Error(`unexpected fetch ${url}`);
+    });
+    vi.stubGlobal('fetch', fetchMock);
+
+    const emitTaskRunEvent = vi.fn();
+    const updateScheduledTaskState = vi.fn(async (_projectID, _taskID, state) => ({
+      task: { ...scheduledTask, state: { ...scheduledTask.state, ...state } },
+    }));
+    const runtime = createRuntime(updateScheduledTaskState, {
+      runHistoryStore: history,
+      waitForOpenCodeReady: vi.fn(async () => {}),
+      emitTaskRunEvent,
+    });
+    await runtime.syncProject('project-1');
+    const result = await runtime.runNow('project-1', 'task-1');
+    expect(result.status).toBe('error');
+    expect(history.finishRun).toHaveBeenCalledTimes(1);
+
+    client.messages.mockImplementation(async () => ({
+      data: [{
+        info: {
+          id: 'msg_ok',
+          role: 'assistant',
+          time: { completed: Date.now() },
+        },
+      }],
+    }));
+
+    await runtime.observeSessionEvent({
+      payload: {
+        type: 'session.idle',
+        properties: { sessionID: 'ses_1' },
+      },
+    });
+
+    expect(history.finishRun).toHaveBeenCalledTimes(1);
+    const correctionPatch = updateScheduledTaskState.mock.calls.at(-1)[2];
+    expect(correctionPatch).toEqual(expect.objectContaining({
+      lastStatus: 'success',
+      lastError: undefined,
+      lastSessionId: 'ses_1',
+    }));
+    expect(Object.hasOwn(correctionPatch, 'lastRunAt')).toBe(false);
+    expect(Object.hasOwn(correctionPatch, 'lastDurationMs')).toBe(false);
+    expect(Object.hasOwn(correctionPatch, 'nextRunAt')).toBe(false);
+    expect(emitTaskRunEvent).toHaveBeenCalledWith(expect.objectContaining({
+      projectID: 'project-1',
+      taskID: 'task-1',
+      status: 'success',
+      sessionID: 'ses_1',
+    }));
+
+    vi.unstubAllGlobals();
+  });
+
+  it('does not correct lastStatus while the task is still running', async () => {
+    vi.useFakeTimers();
+    const history = createHistoryStore();
+    const erroredTask = {
+      ...scheduledTask,
+      state: {
+        ...scheduledTask.state,
+        lastStatus: 'error',
+        lastSessionId: 'ses_1',
+        lastError: 'ProviderError',
+      },
+    };
+    createSuccessfulClient({ settlement: 'busy-then-success' });
+    const fetchMock = vi.fn(async (url) => {
+      if (String(url).includes('prompt_async')) {
+        return { ok: true, text: async () => '' };
+      }
+      throw new Error(`unexpected fetch ${url}`);
+    });
+    vi.stubGlobal('fetch', fetchMock);
+
+    const emitTaskRunEvent = vi.fn();
+    const updateScheduledTaskState = vi.fn(async (_projectID, _taskID, state) => ({
+      task: { ...erroredTask, state: { ...erroredTask.state, ...state } },
+    }));
+    const runtime = createRuntime(updateScheduledTaskState, {
+      projectConfigRuntime: {
+        listScheduledTasks: vi.fn(async () => [erroredTask]),
+        updateScheduledTaskState,
+        upsertScheduledTask: vi.fn(),
+      },
+      runHistoryStore: history,
+      waitForOpenCodeReady: vi.fn(async () => {}),
+      emitTaskRunEvent,
+    });
+    await runtime.syncProject('project-1');
+
+    const runPromise = runtime.runNow('project-1', 'task-1');
+    await vi.advanceTimersByTimeAsync(0);
+    expect(history.finishRun).not.toHaveBeenCalled();
+
+    const successEmitsBefore = emitTaskRunEvent.mock.calls.filter((call) => call[0].status === 'success').length;
+    await runtime.observeSessionEvent({
+      payload: {
+        type: 'session.idle',
+        properties: { sessionID: 'ses_1' },
+      },
+    });
+    expect(history.finishRun).not.toHaveBeenCalled();
+    expect(updateScheduledTaskState.mock.calls.map((call) => call[2].lastStatus)).not.toContain('success');
+    expect(emitTaskRunEvent.mock.calls.filter((call) => call[0].status === 'success')).toHaveLength(successEmitsBefore);
+
+    await vi.advanceTimersByTimeAsync(1_000);
+    const result = await runPromise;
+    expect(result.ok).toBe(true);
+
+    vi.unstubAllGlobals();
+    vi.useRealTimers();
+  });
+
+  it('does not correct lastStatus when it is already success', async () => {
+    const history = createHistoryStore();
+    const client = createSuccessfulClient();
+    const fetchMock = vi.fn(async (url) => {
+      if (String(url).includes('prompt_async')) {
+        return { ok: true, text: async () => '' };
+      }
+      throw new Error(`unexpected fetch ${url}`);
+    });
+    vi.stubGlobal('fetch', fetchMock);
+
+    const emitTaskRunEvent = vi.fn();
+    const updateScheduledTaskState = vi.fn(async (_projectID, _taskID, state) => ({
+      task: { ...scheduledTask, state: { ...scheduledTask.state, ...state } },
+    }));
+    const runtime = createRuntime(updateScheduledTaskState, {
+      runHistoryStore: history,
+      waitForOpenCodeReady: vi.fn(async () => {}),
+      emitTaskRunEvent,
+    });
+    await runtime.syncProject('project-1');
+    const result = await runtime.runNow('project-1', 'task-1');
+    expect(result.ok).toBe(true);
+    expect(history.finishRun).toHaveBeenCalledTimes(1);
+    const stateWritesAfterRun = updateScheduledTaskState.mock.calls.length;
+    const successEmitsAfterRun = emitTaskRunEvent.mock.calls.filter((call) => call[0].status === 'success').length;
+
+    client.messages.mockImplementation(async () => ({
+      data: [{
+        info: {
+          id: 'msg_ok',
+          role: 'assistant',
+          time: { completed: Date.now() },
+        },
+      }],
+    }));
+
+    await runtime.observeSessionEvent({
+      payload: {
+        type: 'session.status',
+        properties: {
+          sessionID: 'ses_1',
+          status: { type: 'idle' },
+        },
+      },
+    });
+
+    expect(history.finishRun).toHaveBeenCalledTimes(1);
+    expect(updateScheduledTaskState).toHaveBeenCalledTimes(stateWritesAfterRun);
+    expect(emitTaskRunEvent.mock.calls.filter((call) => call[0].status === 'success')).toHaveLength(successEmitsAfterRun);
+
+    vi.unstubAllGlobals();
+  });
 });