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

package/server/lib/assistants/service.js

@@ -2,9 +2,8 @@ import crypto from 'node:crypto';
 import fs from 'node:fs';
 import { createRequire } from 'node:module';
 import path from 'node:path';
-import { createOpencodeClient } from '@opencode-ai/sdk/v2';
+import { makeOpenCodeV2Client } from '../opencode/v2-client.js';
 import { validAssistantDeliveryParts } from '../assistant-delivery-parts.js';
-import { reduceBackfillState } from './history-state.js';
 import { createContactMemoryReader } from './memory.js';
 import { getWorktrees as defaultListWorktrees } from '../git/service.js';
 import { contactCardIdentity, parseContactCard, parseContactPart } from './cards.js';
@@ -78,6 +77,7 @@ import {
 } from './assign.js';
 import { runContactTurn as defaultRunContactTurn } from './harness.js';
 import { loadConnectedCatalog } from '../llm/catalog.js';
+import { buildAssistantSessionMetadata } from '../session-metadata/system-session.js';
 
 const require = createRequire(import.meta.url);
 const SCHEMA_VERSION = 13;
@@ -117,22 +117,98 @@ export class AssistantError extends Error {
 const fail = (code, message) => { throw new AssistantError(code, message); };
 const string = (value, max = 10_000, required = false) => { if (value == null && !required) return null; if (typeof value !== 'string' || value.length > max || (required && !value.trim())) fail('validation_error'); return value.trim(); };
 const nonEmptyString = (value, max = 10_000) => typeof value === 'string' && value.length > 0 && value.length <= max;
-const isMissing = (result) => result?.error?.status === 404 || result?.error?.statusCode === 404 || result?.error?.code === 'not_found' || result?.status === 404;
+const isMissing = (result) => {
+  if (!result || typeof result !== 'object') return false;
+  if (result.error?.status === 404 || result.error?.statusCode === 404 || result.status === 404) return true;
+  const code = result.error?.code ?? result.error?.type ?? result.error?._tag ?? result._tag ?? result.code;
+  return code === 'not_found' || code === 'SessionNotFoundError' || code === 'MessageNotFoundError';
+};
 const messagesErrorStatus = (result) => { const status = result?.error?.status ?? result?.error?.statusCode ?? result?.status; return Number.isFinite(status) ? status : null; };
+const getHttpStatus = (error) => {
+  const candidates = [error?.cause?.status, error?.status, error?.response?.status];
+  for (const value of candidates) { if (Number.isFinite(value)) return value; }
+  return undefined;
+};
+// Real @opencode/client throws declared JSON with `_tag` (no HTTP status).
+const isMissingError = (error) => {
+  if (getHttpStatus(error) === 404 || isMissing(error)) return true;
+  if (!error || typeof error !== 'object') return false;
+  const tag = error._tag ?? error.name ?? error.code ?? error.type ?? error.error?._tag;
+  return tag === 'SessionNotFoundError' || tag === 'MessageNotFoundError' || tag === 'not_found';
+};
+const ASSISTANT_SUCCESS_FINISH = new Set(['stop']);
+const ASSISTANT_ERROR_FINISH = new Set(['error', 'length', 'content-filter']);
+const GOAL_ACTIVE_STATUSES = new Set(['active', 'paused']);
+const GOAL_ERROR_STATUSES = new Set(['blocked', 'budgetLimited']);
 const isTransientMessagesFailure = (result, error) => {
   if (error) {
     if (error instanceof AssistantError) return false;
-    if (error?.name === 'TypeError' || error?.name === 'FetchError') return true;
+    if (error?.reason === 'Transport' || error?.name === 'TypeError' || error?.name === 'FetchError' || error?.name === 'AbortError') return true;
     const code = error?.cause?.code || error?.code;
     if (code === 'ECONNREFUSED' || code === 'ENOTFOUND' || code === 'ECONNRESET' || code === 'ETIMEDOUT' || code === 'EPIPE') return true;
-    return false;
+    const status = getHttpStatus(error);
+    if (status == null) return false;
+    return status === 408 || status === 429 || status >= 500;
   }
   const status = messagesErrorStatus(result);
   if (status == null) return true;
   return status === 408 || status === 429 || status >= 500;
 };
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-const promptAdmitted = (result) => !result?.error && (result?.response?.status === 204 || result?.status === 204 || result?.data !== undefined || result?.response?.ok === true);
+const sessionRecord = (value) => (value && typeof value === 'object' && value.data && value.id == null ? value.data : value);
+const sessionIDOf = (value) => sessionRecord(value)?.id ?? null;
+const sessionDirectoryOf = (value) => {
+  const session = sessionRecord(value);
+  return session?.location?.directory ?? session?.directory ?? session?.project?.worktree ?? null;
+};
+const toV2PromptInput = (sessionID, parts, messageID) => {
+  const text = (parts || []).filter((part) => part?.type === 'text').map((part) => part.text).join('\n');
+  const files = (parts || []).filter((part) => part?.type === 'file').map((part) => ({ uri: part.url, ...(part.filename ? { name: part.filename } : {}) }));
+  const agents = (parts || []).filter((part) => part?.type === 'agent').map((part) => ({ name: part.name }));
+  return { sessionID, id: messageID, text, ...(files.length ? { files } : {}), ...(agents.length ? { agents } : {}), delivery: 'steer' };
+};
+const projectV2Parts = (entry, sessionID) => {
+  if (Array.isArray(entry?.parts)) return entry.parts;
+  const messageID = entry?.id;
+  const parts = [];
+  if (typeof entry?.text === 'string' && entry.text) parts.push({ id: `${messageID}:text`, sessionID, messageID, type: 'text', text: entry.text });
+  if (Array.isArray(entry?.files)) entry.files.forEach((file, index) => parts.push({ id: `${messageID}:file:${index}`, sessionID, messageID, type: 'file', mime: file?.mime || 'application/octet-stream', url: file?.uri ?? file?.url, ...(file?.name ? { filename: file.name } : {}) }));
+  if (Array.isArray(entry?.content)) entry.content.forEach((item, index) => {
+    const partID = item?.id || `${messageID}:content:${index}`;
+    if (item?.type === 'text') parts.push({ id: partID, sessionID, messageID, type: 'text', text: item.text ?? '' });
+    else if (item?.type === 'reasoning') parts.push({ id: partID, sessionID, messageID, type: 'reasoning', text: item.text ?? '' });
+    else if (item?.type === 'tool') parts.push({ id: partID, sessionID, messageID, type: 'tool', tool: item.name, callID: item.id, state: item.state ?? {} });
+  });
+  return parts;
+};
+const projectProjectionEntry = (entry, sessionID) => {
+  if (plainObject(entry?.info)) return { info: entry.info, parts: Array.isArray(entry.parts) ? entry.parts : [] };
+  if (!plainObject(entry) || !nonEmptyString(entry.id)) return { info: entry, parts: [] };
+  const role = entry.type === 'user' || entry.type === 'assistant' ? entry.type : (entry.role ?? entry.type);
+  return { info: { id: entry.id, sessionID: nonEmptyString(entry.sessionID) ? entry.sessionID : sessionID, role, time: entry.time ?? { created: 0 }, ...entry }, parts: projectV2Parts(entry, nonEmptyString(entry.sessionID) ? entry.sessionID : sessionID) };
+};
+const projectionEntries = (payload, sessionID) => {
+  const items = Array.isArray(payload?.data) ? payload.data : Array.isArray(payload) ? payload : Array.isArray(payload?.data?.items) ? payload.data.items : null;
+  if (!items) return null;
+  return items.map((entry) => projectProjectionEntry(entry, sessionID));
+};
+const projectionCursor = (result) => { const next = typeof result?.cursor === 'string' ? result.cursor : result?.cursor?.next; return (typeof next === 'string' && next) ? next : (result?.response?.headers?.get?.('x-next-cursor') ?? null); };
+const promptAdmitted = (result) => !result?.error && (result?.response?.status === 204 || result?.status === 204 || result?.id != null || result?.type != null || result?.data !== undefined || result?.response?.ok === true);
+const invokeSession = async (work) => {
+  try {
+    const value = await work();
+    if (isMissing(value)) return { error: { status: 404 }, status: 404 };
+    if (value?.error) return value;
+    return value;
+  } catch (error) {
+    if (error instanceof AssistantError) throw error;
+    if (isMissingError(error)) return { error: { status: 404 }, status: 404 };
+    const status = getHttpStatus(error);
+    if (status != null) return { error: { status }, status };
+    return { error: { status: 500 }, status: 500 };
+  }
+};
+
 /** Bound catalog / project list waits so a contact lane cannot hang forever. */
 export const CONTACT_CATALOG_DEADLINE_MS = 8_000;
 /** Bound last worker assistant text injected into assigned-session resume prompts. */
@@ -160,7 +236,7 @@ const awaitWithDeadline = async (work, ms = CONTACT_CATALOG_DEADLINE_MS, code =
   }
 };
 
-export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, getOpenCodeAuthHeaders, getServerId = async () => null, getAllowedRoots = () => [], listProjects = async () => [], readModelPreferences = async () => null, listScheduledTasks = null, sessionIndexService = null, upsertScheduledTask = null, syncScheduledTaskProject = null, globalEventHub = null, onRevisionTip = null, onContactTurnEvent = null, onContactTurnComplete = null, clock = () => Date.now(), setIntervalFn = setInterval, clearIntervalFn = clearInterval, setImmediateFn = setImmediate, reconcileIntervalMs = 60_000, clientFactory, createChatCompletion = null, runContactTurn = defaultRunContactTurn, listWorktrees = defaultListWorktrees } = {}) => {
+export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, getOpenCodeAuthHeaders, getServerId = async () => null, getAllowedRoots = () => [], listProjects = async () => [], readModelPreferences = async () => null, listScheduledTasks = null, sessionIndexService = null, upsertScheduledTask = null, syncScheduledTaskProject = null, globalEventHub = null, onRevisionTip = null, onContactTurnEvent = null, onContactTurnComplete = null, /** Host archive op: ({ sessionID, directory, archivedAt }) => Promise */ archiveSessionHost = null, /** Idempotent Host metadata drop after successful SDK delete */ forgetSessionHost = null, /** Host store write: (sessionId, patch) => Promise */ persistSessionMetadata = null, /** After Host isolation metadata is committed. */ onSystemSessionPersisted = null, clock = () => Date.now(), setIntervalFn = setInterval, clearIntervalFn = clearInterval, setImmediateFn = setImmediate, reconcileIntervalMs = 60_000, clientFactory, fetchImpl, createChatCompletion = null, runContactTurn = defaultRunContactTurn, listWorktrees = defaultListWorktrees } = {}) => {
   if (!dbPath || !dataDir) return null;
   const Database = require('better-sqlite3');
   fs.mkdirSync(path.dirname(dbPath), { recursive: true });
@@ -244,15 +320,11 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
     const existing = db.prepare('SELECT directory FROM assistant_session_history WHERE assistant_id=? AND session_id=?').get(assistantID, sessionID);
     if (existing) {
       if (existing.directory == null && directory != null) db.prepare('UPDATE assistant_session_history SET directory=? WHERE assistant_id=? AND session_id=?').run(directory, assistantID, sessionID);
-      db.prepare('DELETE FROM assistant_message_backfill WHERE assistant_id=? AND session_id=?').run(assistantID, sessionID);
-      db.prepare("UPDATE assistant_message_mirror SET covered=0 WHERE assistant_id=? AND session_id=? AND COALESCE(json_extract(info_json,'$.role'),'')<>'user' AND COALESCE(json_extract(info_json,'$.openchamberAssistantAdmission'),0)<>1").run(assistantID, sessionID);
       return;
     }
     const effectiveDirectory = directory ?? effectiveWorkspace(editable(assistantID));
     const ordinal = Number(db.prepare('SELECT COALESCE(MAX(ordinal), 0) + 1 AS next FROM assistant_session_history WHERE assistant_id=?').get(assistantID).next);
     db.prepare('INSERT INTO assistant_session_history(assistant_id, session_id, ordinal, directory, created_at) VALUES (?,?,?,?,?)').run(assistantID, sessionID, ordinal, effectiveDirectory, now());
-    db.prepare('DELETE FROM assistant_message_backfill WHERE assistant_id=? AND session_id=?').run(assistantID, sessionID);
-    db.prepare("UPDATE assistant_message_mirror SET covered=0 WHERE assistant_id=? AND session_id=? AND COALESCE(json_extract(info_json,'$.role'),'')<>'user' AND COALESCE(json_extract(info_json,'$.openchamberAssistantAdmission'),0)<>1").run(assistantID, sessionID);
   };
   const activeContactTurnsFor = (assistantID) => activeContactTurnsByAssistant.get(assistantID) ?? new Map();
   const rememberActiveContactTurn = (assistantID, input) => {
@@ -348,30 +420,43 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
     };
   };
   const binding = (row) => ({ sessionID: row.current_session_id, directory: effectiveWorkspace(row), sessionGeneration: row.session_generation });
-  const client = () => clientFactory ? clientFactory() : createOpencodeClient({ baseUrl: buildOpenCodeUrl('/', '').replace(/\/$/, ''), headers: getOpenCodeAuthHeaders() });
-  const metadata = (row) => ({ openchamber: { assistant: { assistantID: row.assistant_id, name: row.name } } });
-  const ARCHIVE_RETRY_MS = 25;
-  const archiveCreatedSession = async (sessionID, directory) => {
-    const archiveAt = now();
-    const update = () => client().session.update({ sessionID, directory, time: { archived: archiveAt } });
-    let result = await update();
-    if (isMissing(result)) {
-      await sleep(ARCHIVE_RETRY_MS);
-      result = await update();
-    }
-    if (result?.error || isMissing(result)) fail('upstream_error');
+  const client = () => clientFactory
+    ? clientFactory()
+    : makeOpenCodeV2Client({
+      baseUrl: buildOpenCodeUrl('/', '').replace(/\/$/, ''),
+      authHeaders: getOpenCodeAuthHeaders(),
+    });
+  const metadata = (row) => buildAssistantSessionMetadata({
+    assistantID: row.assistant_id,
+    name: row.name,
+  });
+  const persistAssistantIsolation = async (sessionID, directory, isolation) => {
+    if (typeof persistSessionMetadata !== 'function') return;
+    try {
+      await persistSessionMetadata(sessionID, isolation);
+      onSystemSessionPersisted?.({ sessionID, directory, metadata: isolation });
+    } catch {
+      // Archive still isolates; Host persist is the sidebar authority when it succeeds.
+    }
   };
   const createSession = async (row) => {
     const directory = effectiveWorkspace(row);
-    const result = await client().session.create({ directory, title: `[Assistant] ${row.name}`, metadata: metadata(row) });
-    if (result.error || !result.data?.id) fail('upstream_error');
-    const sessionID = result.data.id;
+    const isolation = metadata(row);
+    const result = await invokeSession(() => client().session.create({
+      title: `[Assistant] ${row.name}`,
+      location: { directory },
+      metadata: isolation,
+      ...(row.agent ? { agent: row.agent } : {}),
+      ...(row.provider_id && row.model_id ? { model: { id: row.model_id, providerID: row.provider_id, ...(row.variant ? { variant: row.variant } : {}) } } : {}),
+    }));
+    const sessionID = sessionIDOf(result);
+    if (result?.error || !sessionID) fail('upstream_error');
+    // Host metadata isolates the session if archive is delayed or unavailable.
+    await persistAssistantIsolation(sessionID, directory, isolation);
     // Archive before binding so ordinary session lists never flash system sessions.
-    // Metadata still isolates the session if archive fails after create.
-    await archiveCreatedSession(sessionID, directory);
     return { sessionID, directory };
   };
-  const sessionExists = async (row) => { if (!row.current_session_id) return false; const result = await client().session.get({ sessionID: row.current_session_id, directory: effectiveWorkspace(row) }); if (isMissing(result)) return false; if (result.error) fail('upstream_error'); return Boolean(result.data); };
+  const sessionExists = async (row) => { if (!row.current_session_id) return false; const result = await invokeSession(() => client().session.get({ sessionID: row.current_session_id })); if (isMissing(result)) return false; if (result.error) fail('upstream_error'); return Boolean(sessionIDOf(result) || result); };
   const replaceBinding = (row, created) => { if (row.current_session_id && row.current_session_id !== created.sessionID) archiveSession(row.assistant_id, row.current_session_id, effectiveWorkspace(row)); const result = db.prepare('UPDATE assistant_v2 SET current_session_id=?,session_generation=session_generation+1,updated_at=? WHERE assistant_id=? AND session_generation=? AND tombstone_at IS NULL').run(created.sessionID, now(), row.assistant_id, row.session_generation); if (result.changes) bump(); return result.changes ? assistant(row.assistant_id) : null; };
   const statelessLanes = new Map();
   const inStatelessLane = (assistantID, task) => {
@@ -413,75 +498,21 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
     db.prepare("INSERT OR REPLACE INTO assistant_meta(key,value) VALUES ('schema_version',?)").run(String(SCHEMA_VERSION));
   };
   migrate();
-  const mirrorMessage = (assistantID, sessionID, info, ordinal, covered = false) => {
-    const messageID = info?.id;
-    if (!nonEmptyString(assistantID) || !nonEmptyString(sessionID) || !nonEmptyString(messageID) || !plainObject(info)) return;
-    const existing = db.prepare('SELECT ordinal FROM assistant_message_mirror WHERE assistant_id=? AND session_id=? AND message_id=?').get(assistantID, sessionID, messageID);
-    const nextOrdinal = Number.isSafeInteger(ordinal) ? ordinal : existing?.ordinal ?? Number(db.prepare('SELECT COALESCE(MAX(ordinal), 0) + 1 AS next FROM assistant_message_mirror WHERE assistant_id=? AND session_id=?').get(assistantID, sessionID).next);
-    db.prepare('INSERT INTO assistant_message_mirror(assistant_id,session_id,message_id,info_json,ordinal,covered,updated_at) VALUES (?,?,?,?,?,?,?) ON CONFLICT(assistant_id,session_id,message_id) DO UPDATE SET info_json=excluded.info_json,ordinal=excluded.ordinal,covered=CASE WHEN assistant_message_mirror.covered=1 OR excluded.covered=1 THEN 1 ELSE 0 END,updated_at=excluded.updated_at').run(assistantID, sessionID, messageID, json(info), nextOrdinal, covered ? 1 : 0, now());
-  };
-  const mirrorPart = (assistantID, sessionID, part, ordinal) => {
-    const messageID = part?.messageID; const partID = part?.id;
-    if (!nonEmptyString(assistantID) || !nonEmptyString(sessionID) || !nonEmptyString(messageID) || !nonEmptyString(partID) || !plainObject(part)) return;
-    const existing = db.prepare('SELECT ordinal FROM assistant_message_part_mirror WHERE assistant_id=? AND session_id=? AND message_id=? AND part_id=?').get(assistantID, sessionID, messageID, partID);
-    const nextOrdinal = Number.isSafeInteger(ordinal) ? ordinal : existing?.ordinal ?? Number(db.prepare('SELECT COALESCE(MAX(ordinal), 0) + 1 AS next FROM assistant_message_part_mirror WHERE assistant_id=? AND session_id=? AND message_id=?').get(assistantID, sessionID, messageID).next);
-    db.prepare('INSERT INTO assistant_message_part_mirror(assistant_id,session_id,message_id,part_id,part_json,ordinal,updated_at) VALUES (?,?,?,?,?,?,?) ON CONFLICT(assistant_id,session_id,message_id,part_id) DO UPDATE SET part_json=excluded.part_json,ordinal=excluded.ordinal,updated_at=excluded.updated_at').run(assistantID, sessionID, messageID, partID, json(part), nextOrdinal, now());
-  };
-  const mirrorAdmittedUserMessage = (row, sessionID, messageID, parts, config) => {
-    const existingMessage = db.prepare('SELECT info_json FROM assistant_message_mirror WHERE assistant_id=? AND session_id=? AND message_id=?').get(row.assistant_id, sessionID, messageID);
-    const existingInfo = existingMessage ? parse(existingMessage.info_json) : null;
-    const info = plainObject(existingInfo) && existingInfo.role === 'user'
-      ? existingInfo
-      : {
-          id: messageID,
-          sessionID,
-          role: 'user',
-          time: { created: now() },
-          ...(config?.agent ? { agent: config.agent } : {}),
-          ...(plainObject(config?.model) ? { model: config.model } : {}),
-          ...(typeof config?.system === 'string' && config.system ? { system: config.system } : {}),
-          summary: { diffs: [] },
-          openchamberAssistantAdmission: true,
-        };
-    db.exec('BEGIN IMMEDIATE');
-    try {
-      mirrorMessage(row.assistant_id, sessionID, info, undefined, true);
-      const hasAuthoritativeParts = Number(db.prepare("SELECT COUNT(*) AS count FROM assistant_message_part_mirror WHERE assistant_id=? AND session_id=? AND message_id=? AND part_id NOT GLOB 'oc_asst_admission:*'").get(row.assistant_id, sessionID, messageID).count) > 0;
-      if (!hasAuthoritativeParts) {
-        db.prepare("DELETE FROM assistant_message_part_mirror WHERE assistant_id=? AND session_id=? AND message_id=? AND part_id GLOB 'oc_asst_admission:*'").run(row.assistant_id, sessionID, messageID);
-        parts.forEach((part, index) => mirrorPart(row.assistant_id, sessionID, {
-          ...part,
-          id: `oc_asst_admission:${index + 1}`,
-          sessionID,
-          messageID,
-        }, index + 1));
-      }
-      db.exec('COMMIT');
-    } catch (error) {
-      db.exec('ROLLBACK');
-      throw error;
-    }
-    bump();
-  };
+  // V2: OpenCode projection is the sole message-body authority. Legacy mirror /
+  // backfill tables may still exist for leftover rows but are never written or
+  // read for history serving.
   const mappedAssistants = (sessionID) => db.prepare("SELECT assistant_id FROM assistant_v2 WHERE current_session_id=? AND tombstone_at IS NULL UNION SELECT h.assistant_id FROM assistant_session_history h JOIN assistant_v2 a ON a.assistant_id=h.assistant_id WHERE h.session_id=? AND a.tombstone_at IS NULL").all(sessionID, sessionID).map((row) => row.assistant_id);
-  const invalidateCoverage = (assistantID, sessionID) => {
-    db.prepare('UPDATE assistant_message_mirror SET covered=0 WHERE assistant_id=? AND session_id=?').run(assistantID, sessionID);
-    db.prepare('INSERT INTO assistant_message_backfill(assistant_id,session_id,cursor,complete,updated_at) VALUES (?,?,?,?,?) ON CONFLICT(assistant_id,session_id) DO UPDATE SET cursor=NULL,complete=0,updated_at=excluded.updated_at').run(assistantID, sessionID, null, 0, now());
-  };
-  // Reopen demand backfill without clearing covered/provisional mirrors.
-  const invalidateBackfill = (assistantID, sessionID) => {
-    const current = db.prepare('SELECT cursor,complete FROM assistant_message_backfill WHERE assistant_id=? AND session_id=?').get(assistantID, sessionID);
-    const next = reduceBackfillState({ cursor: current?.cursor ?? null, complete: Boolean(current?.complete) }, 'invalidate');
-    db.prepare('INSERT INTO assistant_message_backfill(assistant_id,session_id,cursor,complete,updated_at) VALUES (?,?,?,?,?) ON CONFLICT(assistant_id,session_id) DO UPDATE SET cursor=excluded.cursor,complete=excluded.complete,updated_at=excluded.updated_at').run(assistantID, sessionID, next.cursor, next.complete ? 1 : 0, now());
-  };
-  // Structural part deletes may leave a covered message incomplete; re-demand that session only.
-  // Do not blanket-uncover on ordinary message/part upserts — that blanks served history until re-backfill.
-  const invalidateMessageCoverage = (assistantID, sessionID, messageID) => {
-    db.prepare('UPDATE assistant_message_mirror SET covered=0 WHERE assistant_id=? AND session_id=? AND message_id=?').run(assistantID, sessionID, messageID);
-    db.prepare('INSERT INTO assistant_message_backfill(assistant_id,session_id,cursor,complete,updated_at) VALUES (?,?,?,?,?) ON CONFLICT(assistant_id,session_id) DO UPDATE SET cursor=NULL,complete=0,updated_at=excluded.updated_at').run(assistantID, sessionID, null, 0, now());
-  };
-  const eventSessionID = (properties) => {
-    const sessionID = properties?.sessionID || properties?.sessionId || properties?.info?.sessionID || properties?.info?.sessionId;
+  // Accept bridge/legacy `{ properties }` and native v2 `{ data }` envelopes.
+  const eventBody = (payload) => {
+    if (!plainObject(payload)) return null;
+    const data = plainObject(payload.data) ? payload.data : null;
+    const properties = plainObject(payload.properties) ? payload.properties : null;
+    if (data && Object.keys(data).length > 0) return data;
+    if (properties) return properties;
+    return data || properties || null;
+  };
+  const eventSessionID = (body) => {
+    const sessionID = body?.sessionID || body?.sessionId || body?.info?.sessionID || body?.info?.sessionId;
     return nonEmptyString(sessionID) ? sessionID : '';
   };
   const isUserAbort = (error) => error?.name === 'MessageAbortedError';
@@ -519,21 +550,44 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
       if (status === 'cancelled') entry.observed.resume = resume !== false;
     }
   };
-  const settleStatusFromEvent = (payload, properties) => {
-    if (payload.type === 'session.error') return isUserAbort(properties.error) ? 'cancelled' : 'error';
-    if (payload.type === 'question.asked' || payload.type === 'permission.asked') return 'question';
-    if (payload.type === 'session.idle') return 'complete';
-    if (payload.type === 'session.status') {
-      const statusType = typeof properties.status?.type === 'string' ? properties.status.type : typeof properties.info?.type === 'string' ? properties.info.type : '';
-      if (statusType === 'busy' || statusType === 'retry') return 'busy';
+  const settleStatusFromEvent = (payload, body) => {
+    const type = typeof payload?.type === 'string' ? payload.type : '';
+    if (type === 'session.error' || type === 'session.execution.failed') {
+      return isUserAbort(body?.error) ? 'cancelled' : 'error';
+    }
+    // Official reason: user | shutdown | superseded | inactivity (ticket 07).
+    // Shutdown keeps the upstream execution claim for restart recovery — do not
+    // settle the watch or schedule contact resume; wait for authoritative terminal.
+    if (type === 'session.execution.interrupted') {
+      const reason = typeof body?.reason === 'string' ? body.reason.trim() : '';
+      if (reason === 'shutdown') return null;
+      if (reason === 'user' || isUserAbort(body?.error)) return 'cancelled';
+      return 'error';
+    }
+    if (type === 'session.execution.succeeded') return 'complete';
+    if (type === 'session.execution.started' || type === 'session.retry.scheduled') return 'busy';
+    if (type === 'question.asked' || type === 'permission.asked'
+      || type === 'session.pending.question' || type === 'session.pending.permission'
+      || type === 'pending.question' || type === 'pending.permission') return 'question';
+    if (type === 'session.idle') return 'complete';
+    if (type === 'session.status') {
+      const statusType = typeof body?.status?.type === 'string' ? body.status.type : typeof body?.info?.type === 'string' ? body.info.type : '';
+      if (statusType === 'busy' || statusType === 'retry' || statusType === 'running') return 'busy';
       if (statusType === 'idle') return 'complete';
     }
     return null;
   };
+  // Stash assign delivery message IDs until the session card watch is written.
+  const pendingAssignMessageIDs = new Map();
   // Assigned-session complete/error/cancelled resumes the contact LLM (no canned settle bubble).
   // Assigned after inContactTurnLane exists; reportAssignedSession only schedules via this ref.
   const assignedSessionResumeRef = { schedule: null };
-  const reportAssignedSession = (sessionID, status, resume = true) => {
+  const reportAssignedSession = (sessionID, status, resumeOrOpts = true) => {
+    const opts = plainObject(resumeOrOpts)
+      ? resumeOrOpts
+      : { resume: resumeOrOpts !== false };
+    const resume = opts.resume !== false;
+    const requireExecutionOwned = opts.requireExecutionOwned === true;
     const inflight = sessionAbortInflight.get(sessionID);
     if (inflight) {
       // Defer watch terminal + continuation until stop_session abort settles.
@@ -554,6 +608,9 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
         if (watch.status === status || watch.status === 'cancelled') continue;
         // session.idle / status idle follow session.error. Do not rewrite 失败 as 完成.
         if (status === 'complete' && watch.status === 'error') continue;
+        // Weak idle signals must not settle a delivery-watermarked watch — old
+        // session.idle can race a reuse assign. Formal execution.* owns that path.
+        if (requireExecutionOwned && status === 'complete' && watch.messageID) continue;
         const updatedAt = now();
         updateSessionCardStatus(db, { assistantID: watch.assistantID, sessionID, status });
         upsertContactWatch(db, {
@@ -563,6 +620,7 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
           status,
           updatedAt,
           resumeAllowed: watch.resumeAllowed,
+          ...(watch.messageID ? { messageID: watch.messageID } : {}),
         });
         // complete/error/user-interrupt cancelled: hand result back to contact LLM.
         // question: card only (worker waiting). stop_session passes resume=false.
@@ -586,7 +644,7 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
     }
     // processEvent stays sync; resume runs on the contact turn lane asynchronously.
     if (typeof assignedSessionResumeRef.schedule === 'function') {
-      for (const resume of resumes) assignedSessionResumeRef.schedule(resume);
+      for (const item of resumes) assignedSessionResumeRef.schedule(item);
     }
     return changed;
   };
@@ -596,26 +654,134 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
     if (typeof session?.type === 'string') return session.type;
     return '';
   };
+  const readMessageInfo = (entry) => {
+    if (!entry || typeof entry !== 'object') return null;
+    if (plainObject(entry.info)) return entry.info;
+    return entry;
+  };
+  const isAssistantMessage = (info) => info && (info.type === 'assistant' || info.role === 'assistant');
+  const messageListItems = (result) => {
+    if (!result || result.error) return null;
+    if (Array.isArray(result.data)) return result.data;
+    if (Array.isArray(result)) return result;
+    if (Array.isArray(result.data?.items)) return result.data.items;
+    return null;
+  };
+  const activeMapOf = (value) => {
+    if (!value || typeof value !== 'object' || Array.isArray(value) || value.error) return null;
+    // Tolerate `{ data: { ses_x: … } }` wrappers without treating a bare map as nested data.
+    if (value.data && typeof value.data === 'object' && !Array.isArray(value.data) && value.id == null
+      && !Object.prototype.hasOwnProperty.call(value, 'type')) {
+      const nested = value.data;
+      if (!Array.isArray(nested) && typeof nested === 'object') return nested;
+    }
+    return value;
+  };
+  const goalOfSession = (session) => {
+    const goal = session?.metadata?.openchamber?.goal;
+    if (!goal || typeof goal !== 'object') return null;
+    const status = typeof goal.status === 'string' ? goal.status.trim() : '';
+    return status ? { status } : null;
+  };
+  /** Messages that belong to this delivery watermark (assign prompt messageID). */
+  const messagesOwnedByDelivery = (messages, deliveryMessageID) => {
+    if (!Array.isArray(messages)) return [];
+    if (!nonEmptyString(deliveryMessageID)) return messages;
+    const rows = messages.map((entry) => ({ entry, info: readMessageInfo(entry) }));
+    const delivery = rows.find((row) => row.info?.id === deliveryMessageID);
+    if (delivery) {
+      const created = typeof delivery.info?.time?.created === 'number' ? delivery.info.time.created : null;
+      return rows
+        .filter((row) => {
+          if (row.info?.id === deliveryMessageID) return true;
+          const rowCreated = typeof row.info?.time?.created === 'number' ? row.info.time.created : null;
+          if (created != null && rowCreated != null) {
+            if (rowCreated > created) return true;
+            if (rowCreated < created) return false;
+          }
+          // Ascending msg_ ids: strictly after the delivery user row.
+          return typeof row.info?.id === 'string' && row.info.id > deliveryMessageID;
+        })
+        .map((row) => row.entry);
+    }
+    // Delivery not on this page — only keep ids after the watermark.
+    return rows
+      .filter((row) => typeof row.info?.id === 'string' && row.info.id > deliveryMessageID)
+      .map((row) => row.entry);
+  };
   const lastAssistantInfo = (messages) => {
-    if (!Array.isArray(messages)) return null;
-    for (let index = messages.length - 1; index >= 0; index -= 1) {
-      const info = messages[index]?.info ?? messages[index];
-      if (info?.role === 'assistant') return info;
+    if (!Array.isArray(messages) || messages.length === 0) return null;
+    // Prefer newest by time.created; fall back to array order (desc list → index 0).
+    let best = null;
+    let bestCreated = Number.NEGATIVE_INFINITY;
+    let bestIndex = -1;
+    for (let index = 0; index < messages.length; index += 1) {
+      const info = readMessageInfo(messages[index]);
+      if (!isAssistantMessage(info)) continue;
+      const created = typeof info?.time?.created === 'number' ? info.time.created : Number.NEGATIVE_INFINITY;
+      if (!best || created > bestCreated || (created === bestCreated && index < bestIndex)) {
+        best = info;
+        bestCreated = created;
+        bestIndex = index;
+      }
+    }
+    if (best) return best;
+    // Desc page without timestamps: first assistant from the start.
+    for (let index = 0; index < messages.length; index += 1) {
+      const info = readMessageInfo(messages[index]);
+      if (isAssistantMessage(info)) return info;
     }
     return null;
   };
-  const inferAssignedSessionSettleStatus = (getResult, messagesResult) => {
+  const classifyOwnedAssistantTail = (assistantInfo) => {
+    if (!assistantInfo) return null;
+    if (assistantInfo.error) {
+      // MessageAbortedError → cancelled for contact resume; other errors fail the card.
+      return isUserAbort(assistantInfo.error) ? 'cancelled' : 'error';
+    }
+    const finish = typeof assistantInfo.finish === 'string' ? assistantInfo.finish.trim() : '';
+    // Mid-loop tool-calls (even with time.completed) are intermediate steps.
+    if (finish === 'tool-calls') return null;
+    if (ASSISTANT_ERROR_FINISH.has(finish)) return 'error';
+    if (assistantInfo.time?.completed && (!finish || ASSISTANT_SUCCESS_FINISH.has(finish))) return 'complete';
+    if (!finish && !assistantInfo.time?.completed) return null;
+    return null;
+  };
+  const inferAssignedSessionSettleStatus = (getResult, messagesResult, { deliveryMessageID = null, activeBusy = null } = {}) => {
     if (isMissing(getResult)) return 'complete';
     if (getResult?.error) return null;
-    const session = getResult?.data;
+    // Authoritative active membership wins over stale get snapshots.
+    if (activeBusy === true) return null;
+    const session = sessionRecord(getResult);
     if (session?.error) return isUserAbort(session.error) ? 'cancelled' : 'error';
+    const goal = goalOfSession(session);
+    // Goal settle is owned by the session-goal reporter — never invent success.
+    if (goal && GOAL_ACTIVE_STATUSES.has(goal.status)) return null;
+    if (goal && GOAL_ERROR_STATUSES.has(goal.status)) return 'error';
+    if (goal && goal.status === 'complete') return 'complete';
     const statusType = sessionStatusType(session);
-    if (statusType === 'busy' || statusType === 'retry') return null;
+    if (statusType === 'busy' || statusType === 'retry' || statusType === 'running') return null;
     if (isMissing(messagesResult)) return 'complete';
-    const assistant = messagesResult && !messagesResult.error ? lastAssistantInfo(messagesResult.data) : null;
-    if (assistant?.error) return isUserAbort(assistant.error) ? 'cancelled' : 'error';
-    if (statusType === 'idle' || session?.time?.completed) return 'complete';
-    if (assistant?.time?.completed) return 'complete';
+    if (messagesResult?.error) return null;
+    const items = messageListItems(messagesResult);
+    if (!items) return null;
+    const owned = messagesOwnedByDelivery(items, deliveryMessageID);
+    // Reused session: only pre-delivery assistants remain → wait for this run.
+    if (nonEmptyString(deliveryMessageID) && owned.length === 0) return null;
+    if (nonEmptyString(deliveryMessageID) && !owned.some((entry) => readMessageInfo(entry)?.id === deliveryMessageID)
+      && !owned.some((entry) => isAssistantMessage(readMessageInfo(entry)))) {
+      return null;
+    }
+    const assistantInfo = lastAssistantInfo(owned);
+    const fromTail = classifyOwnedAssistantTail(assistantInfo);
+    if (fromTail) return fromTail;
+    // No owned assistant yet after delivery — keep waiting (superseded / not started).
+    if (nonEmptyString(deliveryMessageID) && !assistantInfo) return null;
+    // Legacy watches without watermark: idle / session completed may settle.
+    if (!nonEmptyString(deliveryMessageID)) {
+      if (statusType === 'idle' || session?.time?.completed) return 'complete';
+      if (assistantInfo?.time?.completed && assistantInfo.finish !== 'tool-calls') return 'complete';
+    }
     return null;
   };
   const resolveWatchDirectory = (watch) => {
@@ -634,26 +800,50 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
     } catch {
       return;
     }
+    if (watches.length === 0) return;
+    // One active query per reconcile — authoritative busy membership map.
+    let activeMap = null;
+    let activeKnown = false;
+    try {
+      const api = client();
+      if (typeof api.session?.active === 'function') {
+        const raw = await api.session.active();
+        activeMap = activeMapOf(raw);
+        activeKnown = activeMap != null;
+      }
+    } catch {
+      activeKnown = false;
+    }
+    if (closed) return;
     for (const watch of watches) {
       if (closed) return;
       try {
+        const activeBusy = activeKnown
+          ? Object.prototype.hasOwnProperty.call(activeMap, watch.sessionID)
+          : null;
+        if (activeBusy === true) continue;
         const directory = resolveWatchDirectory(watch);
         if (!directory) continue;
         let getResult;
         try {
-          getResult = await client().session.get({ sessionID: watch.sessionID, directory });
-        } catch {
-          continue;
+          getResult = await invokeSession(() => client().session.get({ sessionID: watch.sessionID, directory }));
+        } catch (error) {
+          if (isMissingError(error)) getResult = { error: { status: 404 }, status: 404 };
+          else continue;
         }
         if (closed) return;
         let messagesResult = null;
         try {
-          messagesResult = await client().session.messages({ sessionID: watch.sessionID, directory, limit: 100 });
-        } catch {
-          messagesResult = null;
+          messagesResult = await invokeSession(() => client().message.list({ sessionID: watch.sessionID, limit: 100, order: 'desc' }));
+        } catch (error) {
+          if (isMissingError(error)) messagesResult = { error: { status: 404 }, status: 404 };
+          else messagesResult = null;
         }
         if (closed) return;
-        const status = inferAssignedSessionSettleStatus(getResult, messagesResult);
+        const status = inferAssignedSessionSettleStatus(getResult, messagesResult, {
+          deliveryMessageID: watch.messageID,
+          activeBusy,
+        });
         if (status) reportAssignedSession(watch.sessionID, status);
       } catch {
         // One failed watch must not block unrelated watches.
@@ -662,47 +852,74 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
   };
   const processEvent = (event) => {
     const payload = event?.payload?.payload ?? event?.payload ?? event;
-    const properties = payload?.properties;
-    if (!plainObject(payload) || !plainObject(properties)) return false;
+    if (!plainObject(payload) || typeof payload.type !== 'string') return false;
+    const body = eventBody(payload);
+    // Message lifecycle still requires a body; execution/status may carry sessionID on body only.
     if (payload.type === 'message.updated') {
-      const info = properties.info; const sessionID = info?.sessionID;
+      if (!plainObject(body)) return false;
+      const info = body.info; const sessionID = info?.sessionID;
       if (!nonEmptyString(sessionID) || !plainObject(info)) return false;
       const cancelled = info.role === 'assistant' && isUserAbort(info.error)
         ? reportAssignedSession(sessionID, 'cancelled') : false;
-      const assistants = mappedAssistants(sessionID); for (const assistantID of assistants) { const current = assistant(assistantID)?.current_session_id === sessionID; mirrorMessage(assistantID, sessionID, info, undefined, current); if (!current) invalidateBackfill(assistantID, sessionID); } return cancelled || assistants.length > 0;
+      // Body authority is OpenCode projection GET — do not mirror message bodies.
+      return cancelled || mappedAssistants(sessionID).length > 0;
     }
     if (payload.type === 'message.part.updated') {
-      const part = properties.part; const sessionID = properties.sessionID ?? part?.sessionID;
+      if (!plainObject(body)) return false;
+      const part = body.part; const sessionID = body.sessionID ?? part?.sessionID;
       if (!nonEmptyString(sessionID) || !plainObject(part)) return false;
-      const assistants = mappedAssistants(sessionID); for (const assistantID of assistants) { db.prepare("DELETE FROM assistant_message_part_mirror WHERE assistant_id=? AND session_id=? AND message_id=? AND part_id GLOB 'oc_asst_admission:*'").run(assistantID, sessionID, part.messageID); mirrorPart(assistantID, sessionID, part); if (assistant(assistantID)?.current_session_id !== sessionID) invalidateBackfill(assistantID, sessionID); } return assistants.length > 0;
+      return mappedAssistants(sessionID).length > 0;
     }
     if (payload.type === 'message.removed') {
-      const sessionID = properties.sessionID; const messageID = properties.messageID;
+      if (!plainObject(body)) return false;
+      const sessionID = body.sessionID; const messageID = body.messageID;
       if (!nonEmptyString(sessionID) || !nonEmptyString(messageID)) return false;
-      const assistants = mappedAssistants(sessionID); for (const assistantID of assistants) { db.prepare('DELETE FROM assistant_message_part_mirror WHERE assistant_id=? AND session_id=? AND message_id=?').run(assistantID, sessionID, messageID); db.prepare('DELETE FROM assistant_message_mirror WHERE assistant_id=? AND session_id=? AND message_id=?').run(assistantID, sessionID, messageID); } return assistants.length > 0;
+      return mappedAssistants(sessionID).length > 0;
     }
     if (payload.type === 'message.part.removed') {
-      const sessionID = properties.sessionID; const messageID = properties.messageID ?? properties.part?.messageID; const partID = properties.partID ?? properties.part?.id;
+      if (!plainObject(body)) return false;
+      const sessionID = body.sessionID; const messageID = body.messageID ?? body.part?.messageID; const partID = body.partID ?? body.part?.id;
       if (!nonEmptyString(sessionID) || !nonEmptyString(messageID) || !nonEmptyString(partID)) return false;
-      const assistants = mappedAssistants(sessionID); for (const assistantID of assistants) { db.prepare('DELETE FROM assistant_message_part_mirror WHERE assistant_id=? AND session_id=? AND message_id=? AND part_id=?').run(assistantID, sessionID, messageID, partID); if (assistant(assistantID)?.current_session_id !== sessionID) invalidateMessageCoverage(assistantID, sessionID, messageID); } return assistants.length > 0;
+      return mappedAssistants(sessionID).length > 0;
+    }
+    const sessionID = plainObject(body) ? eventSessionID(body) : '';
+    if (payload.type === 'session.execution.started' || payload.type === 'session.retry.scheduled') {
+      if (!sessionID) return false;
+      return reportAssignedSession(sessionID, 'busy');
+    }
+    if (payload.type === 'session.execution.succeeded'
+      || payload.type === 'session.execution.failed'
+      || payload.type === 'session.execution.interrupted') {
+      if (!sessionID) return false;
+      const status = settleStatusFromEvent(payload, body);
+      // shutdown interrupt: status null — keep watch in-flight (pending recovery).
+      if (!status) {
+        return listWatchesBySession(db, sessionID).length > 0
+          || mappedAssistants(sessionID).length > 0;
+      }
+      const reported = reportAssignedSession(sessionID, status);
+      const assistants = mappedAssistants(sessionID);
+      return reported || assistants.some((assistantID) => assistant(assistantID)?.current_session_id !== sessionID);
     }
     if (payload.type === 'session.idle' || payload.type === 'session.error') {
-      const sessionID = eventSessionID(properties);
       if (!sessionID) return false;
-      const reported = reportAssignedSession(sessionID, settleStatusFromEvent(payload, properties));
-      const assistants = mappedAssistants(sessionID); for (const assistantID of assistants) { if (assistant(assistantID)?.current_session_id !== sessionID) invalidateBackfill(assistantID, sessionID); }
+      // session.idle is a weak fallback: watermarked watches need execution.* or reconcile.
+      const status = settleStatusFromEvent(payload, body);
+      const reported = reportAssignedSession(sessionID, status, { requireExecutionOwned: payload.type === 'session.idle' });
+      const assistants = mappedAssistants(sessionID);
       return reported || assistants.some((assistantID) => assistant(assistantID)?.current_session_id !== sessionID);
     }
     if (payload.type === 'session.status') {
-      const sessionID = eventSessionID(properties);
-      const status = settleStatusFromEvent(payload, properties);
-      if (!sessionID || !status) return false;
-      const reported = reportAssignedSession(sessionID, status);
-      const assistants = mappedAssistants(sessionID); for (const assistantID of assistants) { if (assistant(assistantID)?.current_session_id !== sessionID) invalidateBackfill(assistantID, sessionID); }
+      if (!sessionID) return false;
+      const status = settleStatusFromEvent(payload, body);
+      if (!status) return false;
+      const reported = reportAssignedSession(sessionID, status, { requireExecutionOwned: status === 'complete' });
+      const assistants = mappedAssistants(sessionID);
       return reported || assistants.some((assistantID) => assistant(assistantID)?.current_session_id !== sessionID);
     }
-    if (payload.type === 'question.asked' || payload.type === 'permission.asked') {
-      const sessionID = eventSessionID(properties);
+    if (payload.type === 'question.asked' || payload.type === 'permission.asked'
+      || payload.type === 'session.pending.question' || payload.type === 'session.pending.permission'
+      || payload.type === 'pending.question' || payload.type === 'pending.permission') {
       if (!sessionID) return false;
       return reportAssignedSession(sessionID, 'question');
     }
@@ -715,131 +932,384 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
     }
     return null;
   };
-  const clearUncoveredSessionMirror = (assistantID, sessionID) => {
-    db.prepare('DELETE FROM assistant_message_part_mirror WHERE assistant_id=? AND session_id=? AND message_id IN (SELECT message_id FROM assistant_message_mirror WHERE assistant_id=? AND session_id=? AND covered=0)').run(assistantID, sessionID, assistantID, sessionID);
-    db.prepare('DELETE FROM assistant_message_mirror WHERE assistant_id=? AND session_id=? AND covered=0').run(assistantID, sessionID);
-  };
-  const writeBackfillState = (assistantID, sessionID, next) => {
-    db.prepare('INSERT INTO assistant_message_backfill(assistant_id,session_id,cursor,complete,updated_at) VALUES (?,?,?,?,?) ON CONFLICT(assistant_id,session_id) DO UPDATE SET cursor=excluded.cursor,complete=excluded.complete,updated_at=excluded.updated_at').run(assistantID, sessionID, next.cursor, next.complete ? 1 : 0, now());
-  };
-  // Authoritative 404 means this session ID is gone from OpenCode. Converge its
-  // backfill so one deleted archive cannot block demand scans of other sessions.
-  // Covered/admitted rows stay; only uncovered event mirrors are dropped. Safe
-  // under concurrent ensure: a replaced current binding archives under its old
-  // ID, while a still-current missing ID is recreated with a new session ID.
-  const completeMissingSessionBackfill = (assistantID, sessionID) => {
-    db.exec('BEGIN IMMEDIATE');
+  // Host history cursor: binding ordinal + official opaque upstream cursor +
+  // page-local skip. Carries positions/IDs only — never message bodies.
+  const decodeCursor = (value) => {
+    if (value == null || value === '') return null;
     try {
-      const current = db.prepare('SELECT cursor,complete FROM assistant_message_backfill WHERE assistant_id=? AND session_id=?').get(assistantID, sessionID);
-      const next = reduceBackfillState({ cursor: current?.cursor ?? null, complete: Boolean(current?.complete) }, 'session-missing');
-      if (next.disposition === 'discard-provisional') clearUncoveredSessionMirror(assistantID, sessionID);
-      writeBackfillState(assistantID, sessionID, next);
-      db.exec('COMMIT');
-      return true;
-    } catch (error) { db.exec('ROLLBACK'); throw error; }
-  };
-  const fetchBackfillMessages = async (history, directory, cursor) => {
+      const parsed = parse(Buffer.from(String(value), 'base64url').toString('utf8'));
+      if (!Number.isSafeInteger(parsed?.sessionOrdinal)) fail('validation_error');
+      if (parsed.upstream != null && !nonEmptyString(parsed.upstream)) fail('validation_error');
+      const skip = parsed.skip == null ? 0 : parsed.skip;
+      if (!Number.isSafeInteger(skip) || skip < 0) fail('validation_error');
+      return {
+        sessionOrdinal: parsed.sessionOrdinal,
+        upstream: parsed.upstream ?? null,
+        skip,
+      };
+    } catch (error) {
+      if (error instanceof AssistantError) throw error;
+      fail('validation_error');
+    }
+  };
+  const encodeCursor = (state) => Buffer.from(json({
+    sessionOrdinal: state.sessionOrdinal,
+    upstream: state.upstream ?? null,
+    skip: state.skip ?? 0,
+  })).toString('base64url');
+  // Official v2: GET /api/session/:id/message — first page order=desc; continuation
+  // cursor only (never combine order+cursor). Prefer fetchImpl when injected.
+  const fetchProjectionMessages = async (sessionID, directory, cursor, pageLimit = BACKFILL_PAGE_SIZE) => {
     for (let attempt = 0; attempt < BACKFILL_MESSAGES_ATTEMPTS; attempt++) {
       try {
-        const result = await client().session.messages({ sessionID: history.session_id, ...(directory ? { directory } : {}), limit: BACKFILL_PAGE_SIZE, ...(cursor ? { before: cursor } : {}) });
-        if (!result?.error || isMissing(result)) return result;
-        if (!isTransientMessagesFailure(result, null) || attempt === BACKFILL_MESSAGES_ATTEMPTS - 1) fail('upstream_error');
+        if (typeof fetchImpl === 'function') {
+          const base = String(buildOpenCodeUrl('/', '') || '').replace(/\/$/, '') || 'http://opencode.local';
+          const url = new URL(`${base}/api/session/${encodeURIComponent(sessionID)}/message`);
+          url.searchParams.set('limit', String(pageLimit));
+          // Official contract: do not combine order with cursor.
+          if (cursor) url.searchParams.set('cursor', cursor);
+          else url.searchParams.set('order', 'desc');
+          if (directory) url.searchParams.set('directory', directory);
+          const headers = {
+            Accept: 'application/json',
+            ...(typeof getOpenCodeAuthHeaders === 'function' ? getOpenCodeAuthHeaders() : {}),
+          };
+          const response = await fetchImpl(url, { method: 'GET', headers });
+          const status = response?.status ?? response?.statusCode;
+          if (status === 404) return { error: { status: 404 }, status: 404 };
+          if (status != null && status >= 400) {
+            const errBody = { error: { status }, status };
+            if (!isTransientMessagesFailure(errBody, null) || attempt === BACKFILL_MESSAGES_ATTEMPTS - 1) return errBody;
+          } else {
+            const payload = typeof response?.json === 'function' ? await response.json() : null;
+            return {
+              data: Array.isArray(payload?.data) ? payload.data : (Array.isArray(payload) ? payload : payload?.data),
+              cursor: payload?.cursor,
+              response: {
+                status: status ?? 200,
+                headers: {
+                  get: (name) => {
+                    if (typeof response?.headers?.get === 'function') return response.headers.get(name);
+                    return null;
+                  },
+                },
+              },
+            };
+          }
+        } else {
+          const result = await invokeSession(() => client().message.list({
+            sessionID,
+            limit: pageLimit,
+            // First page: order=desc. Continuation: opaque cursor only.
+            ...(cursor ? { cursor } : { order: 'desc' }),
+          }));
+          if (!result?.error || isMissing(result)) return result;
+          if (!isTransientMessagesFailure(result, null) || attempt === BACKFILL_MESSAGES_ATTEMPTS - 1) return result;
+        }
       } catch (error) {
         if (error instanceof AssistantError) throw error;
-        if (!isTransientMessagesFailure(null, error) || attempt === BACKFILL_MESSAGES_ATTEMPTS - 1) fail('upstream_error');
+        if (isMissingError(error)) return { error: { status: 404 }, status: 404 };
+        if (!isTransientMessagesFailure(null, error) || attempt === BACKFILL_MESSAGES_ATTEMPTS - 1) {
+          const status = getHttpStatus(error);
+          return { error: { status: status ?? 500 }, status: status ?? 500 };
+        }
       }
       await sleep(BACKFILL_RETRY_MS[Math.min(attempt, BACKFILL_RETRY_MS.length - 1)]);
     }
-    fail('upstream_error');
-  };
-  const backfillSession = async (history) => {
-    const state = db.prepare('SELECT cursor,complete FROM assistant_message_backfill WHERE assistant_id=? AND session_id=?').get(history.assistant_id, history.session_id);
-    if (state?.complete) return true;
-    const cursor = state?.cursor ?? null;
-    let directory = history.directory ?? null;
-    if (directory == null) {
-      const session = await client().session.get({ sessionID: history.session_id }).catch(() => null);
-      const resolved = resolveArchivedDirectory(history.assistant_id, session?.data?.directory, session?.data?.project?.worktree);
+    return { error: { status: 500 }, status: 500 };
+  };
+  const resolveBindingDirectory = async (binding) => {
+    let directory = binding.directory ?? null;
+    if (directory != null) return directory;
+    const session = await invokeSession(() => client().session.get({ sessionID: binding.session_id })).catch(() => null);
+    if (!session?.error) {
+      const resolved = resolveArchivedDirectory(
+        binding.assistant_id,
+        sessionDirectoryOf(session),
+        session?.data?.directory,
+        session?.data?.project?.worktree,
+      );
       if (resolved) {
-        db.prepare('UPDATE assistant_session_history SET directory=? WHERE assistant_id=? AND session_id=? AND directory IS NULL').run(resolved, history.assistant_id, history.session_id);
+        db.prepare('UPDATE assistant_session_history SET directory=? WHERE assistant_id=? AND session_id=? AND directory IS NULL')
+          .run(resolved, binding.assistant_id, binding.session_id);
         directory = resolved;
       }
     }
-    const result = await fetchBackfillMessages(history, directory, cursor);
-    if (isMissing(result)) return completeMissingSessionBackfill(history.assistant_id, history.session_id);
-    if (result?.error) fail('upstream_error');
-    const entries = Array.isArray(result?.data) ? result.data : Array.isArray(result?.data?.items) ? result.data.items : null;
-    if (!entries) fail('upstream_error');
-    db.exec('BEGIN IMMEDIATE');
-    try {
-      entries.forEach((entry) => { const info = entry?.info ?? entry; if (nonEmptyString(info?.sessionID) && info.sessionID !== history.session_id) return; const parts = Array.isArray(entry?.parts) ? entry.parts : []; const messageOrdinal = Number.isSafeInteger(info?.time?.created) ? info.time.created : undefined; mirrorMessage(history.assistant_id, history.session_id, info, messageOrdinal, true); const partIDs = parts.filter((part) => nonEmptyString(part?.id)).map((part) => part.id); if (partIDs.length) db.prepare(`DELETE FROM assistant_message_part_mirror WHERE assistant_id=? AND session_id=? AND message_id=? AND part_id NOT IN (${partIDs.map(() => '?').join(',')})`).run(history.assistant_id, history.session_id, info?.id, ...partIDs); else db.prepare('DELETE FROM assistant_message_part_mirror WHERE assistant_id=? AND session_id=? AND message_id=?').run(history.assistant_id, history.session_id, info?.id); parts.forEach((part, partIndex) => mirrorPart(history.assistant_id, history.session_id, part, partIndex + 1)); });
-      const nextCursor = result?.response?.headers?.get('x-next-cursor') ?? null;
-      const next = reduceBackfillState({ cursor, complete: false }, { type: 'page', nextCursor });
-      // Successful pages only upsert authoritative rows; never delete provisional
-      // event mirrors that the snapshot omitted — only 404 / message.removed /
-      // assistant deletion may shrink the message set.
-      writeBackfillState(history.assistant_id, history.session_id, next);
-      db.exec('COMMIT');
-      return next.complete;
-    } catch (error) { db.exec('ROLLBACK'); throw error; }
+    return directory;
   };
-  const decodeCursor = (value) => { if (value == null || value === '') return null; try { const parsed = parse(Buffer.from(String(value), 'base64url').toString('utf8')); return Number.isSafeInteger(parsed?.sessionOrdinal) && Number.isSafeInteger(parsed?.messageOrdinal) && nonEmptyString(parsed?.messageID) && (parsed.scanSessionOrdinal == null || Number.isSafeInteger(parsed.scanSessionOrdinal)) ? parsed : fail('validation_error'); } catch (error) { if (error instanceof AssistantError) throw error; fail('validation_error'); } };
-  const encodeCursor = (row, scanSessionOrdinal = row.session_ordinal) => Buffer.from(json({ sessionOrdinal: row.session_ordinal, messageOrdinal: row.message_ordinal, messageID: row.message_id, scanSessionOrdinal })).toString('base64url');
-  const historicalMessages = async (assistantID, input = {}) => {
-    const row = editable(assistantID); const limit = input.limit == null ? 50 : Number(input.limit); if (!Number.isInteger(limit) || limit < 1 || limit > 100) fail('validation_error'); const before = decodeCursor(input.before);
-    const currentSessionOrdinal = Number(db.prepare('SELECT COALESCE(MAX(ordinal), 0) + 1 AS next FROM assistant_session_history WHERE assistant_id=?').get(row.assistant_id).next);
-    const currentIsArchived = row.current_session_id != null && Boolean(db.prepare('SELECT 1 FROM assistant_session_history WHERE assistant_id=? AND session_id=?').get(row.assistant_id, row.current_session_id));
-    const beforeIncludes = (sessionOrdinal, messageOrdinal, messageID) => before == null || sessionOrdinal < before.sessionOrdinal || (sessionOrdinal === before.sessionOrdinal && (messageOrdinal < before.messageOrdinal || (messageOrdinal === before.messageOrdinal && messageID < before.messageID)));
-    const pageRows = () => {
-      // Archived mirrors include covered=1 authoritative rows and covered=0
-      // provisional event mirrors so a partial REST snapshot cannot hide a reply
-      // already observed on the live channel.
-      const historical = db.prepare(`SELECT h.ordinal AS session_ordinal,h.directory,m.ordinal AS message_ordinal,m.message_id,m.info_json,m.session_id FROM assistant_session_history h JOIN assistant_message_mirror m ON m.assistant_id=h.assistant_id AND m.session_id=h.session_id WHERE h.assistant_id=? AND (? IS NULL OR h.ordinal<? OR (h.ordinal=? AND (m.ordinal<? OR (m.ordinal=? AND m.message_id<?)))) ORDER BY h.ordinal DESC,m.ordinal DESC,m.message_id DESC LIMIT ?`).all(row.assistant_id, before?.sessionOrdinal ?? null, before?.sessionOrdinal ?? 0, before?.sessionOrdinal ?? 0, before?.messageOrdinal ?? 0, before?.messageOrdinal ?? 0, before?.messageID ?? '', limit + 1);
-      const current = row.current_session_id && !currentIsArchived
-        ? db.prepare('SELECT ? AS session_ordinal,? AS directory,ordinal AS message_ordinal,message_id,info_json,session_id FROM assistant_message_mirror WHERE assistant_id=? AND session_id=? AND covered=1 ORDER BY ordinal DESC,message_id DESC LIMIT ?').all(currentSessionOrdinal, effectiveWorkspace(row), row.assistant_id, row.current_session_id, limit + 1).filter((message) => beforeIncludes(message.session_ordinal, message.message_ordinal, message.message_id))
-        : [];
-      return [...historical, ...current].sort((left, right) => right.session_ordinal - left.session_ordinal || right.message_ordinal - left.message_ordinal || right.message_id.localeCompare(left.message_id)).slice(0, limit + 1);
+  /**
+   * Walk one binding from an official upstream position (tip or opaque cursor).
+   * Emits rows in authoritative projection order (order=desc ⇒ newest first).
+   * Host page boundary is `skip` within the current upstream page — no tip rescan.
+   */
+  const loadProjectionBinding = async (binding, {
+    upstream = null,
+    skip = 0,
+    need = BACKFILL_PAGE_SIZE,
+    maxPages = BACKFILL_MAX_PAGES,
+    pageLimit = BACKFILL_PAGE_SIZE,
+  } = {}) => {
+    const directory = await resolveBindingDirectory(binding);
+    const collected = [];
+    let cursor = upstream;
+    let pageSkip = Math.max(0, skip);
+    let exhausted = false;
+    let failed = false;
+    let failedStatus = null;
+    let pagesUsed = 0;
+    let resumeUpstream = upstream;
+    let resumeSkip = pageSkip;
+    const pageSize = Math.min(BACKFILL_PAGE_SIZE, Math.max(1, pageLimit));
+
+    for (let page = 0; page < maxPages; page++) {
+      resumeUpstream = cursor;
+      resumeSkip = pageSkip;
+      const result = await fetchProjectionMessages(binding.session_id, directory, cursor, pageSize);
+      pagesUsed += 1;
+      if (isMissing(result)) {
+        exhausted = true;
+        return {
+          entries: collected, directory, missing: true, failed: false, failedStatus: null,
+          exhausted: true, pagesUsed, resumeUpstream: null, resumeSkip: 0,
+        };
+      }
+      if (result?.error) {
+        failed = true;
+        failedStatus = messagesErrorStatus(result) ?? result.status ?? 500;
+        break;
+      }
+      const entries = projectionEntries(result, binding.session_id);
+      if (!entries) {
+        failed = true;
+        failedStatus = 500;
+        break;
+      }
+      // Empty page is the authoritative end (non-empty pages may still carry next).
+      if (entries.length === 0) {
+        exhausted = true;
+        resumeUpstream = null;
+        resumeSkip = 0;
+        break;
+      }
+      let index = 0;
+      let stoppedEarly = false;
+      for (; index < entries.length; index++) {
+        if (index < pageSkip) continue;
+        const entry = entries[index];
+        const info = entry?.info ?? entry;
+        if (!plainObject(info) || !nonEmptyString(info.id)) continue;
+        if (nonEmptyString(info.sessionID) && info.sessionID !== binding.session_id) continue;
+        collected.push({
+          session_id: binding.session_id,
+          session_ordinal: binding.ordinal,
+          directory,
+          message_id: info.id,
+          // Source seq within authoritative page order (not time.created).
+          seq: collected.length,
+          info,
+          parts: Array.isArray(entry?.parts) ? entry.parts : [],
+        });
+        if (collected.length >= need) {
+          // Keep resumeSkip on this row when it is the probe past `limit`.
+          stoppedEarly = true;
+          break;
+        }
+      }
+      pageSkip = 0;
+      if (collected.length >= need) {
+        // Page boundary: resume at the probe row (or next upstream page if none left).
+        if (stoppedEarly && index < entries.length) {
+          resumeUpstream = cursor;
+          resumeSkip = index;
+        } else {
+          const next = projectionCursor(result);
+          resumeUpstream = next || null;
+          resumeSkip = 0;
+          // Official: last non-empty page may still expose next; empty follow-up ends.
+          if (!next) exhausted = true;
+        }
+        break;
+      }
+      const next = projectionCursor(result);
+      if (!next) {
+        exhausted = true;
+        resumeUpstream = null;
+        resumeSkip = 0;
+        break;
+      }
+      cursor = next;
+      pageSkip = 0;
+      resumeUpstream = next;
+      resumeSkip = 0;
+    }
+
+    return {
+      entries: collected,
+      directory,
+      missing: false,
+      failed,
+      failedStatus,
+      exhausted: exhausted && !failed,
+      pagesUsed,
+      resumeUpstream,
+      resumeSkip,
     };
-    const nextIncomplete = (boundary = before?.scanSessionOrdinal ?? before?.sessionOrdinal ?? null) => db.prepare(`SELECT h.* FROM assistant_session_history h LEFT JOIN assistant_message_backfill b ON b.assistant_id=h.assistant_id AND b.session_id=h.session_id WHERE h.assistant_id=? AND (b.complete IS NULL OR b.complete=0) AND (? IS NULL OR h.ordinal<=?) ORDER BY h.ordinal DESC LIMIT 1`).get(row.assistant_id, boundary, boundary ?? 0);
-    let rows = pageRows();
-    // Demand-backfill incomplete archived sessions even when provisional
-    // mirrors already fill the page, so authoritative upserts can elevate
-    // covered=0 fallbacks. Cap remains BACKFILL_MAX_PAGES per request.
-    for (let page = 0; page < BACKFILL_MAX_PAGES; page++) {
-      const target = nextIncomplete();
-      if (!target) break;
-      try {
-        await backfillSession(target);
-      } catch (error) {
-        // Partial-result scope is this request's pageRows() only: any already
-        // visible covered or provisional row keeps the page usable and the
-        // incomplete cursor retryable. An empty current page still throws.
-        if (rows.length === 0) throw error;
+  };
+  const listHistoryBindings = (row) => {
+    const history = db.prepare('SELECT session_id, directory, ordinal FROM assistant_session_history WHERE assistant_id=? ORDER BY ordinal ASC')
+      .all(row.assistant_id);
+    const bindings = history.map((item) => ({
+      assistant_id: row.assistant_id,
+      session_id: item.session_id,
+      directory: item.directory ?? null,
+      ordinal: item.ordinal,
+    }));
+    const currentIsArchived = row.current_session_id != null
+      && Boolean(db.prepare('SELECT 1 FROM assistant_session_history WHERE assistant_id=? AND session_id=?').get(row.assistant_id, row.current_session_id));
+    if (row.current_session_id && !currentIsArchived) {
+      const nextOrdinal = Number(db.prepare('SELECT COALESCE(MAX(ordinal), 0) + 1 AS next FROM assistant_session_history WHERE assistant_id=?').get(row.assistant_id).next);
+      bindings.push({
+        assistant_id: row.assistant_id,
+        session_id: row.current_session_id,
+        directory: effectiveWorkspace(row),
+        ordinal: nextOrdinal,
+      });
+    }
+    return bindings;
+  };
+  const historicalMessages = async (assistantID, input = {}) => {
+    const row = editable(assistantID);
+    const limit = input.limit == null ? 50 : Number(input.limit);
+    if (!Number.isInteger(limit) || limit < 1 || limit > 100) fail('validation_error');
+    const before = decodeCursor(input.before);
+    const bindings = listHistoryBindings(row);
+    // Newest bindings first; within a binding keep official projection order.
+    const scanOrder = [...bindings].sort((left, right) => right.ordinal - left.ordinal);
+    let startIndex = 0;
+    if (before != null) {
+      const found = scanOrder.findIndex((binding) => binding.ordinal === before.sessionOrdinal);
+      // Binding disappeared (archive GC) — resume at the nearest older binding.
+      startIndex = found >= 0 ? found : scanOrder.findIndex((binding) => binding.ordinal < before.sessionOrdinal);
+      if (startIndex < 0) startIndex = scanOrder.length;
+    }
+    const collected = [];
+    const failedScope = [];
+    let anySuccess = false;
+    let pagesUsed = 0;
+    let nextState = null;
+
+    for (let index = startIndex; index < scanOrder.length; index++) {
+      if (collected.length > limit) break;
+      if (pagesUsed >= BACKFILL_MAX_PAGES) {
+        const binding = scanOrder[index];
+        nextState = {
+          sessionOrdinal: binding.ordinal,
+          upstream: index === startIndex && before ? before.upstream : null,
+          skip: index === startIndex && before ? before.skip : 0,
+        };
+        break;
+      }
+      const binding = scanOrder[index];
+      const resumeHere = index === startIndex && before != null;
+      const loaded = await loadProjectionBinding(binding, {
+        upstream: resumeHere ? before.upstream : null,
+        skip: resumeHere ? before.skip : 0,
+        need: limit + 1 - collected.length,
+        maxPages: BACKFILL_MAX_PAGES - pagesUsed,
+        pageLimit: limit,
+      });
+      pagesUsed += loaded.pagesUsed;
+      if (loaded.failed) {
+        failedScope.push({
+          sessionID: binding.session_id,
+          sessionOrdinal: binding.ordinal,
+          status: loaded.failedStatus ?? 500,
+        });
+        // Do not advance past a failed binding — cursor stays retryable here.
+        // Newer successes already in `collected` are still delivered.
+        nextState = {
+          sessionOrdinal: binding.ordinal,
+          upstream: loaded.resumeUpstream,
+          skip: loaded.resumeSkip,
+        };
+        break;
+      }
+      if (loaded.missing) {
+        anySuccess = true;
+        continue;
+      }
+      anySuccess = true;
+      collected.push(...loaded.entries);
+      if (collected.length > limit) {
+        // Overshot: drop the probe row and resume at the page boundary of the last binding load.
+        nextState = {
+          sessionOrdinal: binding.ordinal,
+          upstream: loaded.resumeUpstream,
+          skip: loaded.resumeSkip,
+        };
+        break;
+      }
+      if (!loaded.exhausted) {
+        nextState = {
+          sessionOrdinal: binding.ordinal,
+          upstream: loaded.resumeUpstream,
+          skip: loaded.resumeSkip,
+        };
         break;
       }
-      rows = pageRows();
+      // Binding exhausted — fall through to the next older binding.
+    }
+
+    // Total failure must not masquerade as authoritative empty success.
+    if (collected.length === 0 && failedScope.length > 0 && !anySuccess) fail('upstream_error');
+
+    const partial = failedScope.length > 0;
+    // collected is newest-first (binding order + desc projection). Public page is ascending.
+    const pageDesc = collected.slice(0, limit);
+    let nextCursor = nextState != null ? encodeCursor(nextState) : null;
+    if (nextCursor == null && partial && failedScope[0]) {
+      nextCursor = encodeCursor({
+        sessionOrdinal: failedScope[0].sessionOrdinal,
+        upstream: null,
+        skip: 0,
+      });
     }
-    const page = rows.slice(0, limit); const oldest = page[page.length - 1]; const remaining = nextIncomplete(oldest?.session_ordinal ?? before?.scanSessionOrdinal ?? before?.sessionOrdinal ?? null); const nextCursor = oldest ? (rows.length > limit || remaining ? encodeCursor(oldest, oldest.session_ordinal) : null) : remaining ? encodeCursor({ session_ordinal: remaining.ordinal, message_ordinal: Number.MAX_SAFE_INTEGER, message_id: '\uffff' }, remaining.ordinal) : null;
-    const ordered = [...page].reverse().map((message) => ({ sessionID: message.session_id, directory: message.directory, info: parse(message.info_json), parts: db.prepare('SELECT part_json FROM assistant_message_part_mirror WHERE assistant_id=? AND session_id=? AND message_id=? ORDER BY ordinal ASC,part_id ASC').all(row.assistant_id, message.session_id, message.message_id).map((part) => parse(part.part_json)) }));
-    return { entries: ordered, nextCursor, complete: nextCursor === null };
+    // complete only when nothing remains and no partial failure left to retry.
+    const complete = nextCursor == null && !partial;
+    const ordered = [...pageDesc].reverse().map((entry) => ({
+      sessionID: entry.session_id,
+      directory: entry.directory,
+      info: entry.info,
+      parts: entry.parts,
+    }));
+    return {
+      entries: ordered,
+      nextCursor: complete ? null : nextCursor,
+      complete,
+      partial,
+      ...(partial ? { failed: failedScope } : {}),
+    };
   };
-  for (const current of db.prepare('SELECT * FROM assistant_v2 WHERE current_session_id IS NOT NULL AND tombstone_at IS NULL').all()) void backfillSession({ assistant_id: current.assistant_id, session_id: current.current_session_id, directory: effectiveWorkspace(current) }).catch(() => {});
   const unsubscribeEvents = typeof globalEventHub?.subscribeEvent === 'function' ? globalEventHub.subscribeEvent(processEvent) : null;
   const createAssistant = (input) => { const allowed = new Set(['enabled', 'name', 'defaultPrompt', 'providerID', 'modelID', 'agent', 'variant', 'mode', 'workspacePath']); if (!plainObject(input) || Object.keys(input).some((key) => !allowed.has(key))) fail('validation_error'); const mode = input.mode == null ? 'continuous' : input.mode === 'stateless' || input.mode === 'continuous' ? input.mode : fail('validation_error'); const assistantID = id(); const workspacePath = input.workspacePath == null ? null : workspace(input.workspacePath, assistantID); effectiveWorkspace({ assistant_id: assistantID, workspace_path: workspacePath }); const at = now(); db.exec('BEGIN IMMEDIATE'); try { if (Number(db.prepare('SELECT COUNT(*) AS count FROM assistant_v2 WHERE tombstone_at IS NULL').get().count) >= 100) fail('assistant_limit'); db.prepare('INSERT INTO assistant_v2 (assistant_id,revision,enabled,name,default_prompt,workspace_path,provider_id,model_id,agent,variant,mode,current_session_id,session_generation,created_at,updated_at,tombstone_at) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)').run(assistantID, 1, input.enabled === false ? 0 : 1, string(input.name, 256, true), input.defaultPrompt ? string(input.defaultPrompt, 200_000) : '', workspacePath, string(input.providerID, 256, true), string(input.modelID, 256, true), input.agent == null ? null : string(input.agent, 256), input.variant == null ? null : string(input.variant, 256), mode, null, 0, at, at, null); bump(); db.exec('COMMIT'); return output(assistant(assistantID)); } catch (error) { db.exec('ROLLBACK'); throw error; } };
   const updateAssistant = async (assistantID, input) => { const row = editable(assistantID); const allowed = new Set(['expectedRevision', 'enabled', 'name', 'defaultPrompt', 'providerID', 'modelID', 'agent', 'variant', 'mode', 'workspacePath']); if (!plainObject(input) || !Number.isInteger(input.expectedRevision) || Object.keys(input).some((key) => !allowed.has(key))) fail('validation_error'); const next = { enabled: input.enabled === undefined ? row.enabled : input.enabled ? 1 : 0, name: input.name === undefined ? row.name : string(input.name, 256, true), prompt: input.defaultPrompt === undefined ? row.default_prompt : string(input.defaultPrompt, 200_000), provider: input.providerID === undefined ? row.provider_id : string(input.providerID, 256, true), model: input.modelID === undefined ? row.model_id : string(input.modelID, 256, true), agent: input.agent === undefined ? row.agent : input.agent === null ? null : string(input.agent, 256), variant: input.variant === undefined ? row.variant : input.variant === null ? null : string(input.variant, 256), mode: input.mode === undefined ? (row.mode === 'stateless' ? 'stateless' : 'continuous') : input.mode === 'continuous' || input.mode === 'stateless' ? input.mode : fail('validation_error'), workspacePath: input.workspacePath === undefined ? row.workspace_path : input.workspacePath == null ? null : workspace(input.workspacePath, assistantID) }; const nextRow = { ...row, workspace_path: next.workspacePath, name: next.name }; effectiveWorkspace(nextRow); const workspaceChanged = next.workspacePath !== row.workspace_path; if (workspaceChanged && row.current_session_id) archiveSession(assistantID, row.current_session_id); const created = workspaceChanged ? await createSession(nextRow) : null; const result = db.prepare('UPDATE assistant_v2 SET enabled=?,name=?,default_prompt=?,provider_id=?,model_id=?,agent=?,variant=?,mode=?,workspace_path=?,current_session_id=?,session_generation=session_generation+?,revision=revision+1,updated_at=? WHERE assistant_id=? AND revision=? AND session_generation=? AND tombstone_at IS NULL').run(next.enabled, next.name, next.prompt, next.provider, next.model, next.agent, next.variant, next.mode, next.workspacePath, created?.sessionID ?? row.current_session_id, workspaceChanged ? 1 : 0, now(), assistantID, input.expectedRevision, row.session_generation); if (!result.changes) fail('revision_conflict'); bump(); return output(assistant(assistantID)); };
-  const compact = async (assistantID, input) => { const row = active(assistantID); if (!plainObject(input) || input.sessionID !== row.current_session_id || input.sessionGeneration !== row.session_generation || !row.current_session_id) fail('revision_conflict'); let target = row; let result = await client().session.summarize({ sessionID: target.current_session_id, directory: effectiveWorkspace(target), providerID: target.provider_id, modelID: target.model_id }); if (isMissing(result)) { await restoreOnce(row, row.current_session_id, row.session_generation); target = active(assistantID); result = await client().session.summarize({ sessionID: target.current_session_id, directory: effectiveWorkspace(target), providerID: target.provider_id, modelID: target.model_id }); } if (result.error || result.data !== true) fail('upstream_error'); return { binding: binding(active(assistantID)), summarized: true }; };
+  const compact = async (assistantID, input) => { const row = active(assistantID); if (!plainObject(input) || input.sessionID !== row.current_session_id || input.sessionGeneration !== row.session_generation || !row.current_session_id) fail('revision_conflict'); let target = row; let result = await invokeSession(() => client().session.compact({ sessionID: target.current_session_id })); if (isMissing(result)) { await restoreOnce(row, row.current_session_id, row.session_generation); target = active(assistantID); result = await invokeSession(() => client().session.compact({ sessionID: target.current_session_id })); } if (result?.error || (result?.data !== true && result?.id == null && result?.type !== 'compaction')) fail('upstream_error'); return { binding: binding(active(assistantID)), summarized: true }; };
   const sendWithConfig = async ({ row, sessionID, directory, config, parts, messageID, restore }) => {
-    const sendPrompt = (targetSessionID, targetDirectory, targetConfig) => client().session.promptAsync({ sessionID: targetSessionID, directory: targetDirectory, ...targetConfig, parts, messageID });
-    let result = await sendPrompt(sessionID, directory, config);
+    const sendPrompt = async (targetSessionID, targetConfig) => invokeSession(async () => {
+      const api = client();
+      if (typeof api.session.switchAgent === 'function' && targetConfig?.agent) await api.session.switchAgent({ sessionID: targetSessionID, agent: targetConfig.agent });
+      if (typeof api.session.switchModel === 'function' && targetConfig?.model) await api.session.switchModel({ sessionID: targetSessionID, model: { id: targetConfig.model.modelID, providerID: targetConfig.model.providerID, ...(targetConfig.variant ? { variant: targetConfig.variant } : {}) } });
+      if (typeof api.session.instructions?.entry?.put === 'function' && typeof targetConfig?.system === 'string' && targetConfig.system) await api.session.instructions.entry.put({ sessionID: targetSessionID, key: 'system', value: targetConfig.system });
+      return api.session.prompt(toV2PromptInput(targetSessionID, parts, messageID));
+    });
+    let result = await sendPrompt(sessionID, config);
     if (isMissing(result) && restore) {
       const restored = await restoreOnce(row, sessionID, row.session_generation);
       const target = active(row.assistant_id);
       const targetConfig = configuration(target);
-      result = await sendPrompt(restored.sessionID, restored.directory, targetConfig);
-      if (promptAdmitted(result)) mirrorAdmittedUserMessage(target, restored.sessionID, messageID, parts, targetConfig);
+      result = await sendPrompt(restored.sessionID, targetConfig);
       return { result, binding: restored };
     }
-    if (promptAdmitted(result)) mirrorAdmittedUserMessage(row, sessionID, messageID, parts, config);
     return { result, binding: binding(row) };
   };
   const extractUserText = (input) => {
@@ -1012,12 +1482,16 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
         parts: [card],
       });
       if (card.cardType === 'session' && card.sessionID) {
-        upsertContactWatch(db, {
+        const deliveryMessageID = pendingAssignMessageIDs.get(card.sessionID)
+            || (nonEmptyString(card.messageID) ? card.messageID : null);
+          if (pendingAssignMessageIDs.has(card.sessionID)) pendingAssignMessageIDs.delete(card.sessionID);
+          upsertContactWatch(db, {
           assistantID,
           sessionID: card.sessionID,
           directory: card.directory,
           status: card.status === 'error' || card.status === 'question' || card.status === 'complete' ? card.status : 'busy',
           updatedAt: now(),
+          ...(deliveryMessageID ? { messageID: deliveryMessageID } : {}),
         });
       }
       bump();
@@ -1115,12 +1589,16 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
         });
         ordinal += 1;
         if (card.cardType === 'session' && card.sessionID) {
-          upsertContactWatch(db, {
+          const deliveryMessageID = pendingAssignMessageIDs.get(card.sessionID)
+              || (nonEmptyString(card.messageID) ? card.messageID : null);
+            if (pendingAssignMessageIDs.has(card.sessionID)) pendingAssignMessageIDs.delete(card.sessionID);
+            upsertContactWatch(db, {
             assistantID,
             sessionID: card.sessionID,
             directory: card.directory,
             status: card.status === 'error' || card.status === 'question' || card.status === 'complete' ? card.status : 'busy',
             updatedAt: now(),
+            ...(deliveryMessageID ? { messageID: deliveryMessageID } : {}),
           });
         }
       });
@@ -1259,16 +1737,19 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
     };
     const v2 = await viaExact(api?.v2?.session?.message, api?.v2?.session);
     if (v2) return v2;
+    // Official 2.x: session.message.get; shim may also expose callable session.message.
+    const nestedGet = await viaExact(api?.session?.message?.get, api?.session?.message);
+    if (nestedGet) return nestedGet;
     const legacy = await viaExact(api?.session?.message, api?.session);
     if (legacy) return legacy;
     try {
-      const listed = await api.session.messages({
+      const listed = await api.message.list({
         sessionID,
-        ...(directory ? { directory } : {}),
         limit: 100,
+        order: 'desc',
       }, options);
       if (listed?.error) return { found: false };
-      const rows = Array.isArray(listed?.data) ? listed.data : (Array.isArray(listed) ? listed : []);
+      const rows = projectionEntries(listed, sessionID) ?? (Array.isArray(listed?.data) ? listed.data : (Array.isArray(listed) ? listed : []));
       const hit = rows.some((row) => identity(row) === messageID);
       return { found: hit };
     } catch {
@@ -1295,14 +1776,14 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
       const fromSession = extractAssignSessionModel({ session: sessionPayload });
       if (fromSession) return fromSession;
       try {
-        if (typeof api.session.messages !== 'function') return null;
-        const listed = await api.session.messages({
+        if (typeof api.message?.list !== 'function') return null;
+        const listed = await api.message.list({
           sessionID,
-          ...(dir ? { directory: dir } : {}),
           limit: 40,
+          order: 'desc',
         }, options);
         if (listed?.error) return null;
-        messages = listed?.data ?? listed;
+        messages = projectionEntries(listed, sessionID) ?? listed?.data ?? listed;
       } catch {
         return null;
       }
@@ -1456,12 +1937,12 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
     }
 
     let messagesResult = null;
-    if (includeMessages && typeof client().session.messages === 'function') {
+    if (includeMessages && typeof client().message?.list === 'function') {
       try {
-        messagesResult = await client().session.messages({
+        messagesResult = await client().message.list({
           sessionID,
-          directory,
           limit: 100,
+          order: 'desc',
         }, options);
         if (messagesResult?.error && !isMissing(messagesResult)) {
           // Message fetch failure must not invent status; keep messages null.
@@ -1499,14 +1980,17 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
     const { signal } = params;
     signal?.throwIfAborted();
     const resolved = await resolveReferencedSession({ sessionID: params.sessionID, signal, includeMessages: false });
-    const result = await client().session.messages({
-      sessionID: resolved.sessionID, directory: resolved.directory, limit,
-      ...(params.before ? { before: params.before } : {}),
-    }, signal ? { signal } : undefined);
+    // First page: order=desc. Continuation: opaque cursor only (upstream 400s on both).
+    const result = await invokeSession(() => client().message.list({
+      sessionID: resolved.sessionID, limit,
+      ...(params.before ? { cursor: params.before } : { order: 'desc' }),
+    }));
     signal?.throwIfAborted();
     if (isMissing(result)) throw new AssignError(ASSIGN_CODES.NOT_FOUND, 'That session no longer exists.');
-    if (result?.error || !Array.isArray(result?.data)) throw new AssignError(ASSIGN_CODES.UPSTREAM, 'Could not read session messages.');
-    const rows = result.data;
+    const projected = result?.error ? null : projectionEntries(result, resolved.sessionID);
+    if (!projected) throw new AssignError(ASSIGN_CODES.UPSTREAM, 'Could not read session messages.');
+    // Desc pages arrive newest-first; quote them oldest→newest.
+    const rows = projected.slice().reverse();
     if (rows.some((entry) => (entry?.info?.sessionID && entry.info.sessionID !== resolved.sessionID))) throw new AssignError(ASSIGN_CODES.UPSTREAM, 'Session message identity mismatch.');
     let remaining = 24000;
     let partial = rows.length > limit;
@@ -1532,8 +2016,7 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
       }
       return { messageID: info.id, role: info.role, parts };
     });
-    const cursor = result.response?.headers?.get('x-next-cursor');
-    const nextCursor = typeof cursor === 'string' && cursor ? cursor : null;
+    const nextCursor = projectionCursor(result);
     return { sessionID: resolved.sessionID, directory: resolved.directory, title: resolved.title.slice(0, 500), messages, nextCursor, partial: partial || nextCursor !== null };
   };
   const assignWork = async (row, params = {}) => {
@@ -1614,7 +2097,7 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
     }
     // Worker model is prompt-only. Never mutate the contact assistant row.
     // Forward tool variant + AbortSignal; lookupMessage uses real SDK exact/list paths.
-    return assignSession({
+    const assigned = await assignSession({
       ...params,
       ...(reuseScope ? {
         sessionID: reuseScope.sessionID,
@@ -1641,16 +2124,43 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
       allowedRoots: getAllowedRoots(),
       managedWorkspaceRoot: path.resolve(dataDir, 'assistant-workspaces'),
       listWorktrees,
-      createSession: (created) => client().session.create(created, sdkOptions),
-      promptExisting: (prompted) => client().session.promptAsync(prompted, sdkOptions),
+      createSession: (created) => client().session.create({
+        title: created?.title,
+        ...(created?.directory ? { location: { directory: created.directory } } : {}),
+        ...(created?.agent ? { agent: created.agent } : {}),
+        ...(created?.model ? { model: created.model } : {}),
+        ...(created?.metadata ? { metadata: created.metadata } : {}),
+      }),
+      promptExisting: async (prompted) => {
+        const api = client();
+        if (typeof api.session.switchAgent === 'function' && prompted.agent) {
+          await api.session.switchAgent({ sessionID: prompted.sessionID, agent: prompted.agent });
+        }
+        if (typeof api.session.switchModel === 'function' && prompted.model) {
+          await api.session.switchModel({
+            sessionID: prompted.sessionID,
+            model: {
+              id: prompted.model.modelID,
+              providerID: prompted.model.providerID,
+              ...(prompted.variant ? { variant: prompted.variant } : {}),
+            },
+          });
+        }
+        return api.session.prompt(toV2PromptInput(prompted.sessionID, prompted.parts, prompted.messageID));
+      },
       deleteSession: (deleted) => (
-        typeof client().session.delete === 'function'
-          ? client().session.delete(deleted, sdkOptions)
+        typeof client().session.remove === 'function'
+          ? client().session.remove({ sessionID: deleted?.sessionID, ...(deleted?.directory ? {} : {}) })
           : undefined
       ),
       lookupMessage: (lookup) => lookupAssignMessage({ ...lookup, signal }),
       messageID: params?.messageID || `msg_assign_${id()}`,
     });
+    // Stash until the session card watch is written so reuse cannot settle on an old tail.
+    if (nonEmptyString(assigned?.sessionID) && nonEmptyString(assigned?.messageID)) {
+      pendingAssignMessageIDs.set(assigned.sessionID, assigned.messageID);
+    }
+    return assigned;
   };
   /** Watch an existing session only — no prompt. Baseline status avoids false settle resume. */
   const watchSessionWork = async (_row, params = {}) => {
@@ -1675,7 +2185,7 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
       reused: true,
     };
   };
-  /** Abort an existing coding session via real OpenCode session.abort. */
+  /** Abort an existing coding session via real OpenCode session.interrupt. */
   const stopSessionWork = async (_row, params = {}) => {
     const sessionID = typeof params.sessionID === 'string' ? params.sessionID.trim() : '';
     if (!sessionID) {
@@ -1690,8 +2200,8 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
     });
     const signal = params.signal;
     signal?.throwIfAborted();
-    if (typeof client().session.abort !== 'function') {
-      throw new AssignError(ASSIGN_CODES.UPSTREAM, 'Session abort is unavailable.');
+    if (typeof client().session.interrupt !== 'function') {
+      throw new AssignError(ASSIGN_CODES.UPSTREAM, 'Session interrupt is unavailable.');
     }
     const targetID = resolved.sessionID;
     // Share one abort lifecycle per worker session (register before await abort).
@@ -1719,10 +2229,9 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
       let result;
       try {
         signal?.throwIfAborted();
-        result = await client().session.abort({
+        result = await invokeSession(() => client().session.interrupt({
           sessionID: targetID,
-          directory: resolved.directory,
-        }, sdkOptions);
+        }));
       } catch (error) {
         const observed = entry.observed;
         if (sessionAbortInflight.get(targetID) === entry) sessionAbortInflight.delete(targetID);
@@ -1784,27 +2293,69 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
     }
     const resolved = await resolveReferencedSession({ sessionID, signal: params.signal, includeMessages: false });
     params.signal?.throwIfAborted();
-    const session = client().session;
-    const method = operation === 'steer' ? 'promptAsync' : operation === 'archive' ? 'update' : 'delete';
-    if (typeof session[method] !== 'function') throw new AssignError(ASSIGN_CODES.UPSTREAM, `Session ${operation} is unavailable.`);
-    const request = { sessionID, directory: resolved.directory };
-    if (operation === 'steer') Object.assign(request, {
-      messageID: `msg_steer_${id()}`, delivery: 'steer', parts: [{ type: 'text', text: params.text.trim() }],
-    });
-    if (operation === 'archive') request.time = { archived: now() };
+    const api = client();
     let result;
     try {
-      result = await session[method](request, params.signal ? { signal: params.signal } : undefined);
+      if (operation === 'steer') {
+        const messageID = `msg_steer_${id()}`;
+        const parts = [{ type: 'text', text: params.text.trim() }];
+        result = await invokeSession(() => api.session.prompt(toV2PromptInput(sessionID, parts, messageID)));
+        if (isMissing(result)) throw new AssignError(ASSIGN_CODES.NOT_FOUND, `No coding session ${sessionID} was found.`);
+        if (result?.error || !promptAdmitted(result)) {
+          throw new AssignError(ASSIGN_CODES.UPSTREAM, `Session ${operation} was not confirmed. Do not resend automatically.`);
+        }
+        return { sessionID, directory: resolved.directory, operation, messageID, admitted: true };
+      }
+      if (operation === 'archive') {
+        // OC2: Host owns archive stamps (openchamber.archive.archivedAt). Do not
+        // call upstream session.update time.archived — it is unavailable.
+        if (typeof archiveSessionHost !== 'function') {
+          throw new AssignError(ASSIGN_CODES.UPSTREAM, 'Session archive is unavailable.');
+        }
+        result = await archiveSessionHost({
+          sessionID,
+          directory: resolved.directory,
+          archivedAt: now(),
+        });
+      } else if (operation === 'delete') {
+        if (typeof api.session.remove !== 'function') {
+          throw new AssignError(ASSIGN_CODES.UPSTREAM, 'Session delete is unavailable.');
+        }
+        result = await invokeSession(() => api.session.remove({ sessionID }));
+      } else {
+        throw new AssignError(ASSIGN_CODES.VALIDATION, `Unknown session operation ${operation}.`);
+      }
     } catch (error) {
+      if (error instanceof AssignError) throw error;
       throw new AssignError(ASSIGN_CODES.UPSTREAM, error?.message || `Session ${operation} failed.`);
     }
+    if (operation === 'archive') {
+      if (!result?.session?.id) {
+        throw new AssignError(ASSIGN_CODES.UPSTREAM, `Session ${operation} was not confirmed. Do not resend automatically.`);
+      }
+      reportAssignedSession(sessionID, 'cancelled', false);
+      return { sessionID, directory: resolved.directory, operation, archived: true };
+    }
     if (isMissing(result)) throw new AssignError(ASSIGN_CODES.NOT_FOUND, `No coding session ${sessionID} was found.`);
-    if (result?.error || result?.data === false || (operation === 'steer' && !promptAdmitted(result))) {
-      // Do not retry an ambiguous prompt submission: it may already be admitted upstream.
+    if (result?.error || result?.data === false) {
       throw new AssignError(ASSIGN_CODES.UPSTREAM, `Session ${operation} was not confirmed. Do not resend automatically.`);
     }
-    if (operation !== 'steer') reportAssignedSession(sessionID, 'cancelled');
-    return { sessionID, directory: resolved.directory, operation, ...(operation === 'steer' ? { messageID: request.messageID, admitted: true } : { [operation === 'archive' ? 'archived' : 'deleted']: true }) };
+    // Successful delete: direct idempotent Host metadata cleanup; session.deleted
+    // events remain compensatory. Upstream failure never reaches here.
+    if (typeof forgetSessionHost === 'function') {
+      try {
+        const cleanup = forgetSessionHost(sessionID);
+        if (cleanup && typeof cleanup.catch === 'function') {
+          cleanup.catch((error) => {
+            console.warn('[assistants] metadata cleanup after delete failed (retry via event):', error?.message ?? error);
+          });
+        }
+      } catch (error) {
+        console.warn('[assistants] metadata cleanup after delete failed (retry via event):', error?.message ?? error);
+      }
+    }
+    reportAssignedSession(sessionID, 'cancelled', false);
+    return { sessionID, directory: resolved.directory, operation, deleted: true };
   };
   const matchRegisteredProject = async (directory) => {
     const projects = await listProjects();
@@ -2192,11 +2743,11 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
           try { return effectiveWorkspace(live); } catch { return null; }
         })();
         if (resolvedDirectory) {
-          const messagesResult = await client().session.messages({
+          const messagesResult = await invokeSession(() => client().message.list({
             sessionID,
-            directory: resolvedDirectory,
             limit: 100,
-          });
+            order: 'desc',
+          }));
           if (!messagesResult?.error) {
             const rows = Array.isArray(messagesResult?.data)
               ? messagesResult.data
@@ -2959,12 +3510,16 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
         parts: [card],
       });
       if (card.cardType === 'session' && card.sessionID) {
+        const deliveryMessageID = pendingAssignMessageIDs.get(card.sessionID)
+          || (nonEmptyString(card.messageID) ? card.messageID : null);
+        if (pendingAssignMessageIDs.has(card.sessionID)) pendingAssignMessageIDs.delete(card.sessionID);
         upsertContactWatch(db, {
           assistantID: row.assistant_id,
           sessionID: card.sessionID,
           directory: card.directory,
           status: card.status === 'error' || card.status === 'question' || card.status === 'complete' ? card.status : 'busy',
           updatedAt: now(),
+          ...(deliveryMessageID ? { messageID: deliveryMessageID } : {}),
         });
       }
       bump();
@@ -2977,7 +3532,7 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
   };
   /**
    * Read-only inter-assistant DM. Inserts into the recipient's OpenChamber
-   * contact transcript only. Must never call OpenCode promptAsync, mutate
+   * contact transcript only. Must never call OpenCode session.prompt, mutate
    * sessions/files/worktrees, or run tools on the recipient's behalf.
    *
    * Assign opens a worker session on the sender's contact turn — never here.
@@ -3068,17 +3623,17 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
     db.prepare('UPDATE assistant_contact_watch SET resume_allowed=0 WHERE assistant_id=?').run(assistantID);
     if (interrupted) return { binding: binding(row), aborted: true };
     if (!row.current_session_id) fail('revision_conflict');
-    const result = await client().session.abort({ sessionID: row.current_session_id, directory: effectiveWorkspace(row) });
+    const result = await invokeSession(() => client().session.interrupt({ sessionID: row.current_session_id }));
     if (isMissing(result)) fail('not_found');
-    if (result.error) fail('upstream_error');
+    if (result?.error) fail('upstream_error');
     return { binding: binding(row), aborted: true };
   };
   const createNew = async (assistantID) => { for (let attempt = 0; attempt < 3; attempt++) { const row = active(assistantID); const created = await createSession(row); const won = replaceBinding(row, created); if (won) return binding(won); } return binding(active(assistantID)); };
   const shareOperation = (operationID) => { const row = db.prepare('SELECT * FROM assistant_share_operation WHERE operation_id=?').get(operationID); return row && { operationID: row.operation_id, assistantID: row.assistant_id, sessionID: row.session_id, messageID: row.message_id, state: row.state, phase: row.phase, attempt: row.attempt, leaseExpiresAt: row.lease_expires_at, errorCode: row.error_code }; };
   const claim = (operationID, retry = false) => { db.exec('BEGIN IMMEDIATE'); try { const operation = db.prepare('SELECT * FROM assistant_share_operation WHERE operation_id=?').get(operationID); if (!operation) { db.exec('COMMIT'); return null; } const at = now(); const eligible = operation.state === 'failed' ? retry : operation.state === 'running' && operation.lease_expires_at <= at && operation.phase === 'admitted'; if (!eligible || operation.attempt >= SHARE_MAX_ATTEMPTS) { db.exec('COMMIT'); return null; } const result = db.prepare("UPDATE assistant_share_operation SET state='running',phase='submitting',attempt=attempt+1,lease_expires_at=?,error_code=NULL,updated_at=? WHERE operation_id=? AND state=? AND phase=? AND attempt<? AND (state='failed' OR lease_expires_at<=?)").run(at + SHARE_LEASE_MS, at, operationID, operation.state, operation.phase, SHARE_MAX_ATTEMPTS, at); const claimed = result.changes ? db.prepare('SELECT * FROM assistant_share_operation WHERE operation_id=?').get(operationID) : null; db.exec('COMMIT'); return claimed; } catch (error) { db.exec('ROLLBACK'); throw error; } };
   const completeOrFail = (operation, errorCode = null) => { const at = now(); if (errorCode) db.prepare("UPDATE assistant_share_operation SET state='failed',phase='admitted',error_code=?,lease_expires_at=NULL,updated_at=? WHERE operation_id=? AND state='running' AND phase='submitting'").run(errorCode, at, operation.operation_id); else db.prepare("UPDATE assistant_share_operation SET state='running',phase='submitted',error_code=NULL,lease_expires_at=?,updated_at=? WHERE operation_id=? AND state='running' AND phase='submitting'").run(at + SHARE_LEASE_MS, at, operation.operation_id); };
-  const submitClaim = async (operation) => { const payload = parse(operation.response); const row = active(operation.assistant_id); try { const config = configuration(row); const result = await client().session.promptAsync({ sessionID: operation.session_id, directory: effectiveWorkspace(row), ...config, parts: payload.parts, messageID: operation.message_id }); if (!promptAdmitted(result)) fail('upstream_error'); mirrorAdmittedUserMessage(row, operation.session_id, operation.message_id, payload.parts, config); completeOrFail(operation); } catch (error) { completeOrFail(operation, error instanceof AssistantError ? error.code : 'upstream_error'); } };
-  const reconcileShareOperations = async () => { const candidates = db.prepare("SELECT * FROM assistant_share_operation WHERE state='running'").all(); for (const operation of candidates) { const row = assistant(operation.assistant_id); if (!row || !operation.session_id || !operation.message_id) continue; try { const result = await client().session.messages({ sessionID: operation.session_id, directory: effectiveWorkspace(row), limit: 100 }); const messages = result.data ?? []; const found = Array.isArray(messages) && messages.some((message) => message?.info?.id === operation.message_id || message?.id === operation.message_id); if (found) db.prepare("UPDATE assistant_share_operation SET state='completed',phase='submitted',lease_expires_at=NULL,updated_at=? WHERE operation_id=? AND state='running'").run(now(), operation.operation_id); else if (operation.phase === 'admitted' && operation.lease_expires_at <= now() && operation.attempt >= SHARE_MAX_ATTEMPTS) db.prepare("UPDATE assistant_share_operation SET state='failed',lease_expires_at=NULL,error_code='attempt_limit',updated_at=? WHERE operation_id=? AND state='running' AND phase='admitted'").run(now(), operation.operation_id); else if (operation.phase === 'admitted' && operation.lease_expires_at <= now()) { const claimed = claim(operation.operation_id); if (claimed) void submitClaim(claimed); } else if (operation.phase === 'submitted' && operation.lease_expires_at <= now()) db.prepare("UPDATE assistant_share_operation SET state='unresolved',lease_expires_at=NULL,error_code='message_unresolved',updated_at=? WHERE operation_id=? AND state='running' AND phase='submitted'").run(now(), operation.operation_id); } catch { /* Reconciliation remains retryable until its lease expires. */ } } };
+  const submitClaim = async (operation) => { const payload = parse(operation.response); const row = active(operation.assistant_id); try { const config = configuration(row); const sent = await sendWithConfig({ row, sessionID: operation.session_id, directory: effectiveWorkspace(row), config, parts: payload.parts, messageID: operation.message_id, restore: false }); if (!promptAdmitted(sent.result)) fail('upstream_error'); completeOrFail(operation); } catch (error) { completeOrFail(operation, error instanceof AssistantError ? error.code : 'upstream_error'); } };
+  const reconcileShareOperations = async () => { const candidates = db.prepare("SELECT * FROM assistant_share_operation WHERE state='running'").all(); for (const operation of candidates) { const row = assistant(operation.assistant_id); if (!row || !operation.session_id || !operation.message_id) continue; try { const result = await invokeSession(() => client().message.list({ sessionID: operation.session_id, limit: 100, order: 'desc' })); if (result?.error) continue; const messages = projectionEntries(result, operation.session_id) ?? result.data ?? []; const found = Array.isArray(messages) && messages.some((message) => message?.info?.id === operation.message_id || message?.id === operation.message_id); if (found) db.prepare("UPDATE assistant_share_operation SET state='completed',phase='submitted',lease_expires_at=NULL,updated_at=? WHERE operation_id=? AND state='running'").run(now(), operation.operation_id); else if (operation.phase === 'admitted' && operation.lease_expires_at <= now() && operation.attempt >= SHARE_MAX_ATTEMPTS) db.prepare("UPDATE assistant_share_operation SET state='failed',lease_expires_at=NULL,error_code='attempt_limit',updated_at=? WHERE operation_id=? AND state='running' AND phase='admitted'").run(now(), operation.operation_id); else if (operation.phase === 'admitted' && operation.lease_expires_at <= now()) { const claimed = claim(operation.operation_id); if (claimed) void submitClaim(claimed); } else if (operation.phase === 'submitted' && operation.lease_expires_at <= now()) db.prepare("UPDATE assistant_share_operation SET state='unresolved',lease_expires_at=NULL,error_code='message_unresolved',updated_at=? WHERE operation_id=? AND state='running' AND phase='submitted'").run(now(), operation.operation_id); } catch { /* Reconciliation remains retryable until its lease expires. */ } } };
   const reconcile = async () => {
     if (closed) return;
     try {
@@ -3154,7 +3709,7 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
       )),
     };
   };
-  return { capability: async () => ({ supported: true, enabled: enabled(), revision: revision(), serverInstanceID: await getServerId() }), snapshot, createAssistant, updateAssistant, setEnabled: (input) => { if (!plainObject(input) || typeof input.enabled !== 'boolean' || input.expectedRevision !== revision()) fail('revision_conflict'); db.prepare("UPDATE assistant_meta SET value=? WHERE key='enabled'").run(input.enabled ? '1' : '0'); return { enabled: input.enabled, revision: bump() }; }, removeAssistant: (assistantID, expectedRevision) => {
+  return { capability: async () => ({ supported: true, enabled: enabled(), revision: revision(), serverInstanceID: await getServerId(), sharingAvailable: false, archiveMetadataAvailable: typeof archiveSessionHost === 'function', sessionMetadataAvailable: false }), snapshot, createAssistant, updateAssistant, setEnabled: (input) => { if (!plainObject(input) || typeof input.enabled !== 'boolean' || input.expectedRevision !== revision()) fail('revision_conflict'); db.prepare("UPDATE assistant_meta SET value=? WHERE key='enabled'").run(input.enabled ? '1' : '0'); return { enabled: input.enabled, revision: bump() }; }, removeAssistant: (assistantID, expectedRevision) => {
     db.exec('BEGIN IMMEDIATE');
     try {
       const result = db.prepare('UPDATE assistant_v2 SET tombstone_at=?,revision=revision+1,updated_at=? WHERE assistant_id=? AND revision=? AND tombstone_at IS NULL').run(now(), now(), assistantID, expectedRevision);
@@ -3178,6 +3733,7 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
   }, ensure, createNew, compact, send, whenContactTurnSettled, abort, captureQueueDeliveryTarget, sendWithCapturedConfig, share, shareOperation, historicalMessages, contactMessages, clearContactMemory, resetContact, markContactRead, appendContactCard, deliverPeerMessage, listAssistantScheduledTasks, putAssistantContactAttachment, getAssistantContactAttachment, migrateContactAttachments, processEvent, reportAssignedSessionSettle: reportAssignedSession, reconcile,   close: () => {
     cancelAssignedResumes({});
     sessionAbortInflight.clear();
+    pendingAssignMessageIDs.clear();
     for (const turn of contactControllers.values()) turn.controller.abort();
     if (!closed) {
       closed = true;