@vantran-se/openchamber-web 1.24.3 → 2.0.1

package/server/lib/session-assist/runtime.test.js

@@ -1,203 +1,175 @@
-import { createServer } from 'node:http';
 import { afterEach, describe, expect, it, vi } from 'vitest';
 import { createSessionAssistRuntime } from './runtime.js';
 
-const resources = [];
-const message = (id, role, text, extra = {}) => ({
-  info: { id, role, parentID: 'user', finish: 'stop', time: { completed: 1 }, providerID: 'test-provider', modelID: 'test-model', ...extra },
-  parts: [{ type: 'text', text }],
-});
-const output = (recap = 'Зміни готові', suggestion = '') => ({ text: JSON.stringify({ recap, suggestion }), providerID: 'test-provider', modelID: 'test-model' });
-const pause = () => new Promise((resolve) => setTimeout(resolve, 15));
-
-async function fixture(generate = async () => output()) {
-  const state = {
-    messages: [message('user', 'user', 'Виправ помилку'), message('answer', 'assistant', 'Виправлено')],
-    session: { id: 'session', directory: '/project', time: {}, metadata: { external: 'keep', openchamber: { note: 'keep' } } },
-    targets: { recap: true, suggestion: true },
-    gets: 0, failFresh: false, patches: [], requests: [], calls: [],
-  };
-  const server = createServer(async (request, response) => {
-    const url = new URL(request.url, 'http://localhost');
-    state.requests.push({ method: request.method, directory: url.searchParams.get('directory'), limit: url.searchParams.get('limit'), auth: request.headers['x-test-auth'] });
-    response.setHeader('content-type', 'application/json');
-    if (request.method === 'PATCH') {
-      const chunks = [];
-      for await (const chunk of request) chunks.push(chunk);
-      state.patches.push(JSON.parse(Buffer.concat(chunks).toString()));
-      response.end(JSON.stringify(state.session));
-    } else if (url.pathname.endsWith('/message')) {
-      response.end(JSON.stringify(url.searchParams.get('limit') === '1' ? state.messages.slice(-1) : state.messages));
-    } else {
-      state.gets++;
-      response.statusCode = state.failFresh && state.gets > 1 ? 500 : 200;
-      response.end(JSON.stringify(state.session));
-    }
+/**
+ * The recap and the suggestion live in OpenChamber's own session metadata
+ * store, because OpenCode 2.x accepts session metadata only at create time.
+ * `persistSessionAssist` is the seam. What is pinned here is the wiring: no
+ * store means no work and no cost, and injecting one turns generation back on.
+ *
+ * The previous suite drove the whole generation through a fake v1 OpenCode
+ * server. It is gone rather than rewritten: every shape it asserted on
+ * (`message.parts`, `info.parentID`, `info.summary`, `PATCH /session/{id}`)
+ * belongs to v1, so keeping it green would prove nothing about v2. The reader
+ * itself is covered by `context.test.js`.
+ */
+
+const runtimes = [];
+
+const makeRuntime = (overrides = {}) => {
+  const buildOpenCodeUrl = vi.fn(() => 'http://127.0.0.1:1/');
+  const getOpenCodeAuthHeaders = vi.fn(() => ({}));
+  const getSmallModelService = vi.fn(async () => {
+    throw new Error('the small model must not be consulted while assist is parked');
   });
-  await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
-  const base = `http://127.0.0.1:${server.address().port}`;
-  state.base = base;
   const runtime = createSessionAssistRuntime({
-    buildOpenCodeUrl: (route) => state.base + route,
-    getOpenCodeAuthHeaders: () => ({ 'x-test-auth': 'fixture' }),
-    getTargets: () => state.targets,
+    buildOpenCodeUrl,
+    getOpenCodeAuthHeaders,
+    getSmallModelService,
+    getTargets: () => ({ recap: true, suggestion: true }),
     quietMs: 1,
-    getSmallModelService: async () => ({
-      describeSmallModel: async () => ({ inputCharBudget: 64_000 }),
-      generateSmallModelText: async (args) => { state.calls.push(args); return generate(args, state); },
-    }),
+    ...overrides,
   });
-  resources.push({ runtime, server });
-  const status = (type) => runtime.processPayload({ type: 'session.status', properties: { sessionID: 'session', status: { type } } }, '/project');
-  return { state, runtime, status };
-}
+  runtimes.push(runtime);
+  return { runtime, buildOpenCodeUrl, getOpenCodeAuthHeaders, getSmallModelService };
+};
 
-afterEach(async () => {
-  for (const { runtime, server } of resources.splice(0)) {
-    runtime.stop();
-    server.closeAllConnections();
-    await new Promise((resolve) => server.close(resolve));
-  }
+const idle = (sessionId = 'ses_1') => ({
+  type: 'session.status',
+  properties: { sessionID: sessionId, status: { type: 'idle' } },
+});
+
+afterEach(() => {
+  while (runtimes.length > 0) runtimes.pop().stop();
   vi.restoreAllMocks();
 });
 
 describe('session assist runtime', () => {
-  it('uses bounded authenticated SDK reads and preserves metadata with an empty suggestion', async () => {
-    const { state, status } = await fixture(async (_args, current) => {
-      current.session.metadata.openchamber.concurrent = 'new';
-      return output();
-    });
-    status('idle');
-    await vi.waitFor(() => expect(state.patches).toHaveLength(1));
-    expect(state.requests.every((r) => r.directory === '/project' && r.auth === 'fixture')).toBe(true);
-    expect(state.requests.filter((r) => r.limit).map((r) => r.limit)).toEqual(['50', '1']);
-    expect(state.calls[0]).toMatchObject({ restrictToPreferredProvider: true, onOverflow: 'error', preferredProviderID: 'test-provider', preferredModelID: 'test-model', sessionID: 'session' });
-    expect(state.patches[0].metadata).toMatchObject({ external: 'keep', openchamber: {
-      note: 'keep', concurrent: 'new', assist: { recap: 'Зміни готові', suggestion: '', forMessageID: 'answer' },
-    } });
+  it('does no work and reaches no service while no assist store is injected', async () => {
+    vi.spyOn(console, 'log').mockImplementation(() => {});
+    const { runtime, buildOpenCodeUrl, getSmallModelService } = makeRuntime();
+
+    runtime.processPayload(idle());
+    await new Promise((resolve) => setTimeout(resolve, 20));
+
+    expect(buildOpenCodeUrl).not.toHaveBeenCalled();
+    expect(getSmallModelService).not.toHaveBeenCalled();
   });
 
-  it('does no work with both settings off and skips child, archived, or reverted sessions', async () => {
-    const { state, status } = await fixture();
-    state.targets = { recap: false, suggestion: false };
-    status('idle');
-    await pause();
-    expect(state.requests).toHaveLength(0);
-    state.targets.recap = true;
-    state.session.parentID = 'parent';
-    status('idle');
-    await vi.waitFor(() => expect(state.gets).toBe(1));
-    delete state.session.parentID;
-    state.session.revert = { messageID: 'user' };
-    status('idle');
-    await vi.waitFor(() => expect(state.gets).toBe(2));
-    delete state.session.revert;
-    state.session.time.archived = 1;
-    status('idle');
-    await vi.waitFor(() => expect(state.gets).toBe(3));
-    expect(state.calls).toHaveLength(0);
+  it('explains itself once, not on every idle session', async () => {
+    const log = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const { runtime } = makeRuntime();
+
+    runtime.processPayload(idle('ses_1'));
+    runtime.processPayload(idle('ses_2'));
+    runtime.processPayload(idle('ses_3'));
+
+    const notices = log.mock.calls.filter(([line]) => String(line).includes('[session-assist] parked'));
+    expect(notices).toHaveLength(1);
   });
 
-  it('keeps recent context for recap-only and performs no write for an empty suggestion-only result', async () => {
-    const { state, status } = await fixture();
-    state.targets.suggestion = false;
-    state.messages.unshift(message('previous-user', 'user', 'Попередня задача'), message('previous-answer', 'assistant', 'Зміст зробленого', { parentID: 'previous-user' }));
-    status('idle');
-    await vi.waitFor(() => expect(state.patches).toHaveLength(1));
-    expect(state.calls[0].prompt).toContain('Зміст зробленого');
-    expect(state.calls[0].system).not.toContain('suggestion');
-    state.targets = { recap: false, suggestion: true };
-    status('idle');
-    await vi.waitFor(() => expect(state.calls).toHaveLength(2));
-    await pause();
-    expect(state.patches).toHaveLength(1);
+  it('ignores everything after stop', async () => {
+    const log = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const { runtime } = makeRuntime();
+
+    runtime.stop();
+    runtime.processPayload(idle());
+
+    expect(log).not.toHaveBeenCalled();
   });
 
-  it('does not write a stale result when the tail moves during generation', async () => {
-    const { state, status } = await fixture(async (_args, current) => {
-      current.messages.push(message('new-user', 'user', 'Нова задача'));
-      return output();
+  it('leaves an archived session alone: no context is loaded and no model is called', async () => {
+    const persistSessionAssist = vi.fn(async () => undefined);
+    const getSmallModelService = vi.fn(async () => {
+      throw new Error('the small model must not be consulted for an archived session');
+    });
+    const fetchMock = vi.fn(async (input) => {
+      const url = new URL(String(input));
+      const body = url.pathname === '/api/session/ses_1'
+        ? { location: { directory: '/repo' }, data: { id: 'ses_1', location: { directory: '/repo' } } }
+        : { location: { directory: '/repo' }, data: { data: [], cursor: null } };
+      return new Response(JSON.stringify(body), { status: 200, headers: { 'content-type': 'application/json' } });
+    });
+    vi.stubGlobal('fetch', fetchMock);
+    const { runtime } = makeRuntime({
+      persistSessionAssist,
+      getSmallModelService,
+      buildOpenCodeUrl: (fetchPath) => `http://opencode.test${fetchPath}`,
+      isSessionArchived: async (sessionId) => sessionId === 'ses_1',
     });
-    status('idle');
-    await vi.waitFor(() => expect(state.requests.some((r) => r.limit === '1')).toBe(true));
-    await pause();
-    expect(state.patches).toHaveLength(0);
-  });
 
-  it('does not fall back to stale metadata when the fresh read fails', async () => {
-    const warning = vi.spyOn(console, 'warn').mockImplementation(() => {});
-    const { state, status } = await fixture();
-    state.failFresh = true;
-    status('idle');
-    await vi.waitFor(() => expect(warning).toHaveBeenCalled());
-    expect(state.gets).toBe(2);
-    expect(state.patches).toHaveLength(0);
-  });
+    runtime.processPayload(idle());
+    await new Promise((resolve) => setTimeout(resolve, 40));
 
-  it('cancels old work and retains an expired newer idle timer until it can run', async () => {
-    const releases = [];
-    const { state, status } = await fixture(() => new Promise((resolve) => releases.push(resolve)));
-    status('idle');
-    await vi.waitFor(() => expect(releases).toHaveLength(1));
-    status('busy');
-    expect(state.calls[0].signal.aborted).toBe(true);
-    state.messages.push(message('next-user', 'user', 'Далі'), message('next-answer', 'assistant', 'Готово', { parentID: 'next-user' }));
-    status('idle');
-    await pause();
-    releases[0](output('Старий результат'));
-    await vi.waitFor(() => expect(releases).toHaveLength(2));
-    expect(state.patches).toHaveLength(0);
-    releases[1](output('Новий результат'));
-    await vi.waitFor(() => expect(state.patches).toHaveLength(1));
-    expect(state.patches[0].metadata.openchamber.assist).toMatchObject({ recap: 'Новий результат', forMessageID: 'next-answer' });
+    // The session record was read (that is where the parent/revert checks
+    // live), then the archive check stopped everything else.
+    expect(fetchMock.mock.calls.map(([input]) => new URL(String(input)).pathname)).toEqual(['/api/session/ses_1']);
+    expect(getSmallModelService).not.toHaveBeenCalled();
+    expect(persistSessionAssist).not.toHaveBeenCalled();
+    vi.unstubAllGlobals();
   });
 
-  it('aborts on stop and honors settings switched off during generation', async () => {
-    let release;
-    const { state, runtime, status } = await fixture(() => new Promise((resolve) => { release = resolve; }));
-    status('idle');
-    await vi.waitFor(() => expect(state.calls).toHaveLength(1));
-    runtime.stop();
-    expect(state.calls[0].signal.aborted).toBe(true);
-    release(output());
-    await pause();
-    expect(state.patches).toHaveLength(0);
-    const second = await fixture(async (_args, current) => {
-      current.targets = { recap: false, suggestion: false };
-      return output();
+  it('generates and saves an assist for a turn that v2 closed with an idle marker', async () => {
+    vi.spyOn(console, 'log').mockImplementation(() => {});
+    const persistSessionAssist = vi.fn(async () => undefined);
+    const listLimits = [];
+    // Newest first, the way OpenCode serves it: the idle marker sits above
+    // the answer, and a model switch the user made afterwards above that.
+    const records = [
+      { id: 'msg_switch', type: 'model-switched', model: { providerID: 'p', id: 'm' } },
+      { id: 'msg_idle', type: 'idle', outcome: 'succeeded' },
+      { id: 'msg_a', type: 'assistant', content: [{ type: 'text', text: 'All done.' }], finish: 'stop', time: { completed: 2 }, model: { providerID: 'p', id: 'm' } },
+      { id: 'msg_u', type: 'user', text: 'Do the thing' },
+    ];
+    const fetchMock = vi.fn(async (input) => {
+      const url = new URL(String(input));
+      let body;
+      // `session.get` answers `{ data }`, which the client unwraps; the message
+      // page is `{ data, cursor }` and reaches the reader as is.
+      if (url.pathname === '/api/session/ses_1') body = { data: { id: 'ses_1', location: { directory: '/repo' } } };
+      else if (url.pathname === '/api/session/ses_1/message') {
+        listLimits.push(Number(url.searchParams.get('limit')));
+        body = { data: records.slice(0, Number(url.searchParams.get('limit'))), cursor: {} };
+      } else throw new Error(`unexpected ${url.pathname}`);
+      return new Response(JSON.stringify(body), { status: 200, headers: { 'content-type': 'application/json' } });
     });
-    second.status('idle');
-    await vi.waitFor(() => expect(second.state.gets).toBe(2));
-    await pause();
-    expect(second.state.patches).toHaveLength(0);
-  });
+    vi.stubGlobal('fetch', fetchMock);
+    const { runtime } = makeRuntime({
+      persistSessionAssist,
+      buildOpenCodeUrl: (fetchPath) => `http://opencode.test${fetchPath}`,
+      isSessionArchived: async () => false,
+      getSmallModelService: async () => ({
+        describeSmallModel: async () => ({ inputCharBudget: 20_000 }),
+        generateSmallModelText: async () => ({ text: '{"recap":"Did the thing.","suggestion":"Verify it."}' }),
+      }),
+    });
+
+    runtime.processPayload(idle());
+    for (let i = 0; i < 20 && persistSessionAssist.mock.calls.length === 0; i += 1) {
+      await new Promise((resolve) => setTimeout(resolve, 10));
+    }
 
-  it('ignores historical user updates but cancels a new request during generation', async () => {
-    let release;
-    const { state, runtime, status } = await fixture(() => new Promise((resolve) => { release = resolve; }));
-    status('idle');
-    await vi.waitFor(() => expect(state.calls).toHaveLength(1));
-    const userUpdate = (created) => runtime.processPayload({ type: 'message.updated', properties: {
-      info: { id: 'user', sessionID: 'session', role: 'user', time: { created } },
-    } });
-    userUpdate(1);
-    expect(state.calls[0].signal.aborted).toBe(false);
-    userUpdate(Date.now());
-    expect(state.calls[0].signal.aborted).toBe(true);
-    release(output());
-    await pause();
-    expect(state.patches).toHaveLength(0);
+    expect(persistSessionAssist).toHaveBeenCalledTimes(1);
+    expect(persistSessionAssist.mock.calls[0][2]).toMatchObject({ recap: 'Did the thing.', suggestion: 'Verify it.', forMessageID: 'msg_a' });
+    // The pre-write re-check must see past the idle marker as well.
+    expect(listLimits.at(-1)).toBeGreaterThan(2);
+    vi.unstubAllGlobals();
   });
 
-  it('rejects endpoint changes before writing instead of carrying a session into a new runtime', async () => {
-    const warning = vi.spyOn(console, 'warn').mockImplementation(() => {});
-    const { state, status } = await fixture(async (_args, current) => {
-      current.base = 'http://unreachable.invalid';
-      return output();
+  it('arms generation again as soon as a store is injected', async () => {
+    const persistSessionAssist = vi.fn(async () => undefined);
+    const getSmallModelService = vi.fn(async () => {
+      throw new Error('stop here: the transport is what this test observes');
     });
-    status('idle');
-    await vi.waitFor(() => expect(warning).toHaveBeenCalled());
-    expect(state.patches).toHaveLength(0);
-    expect(state.gets).toBe(1);
+    const buildOpenCodeUrl = vi.fn(() => 'http://127.0.0.1:1/');
+    const { runtime } = makeRuntime({ persistSessionAssist, getSmallModelService, buildOpenCodeUrl });
+
+    vi.spyOn(console, 'warn').mockImplementation(() => {});
+    runtime.processPayload(idle());
+    await new Promise((resolve) => setTimeout(resolve, 30));
+
+    // The idle timer fired and the generation path ran, which is what the gate
+    // above suppresses.
+    expect(buildOpenCodeUrl).toHaveBeenCalled();
   });
 });

package/server/lib/session-goal/DOCUMENTATION.md

@@ -81,13 +81,19 @@ before touching the filesystem). Rationale: metadata rides every
    a goal on an idle session emits no status transition.
 3. On fire (`tick`), gated by the `sessionGoalEnabled` setting:
    - fetch session (skip sub-agent sessions), require an `active` goal;
-   - authoritative live-activity check after the quiet window: re-read the
-     session status map, bail if the parent resumed, then list direct child
-     sessions and bail while any child is `busy`/`retry`. A background
-     subagent leaves its parent idle, then injects its result into the parent
-     when done; that parent `busy` → `idle` cycle re-arms the loop without
-     polling. Status/children fetch failure is unknown, not empty, so it skips
-     the audit and retries after another quiet window;
+   - authoritative live-activity check after the quiet window: re-read
+     `/api/session/active`, bail if the parent resumed; then list the
+     parent's subagent sessions through `GET /api/session?parentID=` (cursor
+     paged) and bail while any of them is active. A status or children fetch
+     failure is unknown, not empty, so it skips the audit and retries after
+     another quiet window;
+     both reads live in `../opencode/session-activity.js`, shared with the
+     notification runtime;
+   - messages come from `/api/session/:id/message` as v2's flat records
+     (`type`, `content[]`, `model`, `finish`, `tokens`); `toLoopMessage`
+     projects them into the `{ info, parts }` view the rest of the tick reads,
+     and a completed `compaction` record plays v1's `summary: true` assistant
+     turn. Other plumbing roles are dropped from the view;
    - quiescence check via the message tail (trailing user message or
      unfinished assistant reply → bail; the next idle transition re-arms);
    - token accounting as a SNAPSHOT of the latest completed assistant turn:
@@ -143,9 +149,10 @@ before touching the filesystem). Rationale: metadata rides every
      loop blind to the turn cap;
    - continue: persist accounting + `turnsUsed` first (a crash after the
      write just waits for the next idle tick; the reverse could double-send),
-     re-check the tail, then `POST /session/:id/prompt_async` with the
-     continuation prompt using the last assistant message's
-     provider/model/agent — the goal spends the session's own subscription.
+     re-check the tail, then `POST /api/session/:id/prompt` with the
+     continuation prompt. v2 keeps the model and agent on the session, so the
+     prompt runs on what the session already uses; nothing is re-selected —
+     the goal spends the session's own subscription.
 4. Settling (`complete`/`blocked`/`budgetLimited`) fires the injected
    `emitGoalNotification` so the user hears about it even with the UI closed:
    desktop + UI broadcast + the standard push fanout (web-push with full
@@ -190,10 +197,11 @@ sees only that final turn, so the report is its evidence.
 
 Scheduled tasks can run as goals: `execution.goalEnabled` (+ optional
 `execution.goalTokenBudget`) on a task makes the scheduled-tasks runtime
-stamp `metadata.openchamber.goal` onto the fresh session (objective = the
-expanded task prompt, or the argument-expanded command template for a slash
-command) and attach the goal-mode intro part to normal prompts.
-The loop here picks it up from session events like any other goal.
+write the goal into OpenChamber's session metadata store through the
+`persistSessionGoal` seam `server/index.js` hands it (objective = the expanded
+task prompt; v2 `CommandInfo` carries no template, so a slash command's
+objective is its raw invocation) and attach the goal-mode intro part to normal
+prompts. The store write is what arms the loop (`notifyGoalChanged`).
 
 ## CLI-created goals
 
@@ -220,7 +228,7 @@ ordering used by create and scheduled goals.
 - Web-server feature: VS Code (extension-only) renders goal state via
   `session.updated` but does not run the loop.
 - A goal on a session with no assistant reply yet starts after the first
-  user exchange completes (no provider/model to continue with before that).
+  user exchange completes (there is no reply to audit before that).
 - `tokensUsed` only counts completed assistant messages seen within the
   40-message fetch window per tick; extremely long busy stretches between
   idles undercount (acceptable: budget is a guardrail, not billing).

package/server/lib/session-goal/create.js

@@ -56,6 +56,7 @@ export const createSessionGoal = async ({
   providerID,
   modelID,
   onWarning,
+  persistSessionGoal,
 }) => {
   const warn = (message, error) => {
     if (typeof onWarning === 'function') {
@@ -98,17 +99,13 @@ export const createSessionGoal = async ({
     createdAt: now,
     updatedAt: now,
   };
-  const url = new URL(`${baseUrl}/session/${encodeURIComponent(sessionID)}`);
-  url.searchParams.set('directory', directory);
-  const response = await fetch(url.toString(), {
-    method: 'PATCH',
-    headers: {
-      ...authHeaders,
-      'content-type': 'application/json',
-      accept: 'application/json',
-    },
-    body: JSON.stringify({ metadata: { openchamber: { goal } } }),
-  });
-  if (!response.ok) throw new Error(`goal metadata patch failed (${response.status})`);
+  // OpenCode 2.x accepts session metadata only at create time, so the goal
+  // record lives in OpenChamber's own store next to the objective text.
+  void baseUrl;
+  void authHeaders;
+  if (typeof persistSessionGoal !== 'function') {
+    throw new Error('goal mode needs a session metadata store to save the goal in');
+  }
+  await persistSessionGoal(sessionID, directory, goal);
   return goal;
 };

package/server/lib/session-goal/create.test.js

@@ -20,8 +20,9 @@ describe('session goal creation', () => {
     generateSmallModelTextMock.mockReset().mockResolvedValue({ text: '' });
   });
 
-  it('writes the objective before patching active goal metadata', async () => {
-    const fetchMock = vi.fn(async () => ({ ok: true }));
+  it('saves the goal in OpenChamber\'s own store, never through OpenCode', async () => {
+    const fetchMock = vi.fn();
+    const persistSessionGoal = vi.fn(async () => undefined);
     const originalFetch = globalThis.fetch;
     globalThis.fetch = fetchMock;
     try {
@@ -34,43 +35,41 @@ describe('session goal creation', () => {
         tokenBudget: 200_000,
         providerID: 'openai',
         modelID: 'gpt-5.5',
+        persistSessionGoal,
       });
 
       expect(writeObjectiveMock).toHaveBeenCalledWith('ses_123', 'Finish and verify the migration');
-      expect(writeObjectiveMock.mock.invocationCallOrder[0]).toBeLessThan(fetchMock.mock.invocationCallOrder[0]);
       expect(goal).toMatchObject({ objective: '', objectiveFile: true, status: 'active', tokenBudget: 200_000 });
-      expect(fetchMock).toHaveBeenCalledWith(
-        'http://opencode.test/session/ses_123?directory=%2Frepo%2Fapp',
-        expect.objectContaining({ method: 'PATCH' }),
-      );
+      expect(persistSessionGoal).toHaveBeenCalledWith('ses_123', '/repo/app', goal);
+      // v2 has no session-metadata route; nothing may be sent to OpenCode.
+      expect(fetchMock).not.toHaveBeenCalled();
     } finally {
       globalThis.fetch = originalFetch;
     }
   });
 
-  it('falls back to inline metadata when objective storage fails', async () => {
+  it('falls back to an inline objective when the objective file cannot be written', async () => {
     writeObjectiveMock.mockRejectedValueOnce(new Error('disk unavailable'));
-    const fetchMock = vi.fn(async () => ({ ok: true }));
-    const originalFetch = globalThis.fetch;
-    globalThis.fetch = fetchMock;
-    try {
-      await createSessionGoal({
-        baseUrl: 'http://opencode.test',
-        authHeaders: {},
-        sessionID: 'ses_123',
-        directory: '/repo/app',
-        objective: 'Finish the migration',
-        onWarning: vi.fn(),
-      });
+    const persistSessionGoal = vi.fn(async () => undefined);
 
-      const payload = JSON.parse(fetchMock.mock.calls[0][1].body);
-      expect(payload.metadata.openchamber.goal).toMatchObject({
-        objective: 'Finish the migration',
-        objectiveFile: false,
-      });
-    } finally {
-      globalThis.fetch = originalFetch;
-    }
+    await createSessionGoal({
+      sessionID: 'ses_123',
+      directory: '/repo/app',
+      objective: 'Finish the migration',
+      onWarning: vi.fn(),
+      persistSessionGoal,
+    });
+
+    const [, , goal] = persistSessionGoal.mock.calls[0];
+    expect(goal).toMatchObject({ objective: 'Finish the migration', objectiveFile: false });
+  });
+
+  it('refuses to report a goal it has nowhere to save', async () => {
+    await expect(createSessionGoal({
+      sessionID: 'ses_123',
+      directory: '/repo/app',
+      objective: 'Finish the migration',
+    })).rejects.toThrow(/needs a session metadata store/);
   });
 
   it('builds the same goal intro with an optional budget', () => {