@openchambery/web 1.19.21-beta.1 → 2.0.0-beta.1

package/server/lib/assistants/service.js

@@ -2,7 +2,7 @@ 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';
@@ -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, 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 });
@@ -348,30 +424,29 @@ 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 client = () => clientFactory
+    ? clientFactory()
+    : makeOpenCodeV2Client({
+      baseUrl: buildOpenCodeUrl('/', '').replace(/\/$/, ''),
+      authHeaders: 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 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 result = await invokeSession(() => client().session.create({
+      title: `[Assistant] ${row.name}`,
+      location: { directory },
+      ...(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');
     // 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);
+    // v2 has no session.update archive-metadata write; local history + title prefix are the equivalent isolation.
     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) => {
@@ -480,8 +555,17 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
     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 +603,39 @@ 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';
+    }
+    // User interrupt: prefer cancelled so contact resume path can notify.
+    if (type === 'session.execution.interrupted') {
+      return isUserAbort(body?.error) ? 'cancelled' : '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 +656,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 +668,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 +692,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 +702,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 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) => {
+  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 +848,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 +900,69 @@ 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;
     }
     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;
     }
     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;
     }
     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;
     }
+    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);
+      if (!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); }
+      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));
+      // 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); for (const assistantID of assistants) { if (assistant(assistantID)?.current_session_id !== sessionID) invalidateBackfill(assistantID, 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);
+      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); for (const assistantID of assistants) { if (assistant(assistantID)?.current_session_id !== sessionID) invalidateBackfill(assistantID, 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');
     }
@@ -741,7 +1001,7 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
   const fetchBackfillMessages = async (history, directory, cursor) => {
     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 } : {}) });
+        const result = await invokeSession(() => client().message.list({ sessionID: history.session_id, limit: BACKFILL_PAGE_SIZE, order: 'desc', ...(cursor ? { cursor } : {}) }));
         if (!result?.error || isMissing(result)) return result;
         if (!isTransientMessagesFailure(result, null) || attempt === BACKFILL_MESSAGES_ATTEMPTS - 1) fail('upstream_error');
       } catch (error) {
@@ -768,12 +1028,12 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
     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;
+    const entries = projectionEntries(result, history.session_id);
     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 nextCursor = projectionCursor(result) ?? 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 /
@@ -785,6 +1045,31 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
   };
   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 loadProjectionSession = async (history, pageLimit = BACKFILL_PAGE_SIZE) => {
+    let directory = history.directory ?? null;
+    if (directory == null) {
+      const session = await invokeSession(() => client().session.get({ sessionID: history.session_id })).catch(() => null);
+      const resolved = resolveArchivedDirectory(history.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);
+        directory = resolved;
+      }
+    }
+    const collected = [];
+    let cursor = null;
+    for (let page = 0; page < BACKFILL_MAX_PAGES; page++) {
+      const result = await fetchBackfillMessages(history, directory, cursor);
+      if (isMissing(result)) return { entries: collected, directory, missing: true };
+      if (result?.error) fail('upstream_error');
+      const entries = projectionEntries(result, history.session_id);
+      if (!entries) fail('upstream_error');
+      collected.push(...entries);
+      cursor = projectionCursor(result);
+      if (!cursor) break;
+      if (collected.length >= pageLimit) break;
+    }
+    return { entries: collected.slice(0, pageLimit), directory, missing: false };
+  };
   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);
@@ -820,22 +1105,50 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
       rows = pageRows();
     }
     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)) }));
+    let 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)) }));
+    // Current binding may still be live-only: if the mirror page has no
+    // current-session rows, read the v2 projection instead of returning empty.
+    if (page.length === 0 && row.current_session_id && !currentIsArchived) {
+      try {
+        const loaded = await loadProjectionSession({ assistant_id: row.assistant_id, session_id: row.current_session_id, directory: effectiveWorkspace(row), ordinal: currentSessionOrdinal }, limit);
+        const live = [];
+        for (const entry of loaded.entries) {
+          const info = entry?.info ?? entry;
+          if (!plainObject(info) || !nonEmptyString(info.id)) continue;
+          if (nonEmptyString(info.sessionID) && info.sessionID !== row.current_session_id) continue;
+          live.push({
+            sessionID: row.current_session_id,
+            directory: loaded.directory,
+            info,
+            parts: Array.isArray(entry?.parts) ? entry.parts : [],
+          });
+        }
+        ordered = [...live, ...ordered];
+      } catch {
+        // Keep archived/mirror rows; current live projection is best-effort.
+      }
+    }
     return { entries: ordered, nextCursor, complete: nextCursor === null };
   };
   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);
+      result = await sendPrompt(restored.sessionID, targetConfig);
       if (promptAdmitted(result)) mirrorAdmittedUserMessage(target, restored.sessionID, messageID, parts, targetConfig);
       return { result, binding: restored };
     }
@@ -1012,12 +1325,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 +1432,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 +1580,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 +1619,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 +1780,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,10 +1823,10 @@ 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);
+    const result = await invokeSession(() => client().message.list({
+      sessionID: resolved.sessionID, limit, order: 'desc',
+      ...(params.before ? { cursor: params.before } : {}),
+    }));
     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.');
@@ -1614,7 +1938,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 +1965,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 +2026,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 +2041,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 +2070,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 +2134,42 @@ 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') {
+        if (typeof api.session.update !== 'function') {
+          throw new AssignError(ASSIGN_CODES.UPSTREAM, 'Session archive is unavailable.');
+        }
+        result = await invokeSession(() => api.session.update({ sessionID, directory: resolved.directory, time: { archived: 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 (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 }) };
+    reportAssignedSession(sessionID, 'cancelled', false);
+    return { sessionID, directory: resolved.directory, operation, ...(operation === 'archive' ? { archived: true } : { deleted: true }) };
   };
   const matchRegisteredProject = async (directory) => {
     const projects = await listProjects();
@@ -2192,11 +2557,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 +3324,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 +3346,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 +3437,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 +3523,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: false, 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 +3547,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;