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

package/server/lib/llm/routes.js

@@ -1,6 +1,6 @@
 import { createChatCompletion, LlmError } from './completions.js';
 import { loadConnectedCatalog } from './catalog.js';
-import { createOpencodeClient } from '@opencode-ai/sdk/v2';
+import { OpenCode } from '@opencode/client';
 import { ensureLlmTempDirectory } from './temp-directory.js';
 
 const fail = (res, error) => {
@@ -11,14 +11,16 @@ const fail = (res, error) => {
       ? 400
       : code === 'validation_error'
         ? 400
-        : code === 'upstream_error'
+        : code === 'llm_attachment_generation_unavailable'
           ? 502
-          : 500;
+          : code === 'upstream_error'
+            ? 502
+            : 500;
   res.status(status).json({ ok: false, error: code, message: error?.message || code });
 };
 
 export const registerLlmRoutes = (app, dependencies) => {
-  const client = () => createOpencodeClient({
+  const client = () => OpenCode.make({
     baseUrl: dependencies.buildOpenCodeUrl('/', '').replace(/\/$/, ''),
     headers: dependencies.getOpenCodeAuthHeaders(),
   });
@@ -38,6 +40,8 @@ export const registerLlmRoutes = (app, dependencies) => {
         getOpenCodeAuthHeaders: dependencies.getOpenCodeAuthHeaders,
         clientFactory: client,
         ensureTempDirectory: ensureLlmTempDirectory,
+        persistSessionMetadata: dependencies.persistSessionMetadata,
+        onSystemSessionPersisted: dependencies.onSystemSessionPersisted,
       }))
       .then(({ completion }) => {
         res.status(200).json(completion);

package/server/lib/message-queue/DOCUMENTATION.md

@@ -44,12 +44,12 @@ Claim selection and update fence a scope with every `sending` row and every vali
 
 The worker starts paused. Start, timer, and wake calls share one launched run flight; their public wake promise settles with status, while rejected flights emit a worker diagnostic and later wakes may retry. Stop aborts controllers and waits for every active task to settle before the runtime closes SQLite. Each run captures one runtime key and adapter runtime snapshot, **starts dispatch probe tasks first** (up to concurrency), then claims and awaits due reconciliation work, and finally joins active probes. That ordering keeps a hung `findMessage` (bounded by the 10s reconcile timeout) from delaying a waiting manual intent's POST while same-scope `sending` and same-row leases still prevent a second concurrent POST; automatic candidates remain gated on `available` + `idle` + `settled`. It reserves a queued candidate with an expiring probe token, and promotes that token only after the bounded eligibility probe permits dispatch. Stateless Assistant items deliberately bypass OpenCode eligibility and automatic admission tokens because their synthetic scope is not an execution Session; same-Assistant scope claiming still serializes them, while different Assistant scopes use normal worker concurrency. A successful stateless Assistant `promptAsync` admission first persists its user message in Assistant SQLite and advances the Assistant binding revision, then completes and deletes the queue row. The resulting Assistant revision tip refreshes clients that were still displaying the previous disposable binding. An ambiguous stateless delivery becomes a client-mutable `failed` row instead of an indefinitely active reconciliation row, and terminal rows do not block later dispatchable rows in their scope. Upgrade recovery also settles legacy stateless reconciliation rows without querying their disposable Session: null-error rows represent the old accepted path and complete, while rows carrying a transport error become failed. Busy, unsettled, timed-out, and unavailable candidates remain queued without row-version, scope-revision, or revision-tip churn. Every lease mutation carries `{ queueItemID, leaseToken, fenceGeneration, runtimeKey }`. `claimNext` returns `{ item, leaseToken, leaseExpiresAt, fenceGeneration }`; the item includes scope ID, directory, and session ID. The service receives the durable queue runtime identity, while the adapter receives an independently injected upstream OpenCode runtime snapshot.
 
-OpenCode adapter (SDK 1.18.x) hardening:
+OpenCode adapter (`@opencode/client` / v2) hardening:
 
-- `safeStatus` reads `result.response.status`, `result.error.status`, then `result.status`.
-- `send` treats only explicit 2xx (including empty 200/202/204) with no `error` as `ok`. `undefined`/malformed results are never success.
-- Definitive 4xx (except 408/429) is `failed`; 408/429/5xx and transport throws are `ambiguous`.
-- `findMessage` prefers `client.v2.session.message` when present; 404 means `found: false`. On 404/405/501 or unsupported surfaces it falls back to legacy `client.session.message` (if the SDK exposes it), then the existing bounded `session.messages` scan—without re-POSTing.
+- `send` builds the official SessionPrompt body only (`id` / `text` / `files` / `delivery`). Captured per-item `sendConfig` (`providerID`/`modelID`/`agent`/`variant`) is **not** stuffed into the prompt body — real prompt rejects that shape.
+- At the session serial submit boundary, `send` applies config first: `POST .../agent` then `POST .../model` (model uses `{ id, providerID, variant? }`), then a single `POST .../prompt`. Switch failure or session busy returns **without** posting prompt (no wrong-model send / no double admission). Busy → `{ kind: 'retry', code: 'session_busy' }` (worker schedules retry; not marked accepted). Definitive switch 4xx → `{ kind: 'failed', code: 'config_switch_failed' }`.
+- `send` treats only explicit 2xx (including empty 200/202/204) as `ok`. `undefined`/malformed results are never success. Prompt 409 → retry/`session_busy`; definitive other 4xx (except 408/429) is `failed`; 408/429/5xx and transport throws are `ambiguous`.
+- `findMessage` uses inbox then `session.message` projection. Real client not-found is `_tag: MessageNotFoundError` / `SessionNotFoundError` (not only HTTP 404 status) → `found: false`. Projection is `await`ed so rejections stay inside the adapter catch (`unavailable`) instead of escaping. Non-404 failures stay `unavailable` without re-POSTing.
 
 ## Confirmation and reconciliation
 

package/server/lib/message-queue/opencode-adapter.js

@@ -1,24 +1,50 @@
-import { createOpencodeClient } from '@opencode-ai/sdk/v2';
+import { makeOpenCodeV2Client } from '../opencode/v2-client.js';
 import { createAscendingMessageID } from './message-id.js';
 import { createSessionTurnGate } from './session-turn-gate.js';
 
 // SDK 1.18 result shapes vary: success may be 2xx with empty body (200/202/204),
 // failures may place status on response, error, or the top-level result.
-const safeStatus = (result) => {
-  for (const candidate of [result?.response?.status, result?.error?.status, result?.status]) {
+const isSuccessStatus = (status) => Number.isInteger(status) && status >= 200 && status < 300;
+const runtimeToken = (config, generation) => JSON.stringify([generation ?? null, config?.apiBaseUrl ?? config?.baseUrl ?? null]);
+const messageIdentity = (message) => message?.info?.id ?? message?.id;
+const inboxItemIdentity = (item) => item?.id ?? item?.info?.id ?? messageIdentity(item);
+const httpStatus = (error) => {
+  for (const candidate of [error?.cause?.status, error?.status, error?.response?.status, error?.statusCode]) {
     if (Number.isInteger(candidate)) return candidate;
   }
   return undefined;
 };
-const isSuccessStatus = (status) => Number.isInteger(status) && status >= 200 && status < 300;
-const runtimeToken = (config, generation) => JSON.stringify([generation ?? null, config?.apiBaseUrl ?? config?.baseUrl ?? null]);
-const messageIdentity = (message) => message?.info?.id ?? message?.id;
-const isNotFoundOrUnsupported = (status) => status === 404 || status === 405 || status === 501;
-const isUnsupportedLookupError = (error) => {
-  if (!error) return false;
-  if (error instanceof TypeError) return true;
-  const message = typeof error?.message === 'string' ? error.message : '';
-  return /is not a function|not a function|undefined is not|Cannot read properties of undefined/i.test(message);
+/**
+ * Real `@opencode/client` throws declared JSON with `_tag` (no status).
+ * MessageNotFoundError / SessionNotFoundError must map to found:false, not unavailable.
+ */
+const isNotFoundError = (error) => {
+  if (!error || typeof error !== 'object') return false;
+  const tag = error._tag ?? error.name;
+  if (tag === 'MessageNotFoundError' || tag === 'SessionNotFoundError') return true;
+  if (httpStatus(error) === 404) return true;
+  const code = error.code ?? error.type ?? error.error?.code ?? error.error?.type ?? error.error?._tag;
+  return code === 'not_found'
+    || code === 'NotFound'
+    || code === 'MessageNotFoundError'
+    || code === 'SessionNotFoundError';
+};
+const isSessionBusyError = (error) => {
+  if (!error || typeof error !== 'object') return false;
+  if ((error._tag ?? error.name) === 'SessionBusyError') return true;
+  const code = error.code ?? error.type ?? error.error?._tag;
+  return code === 'session_busy' || code === 'SessionBusyError';
+};
+const isAbortError = (error) => (
+  error?.name === 'AbortError'
+  || error?.code === 'aborted'
+  || error?.cause?.name === 'AbortError'
+);
+const messageType = (message) => {
+  const info = message?.info ?? message;
+  if (info?.type === 'assistant' || info?.type === 'user') return info.type;
+  if (info?.role === 'assistant' || info?.role === 'user') return info.role;
+  return message ? 'unknown' : null;
 };
 
 export const createOpenCodeMessageQueueAdapter = ({
@@ -35,7 +61,7 @@ export const createOpenCodeMessageQueueAdapter = ({
 } = {}) => {
   const captureRuntime = () => { const config = getRuntimeConfig(); const generation = getRuntimeGeneration(); return { config: { ...config, apiBaseUrl: config?.apiBaseUrl ?? config?.baseUrl ?? buildOpenCodeUrl('/', ''), authHeaders: { ...getOpenCodeAuthHeaders() } }, generation, token: runtimeToken(config, generation) }; };
   const isCurrent = (runtime) => !runtime || runtime.token === runtimeToken(getRuntimeConfig(), getRuntimeGeneration());
-  const client = (runtime) => createOpencodeClient({ baseUrl: (runtime?.config?.apiBaseUrl ?? buildOpenCodeUrl('/', '')).replace(/\/$/, ''), headers: runtime?.config?.authHeaders ?? getOpenCodeAuthHeaders() });
+  const client = (runtime) => makeOpenCodeV2Client({ baseUrl: (runtime?.config?.apiBaseUrl ?? buildOpenCodeUrl('/', '')).replace(/\/$/, ''), authHeaders: runtime?.config?.authHeaders ?? getOpenCodeAuthHeaders() });
   const turnKey = (scope, runtime) => JSON.stringify([runtime?.token ?? runtimeToken(getRuntimeConfig(), getRuntimeGeneration()), scope.directory, scope.sessionID]);
   const checkEligibility = async (scope, runtime, { signal } = {}) => {
     const key = turnKey(scope, runtime);
@@ -44,24 +70,25 @@ export const createOpenCodeMessageQueueAdapter = ({
       return { available: false, idle: false, settled: false };
     };
     try {
-      const api = client(runtime); const status = getSessionEligibility ? await getSessionEligibility(scope, { signal }) : await api.session.status({ directory: scope.directory }, { signal });
-      const messages = getLatestMessageID ? null : await api.session.messages({ sessionID: scope.sessionID, directory: scope.directory }, { signal });
+      const api = client(runtime);
+      const status = getSessionEligibility ? await getSessionEligibility(scope, { signal }) : await api.session.active({ signal });
+      const listed = getLatestMessageID ? null : await api.message.list({ sessionID: scope.sessionID, limit: 1, order: 'desc' }, { signal });
+      const messages = getLatestMessageID ? null : listed?.data;
       const injectedStatus = getSessionEligibility && status && typeof status === 'object' && typeof status.idle === 'boolean' && typeof status.settled === 'boolean';
-      const apiStatus = !getSessionEligibility && status?.data && typeof status.data === 'object' && !Array.isArray(status.data);
-      if (status?.error || messages?.error || (!injectedStatus && !apiStatus) || (!getSessionEligibility && !Array.isArray(messages?.data))) return unavailable();
-      const latestMessageID = getLatestMessageID ? await getLatestMessageID(scope, { signal }) : (messages?.data ?? []).at(-1)?.info?.id ?? (messages?.data ?? []).at(-1)?.id;
+      const activeMap = !getSessionEligibility && status && typeof status === 'object' && !Array.isArray(status);
+      if (!injectedStatus && !activeMap) return unavailable();
+      if (!getLatestMessageID && !Array.isArray(messages)) return unavailable();
+      const latest = Array.isArray(messages) ? messages[0] : null;
+      const latestMessageID = getLatestMessageID ? await getLatestMessageID(scope, { signal }) : latest?.id ?? latest?.info?.id;
       if (latestMessageID !== undefined && latestMessageID !== null && typeof latestMessageID !== 'string') return unavailable();
-      const last = (messages?.data ?? []).at(-1); const lastInfo = last?.info ?? last;
-      const statusMap = status?.data;
-      const statusValue = statusMap && typeof statusMap === 'object' && !Array.isArray(statusMap) ? statusMap[scope.sessionID] : statusMap;
-      const missingSessionStatus = statusMap && typeof statusMap === 'object' && !Array.isArray(statusMap) && !Object.hasOwn(statusMap, scope.sessionID);
-      const idle = getSessionEligibility ? status.idle : missingSessionStatus || statusValue?.type === 'idle' || statusValue?.status === 'idle' || status?.idle === true;
+      const lastInfo = latest?.info ?? latest;
+      const idle = getSessionEligibility ? status.idle : !Object.hasOwn(status, scope.sessionID);
       if (getSessionEligibility) return { available: true, idle, settled: status?.settled === true, latestMessageID };
       const settlement = turnGate.evaluate(key, {
         available: true,
         idle,
         tailID: typeof lastInfo?.id === 'string' ? lastInfo.id : null,
-        tailRole: lastInfo?.role === 'assistant' || lastInfo?.role === 'user' ? lastInfo.role : last ? 'unknown' : null,
+        tailRole: messageType(latest),
         tailCompleted: Boolean(lastInfo?.time?.completed),
       });
       return { available: true, idle, settled: settlement.ready, latestMessageID, settlementReason: settlement.reason, ...(settlement.nextCheckAt === undefined ? {} : { nextCheckAt: settlement.nextCheckAt }) };
@@ -84,95 +111,156 @@ export const createOpenCodeMessageQueueAdapter = ({
       return { type: 'file', mime: part.mime, url: file.url };
     }));
   };
+  const openCodeUrl = (pathname, directory, runtime) => {
+    const base = (runtime?.config?.apiBaseUrl ?? buildOpenCodeUrl('/', '')).replace(/\/$/, '');
+    const url = new URL(`${base}${pathname.startsWith('/') ? pathname : `/${pathname}`}`);
+    if (directory) url.searchParams.set('directory', directory);
+    return url;
+  };
+  const authHeaders = (runtime) => runtime?.config?.authHeaders ?? getOpenCodeAuthHeaders();
+  /**
+   * Official v2 SessionPrompt body: id/text/files/delivery only.
+   * model/agent/variant are NOT accepted on prompt — applied via
+   * session.switchAgent / session.switchModel at the serial submit boundary.
+   */
+  const promptBodyFromContext = (context) => {
+    const parts = Array.isArray(context.parts) ? context.parts : [];
+    const text = typeof context.content === 'string' && context.content
+      ? context.content
+      : parts.filter((part) => part?.type === 'text' && typeof part.text === 'string').map((part) => part.text).join('\n');
+    const files = parts
+      .filter((part) => part?.type === 'file' && typeof part.url === 'string')
+      .map((part) => ({
+        uri: part.url,
+        ...(part.filename || part.name ? { name: part.filename || part.name } : {}),
+        ...(part.mime ? { mime: part.mime } : {}),
+      }));
+    return {
+      id: context.messageID,
+      text,
+      delivery: context.delivery === 'queue' ? 'queue' : 'steer',
+      ...(files.length ? { files } : {}),
+    };
+  };
+  const classifyHttpStatus = (status, { ok } = {}) => {
+    if (ok || isSuccessStatus(status)) return { ok: true, status };
+    // 409 conflict / busy: definitive rejection before admission — retry later,
+    // do not mark accepted or re-POST as a new success path.
+    if (status === 409) return { ok: false, kind: 'retry', code: 'session_busy' };
+    if (status === 408 || status === 429 || (Number.isInteger(status) && status >= 500)) {
+      return { ok: false, status, kind: 'ambiguous' };
+    }
+    if (Number.isInteger(status) && status >= 400 && status < 500) {
+      return { ok: false, status, kind: 'failed' };
+    }
+    return { ok: false, kind: 'ambiguous', code: 'malformed_result' };
+  };
+  const classifySwitchStatus = (status, { ok } = {}) => {
+    if (ok || isSuccessStatus(status)) return { ok: true, status };
+    if (status === 409) return { ok: false, kind: 'retry', code: 'session_busy' };
+    if (status === 408 || status === 429 || (Number.isInteger(status) && status >= 500)) {
+      return { ok: false, status, kind: 'ambiguous', code: 'config_switch_ambiguous' };
+    }
+    if (Number.isInteger(status) && status >= 400 && status < 500) {
+      return { ok: false, status, kind: 'failed', code: 'config_switch_failed' };
+    }
+    return { ok: false, kind: 'ambiguous', code: 'config_switch_ambiguous' };
+  };
+  /**
+   * Apply captured per-item sendConfig before prompt on the session serial
+   * boundary. Failure returns without POSTing prompt (no accidental re-send
+   * under the wrong model/agent). Order: agent → model(+variant).
+   */
+  const applySendConfig = async (sessionID, directory, runtime, sendConfig, { signal } = {}) => {
+    if (!sendConfig || typeof sendConfig !== 'object') return { ok: true };
+    const headers = { 'Content-Type': 'application/json', Accept: 'application/json', ...authHeaders(runtime) };
+    if (typeof sendConfig.agent === 'string' && sendConfig.agent) {
+      const response = await fetch(openCodeUrl(`/api/session/${encodeURIComponent(sessionID)}/agent`, directory, runtime), {
+        method: 'POST',
+        headers,
+        body: JSON.stringify({ agent: sendConfig.agent }),
+        signal,
+      });
+      if (!response || typeof response !== 'object') {
+        return { ok: false, kind: 'ambiguous', code: 'config_switch_ambiguous' };
+      }
+      const classified = classifySwitchStatus(response.status, { ok: response.ok });
+      if (!classified.ok) return classified;
+    }
+    if (typeof sendConfig.providerID === 'string' && sendConfig.providerID
+      && typeof sendConfig.modelID === 'string' && sendConfig.modelID) {
+      const model = {
+        id: sendConfig.modelID,
+        providerID: sendConfig.providerID,
+        ...(typeof sendConfig.variant === 'string' && sendConfig.variant
+          ? { variant: sendConfig.variant }
+          : {}),
+      };
+      const response = await fetch(openCodeUrl(`/api/session/${encodeURIComponent(sessionID)}/model`, directory, runtime), {
+        method: 'POST',
+        headers,
+        body: JSON.stringify({ model }),
+        signal,
+      });
+      if (!response || typeof response !== 'object') {
+        return { ok: false, kind: 'ambiguous', code: 'config_switch_ambiguous' };
+      }
+      const classified = classifySwitchStatus(response.status, { ok: response.ok });
+      if (!classified.ok) return classified;
+    }
+    return { ok: true };
+  };
   const send = async (context, { signal } = {}) => {
     if (!isCurrent(context.runtime)) return { ok: false, kind: 'retry', code: 'runtime_stale' };
     try {
-      const config = context.sendConfig ?? context;
-      const result = await client(context.runtime).session.promptAsync({
-        sessionID: context.scope?.sessionID ?? context.sessionID,
-        directory: context.scope?.directory ?? context.directory,
-        messageID: context.messageID,
-        model: { providerID: config.providerID, modelID: config.modelID },
-        ...(config.agent ? { agent: config.agent } : {}),
-        ...(config.variant ? { variant: config.variant } : {}),
-        parts: context.parts ?? await materializeAttachments(context, { signal }),
-      }, { signal });
+      const parts = context.parts ?? await materializeAttachments(context, { signal });
+      const sessionID = context.scope?.sessionID ?? context.sessionID;
+      const directory = context.scope?.directory ?? context.directory;
+      const sendConfig = context.sendConfig && typeof context.sendConfig === 'object'
+        ? context.sendConfig
+        : null;
+      // Serial session boundary: switch captured config, then prompt once.
+      if (sendConfig) {
+        const switched = await applySendConfig(sessionID, directory, context.runtime, sendConfig, { signal });
+        if (!switched.ok) return switched;
+      }
+      const response = await fetch(openCodeUrl(`/api/session/${encodeURIComponent(sessionID)}/prompt`, directory, context.runtime), {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', Accept: 'application/json', ...authHeaders(context.runtime) },
+        body: JSON.stringify(promptBodyFromContext({ ...context, parts })),
+        signal,
+      });
       // Only an explicit 2xx (incl. empty 200/202/204) with no error is success.
       // undefined/malformed results must not be treated as accepted POSTs.
-      if (!result || typeof result !== 'object') return { ok: false, kind: 'ambiguous', code: 'malformed_result' };
-      const status = safeStatus(result);
-      if (result.error) {
-        return {
-          ok: false,
-          status,
-          kind: status === 408 || status === 429 || (Number.isInteger(status) && status >= 500) || status === undefined
-            ? 'ambiguous'
-            : Number.isInteger(status) && status >= 400 && status < 500
-              ? 'failed'
-              : 'ambiguous',
-        };
-      }
-      if (isSuccessStatus(status)) return { ok: true, status };
-      if (Number.isInteger(status) && status >= 400 && status < 500 && status !== 408 && status !== 429) {
-        return { ok: false, status, kind: 'failed' };
-      }
-      if (status === 408 || status === 429 || (Number.isInteger(status) && status >= 500)) {
-        return { ok: false, status, kind: 'ambiguous' };
-      }
-      // Missing status without error is ambiguous (empty/malformed transport), not ok.
-      return { ok: false, kind: 'ambiguous', code: 'malformed_result' };
+      if (!response || typeof response !== 'object') return { ok: false, kind: 'ambiguous', code: 'malformed_result' };
+      return classifyHttpStatus(response.status, { ok: response.ok });
     } catch (error) {
-      if (error?.name === 'AbortError') return { ok: false, kind: 'ambiguous', code: 'aborted' };
+      if (isAbortError(error)) return { ok: false, kind: 'ambiguous', code: 'aborted' };
+      if (isSessionBusyError(error)) return { ok: false, kind: 'retry', code: 'session_busy' };
       return { ok: false, kind: 'ambiguous', code: 'transport' };
     }
   };
-  const findViaBoundedMessages = async (api, scope, messageID, { signal } = {}) => {
-    const result = await api.session.messages({ sessionID: scope.sessionID, directory: scope.directory, limit: 100 }, { signal });
-    if (result?.error) return { unavailable: true };
-    const found = (result?.data ?? []).some((message) => messageIdentity(message) === messageID);
-    if (found) return { found: true };
-    if (result?.data?.length >= 100 || result?.nextCursor || result?.hasMore) return { unavailable: true };
-    return { found: false };
-  };
-  const findViaLegacySessionMessage = async (api, scope, messageID, { signal } = {}) => {
-    const legacy = api?.session?.message;
-    if (typeof legacy !== 'function') return null;
+  const findViaInbox = async (scope, messageID, { signal, runtime } = {}) => {
     try {
-      const result = await legacy.call(api.session, { sessionID: scope.sessionID, messageID, directory: scope.directory }, { signal });
-      const status = safeStatus(result);
-      if (result?.error) {
-        if (status === 404) return { found: false };
-        if (isNotFoundOrUnsupported(status)) return null;
-        return { unavailable: true };
-      }
-      const record = result?.data ?? result;
-      const id = messageIdentity(record);
-      if (id === messageID || Boolean(record?.info ?? record?.id)) return { found: true };
-      return { found: false };
+      const list = await client(runtime).session.inbox.list({ sessionID: scope.sessionID }, { signal });
+      if (!Array.isArray(list)) throw Object.assign(new Error('upstream'), { code: 'upstream' });
+      return { found: list.some((item) => inboxItemIdentity(item) === messageID) };
     } catch (error) {
-      if (isUnsupportedLookupError(error)) return null;
-      return { unavailable: true };
+      if (isNotFoundError(error)) return { found: false };
+      throw error;
     }
   };
-  const findViaExactV2Message = async (api, scope, messageID, { signal } = {}) => {
-    // Prefer client.v2.session.message when the 1.18 SDK surface exposes it.
-    const exact = api?.v2?.session?.message;
-    if (typeof exact !== 'function') return { kind: 'unsupported' };
+  // Prefer client.v2.session.message when the 1.18 SDK surface exposes it.
+  // Ticket 12: after prompt admission, reconcile only asks inbox + projection.
+  const findViaProjection = async (scope, messageID, { signal, runtime } = {}) => {
     try {
-      const result = await exact.call(api.v2.session, { sessionID: scope.sessionID, messageID, directory: scope.directory }, { signal });
-      const status = safeStatus(result);
-      if (result?.error) {
-        if (status === 404) return { kind: 'result', value: { found: false } };
-        if (isNotFoundOrUnsupported(status)) return { kind: 'unsupported' };
-        return { kind: 'result', value: { unavailable: true } };
-      }
-      const record = result?.data ?? result;
+      const record = await client(runtime).session.message({ sessionID: scope.sessionID, messageID }, { signal });
       const id = messageIdentity(record);
-      if (id === messageID || Boolean(record?.info ?? record?.id)) return { kind: 'result', value: { found: true } };
-      return { kind: 'result', value: { found: false } };
+      if (id === messageID || Boolean(record?.info ?? record?.id)) return { found: true };
+      return { found: false };
     } catch (error) {
-      if (isUnsupportedLookupError(error)) return { kind: 'unsupported' };
-      return { kind: 'result', value: { unavailable: true } };
+      if (isNotFoundError(error)) return { found: false };
+      throw error;
     }
   };
   const findMessage = async (scope, messageID, { signal, runtime } = {}) => {
@@ -182,13 +270,12 @@ export const createOpenCodeMessageQueueAdapter = ({
         if (exact?.unavailable) return { unavailable: true };
         return { found: Boolean(exact?.found ?? exact?.data ?? exact?.id) };
       }
-      const api = client(runtime);
-      const v2 = await findViaExactV2Message(api, scope, messageID, { signal });
-      if (v2.kind === 'result') return v2.value;
-      // Missing/unsupported v2 endpoint (or 405/501): try legacy client.session.message, then bounded list.
-      const legacy = await findViaLegacySessionMessage(api, scope, messageID, { signal });
-      if (legacy) return legacy;
-      return findViaBoundedMessages(api, scope, messageID, { signal });
+      const inbox = await findViaInbox(scope, messageID, { signal, runtime });
+      if (inbox.unavailable) return { unavailable: true };
+      if (inbox.found) return { found: true };
+      // Must await so projection rejections stay inside this try/catch
+      // (bare return of a Promise lets rejections escape as unhandled).
+      return await findViaProjection(scope, messageID, { signal, runtime });
     } catch { return { unavailable: true }; }
   };
   const observeSessionEvent = (scope, phase, runtime = captureRuntime()) => turnGate.observeEvent(turnKey(scope, runtime), phase);