@vantran-se/openchamber-web 1.24.4 → 2.0.2

package/server/lib/browser-control/provider.js

@@ -0,0 +1,217 @@
+/**
+ * Chooses who answers the agent's `browser.*` actions: the in-app browser view
+ * (through the broker) or an extension service that provides the browser
+ * (`contributes.service.provides: ["browser"]`).
+ *
+ * The choice is the `browserProvider` setting: `builtin`, or the id of an
+ * installed extension. It is read for every action, so a change in Settings
+ * applies to the next action without a restart. A selected extension that can
+ * no longer serve — paused, removed, approval withdrawn, or a newer version
+ * without the role — is not silently kept: the setting goes back to `builtin`,
+ * every client is told so it can say so, and the action runs in-app. Doing
+ * that at the moment the extension is deactivated (`handleGuestDeactivated`)
+ * gives the user the notice right away; doing it again on the next action
+ * covers everything else, such as a folder install that went missing.
+ *
+ * The service is a host-spawned loopback process, so the proxy that panels
+ * use serves here too. It starts the process on the first action, which is
+ * what lets an agent browse with no panel open, and stops it after
+ * `BROWSER_PROVIDER_IDLE_MS` without actions.
+ */
+
+import {
+  BROWSER_PROVIDER_ACTION_TIMEOUT_MS,
+  BROWSER_PROVIDER_IDLE_MS,
+  BROWSER_PROVIDER_OPEN_TIMEOUT_MS,
+  BROWSER_PROVIDER_PATH,
+  BROWSER_PROVIDER_RESPONSE_MAX,
+  isGuestApproved,
+  requestedGuestCapabilities,
+  serviceProvides,
+} from '@openchamber/sdk';
+import { browserProviderResultSchema } from '@openchamber/sdk/schemas';
+
+import { GuestServiceError, proxyGuestServiceRequest } from '../guests/service.js';
+import { BrowserControlError } from './broker.js';
+
+const BUILTIN_BROWSER_PROVIDER = 'builtin';
+
+/**
+ * Whether this catalog row can answer browser actions right now. Mirrors what
+ * the Settings dropdown offers: enabled, fully approved, and declaring the
+ * role. The `service` grant is implied by full approval.
+ */
+/** The control service builds the caller's scope; a caller without one (tests, CLI) means unknown. */
+const UNKNOWN_CONTEXT = Object.freeze({ directory: null, sessionId: null });
+
+export const isBrowserProviderGuest = (guest) => (
+  Boolean(guest)
+  && guest.enabled !== false
+  && serviceProvides(guest.service, 'browser')
+  && isGuestApproved({
+    requested: requestedGuestCapabilities(guest),
+    granted: Array.isArray(guest.capabilityGrants) ? guest.capabilityGrants : [],
+  })
+);
+
+/**
+ * @param {{
+ *   broker: { request: Function },
+ *   readSettings: () => Promise<Record<string, unknown> | null>,
+ *   persistSettings: (changes: Record<string, unknown>) => Promise<unknown>,
+ *   findGuest: (id: string) => Promise<object | null>,
+ *   persistPath: string,
+ *   emitProviderReset: (event: { guestId: string, guestName: string }) => void,
+ *   createId: () => string,
+ *   proxyServiceRequest?: typeof proxyGuestServiceRequest,
+ *   surfaceControl?: { userControls: (guestId: string) => boolean, noteAgentActivity: (guestId: string) => void },
+ * }} deps `surfaceControl` is the shared-surface lease: an action is refused
+ * while the user is driving the extension's surface, and every action the
+ * provider runs counts as agent activity there.
+ */
+export const createBrowserControlRouter = ({
+  broker,
+  readSettings,
+  persistSettings,
+  findGuest,
+  persistPath,
+  emitProviderReset,
+  createId,
+  proxyServiceRequest = proxyGuestServiceRequest,
+  surfaceControl = { userControls: () => false, noteAgentActivity: () => undefined },
+}) => {
+  // `browserProvider` was sanitized on write (settings-helpers.js keeps a
+  // trimmed non-empty string), so the only decision left is builtin or not.
+  // A read that fails is not "builtin": the action must not run somewhere
+  // the user did not choose.
+  const selectedProviderId = async () => {
+    let settings;
+    try {
+      settings = await readSettings();
+    } catch {
+      throw new BrowserControlError(
+        'OpenChamber could not read which browser answers agent actions, so the action was not run. Try again.',
+        503,
+      );
+    }
+    const value = settings?.browserProvider ?? BUILTIN_BROWSER_PROVIDER;
+    return value === BUILTIN_BROWSER_PROVIDER ? null : String(value);
+  };
+
+  const resetToBuiltin = async ({ guestId, guestName }) => {
+    await persistSettings({ browserProvider: BUILTIN_BROWSER_PROVIDER });
+    emitProviderReset({ guestId, guestName });
+  };
+
+  const requestFromProvider = async (guest, action, parameters, { signal, timeoutMs, context }) => {
+    if (surfaceControl.userControls(guest.id)) {
+      // Read by the agent: the page is being used by a person right now.
+      throw new BrowserControlError(
+        'The user is interacting with this page in the panel right now, so the action was not run. '
+        + 'Wait for them to hand control back, or ask them to. Nothing was changed.',
+        409,
+      );
+    }
+    surfaceControl.noteAgentActivity(guest.id);
+    const requestId = createId();
+    let proxied;
+    try {
+      proxied = await proxyServiceRequest({
+        guestId: guest.id,
+        guestName: guest.name,
+        packageRoot: guest.packageRoot,
+        service: guest.service,
+        granted: guest.capabilityGrants,
+        persistPath,
+        method: 'POST',
+        path: BROWSER_PROVIDER_PATH,
+        body: JSON.stringify({ requestId, action, parameters, context: context ?? UNKNOWN_CONTEXT }),
+        timeoutMs: timeoutMs ?? (action === 'browser.open' ? BROWSER_PROVIDER_OPEN_TIMEOUT_MS : BROWSER_PROVIDER_ACTION_TIMEOUT_MS),
+        responseMax: BROWSER_PROVIDER_RESPONSE_MAX,
+        idleStopMs: BROWSER_PROVIDER_IDLE_MS,
+        signal,
+      });
+    } catch (error) {
+      if (error instanceof GuestServiceError) {
+        // Read by the agent. A request that was sent and lost may have been
+        // acted on; only a service that never took it leaves the page as it was.
+        const outcome = error.code === 'REQUEST_FAILED' || error.code === 'CANCELLED'
+          ? 'The action was sent but no answer came back, so it may or may not have run; read the page before repeating it.'
+          : 'Nothing was changed.';
+        throw new BrowserControlError(
+          `The browser provider "${guest.name}" could not complete this action (${error.code}): ${error.message} ${outcome}`,
+          error.code === 'REQUEST_FAILED' ? 504 : 503,
+        );
+      }
+      throw error;
+    }
+    if (proxied.status !== 200) {
+      throw new BrowserControlError(
+        `The browser provider "${guest.name}" answered HTTP ${proxied.status} instead of a result. Nothing is known about the page.`,
+        502,
+      );
+    }
+    let parsed;
+    try {
+      parsed = browserProviderResultSchema.safeParse(JSON.parse(proxied.body));
+    } catch {
+      parsed = { success: false };
+    }
+    if (!parsed.success) {
+      throw new BrowserControlError(
+        `The browser provider "${guest.name}" answered something that is not a browser result. Nothing is known about the page.`,
+        502,
+      );
+    }
+    if (!parsed.data.ok) {
+      throw new BrowserControlError(parsed.data.error, 400);
+    }
+    return parsed.data.data;
+  };
+
+  return {
+    /** Same signature as the broker; the control service does not know which path ran. */
+    async request(action, parameters = {}, options = {}) {
+      const providerId = await selectedProviderId();
+      if (!providerId) {
+        return broker.request(action, parameters, options);
+      }
+      let guest;
+      try {
+        guest = await findGuest(providerId);
+      } catch {
+        // The catalog could not be read; that says nothing about the
+        // extension, so neither the choice nor the target browser changes.
+        throw new BrowserControlError(
+          'OpenChamber could not read the extension catalog, so the action was not run. Try again.',
+          503,
+        );
+      }
+      if (!isBrowserProviderGuest(guest)) {
+        await resetToBuiltin({ guestId: providerId, guestName: guest?.name ?? providerId });
+        return broker.request(action, parameters, options);
+      }
+      return requestFromProvider(guest, action, parameters, options);
+    },
+
+    /**
+     * Called when an extension is paused, removed, or loses approval. The
+     * catalog may not reflect the change yet, so this does not re-check it:
+     * the selection alone decides.
+     */
+    async handleGuestDeactivated({ guestId, guestName }) {
+      // The pause or removal already happened; a failure here must not turn
+      // it into an error response. The next action re-checks the catalog
+      // and resets the setting then.
+      try {
+        const providerId = await selectedProviderId();
+        if (providerId !== guestId) return false;
+        await resetToBuiltin({ guestId, guestName: guestName || guestId });
+        return true;
+      } catch (error) {
+        console.warn('[browser-provider] could not reset the provider after a deactivation:', error instanceof Error ? error.message : error);
+        return false;
+      }
+    },
+  };
+};

package/server/lib/browser-control/provider.test.js

@@ -0,0 +1,251 @@
+import { describe, expect, test } from 'bun:test';
+
+import { BROWSER_PROVIDER_IDLE_MS, BROWSER_PROVIDER_OPEN_TIMEOUT_MS, BROWSER_PROVIDER_PATH } from '@openchamber/sdk';
+
+import { BrowserControlError } from './broker.js';
+import { createBrowserControlRouter, isBrowserProviderGuest } from './provider.js';
+import { GuestServiceError } from '../guests/service.js';
+
+const providerGuest = (overrides = {}) => ({
+  id: 'server-chrome',
+  name: 'Server Chrome',
+  packageRoot: '/ext/server-chrome',
+  enabled: true,
+  service: { entry: 'service/main.js', runtime: 'host', provides: ['browser'] },
+  capabilityGrants: ['service'],
+  panel: { id: 'server-chrome', name: 'Server Chrome', icon: 'window' },
+  ...overrides,
+});
+
+const createRouter = ({
+  settings = { browserProvider: 'server-chrome' },
+  guest = providerGuest(),
+  serviceAnswer = { status: 200, body: JSON.stringify({ ok: true, data: { url: 'http://localhost:3000/', title: 'App' } }) },
+  userControls = false,
+  readSettingsError = null,
+  findGuestError = null,
+} = {}) => {
+  const brokerCalls = [];
+  const proxied = [];
+  const persisted = [];
+  const resets = [];
+  const agentActivity = [];
+  let current = { ...settings };
+  const router = createBrowserControlRouter({
+    surfaceControl: {
+      userControls: () => userControls,
+      noteAgentActivity: (guestId) => agentActivity.push(guestId),
+    },
+    broker: {
+      request: async (action, parameters, options) => {
+        brokerCalls.push({ action, parameters, options });
+        return { from: 'broker' };
+      },
+    },
+    readSettings: async () => {
+      if (readSettingsError) throw readSettingsError;
+      return current;
+    },
+    persistSettings: async (changes) => {
+      persisted.push(changes);
+      current = { ...current, ...changes };
+    },
+    findGuest: async (id) => {
+      if (findGuestError) throw findGuestError;
+      return guest && guest.id === id ? guest : null;
+    },
+    persistPath: '/data/extensions.json',
+    emitProviderReset: (event) => resets.push(event),
+    createId: () => 'req-1',
+    proxyServiceRequest: async (params) => {
+      proxied.push(params);
+      if (serviceAnswer instanceof Error) throw serviceAnswer;
+      return serviceAnswer;
+    },
+  });
+  return { router, brokerCalls, proxied, persisted, resets, agentActivity };
+};
+
+describe('isBrowserProviderGuest', () => {
+  test('needs enabled, approved, and the browser role', () => {
+    expect(isBrowserProviderGuest(providerGuest())).toBe(true);
+    expect(isBrowserProviderGuest(providerGuest({ enabled: false }))).toBe(false);
+    expect(isBrowserProviderGuest(providerGuest({ capabilityGrants: [] }))).toBe(false);
+    expect(isBrowserProviderGuest(providerGuest({ service: { entry: 'service/main.js', runtime: 'host' } }))).toBe(false);
+    expect(isBrowserProviderGuest(null)).toBe(false);
+  });
+});
+
+describe('browser control router', () => {
+  test('sends the action to the in-app broker when no provider is selected', async () => {
+    const { router, brokerCalls, proxied } = createRouter({ settings: {} });
+    const result = await router.request('browser.snapshot', {}, { timeoutMs: 20_000 });
+    expect(result).toEqual({ from: 'broker' });
+    expect(brokerCalls).toHaveLength(1);
+    expect(proxied).toHaveLength(0);
+  });
+
+  test('"builtin" is the in-app broker as well', async () => {
+    const { router, brokerCalls } = createRouter({ settings: { browserProvider: 'builtin' } });
+    await router.request('browser.snapshot', {});
+    expect(brokerCalls).toHaveLength(1);
+  });
+
+  test('posts the action to the selected provider service and returns its data', async () => {
+    const { router, brokerCalls, proxied } = createRouter();
+    const result = await router.request('browser.open', { url: 'http://localhost:3000/' }, {
+      timeoutMs: 45_000,
+      context: { directory: '/repo', sessionId: 'ses_1' },
+    });
+    expect(result).toEqual({ url: 'http://localhost:3000/', title: 'App' });
+    expect(brokerCalls).toHaveLength(0);
+    expect(proxied).toHaveLength(1);
+    const call = proxied[0];
+    expect(call.guestId).toBe('server-chrome');
+    expect(call.method).toBe('POST');
+    expect(call.path).toBe(BROWSER_PROVIDER_PATH);
+    expect(JSON.parse(call.body)).toEqual({
+      requestId: 'req-1',
+      action: 'browser.open',
+      parameters: { url: 'http://localhost:3000/' },
+      context: { directory: '/repo', sessionId: 'ses_1' },
+    });
+    expect(call.idleStopMs).toBe(BROWSER_PROVIDER_IDLE_MS);
+    expect(call.granted).toEqual(['service']);
+  });
+
+  test('a slow page gets the open budget when the caller sets none', async () => {
+    const { router, proxied } = createRouter();
+    await router.request('browser.open', { url: 'http://a/' });
+    expect(proxied[0].timeoutMs).toBe(BROWSER_PROVIDER_OPEN_TIMEOUT_MS);
+  });
+
+  test('a provider error becomes the agent-visible error, not a transport failure', async () => {
+    const { router } = createRouter({
+      serviceAnswer: { status: 200, body: JSON.stringify({ ok: false, error: 'No element matches #save' }) },
+    });
+    try {
+      await router.request('browser.click', { selector: '#save' });
+      throw new Error('expected rejection');
+    } catch (error) {
+      expect(error).toBeInstanceOf(BrowserControlError);
+      expect(error.message).toBe('No element matches #save');
+      expect(error.status).toBe(400);
+    }
+  });
+
+  test('a non-200 or malformed answer is reported as unknown page state', async () => {
+    for (const serviceAnswer of [
+      { status: 500, body: 'boom' },
+      { status: 200, body: 'not json' },
+      { status: 200, body: JSON.stringify({ ok: true }) },
+    ]) {
+      const { router } = createRouter({ serviceAnswer });
+      await expect(router.request('browser.snapshot', {})).rejects.toMatchObject({ status: 502 });
+    }
+  });
+
+  test('a service that will not start tells the agent nothing changed', async () => {
+    const { router } = createRouter({
+      serviceAnswer: new GuestServiceError('Guest service failed to become ready.', 'SERVICE_FAILED'),
+    });
+    try {
+      await router.request('browser.snapshot', {});
+      throw new Error('expected rejection');
+    } catch (error) {
+      expect(error).toBeInstanceOf(BrowserControlError);
+      expect(error.status).toBe(503);
+      expect(error.message).toContain('Server Chrome');
+      expect(error.message).toContain('Nothing was changed');
+    }
+  });
+
+  test('a selected extension that cannot serve resets the setting, tells clients, and runs in-app', async () => {
+    const { router, brokerCalls, persisted, resets } = createRouter({ guest: providerGuest({ enabled: false }) });
+    const result = await router.request('browser.snapshot', {});
+    expect(result).toEqual({ from: 'broker' });
+    expect(brokerCalls).toHaveLength(1);
+    expect(persisted).toEqual([{ browserProvider: 'builtin' }]);
+    expect(resets).toEqual([{ guestId: 'server-chrome', guestName: 'Server Chrome' }]);
+  });
+
+  test('a removed extension resets by id when no name is known', async () => {
+    const { router, resets } = createRouter({ guest: null });
+    await router.request('browser.snapshot', {});
+    expect(resets).toEqual([{ guestId: 'server-chrome', guestName: 'server-chrome' }]);
+  });
+
+  test('deactivating the selected extension resets right away; another one does not', async () => {
+    const { router, persisted, resets } = createRouter();
+    expect(await router.handleGuestDeactivated({ guestId: 'other', guestName: 'Other' })).toBe(false);
+    expect(persisted).toHaveLength(0);
+    expect(await router.handleGuestDeactivated({ guestId: 'server-chrome', guestName: 'Server Chrome' })).toBe(true);
+    expect(persisted).toEqual([{ browserProvider: 'builtin' }]);
+    expect(resets).toEqual([{ guestId: 'server-chrome', guestName: 'Server Chrome' }]);
+  });
+
+  test('an action is refused while the user drives the shared surface', async () => {
+    const { router, proxied, agentActivity } = createRouter({ userControls: true });
+    try {
+      await router.request('browser.click', { selector: '#save' });
+      throw new Error('expected rejection');
+    } catch (error) {
+      expect(error).toBeInstanceOf(BrowserControlError);
+      expect(error.status).toBe(409);
+      expect(error.message).toContain('Nothing was changed');
+    }
+    expect(proxied).toHaveLength(0);
+    expect(agentActivity).toHaveLength(0);
+  });
+
+  test('a provider action counts as agent activity on the surface', async () => {
+    const { router, agentActivity } = createRouter();
+    await router.request('browser.snapshot', {});
+    expect(agentActivity).toEqual(['server-chrome']);
+  });
+
+  test('a settings read that fails runs nothing anywhere and changes nothing', async () => {
+    const { router, brokerCalls, proxied, persisted, resets } = createRouter({ readSettingsError: new Error('disk') });
+    await expect(router.request('browser.click', { selector: '#save' })).rejects.toMatchObject({ status: 503 });
+    expect(brokerCalls).toHaveLength(0);
+    expect(proxied).toHaveLength(0);
+    expect(persisted).toHaveLength(0);
+    expect(resets).toHaveLength(0);
+  });
+
+  test('a catalog read that fails runs nothing anywhere and keeps the choice', async () => {
+    const { router, brokerCalls, proxied, persisted, resets } = createRouter({ findGuestError: new Error('catalog') });
+    await expect(router.request('browser.click', { selector: '#save' })).rejects.toMatchObject({ status: 503 });
+    expect(brokerCalls).toHaveLength(0);
+    expect(proxied).toHaveLength(0);
+    expect(persisted).toHaveLength(0);
+    expect(resets).toHaveLength(0);
+  });
+
+  test('a request that was sent and lost is reported as unknown, not as unchanged', async () => {
+    const { router } = createRouter({
+      serviceAnswer: new GuestServiceError('Guest service request failed.', 'REQUEST_FAILED'),
+    });
+    try {
+      await router.request('browser.click', { selector: '#save' });
+      throw new Error('expected rejection');
+    } catch (error) {
+      expect(error).toBeInstanceOf(BrowserControlError);
+      expect(error.status).toBe(504);
+      expect(error.message).toContain('may or may not have run');
+      expect(error.message).not.toContain('Nothing was changed');
+    }
+  });
+
+  test('a settings read that fails during deactivation is logged, not raised', async () => {
+    const { router, persisted } = createRouter({ readSettingsError: new Error('disk') });
+    const warn = console.warn;
+    console.warn = () => undefined;
+    try {
+      expect(await router.handleGuestDeactivated({ guestId: 'server-chrome', guestName: 'Server Chrome' })).toBe(false);
+    } finally {
+      console.warn = warn;
+    }
+    expect(persisted).toHaveLength(0);
+  });
+});

package/server/lib/context-obligatory/runtime.js

@@ -1,3 +1,4 @@
+import { unwrapOpenCodeResponse } from '../opencode/response-envelope.js';
 const FETCH_TIMEOUT_MS = 15_000;
 const MESSAGE_FETCH_LIMIT = 20;
 
@@ -30,10 +31,20 @@ const buildContextPrompt = (entries) => {
   ].join('\n');
 };
 
+/**
+ * Re-injects the messages the user pinned as obligatory after a compaction.
+ *
+ * Both the pinned list and the cursor live in OpenChamber's own session
+ * metadata store — v2 accepts session metadata only at create time.
+ * `readSessionMetadata` reads it and `persistContextCursor` records how far we
+ * got; without both seams the runtime stays inert.
+ */
 export const createContextObligatoryRuntime = ({
   buildOpenCodeUrl,
   getOpenCodeAuthHeaders,
   sessionKnowledgeRuntime = null,
+  persistContextCursor = null,
+  readSessionMetadata = null,
 }) => {
   const inflight = new Set();
   let stopped = false;
@@ -53,13 +64,15 @@ export const createContextObligatoryRuntime = ({
       signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
     });
     if (!response.ok) throw new Error(`OpenCode ${method} ${fetchPath} failed with ${response.status}`);
-    return response.json().catch(() => null);
+    return unwrapOpenCodeResponse(await response.json().catch(() => null));
   };
 
   const tick = async (sessionId, directory) => {
-    const session = await openCodeFetch(`/session/${encodeURIComponent(sessionId)}`, { directory });
+    const session = await openCodeFetch(`/api/session/${encodeURIComponent(sessionId)}`, { directory });
     if (session?.parentID) return;
-    const state = readContextState(session);
+    // Pins and the cursor are OpenChamber's, not OpenCode's.
+    const stored = { metadata: await readSessionMetadata(sessionId) };
+    const state = readContextState(stored);
 
     /**
      * Project knowledge rides along with the pinned messages. Compaction takes
@@ -74,32 +87,40 @@ export const createContextObligatoryRuntime = ({
           // Compaction removed the previously delivered block, so its stored
           // signature is no longer evidence that the session still carries it.
           '',
-          sessionKnowledgeRuntime.readPins(session),
+          sessionKnowledgeRuntime.readPins(stored),
         )
         .catch(() => ({ text: '', signature: '' }))
       : { text: '', signature: '' };
 
     if (state.messages.length === 0 && !knowledge.text) return;
 
-    const recent = await openCodeFetch(`/session/${encodeURIComponent(sessionId)}/message`, {
+    const recent = await openCodeFetch(`/api/session/${encodeURIComponent(sessionId)}/message`, {
       directory,
       query: { limit: String(MESSAGE_FETCH_LIMIT) },
     });
-    if (!Array.isArray(recent) || recent.length === 0) return;
-    const summary = recent.toReversed().find((message) =>
-      message?.info?.role === 'assistant' && message.info.summary === true)?.info;
+    // v2 pages messages as `{ data, cursor }`, newest first, and a compaction
+    // is its own message role rather than an assistant message flagged
+    // `summary`.
+    const recentMessages = Array.isArray(recent?.data) ? recent.data : [];
+    if (recentMessages.length === 0) return;
+    const summary = recentMessages.find((message) => message?.type === 'compaction' && message?.status === 'completed');
     if (!summary?.id || !summary?.time?.completed) return;
     if (state.openchamber.context_obligatory_last_compaction_message_id === summary.id) return;
 
     const fetched = await Promise.allSettled(state.messages.map(async (pinned) => {
       const message = await openCodeFetch(
-        `/session/${encodeURIComponent(sessionId)}/message/${encodeURIComponent(pinned.id)}`,
+        `/api/session/${encodeURIComponent(sessionId)}/message/${encodeURIComponent(pinned.id)}`,
         { directory },
       );
-      const text = Array.isArray(message?.parts)
-        ? message.parts.filter((part) => part?.type === 'text' && typeof part.text === 'string')
-          .map((part) => part.text.trim()).filter(Boolean).join('\n\n')
-        : '';
+      // A user message carries `text`; an assistant one carries `content[]`.
+      const parts = Array.isArray(message?.content)
+        ? message.content
+        : (typeof message?.text === 'string' ? [{ type: 'text', text: message.text }] : []);
+      const text = parts
+        .filter((part) => part?.type === 'text' && typeof part.text === 'string')
+        .map((part) => part.text.trim())
+        .filter(Boolean)
+        .join('\n\n');
       return { pinned, text };
     }));
     const entries = fetched
@@ -108,52 +129,42 @@ export const createContextObligatoryRuntime = ({
       .sort((left, right) => left.pinned.createdAt - right.pinned.createdAt);
     if (entries.length === 0 && !knowledge.text) return;
 
-    const executionInfo = recent.toReversed().find((message) =>
-      message?.info?.role === 'assistant' && message.info.summary !== true)?.info;
-    const providerID = typeof executionInfo?.providerID === 'string' ? executionInfo.providerID : '';
-    const modelID = typeof executionInfo?.modelID === 'string' ? executionInfo.modelID : '';
-    if (!providerID || !modelID) throw new Error('no pre-compaction assistant provider/model');
-    const agent = typeof executionInfo.agent === 'string' ? executionInfo.agent : executionInfo.mode;
-    await openCodeFetch(`/session/${encodeURIComponent(sessionId)}/prompt_async`, {
+    // v2 has no inline synthetic parts, and the model/agent selection lives on
+    // the session, so the restored context is simply its own synthetic message.
+    await openCodeFetch(`/api/session/${encodeURIComponent(sessionId)}/synthetic`, {
       directory,
       method: 'POST',
       body: {
-        model: { providerID, modelID },
-        ...(typeof agent === 'string' && agent ? { agent } : {}),
-        parts: [{
-          type: 'text',
-          text: [knowledge.text, entries.length > 0 ? buildContextPrompt(entries) : '']
-            .filter(Boolean)
-            .join('\n\n---\n\n'),
-          synthetic: true,
-        }],
+        text: [knowledge.text, entries.length > 0 ? buildContextPrompt(entries) : '']
+          .filter(Boolean)
+          .join('\n\n---\n\n'),
+        resume: false,
       },
     });
 
-    const fresh = await openCodeFetch(`/session/${encodeURIComponent(sessionId)}`, { directory });
-    const freshState = readContextState(fresh);
-    await openCodeFetch(`/session/${encodeURIComponent(sessionId)}`, {
-      directory,
-      method: 'PATCH',
-      body: {
-        metadata: {
-          ...freshState.metadata,
-          openchamber: {
-            ...freshState.openchamber,
-            context_obligatory_last_compaction_message_id: summary.id,
-            // Recorded together with the cursor: the session now carries this
-            // knowledge again, so the next send must not repeat it.
-            ...(knowledge.signature
-              ? { [sessionKnowledgeRuntime.metadataKey]: knowledge.signature }
-              : {}),
-          },
-        },
-      },
-    });
+    // A merge patch: the store folds this into whatever else the session's
+    // `openchamber` namespace holds, so a concurrent goal or assist write is
+    // not clobbered.
+    const patch = { context_obligatory_last_compaction_message_id: summary.id };
+    if (knowledge.signature) {
+      // Recorded together with the cursor: the session now carries this
+      // knowledge again, so the next send must not repeat it.
+      patch[sessionKnowledgeRuntime.metadataKey] = knowledge.signature;
+    }
+    await persistContextCursor(sessionId, directory, { openchamber: patch });
   };
 
+  let parkedNoticeLogged = false;
   const processPayload = (payload, directoryHint = '') => {
-    if (stopped || payload?.type !== 'session.compacted') return;
+    if (stopped) return;
+    if (typeof persistContextCursor !== 'function' || typeof readSessionMetadata !== 'function') {
+      if (!parkedNoticeLogged) {
+        parkedNoticeLogged = true;
+        console.log('[context-obligatory] parked: no session metadata store is wired, so the compaction cursor cannot be saved');
+      }
+      return;
+    }
+    if (payload?.type !== 'session.compacted') return;
     const sessionId = payload?.properties?.sessionID;
     if (typeof sessionId !== 'string' || inflight.has(sessionId)) return;
     const directory = payload?.properties?.directory || directoryHint;