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

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

@@ -2,12 +2,20 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
 
-vi.mock('@opencode-ai/sdk/v2', () => ({
-  createOpencodeClient: vi.fn(),
+vi.mock('../opencode/v2-client.js', () => ({
+  makeOpenCodeV2Client: vi.fn(),
 }));
 
-const { createOpencodeClient } = await import('@opencode-ai/sdk/v2');
+vi.mock('../session-goal/objectives.js', () => ({
+  writeObjective: vi.fn(async () => ({ content: 'ok' })),
+}));
+
+const { makeOpenCodeV2Client } = await import('../opencode/v2-client.js');
+const { writeObjective } = await import('../session-goal/objectives.js');
 const { createScheduledTaskRunHistoryStore } = await import('./run-history-store.js');
 const {
   computeNextRunAt,
@@ -37,6 +45,7 @@ const createRuntime = (updateScheduledTaskState, overrides = {}) => createSchedu
   waitForOpenCodeReady: vi.fn(async () => {
     throw new Error('OpenCode unavailable');
   }),
+  persistSessionMetadata: vi.fn(async () => ({})),
   logger: { info: vi.fn(), warn: vi.fn() },
   ...overrides,
 });
@@ -310,10 +319,26 @@ describe('scheduled-tasks project sync isolation', () => {
   });
 });
 
+describe('scheduled-tasks v2 cutover residuals', () => {
+  it('runtime source has no 1.x SDK, HeyAPI wrappers, or retired session APIs', () => {
+    const source = readFileSync(join(dirname(fileURLToPath(import.meta.url)), 'runtime.js'), 'utf8');
+    expect(source).not.toContain('@opencode-ai/sdk');
+    expect(source).not.toContain('createOpencodeClient');
+    expect(source).not.toContain('prompt_async');
+    expect(source).not.toContain('session.abort');
+    expect(source).not.toContain('session.status({');
+    expect(source).not.toContain('session.messages');
+    expect(source).not.toContain('session.update');
+    expect(source).not.toContain('time: { archived');
+    expect(source).not.toContain('result?.error');
+  });
+});
+
 describe('scheduled-tasks run history and session lifecycle', () => {
   beforeEach(() => {
     vi.restoreAllMocks();
-    createOpencodeClient.mockReset();
+    makeOpenCodeV2Client.mockReset();
+    writeObjective.mockClear();
   });
 
   const createHistoryStore = () => {
@@ -341,111 +366,94 @@ describe('scheduled-tasks run history and session lifecycle', () => {
   };
 
   const createSuccessfulClient = ({
-    updateResult,
     sessionID = 'ses_1',
     /** Override session settlement polls after prompt/command admission. */
     settlement = 'success',
+    activeImpl,
+    messageListImpl,
   } = {}) => {
-    const create = vi.fn(async () => ({ data: { id: sessionID } }));
-    const update = vi.fn(async () => updateResult ?? { data: { id: sessionID } });
-    const command = vi.fn(async () => ({ data: {} }));
-    const abort = vi.fn(async () => ({ data: true }));
+    const create = vi.fn(async () => ({ id: sessionID }));
+    const prompt = vi.fn(async () => ({ id: 'inbox_1', type: 'user' }));
+    const command = vi.fn(async () => ({ id: 'inbox_1', type: 'user' }));
+    const interrupt = vi.fn(async () => undefined);
     const list = vi.fn(async () => ({ data: [] }));
-    // Default settlement: idle + completed assistant so history records the real
-    // turn outcome (not prompt_async admission alone).
+    // Default settlement: idle (absent from active map) + completed assistant
+    // so history records the real turn outcome (not prompt admission alone).
     let poll = 0;
-    const status = vi.fn(async () => {
+    const active = vi.fn(async () => {
+      if (typeof activeImpl === 'function') {
+        return activeImpl();
+      }
       poll += 1;
       if (settlement === 'busy-then-success' && poll < 2) {
-        return { data: { [sessionID]: { type: 'busy' } } };
+        return { [sessionID]: { type: 'running' } };
       }
-      return { data: { [sessionID]: { type: 'idle' } } };
+      return {};
     });
-    const messages = vi.fn(async () => {
+    const messageList = vi.fn(async () => {
+      if (typeof messageListImpl === 'function') {
+        return messageListImpl();
+      }
       if (settlement === 'assistant-error') {
         return {
           data: [{
-            info: {
-              id: 'msg_err',
-              role: 'assistant',
-              error: { name: 'ProviderError', message: 'upstream failed' },
-            },
+            id: 'msg_err',
+            type: 'assistant',
+            error: { name: 'ProviderError', message: 'upstream failed' },
           }],
         };
       }
-      if (settlement === 'busy-then-success') {
-        if (poll < 2) {
-          return { data: [{ info: { id: 'msg_user', role: 'user' } }] };
-        }
+      if (settlement === 'busy-then-success' && poll < 2) {
+        return { data: [{ id: 'msg_user', type: 'user' }] };
       }
       return {
         data: [{
-          info: {
-            id: 'msg_ok',
-            role: 'assistant',
-            time: { completed: Date.now() },
-          },
+          id: 'msg_ok',
+          type: 'assistant',
+          time: { created: Date.now(), completed: Date.now() },
+          finish: 'stop',
         }],
       };
     });
-    const get = vi.fn(async () => {
-      if (settlement === 'goal-complete') {
-        return {
-          data: {
-            id: sessionID,
-            metadata: {
-              openchamber: {
-                goal: { id: 'g1', status: 'complete', objective: 'done' },
-              },
-            },
-          },
-        };
-      }
-      if (settlement === 'goal-blocked') {
-        return {
-          data: {
-            id: sessionID,
-            metadata: {
-              openchamber: {
-                goal: { id: 'g1', status: 'blocked', objective: 'x', note: 'stuck' },
-              },
-            },
-          },
-        };
-      }
-      return { data: { id: sessionID, metadata: {} } };
-    });
-    createOpencodeClient.mockReturnValue({
-      session: { create, update, command, abort, status, messages, get },
+    const get = vi.fn(async () => ({
+      id: sessionID,
+      location: { directory: '/tmp/project-1' },
+    }));
+    makeOpenCodeV2Client.mockReturnValue({
+      session: { create, prompt, command, interrupt, active, get },
+      message: { list: messageList },
       command: { list },
     });
-    return { create, update, command, abort, list, status, messages, get };
+    return { create, prompt, command, interrupt, list, active, messageList, get };
   };
 
-  const settledSessionApis = (sessionID = 'ses_1') => ({
-    status: vi.fn(async () => ({ data: { [sessionID]: { type: 'idle' } } })),
-    messages: vi.fn(async () => ({
-      data: [{ info: { id: 'msg_ok', role: 'assistant', time: { completed: Date.now() } } }],
-    })),
-    get: vi.fn(async () => ({ data: { id: sessionID, metadata: {} } })),
+  const completedAssistant = (id = 'msg_ok') => ({
+    id,
+    type: 'assistant',
+    time: { created: 1_000, completed: 1_100 },
+    finish: 'stop',
   });
 
-  it('creates session with Scheduled title and scheduledTask metadata, attaches history, archives before prompt', async () => {
+  const erroredAssistant = (id = 'msg_err') => ({
+    id,
+    type: 'assistant',
+    time: { created: 2_000, completed: 2_100 },
+    error: { name: 'ProviderError', message: 'upstream failed' },
+  });
+
+  it('creates session with Scheduled title and location, attaches history, then prompts via session.prompt', async () => {
     const history = createHistoryStore();
     const client = createSuccessfulClient();
-    const fetchMock = vi.fn(async (url, init) => {
-      if (String(url).includes('prompt_async')) {
-        return { ok: true, text: async () => '' };
-      }
-      throw new Error(`unexpected fetch ${url} ${init?.method}`);
-    });
-    vi.stubGlobal('fetch', fetchMock);
+    const persistSessionMetadata = vi.fn(async () => ({}));
+    const onSystemSessionPersisted = vi.fn();
 
     const updateScheduledTaskState = vi.fn(async (_projectID, _taskID, state) => ({
       task: { ...scheduledTask, state: { ...scheduledTask.state, ...state } },
     }));
     const runtime = createRuntime(updateScheduledTaskState, {
       runHistoryStore: history,
+      persistSessionMetadata,
+      onSystemSessionPersisted,
       waitForOpenCodeReady: vi.fn(async () => {}),
     });
     await runtime.syncProject('project-1');
@@ -463,49 +471,105 @@ describe('scheduled-tasks run history and session lifecycle', () => {
     });
     expect(typeof started.id).toBe('string');
 
+    expect(makeOpenCodeV2Client).toHaveBeenCalledWith({
+      baseUrl: 'http://127.0.0.1:4096',
+      authHeaders: {},
+    });
     expect(client.create).toHaveBeenCalledWith(expect.objectContaining({
-      directory: '/tmp/project-1',
+      location: { directory: '/tmp/project-1' },
       title: expect.stringMatching(/^\[Scheduled\] Task /),
+      model: { id: 'gpt-4.1', providerID: 'openai' },
       metadata: {
         openchamber: {
-          scheduledTask: {
+          scheduledTask: expect.objectContaining({
             projectID: 'project-1',
             taskID: 'task-1',
             runID: started.id,
             name: 'Task',
-          },
+          }),
         },
       },
     }), expect.objectContaining({ signal: expect.any(AbortSignal) }));
-    expect(history.attachSession).toHaveBeenCalledWith(started.id, 'ses_1');
-    expect(client.update).toHaveBeenCalledWith(expect.objectContaining({
+    expect(client.create.mock.calls[0][0].directory).toBeUndefined();
+    expect(persistSessionMetadata).toHaveBeenCalledWith('ses_1', {
+      openchamber: {
+        scheduledTask: expect.objectContaining({
+          projectID: 'project-1',
+          taskID: 'task-1',
+          runID: started.id,
+          name: 'Task',
+        }),
+      },
+    });
+    expect(onSystemSessionPersisted).toHaveBeenCalledWith({
       sessionID: 'ses_1',
       directory: '/tmp/project-1',
-      time: { archived: expect.any(Number) },
-    }), expect.objectContaining({ signal: expect.any(AbortSignal) }));
-    expect(client.update.mock.invocationCallOrder[0]).toBeLessThan(fetchMock.mock.invocationCallOrder[0]);
+      metadata: expect.objectContaining({
+        openchamber: expect.objectContaining({
+          scheduledTask: expect.objectContaining({ taskID: 'task-1' }),
+        }),
+      }),
+    });
+    expect(history.attachSession).toHaveBeenCalledWith(started.id, 'ses_1');
+    expect(client.prompt).toHaveBeenCalledWith({
+      sessionID: 'ses_1',
+      text: 'run',
+    }, expect.objectContaining({ signal: expect.any(AbortSignal) }));
     expect(history.finishRun).toHaveBeenCalledWith(started.id, expect.objectContaining({
       status: 'success',
       sessionId: 'ses_1',
     }));
-    // Must wait for session settlement, not finish on prompt_async admission alone.
-    expect(client.status).toHaveBeenCalled();
-    expect(client.messages).toHaveBeenCalled();
-    expect(client.status.mock.invocationCallOrder[0]).toBeGreaterThan(fetchMock.mock.invocationCallOrder[0]);
+    // Must wait for session settlement, not finish on prompt admission alone.
+    expect(client.active).toHaveBeenCalled();
+    expect(client.messageList).toHaveBeenCalled();
+    expect(client.active.mock.invocationCallOrder[0]).toBeGreaterThan(client.prompt.mock.invocationCallOrder[0]);
+  });
 
-    vi.unstubAllGlobals();
+  it('refuses before session create when Host metadata persist is not configured', async () => {
+    const history = createHistoryStore();
+    const client = createSuccessfulClient();
+    const updateScheduledTaskState = vi.fn(async (_projectID, _taskID, state) => ({
+      task: { ...scheduledTask, state: { ...scheduledTask.state, ...state } },
+    }));
+    const runtime = createRuntime(updateScheduledTaskState, {
+      runHistoryStore: history,
+      persistSessionMetadata: null,
+      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.error).toMatch(/session metadata persist is not configured/);
+    expect(client.create).not.toHaveBeenCalled();
+    expect(client.prompt).not.toHaveBeenCalled();
+  });
+
+  it('fails the run before prompt when Host metadata persist throws', async () => {
+    const history = createHistoryStore();
+    const client = createSuccessfulClient();
+    const updateScheduledTaskState = vi.fn(async (_projectID, _taskID, state) => ({
+      task: { ...scheduledTask, state: { ...scheduledTask.state, ...state } },
+    }));
+    const runtime = createRuntime(updateScheduledTaskState, {
+      runHistoryStore: history,
+      persistSessionMetadata: vi.fn(async () => {
+        throw new Error('store unavailable');
+      }),
+      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.error).toMatch(/store unavailable/);
+    expect(client.create).toHaveBeenCalled();
+    expect(client.prompt).not.toHaveBeenCalled();
   });
 
   it('records error outcome and real duration when the assistant turn fails after admission', 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 updateScheduledTaskState = vi.fn(async (_projectID, _taskID, state) => ({
       task: { ...scheduledTask, state: { ...scheduledTask.state, ...state } },
@@ -528,22 +592,13 @@ describe('scheduled-tasks run history and session lifecycle', () => {
         durationMs: expect.any(Number),
       }),
     );
-    expect(client.messages).toHaveBeenCalled();
-
-    vi.unstubAllGlobals();
+    expect(client.messageList).toHaveBeenCalled();
   });
 
-  it('keeps the run open while the session is busy and only finalizes after idle settlement', async () => {
+  it('keeps the run open while the session is in the active map and only finalizes after idle settlement', async () => {
     vi.useFakeTimers();
     const history = createHistoryStore();
     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 updateScheduledTaskState = vi.fn(async (_projectID, _taskID, state) => ({
       task: { ...scheduledTask, state: { ...scheduledTask.state, ...state } },
@@ -555,7 +610,7 @@ describe('scheduled-tasks run history and session lifecycle', () => {
     await runtime.syncProject('project-1');
 
     const runPromise = runtime.runNow('project-1', 'task-1');
-    // First settlement poll sees busy and sleeps — history must still be open.
+    // First settlement poll sees membership and sleeps — history must still be open.
     await vi.advanceTimersByTimeAsync(0);
     expect(history.finishRun).not.toHaveBeenCalled();
 
@@ -568,17 +623,15 @@ describe('scheduled-tasks run history and session lifecycle', () => {
       expect.objectContaining({ status: 'success', sessionId: 'ses_1' }),
     );
 
-    vi.unstubAllGlobals();
     vi.useRealTimers();
   });
 
-  it('does not prompt when archive fails and finalizes the run as error', async () => {
+  it('does not prompt when attachSession fails and finalizes the run as error', async () => {
     const history = createHistoryStore();
-    createSuccessfulClient({
-      updateResult: { error: { status: 500, message: 'archive failed' } },
+    const client = createSuccessfulClient();
+    history.attachSession.mockImplementation(() => {
+      throw new Error('attach exploded');
     });
-    const fetchMock = vi.fn(async () => ({ ok: true, text: async () => '' }));
-    vi.stubGlobal('fetch', fetchMock);
 
     const updateScheduledTaskState = vi.fn(async (_projectID, _taskID, state) => ({
       task: { ...scheduledTask, state: { ...scheduledTask.state, ...state } },
@@ -592,28 +645,22 @@ describe('scheduled-tasks run history and session lifecycle', () => {
 
     expect(result.ok).toBe(false);
     expect(result.status).toBe('error');
-    expect(fetchMock).not.toHaveBeenCalled();
+    expect(result.error).toMatch(/attachSession failed/);
+    expect(client.prompt).not.toHaveBeenCalled();
     expect(history.finishRun).toHaveBeenCalledWith(
       expect.any(String),
       expect.objectContaining({ status: 'error' }),
     );
-
-    vi.unstubAllGlobals();
   });
 
-  it('retries archive once on 404 then prompts on success', async () => {
+  it('does not treat session.active failure as idle success', async () => {
     vi.useFakeTimers();
     const history = createHistoryStore();
-    const create = vi.fn(async () => ({ data: { id: 'ses_404' } }));
-    const update = vi.fn()
-      .mockResolvedValueOnce({ error: { status: 404 } })
-      .mockResolvedValueOnce({ data: { id: 'ses_404' } });
-    createOpencodeClient.mockReturnValue({
-      session: { create, update, command: vi.fn(), ...settledSessionApis('ses_404') },
-      command: { list: vi.fn(async () => ({ data: [] })) },
+    createSuccessfulClient({
+      activeImpl: async () => {
+        throw new Error('active unavailable');
+      },
     });
-    const fetchMock = vi.fn(async () => ({ ok: true, text: async () => '' }));
-    vi.stubGlobal('fetch', fetchMock);
 
     const updateScheduledTaskState = vi.fn(async (_projectID, _taskID, state) => ({
       task: { ...scheduledTask, state: { ...scheduledTask.state, ...state } },
@@ -621,63 +668,67 @@ describe('scheduled-tasks run history and session lifecycle', () => {
     const runtime = createRuntime(updateScheduledTaskState, {
       runHistoryStore: history,
       waitForOpenCodeReady: vi.fn(async () => {}),
+      maxRunDurationMs: 2_500,
     });
     await runtime.syncProject('project-1');
 
     const runPromise = runtime.runNow('project-1', 'task-1');
-    await vi.advanceTimersByTimeAsync(250);
+    await vi.advanceTimersByTimeAsync(1_000);
+    expect(history.finishRun).not.toHaveBeenCalled();
+
+    await vi.advanceTimersByTimeAsync(1_500);
     const result = await runPromise;
 
-    expect(result.ok).toBe(true);
-    expect(update).toHaveBeenCalledTimes(2);
-    expect(fetchMock).toHaveBeenCalledTimes(1);
+    expect(result.ok).toBe(false);
+    expect(result.status).toBe('error');
+    expect(result.error).toBe('schedule run timed out');
+    expect(history.finishRun).toHaveBeenCalledWith(
+      expect.any(String),
+      expect.objectContaining({
+        status: 'error',
+        error: 'schedule run timed out',
+      }),
+    );
 
-    vi.unstubAllGlobals();
     vi.useRealTimers();
   });
 
-  it('watchdog timeout aborts in-flight work, calls session.abort, and does not continue later stages', async () => {
+  it('watchdog timeout interrupts in-flight work and does not continue later stages', async () => {
     vi.useFakeTimers();
     const history = createHistoryStore();
     let resolvePrompt;
     let promptStarted = false;
     let promptCompleted = false;
-    const create = vi.fn(async () => ({ data: { id: 'ses_timeout' } }));
-    const update = vi.fn(async () => ({ data: { id: 'ses_timeout' } }));
-    const abort = vi.fn(async () => ({ data: true }));
+    const create = vi.fn(async () => ({ id: 'ses_timeout' }));
+    const interrupt = vi.fn(async () => undefined);
     const command = vi.fn(async () => {
       throw new Error('command must not run after hanging prompt path');
     });
     const list = vi.fn(async () => ({ data: [] }));
-    createOpencodeClient.mockReturnValue({
-      session: { create, update, command, abort },
-      command: { list },
-    });
-
-    const fetchMock = vi.fn((url, init) => {
-      if (String(url).includes('prompt_async')) {
-        promptStarted = true;
-        return new Promise((resolve, reject) => {
-          resolvePrompt = () => {
-            promptCompleted = true;
-            resolve({ ok: true, text: async () => '' });
+    const prompt = vi.fn((_params, options) => {
+      promptStarted = true;
+      return new Promise((resolve, reject) => {
+        resolvePrompt = () => {
+          promptCompleted = true;
+          resolve({ id: 'inbox_1', type: 'user' });
+        };
+        const signal = options?.signal;
+        if (signal) {
+          const onAbort = () => {
+            reject(signal.reason ?? new DOMException('Aborted', 'AbortError'));
           };
-          const signal = init?.signal;
-          if (signal) {
-            const onAbort = () => {
-              reject(signal.reason ?? new DOMException('Aborted', 'AbortError'));
-            };
-            if (signal.aborted) {
-              onAbort();
-              return;
-            }
-            signal.addEventListener('abort', onAbort, { once: true });
+          if (signal.aborted) {
+            onAbort();
+            return;
           }
-        });
-      }
-      throw new Error(`unexpected fetch ${url}`);
+          signal.addEventListener('abort', onAbort, { once: true });
+        }
+      });
+    });
+    makeOpenCodeV2Client.mockReturnValue({
+      session: { create, prompt, command, interrupt },
+      command: { list },
     });
-    vi.stubGlobal('fetch', fetchMock);
 
     const updateScheduledTaskState = vi.fn(async (_projectID, _taskID, state) => ({
       task: { ...scheduledTask, state: { ...scheduledTask.state, ...state } },
@@ -706,9 +757,9 @@ describe('scheduled-tasks run history and session lifecycle', () => {
       expect(result.ok).toBe(false);
       expect(result.status).toBe('error');
       expect(result.error).toBe('schedule run timed out');
-      expect(abort).toHaveBeenCalledWith({
+      expect(interrupt).toHaveBeenCalledWith({
         sessionID: 'ses_timeout',
-        directory: '/tmp/project-1',
+        continue: false,
       });
       expect(promptCompleted).toBe(false);
       expect(command).not.toHaveBeenCalled();
@@ -731,18 +782,16 @@ describe('scheduled-tasks run history and session lifecycle', () => {
     } finally {
       process.off('unhandledRejection', onUnhandled);
       resolvePrompt?.();
-      vi.unstubAllGlobals();
       vi.useRealTimers();
     }
   });
 
-  it('watchdog timeout during hanging command aborts session and never prompt_async', async () => {
+  it('watchdog timeout during hanging command interrupts session and never session.prompt', async () => {
     vi.useFakeTimers();
     const history = createHistoryStore();
     let commandReached = false;
-    const create = vi.fn(async () => ({ data: { id: 'ses_cmd' } }));
-    const update = vi.fn(async () => ({ data: { id: 'ses_cmd' } }));
-    const abort = vi.fn(async () => ({ data: true }));
+    const create = vi.fn(async () => ({ id: 'ses_cmd' }));
+    const interrupt = vi.fn(async () => undefined);
     const command = vi.fn((_params, options) => {
       commandReached = true;
       return new Promise((_resolve, reject) => {
@@ -761,14 +810,13 @@ describe('scheduled-tasks run history and session lifecycle', () => {
       });
     });
     const list = vi.fn(async () => ({ data: [{ name: 'review' }] }));
-    createOpencodeClient.mockReturnValue({
-      session: { create, update, command, abort },
-      command: { list },
+    const prompt = vi.fn(async () => {
+      throw new Error('session.prompt must not run when command is selected');
     });
-    const fetchMock = vi.fn(async () => {
-      throw new Error('prompt_async must not run when command is selected');
+    makeOpenCodeV2Client.mockReturnValue({
+      session: { create, prompt, command, interrupt },
+      command: { list },
     });
-    vi.stubGlobal('fetch', fetchMock);
 
     const taskWithCommand = {
       ...scheduledTask,
@@ -790,6 +838,7 @@ describe('scheduled-tasks run history and session lifecycle', () => {
       buildOpenCodeUrl: vi.fn(() => 'http://127.0.0.1:4096'),
       getOpenCodeAuthHeaders: vi.fn(() => ({})),
       waitForOpenCodeReady: vi.fn(async () => {}),
+      persistSessionMetadata: vi.fn(async () => ({})),
       logger: { info: vi.fn(), warn: vi.fn() },
       runHistoryStore: history,
       maxRunDurationMs: 500,
@@ -808,47 +857,41 @@ describe('scheduled-tasks run history and session lifecycle', () => {
       status: 'error',
       error: 'schedule run timed out',
     });
-    expect(abort).toHaveBeenCalledWith({
+    expect(interrupt).toHaveBeenCalledWith({
       sessionID: 'ses_cmd',
-      directory: '/tmp/project-1',
+      continue: false,
     });
-    expect(fetchMock).not.toHaveBeenCalled();
+    expect(command).toHaveBeenCalledWith(expect.objectContaining({
+      sessionID: 'ses_cmd',
+      command: 'review',
+      arguments: 'src',
+      model: { id: 'gpt-4.1', providerID: 'openai' },
+    }), expect.objectContaining({ signal: expect.any(AbortSignal) }));
+    expect(list).toHaveBeenCalledWith({
+      location: { directory: '/tmp/project-1' },
+    }, expect.objectContaining({ signal: expect.any(AbortSignal) }));
+    expect(prompt).not.toHaveBeenCalled();
 
-    vi.unstubAllGlobals();
     vi.useRealTimers();
   });
 
-  it('watchdog timeout during hanging small-model distill returns without waiting and blocks later goal stages', async () => {
-    vi.useFakeTimers();
+  it('goalEnabled without persist refuses before OpenCode ready / distill / session create (no side effects)', async () => {
     const history = createHistoryStore();
-    let resolveDistill;
-    let distillStarted = false;
-    const create = vi.fn(async () => ({ data: { id: 'ses_distill' } }));
-    const update = vi.fn(async () => ({ data: { id: 'ses_distill' } }));
-    const abort = vi.fn(async () => ({ data: true }));
-    const command = vi.fn(async () => {
-      throw new Error('command must not run after hanging distill');
+    const create = vi.fn(async () => ({ id: 'ses_distill' }));
+    const interrupt = vi.fn(async () => undefined);
+    const prompt = vi.fn(async () => {
+      throw new Error('session.prompt must not run without goal persist');
     });
-    const list = vi.fn(async () => ({ data: [] }));
-    createOpencodeClient.mockReturnValue({
-      session: { create, update, command, abort },
-      command: { list },
-    });
-
-    const fetchMock = vi.fn(async (url, init) => {
-      throw new Error(`unexpected fetch ${url} ${init?.method}`);
+    makeOpenCodeV2Client.mockReturnValue({
+      session: { create, prompt, command: vi.fn(), interrupt },
+      command: { list: vi.fn(async () => ({ data: [] })) },
     });
-    vi.stubGlobal('fetch', fetchMock);
 
-    const generateSmallModelText = vi.fn(() => {
-      distillStarted = true;
-      return new Promise((resolve) => {
-        resolveDistill = () => resolve({ text: 'distilled criteria' });
-      });
-    });
+    const generateSmallModelText = vi.fn(async () => ({ text: 'should not distill' }));
     const getSmallModelService = vi.fn(async () => ({ generateSmallModelText }));
+    const waitForOpenCodeReady = vi.fn(async () => {});
 
-    // Oversized prompt forces small-model distill (threshold 5000).
+    // Oversized prompt would force distill if goal were admitted — it must not.
     const largePrompt = `finish the migration ${'x'.repeat(5100)}`;
     const goalTask = {
       ...scheduledTask,
@@ -872,78 +915,162 @@ describe('scheduled-tasks run history and session lifecycle', () => {
       buildOpenCodeUrl: vi.fn(() => 'http://127.0.0.1:4096'),
       getOpenCodeAuthHeaders: vi.fn(() => ({})),
       getSmallModelService,
-      waitForOpenCodeReady: vi.fn(async () => {}),
+      waitForOpenCodeReady,
       logger: { info: vi.fn(), warn: vi.fn() },
       runHistoryStore: history,
-      maxRunDurationMs: 1_000,
+      // intentionally no persistSessionGoal
     });
     await runtime.syncProject('project-1');
+    const result = await runtime.runNow('project-1', 'task-1');
 
-    const unhandled = [];
-    const onUnhandled = (reason) => {
-      unhandled.push(reason);
+    expect(result.ok).toBe(false);
+    expect(result.error).toMatch(/session goal persist is not configured/);
+    expect(waitForOpenCodeReady).not.toHaveBeenCalled();
+    expect(getSmallModelService).not.toHaveBeenCalled();
+    expect(generateSmallModelText).not.toHaveBeenCalled();
+    expect(create).not.toHaveBeenCalled();
+    expect(prompt).not.toHaveBeenCalled();
+    expect(writeObjective).not.toHaveBeenCalled();
+    expect(history.attachSession).not.toHaveBeenCalled();
+    expect(history.finishRun).toHaveBeenCalledWith(
+      expect.any(String),
+      expect.objectContaining({
+        status: 'error',
+        error: expect.stringMatching(/session goal persist is not configured/),
+      }),
+    );
+  });
+
+  it('goalEnabled without persist refuses before session create / objective write', async () => {
+    const history = createHistoryStore();
+    const client = createSuccessfulClient({ sessionID: 'ses_goal' });
+
+    const goalTask = {
+      ...scheduledTask,
+      execution: {
+        ...scheduledTask.execution,
+        prompt: 'finish the migration',
+        goalEnabled: true,
+        goalTokenBudget: 12_000,
+      },
     };
-    process.on('unhandledRejection', onUnhandled);
+    const updateScheduledTaskState = vi.fn(async (_projectID, _taskID, state) => ({
+      task: { ...goalTask, state: { ...goalTask.state, ...state } },
+    }));
+    const runtime = createScheduledTasksRuntime({
+      projectConfigRuntime: {
+        listScheduledTasks: vi.fn(async () => [goalTask]),
+        updateScheduledTaskState,
+        upsertScheduledTask: vi.fn(),
+      },
+      listProjects: vi.fn(async () => [{ id: 'project-1', path: '/tmp/project-1' }]),
+      buildOpenCodeUrl: vi.fn(() => 'http://127.0.0.1:4096'),
+      getOpenCodeAuthHeaders: vi.fn(() => ({})),
+      waitForOpenCodeReady: vi.fn(async () => {}),
+      logger: { info: vi.fn(), warn: vi.fn() },
+      runHistoryStore: history,
+      // intentionally no persistSessionGoal
+    });
+    await runtime.syncProject('project-1');
+    const result = await runtime.runNow('project-1', 'task-1');
 
-    try {
-      const runPromise = runtime.runNow('project-1', 'task-1');
-      await vi.advanceTimersByTimeAsync(0);
-      expect(distillStarted).toBe(true);
-      expect(generateSmallModelText).toHaveBeenCalled();
+    // Missing persist is an explicit run failure before any side effects.
+    expect(result.ok).toBe(false);
+    expect(result.status).toBe('error');
+    expect(result.error).toMatch(/session goal persist is not configured/);
+    expect(client.create).not.toHaveBeenCalled();
+    expect(client.prompt).not.toHaveBeenCalled();
+    expect(writeObjective).not.toHaveBeenCalled();
+    expect(history.finishRun).toHaveBeenCalledWith(
+      expect.any(String),
+      expect.objectContaining({
+        status: 'error',
+        error: expect.stringMatching(/session goal persist is not configured/),
+      }),
+    );
+    // Task config is preserved (goalEnabled stays on the task); only this run fails.
+    const finalPatch = updateScheduledTaskState.mock.calls.at(-1)[2];
+    expect(finalPatch.lastStatus).toBe('error');
+    expect(Object.hasOwn(finalPatch, 'lastSessionId')).toBe(false);
+  });
 
-      // Timeout must return while distill is still gated (non-cancellable).
-      await vi.advanceTimersByTimeAsync(1_000);
-      const result = await runPromise;
+  it('goalEnabled with persist writes objective + active goal then prompts', async () => {
+    const history = createHistoryStore();
+    const client = createSuccessfulClient({ sessionID: 'ses_goal_ok' });
+    const persistSessionGoal = vi.fn(async (_sessionId, _directory, goal) => ({
+      openchamber: { goal },
+    }));
+    const onGoalPersisted = vi.fn();
 
-      expect(result.ok).toBe(false);
-      expect(result.status).toBe('error');
-      expect(result.error).toBe('schedule run timed out');
-      expect(abort).toHaveBeenCalledWith({
-        sessionID: 'ses_distill',
-        directory: '/tmp/project-1',
-      });
-      expect(fetchMock).not.toHaveBeenCalled();
-      expect(command).not.toHaveBeenCalled();
+    const goalTask = {
+      ...scheduledTask,
+      execution: {
+        ...scheduledTask.execution,
+        prompt: 'finish the migration',
+        goalEnabled: true,
+        goalTokenBudget: 12_000,
+      },
+    };
+    const updateScheduledTaskState = vi.fn(async (_projectID, _taskID, state) => ({
+      task: { ...goalTask, state: { ...goalTask.state, ...state } },
+    }));
+    const runtime = createScheduledTasksRuntime({
+      projectConfigRuntime: {
+        listScheduledTasks: vi.fn(async () => [goalTask]),
+        updateScheduledTaskState,
+        upsertScheduledTask: vi.fn(),
+      },
+      listProjects: vi.fn(async () => [{ id: 'project-1', path: '/tmp/project-1' }]),
+      buildOpenCodeUrl: vi.fn(() => 'http://127.0.0.1:4096'),
+      getOpenCodeAuthHeaders: vi.fn(() => ({})),
+      waitForOpenCodeReady: vi.fn(async () => {}),
+      persistSessionMetadata: vi.fn(async () => ({})),
+      logger: { info: vi.fn(), warn: vi.fn() },
+      runHistoryStore: history,
+      persistSessionGoal,
+      onGoalPersisted,
+    });
+    await runtime.syncProject('project-1');
+    const result = await runtime.runNow('project-1', 'task-1');
 
-      const started = history.startRun.mock.calls[0][0];
-      expect(history.attachSession).toHaveBeenCalledWith(started.id, 'ses_distill');
-      expect(history.finishRun).toHaveBeenCalledWith(
-        started.id,
-        expect.objectContaining({
-          status: 'error',
-          error: 'schedule run timed out',
+    expect(result.ok).toBe(true);
+    expect(client.create).toHaveBeenCalled();
+    expect(writeObjective).toHaveBeenCalledWith('ses_goal_ok', 'finish the migration');
+    expect(persistSessionGoal).toHaveBeenCalledTimes(1);
+    expect(persistSessionGoal.mock.calls[0][0]).toBe('ses_goal_ok');
+    expect(persistSessionGoal.mock.calls[0][1]).toBe('/tmp/project-1');
+    expect(persistSessionGoal.mock.calls[0][2]).toMatchObject({
+      status: 'active',
+      objectiveFile: true,
+      objective: '',
+      tokenBudget: 12_000,
+      tokensUsed: 0,
+      turnsUsed: 0,
+      blockedStreak: 0,
+      note: '',
+      statusReason: '',
+      lastAccountedMessageID: '',
+    });
+    expect(typeof persistSessionGoal.mock.calls[0][2].id).toBe('string');
+    expect(persistSessionGoal.mock.calls[0][2].id.length).toBeGreaterThan(0);
+    expect(onGoalPersisted).toHaveBeenCalledWith(expect.objectContaining({
+      sessionID: 'ses_goal_ok',
+      directory: '/tmp/project-1',
+      metadata: expect.objectContaining({
+        openchamber: expect.objectContaining({
+          goal: expect.objectContaining({ status: 'active' }),
         }),
-      );
-
-      // Release distill after finalize; abort gate must block goal PATCH / prompt.
-      resolveDistill?.();
-      await vi.advanceTimersByTimeAsync(0);
-      await Promise.resolve();
-      await Promise.resolve();
-      expect(fetchMock).not.toHaveBeenCalled();
-      expect(unhandled).toEqual([]);
-    } finally {
-      process.off('unhandledRejection', onUnhandled);
-      resolveDistill?.();
-      vi.unstubAllGlobals();
-      vi.useRealTimers();
-    }
+      }),
+    }));
+    expect(client.prompt).toHaveBeenCalled();
   });
 
-  it('goalEnabled PATCH preserves scheduledTask marker alongside goal', async () => {
+  it('goalEnabled persist failure aborts before prompt', async () => {
     const history = createHistoryStore();
-    // Goal runs settle on terminal goal metadata, not the first idle turn.
-    const client = createSuccessfulClient({ sessionID: 'ses_goal', settlement: 'goal-complete' });
-    const fetchMock = vi.fn(async (url, init) => {
-      if (String(url).includes('/session/ses_goal') && init?.method === 'PATCH') {
-        return { ok: true, text: async () => '' };
-      }
-      if (String(url).includes('prompt_async')) {
-        return { ok: true, text: async () => '' };
-      }
-      throw new Error(`unexpected fetch ${url} ${init?.method}`);
+    const client = createSuccessfulClient({ sessionID: 'ses_goal_fail' });
+    const persistSessionGoal = vi.fn(async () => {
+      throw new Error('store unavailable');
     });
-    vi.stubGlobal('fetch', fetchMock);
 
     const goalTask = {
       ...scheduledTask,
@@ -951,7 +1078,6 @@ describe('scheduled-tasks run history and session lifecycle', () => {
         ...scheduledTask.execution,
         prompt: 'finish the migration',
         goalEnabled: true,
-        goalTokenBudget: 12_000,
       },
     };
     const updateScheduledTaskState = vi.fn(async (_projectID, _taskID, state) => ({
@@ -967,44 +1093,228 @@ describe('scheduled-tasks run history and session lifecycle', () => {
       buildOpenCodeUrl: vi.fn(() => 'http://127.0.0.1:4096'),
       getOpenCodeAuthHeaders: vi.fn(() => ({})),
       waitForOpenCodeReady: vi.fn(async () => {}),
+      persistSessionMetadata: vi.fn(async () => ({})),
       logger: { info: vi.fn(), warn: vi.fn() },
       runHistoryStore: history,
+      persistSessionGoal,
+    });
+    await runtime.syncProject('project-1');
+    const result = await runtime.runNow('project-1', 'task-1');
+
+    expect(result.ok).toBe(false);
+    expect(result.error).toMatch(/store unavailable/);
+    expect(writeObjective).toHaveBeenCalled();
+    expect(persistSessionGoal).toHaveBeenCalled();
+    expect(client.prompt).not.toHaveBeenCalled();
+  });
+
+  it('ordinary non-goal runs still create a session and settle on the assistant tail', async () => {
+    const history = createHistoryStore();
+    const client = createSuccessfulClient({ sessionID: 'ses_plain' });
+    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(true);
-    expect(client.get).toHaveBeenCalled();
-    const patchCall = fetchMock.mock.calls.find(
-      ([url, init]) => String(url).includes('/session/ses_goal') && init?.method === 'PATCH',
+    expect(client.create).toHaveBeenCalled();
+    expect(client.prompt).toHaveBeenCalled();
+    expect(writeObjective).not.toHaveBeenCalled();
+  });
+
+  it('settles from the latest-side page: >50 older completed + newest error → error', async () => {
+    const history = createHistoryStore();
+    // order=desc page: newest first. Older completed assistants must not win.
+    const latestPage = [
+      erroredAssistant('msg_latest'),
+      ...Array.from({ length: 49 }, (_, index) => completedAssistant(`msg_old_${index}`)),
+    ];
+    createSuccessfulClient({
+      messageListImpl: async () => ({ data: latestPage }),
+    });
+    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');
+    expect(result.error).toBe('ProviderError');
+    expect(history.finishRun).toHaveBeenCalledWith(
+      expect.any(String),
+      expect.objectContaining({ status: 'error', error: 'ProviderError' }),
     );
-    expect(patchCall).toBeTruthy();
-    const body = JSON.parse(patchCall[1].body);
-    expect(body.metadata.openchamber.scheduledTask).toEqual({
-      projectID: 'project-1',
-      taskID: 'task-1',
-      runID: history.startRun.mock.calls[0][0].id,
-      name: 'Task',
+  });
+
+  it('settles from the latest-side page: >50 older errors + newest completed → success', async () => {
+    const history = createHistoryStore();
+    const latestPage = [
+      completedAssistant('msg_latest'),
+      ...Array.from({ length: 49 }, (_, index) => erroredAssistant(`msg_old_${index}`)),
+    ];
+    createSuccessfulClient({
+      messageListImpl: async () => ({ data: latestPage }),
     });
-    expect(body.metadata.openchamber.goal).toMatchObject({
-      status: 'active',
-      tokenBudget: 12_000,
+    const updateScheduledTaskState = vi.fn(async (_projectID, _taskID, state) => ({
+      task: { ...scheduledTask, state: { ...scheduledTask.state, ...state } },
+    }));
+    const runtime = createRuntime(updateScheduledTaskState, {
+      runHistoryStore: history,
+      waitForOpenCodeReady: vi.fn(async () => {}),
     });
-    expect(typeof body.metadata.openchamber.goal.objectiveFile).toBe('boolean');
-    expect(typeof body.metadata.openchamber.goal.objective).toBe('string');
-    if (!body.metadata.openchamber.goal.objectiveFile) {
-      expect(body.metadata.openchamber.goal.objective.length).toBeGreaterThan(0);
-    }
-    expect(client.abort).not.toHaveBeenCalled();
+    await runtime.syncProject('project-1');
+    const result = await runtime.runNow('project-1', 'task-1');
 
-    vi.unstubAllGlobals();
+    expect(result.ok).toBe(true);
+    expect(history.finishRun).toHaveBeenCalledWith(
+      expect.any(String),
+      expect.objectContaining({ status: 'success' }),
+    );
   });
 
-  it('successful runs never call session.abort', async () => {
+  it('does not succeed when the latest message is model-switched', async () => {
+    vi.useFakeTimers();
+    const history = createHistoryStore();
+    createSuccessfulClient({
+      messageListImpl: async () => ({
+        data: [{
+          id: 'msg_switch',
+          type: 'model-switched',
+          time: { created: Date.now() },
+          model: { providerID: 'openai', id: 'gpt-4.1' },
+        }],
+      }),
+    });
+    const updateScheduledTaskState = vi.fn(async (_projectID, _taskID, state) => ({
+      task: { ...scheduledTask, state: { ...scheduledTask.state, ...state } },
+    }));
+    const runtime = createRuntime(updateScheduledTaskState, {
+      runHistoryStore: history,
+      waitForOpenCodeReady: vi.fn(async () => {}),
+      maxRunDurationMs: 2_500,
+    });
+    await runtime.syncProject('project-1');
+
+    const runPromise = runtime.runNow('project-1', 'task-1');
+    await vi.advanceTimersByTimeAsync(1_000);
+    expect(history.finishRun).not.toHaveBeenCalled();
+    await vi.advanceTimersByTimeAsync(1_500);
+    const result = await runPromise;
+
+    expect(result.ok).toBe(false);
+    expect(result.error).toBe('schedule run timed out');
+    vi.useRealTimers();
+  });
+
+  it('does not succeed when the assistant finish is tool-calls', async () => {
+    vi.useFakeTimers();
+    const history = createHistoryStore();
+    createSuccessfulClient({
+      messageListImpl: async () => ({
+        data: [{
+          id: 'msg_tools',
+          type: 'assistant',
+          time: { created: 1, completed: 2 },
+          finish: 'tool-calls',
+        }],
+      }),
+    });
+    const updateScheduledTaskState = vi.fn(async (_projectID, _taskID, state) => ({
+      task: { ...scheduledTask, state: { ...scheduledTask.state, ...state } },
+    }));
+    const runtime = createRuntime(updateScheduledTaskState, {
+      runHistoryStore: history,
+      waitForOpenCodeReady: vi.fn(async () => {}),
+      maxRunDurationMs: 2_500,
+    });
+    await runtime.syncProject('project-1');
+
+    const runPromise = runtime.runNow('project-1', 'task-1');
+    await vi.advanceTimersByTimeAsync(1_000);
+    expect(history.finishRun).not.toHaveBeenCalled();
+    await vi.advanceTimersByTimeAsync(1_500);
+    const result = await runPromise;
+
+    expect(result.ok).toBe(false);
+    expect(result.error).toBe('schedule run timed out');
+    vi.useRealTimers();
+  });
+
+  it('does not succeed after two incomplete assistant idle probes', async () => {
+    vi.useFakeTimers();
+    const history = createHistoryStore();
+    createSuccessfulClient({
+      messageListImpl: async () => ({
+        data: [{
+          id: 'msg_incomplete',
+          type: 'assistant',
+          time: { created: 1 },
+          // no time.completed, no finish
+        }],
+      }),
+    });
+    const updateScheduledTaskState = vi.fn(async (_projectID, _taskID, state) => ({
+      task: { ...scheduledTask, state: { ...scheduledTask.state, ...state } },
+    }));
+    const runtime = createRuntime(updateScheduledTaskState, {
+      runHistoryStore: history,
+      waitForOpenCodeReady: vi.fn(async () => {}),
+      maxRunDurationMs: 3_500,
+    });
+    await runtime.syncProject('project-1');
+
+    const runPromise = runtime.runNow('project-1', 'task-1');
+    // Two idle polls with incomplete assistant must not finalize as success.
+    await vi.advanceTimersByTimeAsync(2_000);
+    expect(history.finishRun).not.toHaveBeenCalled();
+    await vi.advanceTimersByTimeAsync(1_500);
+    const result = await runPromise;
+
+    expect(result.ok).toBe(false);
+    expect(result.error).toBe('schedule run timed out');
+    expect(history.finishRun).toHaveBeenCalledWith(
+      expect.any(String),
+      expect.objectContaining({ status: 'error', error: 'schedule run timed out' }),
+    );
+    vi.useRealTimers();
+  });
+
+  it('lists settlement messages with order=desc (latest-side page)', async () => {
+    const history = createHistoryStore();
+    const client = createSuccessfulClient();
+    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');
+    await runtime.runNow('project-1', 'task-1');
+
+    expect(client.messageList).toHaveBeenCalledWith(
+      expect.objectContaining({
+        sessionID: 'ses_1',
+        limit: 50,
+        order: 'desc',
+      }),
+      expect.objectContaining({ signal: expect.any(AbortSignal) }),
+    );
+  });
+
+  it('successful runs never call session.interrupt', async () => {
     const history = createHistoryStore();
     const client = createSuccessfulClient();
-    const fetchMock = vi.fn(async () => ({ ok: true, text: async () => '' }));
-    vi.stubGlobal('fetch', fetchMock);
 
     const updateScheduledTaskState = vi.fn(async (_projectID, _taskID, state) => ({
       task: { ...scheduledTask, state: { ...scheduledTask.state, ...state } },
@@ -1017,9 +1327,7 @@ describe('scheduled-tasks run history and session lifecycle', () => {
     const result = await runtime.runNow('project-1', 'task-1');
 
     expect(result.ok).toBe(true);
-    expect(client.abort).not.toHaveBeenCalled();
-
-    vi.unstubAllGlobals();
+    expect(client.interrupt).not.toHaveBeenCalled();
   });
 
   it('persists lastSessionId when an error run still created a session', async () => {
@@ -1114,14 +1422,8 @@ describe('scheduled-tasks run history and session lifecycle', () => {
       sessionID: 'ses_1',
     }));
 
-    client.messages.mockImplementation(async () => ({
-      data: [{
-        info: {
-          id: 'msg_ok',
-          role: 'assistant',
-          time: { completed: Date.now() },
-        },
-      }],
+    client.messageList.mockImplementation(async () => ({
+      data: [completedAssistant('msg_ok')],
     }));
 
     await runtime.observeSessionEvent({
@@ -1165,14 +1467,8 @@ describe('scheduled-tasks run history and session lifecycle', () => {
     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() },
-        },
-      }],
+    client.messageList.mockImplementation(async () => ({
+      data: [completedAssistant('msg_ok')],
     }));
 
     await runtime.observeSessionEvent({
@@ -1303,14 +1599,8 @@ describe('scheduled-tasks run history and session lifecycle', () => {
     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() },
-        },
-      }],
+    client.messageList.mockImplementation(async () => ({
+      data: [completedAssistant('msg_ok')],
     }));
 
     await runtime.observeSessionEvent({
@@ -1369,6 +1659,7 @@ describe('scheduled-tasks cross-process slot occupancy', () => {
         waitForOpenCodeReady: vi.fn(async () => {
           throw new Error('OpenCode unavailable');
         }),
+        persistSessionMetadata: vi.fn(async () => ({})),
         logger: { info: vi.fn(), warn: vi.fn() },
         runHistoryStore: store,
         notifyTaskRun,