@vantran-se/openchamber-web 1.24.3 → 2.0.1

package/server/lib/routing/runtime.test.js

@@ -2,9 +2,9 @@ import { describe, expect, it, vi } from 'vitest';
 import { createRoutingRuntime, requestTextOf } from './runtime.js';
 import { resolveEffectiveConfig } from './store.js';
 import { excerptHead, excerptHeadTail, turnsToHistory } from './history.js';
-import { decidePermission, decideRouting } from './jev.js';
+import { createJevClient, decidePermission, decideRouting } from './jev.js';
 
-const AUTO = { providerID: 'openchamber', modelID: 'auto' };
+const AUTO = { providerID: 'openchamber', id: 'auto' };
 const FALLBACK = { model: { providerID: 'anthropic', modelID: 'claude-sonnet-5' }, variant: 'medium' };
 
 const readyConfig = () => {
@@ -18,8 +18,7 @@ const readyConfig = () => {
   return config;
 };
 
-const makeRuntime = ({ config = readyConfig(), token = 'key', answers, askError, flag = '1' } = {}) => {
-  process.env.OPENCHAMBER_ROUTING_ENABLE = flag;
+const makeRuntime = ({ config = readyConfig(), token = 'key', answers, askError } = {}) => {
   const events = [];
   const store = {
     readConfig: vi.fn(async () => config),
@@ -41,16 +40,15 @@ const makeRuntime = ({ config = readyConfig(), token = 'key', answers, askError,
 };
 
 describe('requestTextOf', () => {
-  it('joins authored text parts and ignores synthetic ones and files', () => {
-    expect(requestTextOf({ parts: [
-      { type: 'text', text: 'fix the typo' },
-      { type: 'text', text: 'injected', synthetic: true },
-      { type: 'file', url: 'data:...' },
-      { type: 'text', text: 'in README' },
-    ] })).toBe('fix the typo\n\nin README');
+  it('reads the prompt text a v2 send carries', () => {
+    expect(requestTextOf({ text: '  fix the typo in README  ', files: [{ uri: 'data:...' }] })).toBe('fix the typo in README');
   });
-  it('renders a slash command with its arguments', () => {
-    expect(requestTextOf({ command: 'review', arguments: ' 3650 ' })).toBe('/review 3650');
+  it('renders a v2 command body (`name` plus `text`) as the slash command', () => {
+    expect(requestTextOf({ name: 'review', text: ' src ' })).toBe('/review src');
+  });
+  it('keeps the command name when it has no arguments', () => {
+    expect(requestTextOf({ name: 'review', text: '' })).toBe('/review');
+    expect(requestTextOf({ name: 'review' })).toBe('/review');
   });
 });
 
@@ -85,63 +83,91 @@ describe('decisions', () => {
   });
 });
 
-describe('resolvePromptBody', () => {
+describe('resolveAutoSelection', () => {
+  const send = (extra = {}) => ({ sessionId: 's1', model: AUTO, requestText: 'find the root cause', ...extra });
+
   it('leaves a real model untouched and does not consult Jev', async () => {
     const { runtime, jev } = makeRuntime({ answers: {} });
-    const body = { model: { providerID: 'anthropic', modelID: 'claude-opus-5' }, parts: [] };
-    expect(await runtime.resolvePromptBody(body, { sessionId: 's1' })).toBeNull();
-    expect(body.model.modelID).toBe('claude-opus-5');
+    expect(await runtime.resolveAutoSelection(send({ model: { providerID: 'anthropic', id: 'claude-opus-5' } }))).toBeNull();
     expect(jev.ask).not.toHaveBeenCalled();
   });
 
-  it('rewrites the sentinel with the routed category model, variant and agent', async () => {
+  it('answers with the routed category model, variant and agent', async () => {
     const { runtime, events } = makeRuntime({ answers: { category: { choice: 'hard', confidence: 0.97 } } });
-    const body = { model: AUTO, variant: 'low', agent: 'build', parts: [{ type: 'text', text: 'find the root cause' }] };
-    const decision = await runtime.resolvePromptBody(body, { sessionId: 's1' });
-    expect(body).toMatchObject({ model: { providerID: 'openai', modelID: 'gpt-6-astra' }, variant: 'high', agent: 'plan' });
-    expect(decision).toMatchObject({ category: 'hard', reason: 'routed', confidence: 0.97 });
+    const resolved = await runtime.resolveAutoSelection(send({ agent: 'build' }));
+    expect(resolved.model).toEqual({ providerID: 'openai', id: 'gpt-6-astra', variant: 'high' });
+    expect(resolved.agent).toBe('plan');
+    expect(resolved.decision).toMatchObject({ category: 'hard', reason: 'routed', confidence: 0.97 });
     expect(events.at(-1)).toMatchObject({ type: 'openchamber:routing.decision', properties: { sessionId: 's1', category: 'hard' } });
   });
 
-  it('rewrites the string sentinel the command route sends, keeping the string shape', async () => {
-    const { runtime } = makeRuntime({ answers: { category: { choice: 'hard', confidence: 0.97 } } });
-    const body = { model: 'openchamber/auto', command: 'review', arguments: '3650' };
-    await runtime.resolvePromptBody(body, { sessionId: 's1' });
-    expect(body.model).toBe('openai/gpt-6-astra');
-    expect(body.agent).toBe('plan');
-  });
-
-  it('uses the fallback and keeps the composer agent when the category has no model', async () => {
+  it('uses the fallback pair and keeps the composer agent when the category has no model', async () => {
     const { runtime } = makeRuntime({ answers: { category: { choice: 'trivial', confidence: 0.99 } } });
-    const body = { model: AUTO, variant: 'high', agent: 'build', parts: [{ type: 'text', text: 'fix typo' }] };
-    await runtime.resolvePromptBody(body, { sessionId: 's1' });
-    expect(body).toMatchObject({ model: FALLBACK.model, variant: 'medium', agent: 'build' });
+    const resolved = await runtime.resolveAutoSelection(send({ agent: 'build', requestText: 'fix typo' }));
+    expect(resolved.model).toEqual({ providerID: 'anthropic', id: 'claude-sonnet-5', variant: 'medium' });
+    expect(resolved.agent).toBe('build');
   });
 
   it('falls back on low confidence and on a Jev failure, and records why', async () => {
     const low = makeRuntime({ answers: { category: { choice: 'hard', confidence: 0.3 } } });
-    const body = { model: AUTO, parts: [] };
-    expect((await low.runtime.resolvePromptBody(body, { sessionId: 's1' })).reason).toBe('low-confidence');
-    expect(body.model).toEqual(FALLBACK.model);
+    const lowResolved = await low.runtime.resolveAutoSelection(send());
+    expect(lowResolved.decision.reason).toBe('low-confidence');
+    expect(lowResolved.model).toMatchObject({ providerID: 'anthropic', id: 'claude-sonnet-5' });
 
     const failing = makeRuntime({ askError: Object.assign(new Error('Jev responded 401'), { status: 401 }) });
-    const body2 = { model: AUTO, parts: [] };
-    const decision = await failing.runtime.resolvePromptBody(body2, { sessionId: 's1' });
-    expect(decision).toMatchObject({ reason: 'error', error: 'Jev responded 401' });
-    expect(body2.model).toEqual(FALLBACK.model);
+    const resolved = await failing.runtime.resolveAutoSelection(send());
+    expect(resolved.decision).toMatchObject({ reason: 'error', error: 'Jev responded 401' });
+    expect(resolved.model).toMatchObject({ providerID: 'anthropic', id: 'claude-sonnet-5' });
   });
 
   it('falls back without asking Jev while Auto is not ready, and refuses without a fallback', async () => {
     const config = readyConfig();
     config.enabled = false;
     const notReady = makeRuntime({ config, answers: {} });
-    const body = { model: AUTO, parts: [] };
-    expect((await notReady.runtime.resolvePromptBody(body, { sessionId: 's1' })).reason).toBe('not-ready');
-    expect(body.model).toEqual(FALLBACK.model);
+    const resolved = await notReady.runtime.resolveAutoSelection(send());
+    expect(resolved.decision.reason).toBe('not-ready');
+    expect(resolved.model).toMatchObject({ providerID: 'anthropic', id: 'claude-sonnet-5' });
     expect(notReady.jev.ask).not.toHaveBeenCalled();
 
     const noFallback = makeRuntime({ config: { ...readyConfig(), fallback: null }, answers: {} });
-    await expect(noFallback.runtime.resolvePromptBody({ model: AUTO, parts: [] }, { sessionId: 's1' })).rejects.toMatchObject({ status: 400 });
+    await expect(noFallback.runtime.resolveAutoSelection(send())).rejects.toMatchObject({ status: 400 });
+  });
+});
+
+describe('jev endpoint', () => {
+  const capture = async (token) => {
+    let call = null;
+    const fetchImpl = async (url, init) => {
+      call = { url, init };
+      return { ok: true, status: 200, text: async () => JSON.stringify({ answers: {} }) };
+    };
+    await createJevClient({ fetchImpl }).ask({ state: 'x', questions: {} }, token);
+    return { url: call.url, headers: call.init.headers, body: JSON.parse(call.init.body) };
+  };
+
+  it('sends a saved key to TypeSafe and falls back to the free model zen serves without one', async () => {
+    const keyed = await capture('secret');
+    expect(keyed.url).toBe('https://api.typesafe.ai/v1/systemone');
+    expect(keyed.headers.authorization).toBe('Bearer secret');
+    expect(keyed.body.model).toBe('jev-latest');
+
+    const free = await capture(null);
+    expect(free.url).toBe('https://opencode.ai/zen/v1/systemone');
+    expect(free.headers.authorization).toBeUndefined();
+    // Zen counts our calls by this header, and does not know the `jev-latest` alias.
+    expect(free.headers['x-opencode-client']).toBe('openchamber');
+    expect(free.body.model).toBe('jev-1.13-free');
+  });
+});
+
+describe('auto sessions', () => {
+  it('remembers the sentinel selection and forgets it when a real model is chosen', () => {
+    const { runtime } = makeRuntime({ answers: {} });
+    expect(runtime.isAutoSession('s1')).toBe(false);
+    expect(runtime.noteModelSelection('s1', AUTO, '/repo')).toBe(true);
+    expect(runtime.isAutoSession('s1')).toBe(true);
+    expect(runtime.noteModelSelection('s1', { providerID: 'anthropic', id: 'claude-opus-5' }, '/repo')).toBe(false);
+    expect(runtime.isAutoSession('s1')).toBe(false);
   });
 });
 
@@ -165,24 +191,22 @@ describe('evaluatePermission', () => {
     expect(events.at(-1)).toMatchObject({ type: 'openchamber:routing.safety-skipped', properties: { permissionId: 'p1', error: 'Jev timed out after 4000ms' } });
   });
 
-  it('accepts without asking when the safety net is off, the key is missing, or the flag is unset', async () => {
+  it('accepts without asking when the safety net is off', async () => {
     const off = readyConfig();
     off.safetyNet.enabled = false;
-    for (const setup of [{ config: off }, { token: null }, { flag: '' }]) {
-      const { runtime, jev } = makeRuntime({ ...setup, answers: {} });
-      expect(await runtime.evaluatePermission(permission, '/repo')).toEqual({ action: 'accept' });
-      expect(jev.ask).not.toHaveBeenCalled();
-    }
+    const { runtime, jev } = makeRuntime({ config: off, answers: {} });
+    expect(await runtime.evaluatePermission(permission, '/repo')).toEqual({ action: 'accept' });
+    expect(jev.ask).not.toHaveBeenCalled();
   });
 });
 
 describe('describe', () => {
-  it('reports Auto ready only with the flag, enabled config, key, fallback and two categories', async () => {
-    expect((await makeRuntime({ answers: {} }).runtime.describe()).autoReady).toBe(true);
-    expect((await makeRuntime({ token: null, answers: {} }).runtime.describe())).toMatchObject({ autoReady: false, tokenPresent: false });
+  it('reports Auto ready with an enabled config, a fallback and two categories, key or no key', async () => {
+    expect((await makeRuntime({ answers: {} }).runtime.describe())).toMatchObject({ autoReady: true, tokenPresent: true, jevSource: 'typesafe' });
+    // Without a key the free Jev model on zen answers, so Auto stays available.
+    expect((await makeRuntime({ token: null, answers: {} }).runtime.describe())).toMatchObject({ autoReady: true, tokenPresent: false, jevSource: 'zen-free' });
     const one = readyConfig();
     one.categories = one.categories.map((c, i) => ({ ...c, enabled: i === 0 }));
     expect((await makeRuntime({ config: one, answers: {} }).runtime.describe()).autoReady).toBe(false);
-    expect(await makeRuntime({ flag: '', answers: {} }).runtime.describe()).toEqual({ available: false, autoReady: false, tokenPresent: false, config: null, builtins: [] });
   });
 });

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

@@ -188,3 +188,7 @@ project write lock on every `syncProject` when the project path is known:
   - `POST /api/projects/:projectId/scheduled-tasks/:taskId/run`
   - `GET /api/openchamber/scheduled-tasks/status`
   - `GET /api/openchamber/events`
+
+The shared `/api/openchamber/events` stream also carries web notifications.
+Its connection ownership and browser capability flag stay unchanged. Delivery
+and duplicate handling are documented in `../notifications/DOCUMENTATION.md`.

package/server/lib/scheduled-tasks/issue-2710-double-execution.test.js

@@ -14,25 +14,33 @@ import { describe, expect, it, vi, beforeEach, afterEach } from 'vitest';
  * before creating a session, so the second instance skips.
  */
 
-const sdk = vi.hoisted(() => ({
-  sessionCreates: [],
-  createOpencodeClient: () => ({
-    session: {
-      create: async () => {
-        sdk.sessionCreates.push(Date.now());
-        return { data: { id: `sess-${sdk.sessionCreates.length}` } };
-      },
-    },
-    command: { list: async () => ({ data: [] }) },
-  }),
-}));
-
-vi.mock('@opencode-ai/sdk/v2', () => ({
-  createOpencodeClient: sdk.createOpencodeClient,
-}));
-
 import { createScheduledTasksRuntime } from './runtime.js';
 
+const opencode = { sessionCreates: [] };
+
+const jsonResponse = (body) => new Response(JSON.stringify(body), {
+  status: 200,
+  headers: { 'content-type': 'application/json' },
+});
+
+/**
+ * Serves the few v2 routes a scheduled run touches so the test drives the real
+ * @opencode/client over its own transport instead of replacing the module.
+ * `gate` holds the prompt open the way a long-running dispatch would.
+ */
+const installOpenCodeFetch = (gate = null) => {
+  globalThis.fetch = vi.fn(async (input) => {
+    const { pathname } = new URL(input);
+    if (pathname === '/api/session') {
+      opencode.sessionCreates.push(Date.now());
+      return jsonResponse({ data: { id: `sess-${opencode.sessionCreates.length}` } });
+    }
+    if (pathname === '/api/command') return jsonResponse({ data: [] });
+    if (gate) await gate;
+    return jsonResponse({ data: {} });
+  });
+};
+
 const UTC = (y, mo, d, h, mi, s = 0) => Date.UTC(y, mo, d, h, mi, s);
 const MINUTE = 60_000;
 const HOUR = 3_600_000;
@@ -118,8 +126,8 @@ const startInstances = async (count, task) => {
 describe('issue 2710: daily scheduled task double execution at the configured time', () => {
   beforeEach(() => {
     vi.useFakeTimers();
-    sdk.sessionCreates.length = 0;
-    globalThis.fetch = vi.fn(async () => ({ ok: true, text: async () => '' }));
+    opencode.sessionCreates.length = 0;
+    installOpenCodeFetch();
   });
 
   afterEach(() => {
@@ -132,8 +140,8 @@ describe('issue 2710: daily scheduled task double execution at the configured ti
     const { runtimes } = await startInstances(1, makeTask({ kind: 'daily', times: ['15:00'] }));
     await vi.advanceTimersByTimeAsync(HOUR + 3_000);
 
-    expect(sdk.sessionCreates.length).toBe(1);
-    const firedAt = new Date(sdk.sessionCreates[0]);
+    expect(opencode.sessionCreates.length).toBe(1);
+    const firedAt = new Date(opencode.sessionCreates[0]);
     expect(firedAt.getUTCHours()).toBe(15);
 
     runtimes.forEach((runtime) => runtime.stop());
@@ -144,9 +152,9 @@ describe('issue 2710: daily scheduled task double execution at the configured ti
     const { runtimes } = await startInstances(1, makeTask({ kind: 'daily', times: ['15:00'] }));
     await vi.advanceTimersByTimeAsync((4 * 24 * HOUR) + 3_000);
 
-    expect(sdk.sessionCreates.length).toBe(4);
+    expect(opencode.sessionCreates.length).toBe(4);
     const byHourBucket = new Map();
-    for (const timestamp of sdk.sessionCreates) {
+    for (const timestamp of opencode.sessionCreates) {
       const date = new Date(timestamp);
       expect(date.getUTCHours()).toBe(15);
       expect(date.getUTCMinutes()).toBe(0);
@@ -168,8 +176,8 @@ describe('issue 2710: daily scheduled task double execution at the configured ti
     );
     await vi.advanceTimersByTimeAsync(HOUR + 3_000);
 
-    expect(sdk.sessionCreates.length).toBe(1);
-    const firedAt = new Date(sdk.sessionCreates[0]);
+    expect(opencode.sessionCreates.length).toBe(1);
+    const firedAt = new Date(opencode.sessionCreates[0]);
     expect(firedAt.getUTCHours()).toBe(15);
     expect(firedAt.getUTCMinutes()).toBe(0);
     expect(projectConfigRuntime.updateScheduledTaskStateIf).toHaveBeenCalled();
@@ -187,7 +195,7 @@ describe('issue 2710: daily scheduled task double execution at the configured ti
     }));
     await vi.advanceTimersByTimeAsync((25 * HOUR) + 3_000);
 
-    expect(sdk.sessionCreates.length).toBe(1);
+    expect(opencode.sessionCreates.length).toBe(1);
 
     runtimes.forEach((runtime) => runtime.stop());
   });
@@ -197,7 +205,7 @@ describe('issue 2710: daily scheduled task double execution at the configured ti
     const { runtimes } = await startInstances(2, makeTask({ kind: 'cron', cron: '*/5 * * * *' }));
     await vi.advanceTimersByTimeAsync(3 * MINUTE);
 
-    expect(sdk.sessionCreates.length).toBe(1);
+    expect(opencode.sessionCreates.length).toBe(1);
 
     runtimes.forEach((runtime) => runtime.stop());
   });
@@ -211,7 +219,7 @@ describe('issue 2710: daily scheduled task double execution at the configured ti
     }));
     await vi.advanceTimersByTimeAsync(HOUR + 3_000);
 
-    expect(sdk.sessionCreates.length).toBe(1);
+    expect(opencode.sessionCreates.length).toBe(1);
 
     runtimes.forEach((runtime) => runtime.stop());
   });
@@ -229,14 +237,14 @@ describe('issue 2710: daily scheduled task double execution at the configured ti
 
     await vi.advanceTimersByTimeAsync(HOUR + 3_000);
 
-    expect(sdk.sessionCreates.length).toBe(0);
+    expect(opencode.sessionCreates.length).toBe(0);
     expect(runtime.getStatus().runningScheduledTasksCount).toBe(0);
     expect(runtime.getStatus().hasRunningScheduledTasks).toBe(false);
 
     // Manual runNow must not be stuck behind a permanently "running" claim failure.
     const manual = await runtime.runNow('p1', 'task-1');
     expect(manual.ok).toBe(true);
-    expect(sdk.sessionCreates.length).toBe(1);
+    expect(opencode.sessionCreates.length).toBe(1);
 
     runtime.stop();
   });
@@ -263,7 +271,7 @@ describe('issue 2710: daily scheduled task double execution at the configured ti
 
     // Initial completion write + best-effort retry.
     expect(completionWrites).toBeGreaterThanOrEqual(2);
-    expect(sdk.sessionCreates.length).toBe(1);
+    expect(opencode.sessionCreates.length).toBe(1);
     expect(runtime.getStatus().runningScheduledTasksCount).toBe(0);
 
     const manual = await runtime.runNow('p1', 'task-1');
@@ -316,7 +324,7 @@ describe('issue 2710: daily scheduled task double execution at the configured ti
     const manual = await runtime.runNow('p1', 'task-1');
     expect(manual.ok).toBe(false);
     expect(manual.reason).toBe('start-state-failed');
-    expect(sdk.sessionCreates.length).toBe(0);
+    expect(opencode.sessionCreates.length).toBe(0);
     expect(runtime.getStatus().runningScheduledTasksCount).toBe(0);
 
     runtime.stop();
@@ -340,7 +348,7 @@ describe('issue 2710: daily scheduled task double execution at the configured ti
 
     await vi.advanceTimersByTimeAsync(5_000);
 
-    expect(sdk.sessionCreates.length).toBe(1);
+    expect(opencode.sessionCreates.length).toBe(1);
 
     runtimeA.stop();
     runtimeB.stop();
@@ -356,7 +364,7 @@ describe('issue 2710: daily scheduled task double execution at the configured ti
     const runtimeA = createScheduledTasksRuntime(createRuntimeDeps(projectConfigRuntime));
     await runtimeA.start();
     await vi.advanceTimersByTimeAsync(HOUR + 3_000);
-    expect(sdk.sessionCreates.length).toBe(1);
+    expect(opencode.sessionCreates.length).toBe(1);
 
     // Advance to day-2 afternoon, still outside slack, so A re-arms for 15:00.
     await vi.advanceTimersByTimeAsync((23 * HOUR) - 3_000);
@@ -367,7 +375,7 @@ describe('issue 2710: daily scheduled task double execution at the configured ti
 
     await vi.advanceTimersByTimeAsync(5_000);
 
-    expect(sdk.sessionCreates.length).toBe(2);
+    expect(opencode.sessionCreates.length).toBe(2);
 
     runtimeA.stop();
     runtimeB.stop();
@@ -380,10 +388,7 @@ describe('issue 2710: daily scheduled task double execution at the configured ti
     const fetchGate = new Promise((resolve) => {
       releaseFetch = resolve;
     });
-    globalThis.fetch = vi.fn(async () => {
-      await fetchGate;
-      return { ok: true, text: async () => '' };
-    });
+    installOpenCodeFetch(fetchGate);
 
     const { runtimes, projectConfigRuntime } = await startInstances(2, makeTask({
       kind: 'once',
@@ -393,21 +398,21 @@ describe('issue 2710: daily scheduled task double execution at the configured ti
 
     await vi.advanceTimersByTimeAsync(HOUR + 3_000);
 
-    // Winner claimed and is blocked in prompt_async; exactly one session.
-    expect(sdk.sessionCreates.length).toBe(1);
+    // Winner claimed and is blocked in the prompt dispatch; exactly one session.
+    expect(opencode.sessionCreates.length).toBe(1);
     const claimsAfterFire = projectConfigRuntime.updateScheduledTaskStateIf.mock.calls.length;
     expect(claimsAfterFire).toBeGreaterThanOrEqual(1);
 
     // Advance through many jitter windows. Loser must not keep re-entering claim.
     await vi.advanceTimersByTimeAsync(60_000);
     expect(projectConfigRuntime.updateScheduledTaskStateIf.mock.calls.length).toBe(claimsAfterFire);
-    expect(sdk.sessionCreates.length).toBe(1);
+    expect(opencode.sessionCreates.length).toBe(1);
 
     releaseFetch();
     await Promise.resolve();
     await vi.advanceTimersByTimeAsync(5_000);
 
-    expect(sdk.sessionCreates.length).toBe(1);
+    expect(opencode.sessionCreates.length).toBe(1);
     expect(runtimes.every((runtime) => runtime.getStatus().runningScheduledTasksCount === 0)).toBe(true);
 
     runtimes.forEach((runtime) => runtime.stop());
@@ -467,7 +472,7 @@ describe('issue 2710: daily scheduled task double execution at the configured ti
     await runtime.start();
     await vi.advanceTimersByTimeAsync(HOUR + 3_000);
 
-    expect(sdk.sessionCreates.length).toBe(0);
+    expect(opencode.sessionCreates.length).toBe(0);
     const tasks = await projectConfigRuntime.listScheduledTasks('p1');
     expect(tasks[0].state.lastStatus).toBe('error');
     expect(tasks[0].state.lastError).toMatch(/Scheduled claim failed/);
@@ -496,12 +501,12 @@ describe('issue 2710: daily scheduled task double execution at the configured ti
 
     // The scheduler must not fire a disabled task on its own.
     await vi.advanceTimersByTimeAsync(HOUR + 3_000);
-    expect(sdk.sessionCreates.length).toBe(0);
+    expect(opencode.sessionCreates.length).toBe(0);
 
     const manual = await runtime.runNow('p1', 'task-1');
     expect(manual.ok).toBe(true);
     expect(manual.sessionID).toBeTruthy();
-    expect(sdk.sessionCreates.length).toBe(1);
+    expect(opencode.sessionCreates.length).toBe(1);
     expect(runtime.getStatus().runningScheduledTasksCount).toBe(0);
 
     // Completion records state but leaves the task paused with no next run.