@openchambery/web 1.19.13-beta.3 → 1.19.13-beta.5

package/server/lib/assistants/service.js

@@ -10,23 +10,29 @@ import { contactCardIdentity, parseContactCard, parseContactPart } from './cards
 import {
   CONTACT_PAGE_DEFAULT_LIMIT,
   CONTACT_PAGE_MAX_LIMIT,
-  CONTACT_SETTLE_TEXT,
+  advanceContactReadWatermark,
   bumpContactGeneration,
   clearContactMemory as clearContactMemoryStore,
   contactHistoryForLlm,
   createActiveContactTurn,
   deleteContactMessages,
+  deleteContactReadState,
   ensureContactSchema,
   contactPartsFingerprint,
   getContactMessage,
+  getContactReadTip,
+  getContactReadWatermark,
+  getContactUnreadSnapshots,
   getLatestContactMessagePreview,
   getLatestContactMessagePreviews,
   insertContactMessage,
   listContactMessages,
   listInFlightWatches,
   listWatchesBySession,
+  migrateContactReadStateDefaultRead,
   nextContactOrdinal,
   projectActiveContactTurn,
+  resetContactReadWatermarkForGeneration,
   updateSessionCardStatus,
   upsertContactWatch,
 } from './contact-store.js';
@@ -64,8 +70,12 @@ import {
   ASSIGN_CODES,
   assignSession,
   attachmentScopeKey,
+  extractSessionDirectory,
+  extractSessionTitle,
   hasAssignImageParts,
+  mapSessionToWatchStatus,
   resolveAssignDirectory,
+  extractAssignSessionModel,
   resolveAssignWorkerModel,
   sanitizeAssignFileParts,
 } from './assign.js';
@@ -73,7 +83,7 @@ import { runContactTurn as defaultRunContactTurn } from './harness.js';
 import { loadConnectedCatalog } from '../llm/catalog.js';
 
 const require = createRequire(import.meta.url);
-const SCHEMA_VERSION = 12;
+const SCHEMA_VERSION = 13;
 const normalizeSessionDirectory = (value) => {
   if (typeof value !== 'string') return null;
   const trimmed = value.trim();
@@ -128,6 +138,12 @@ 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);
 /** 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. */
+export const ASSIGNED_SESSION_RESUME_WORKER_TEXT_MAX = 2_000;
+/** Stable resume turn/message id for assigned-session complete/error continuation. */
+export const assignedSessionResumeMessageID = (assistantID, sessionID, status, updatedAt) => (
+  `resume_${assistantID}_${sessionID}_${status}_${updatedAt}`
+);
 const awaitWithDeadline = async (work, ms = CONTACT_CATALOG_DEADLINE_MS, code = 'upstream_error') => {
   let timer = null;
   try {
@@ -146,7 +162,7 @@ const awaitWithDeadline = async (work, ms = CONTACT_CATALOG_DEADLINE_MS, code =
   }
 };
 
-export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, getOpenCodeAuthHeaders, getServerId = async () => null, getAllowedRoots = () => [], listProjects = async () => [], 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, createChatCompletion = null, runContactTurn = defaultRunContactTurn, listWorktrees = defaultListWorktrees } = {}) => {
   if (!dbPath || !dataDir) return null;
   const Database = require('better-sqlite3');
   fs.mkdirSync(path.dirname(dbPath), { recursive: true });
@@ -283,12 +299,19 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
     }
     activeContactTurnsByAssistant.delete(assistantID);
   };
-  const output = (row, latestMessagePreview) => {
+  const output = (row, latestMessagePreview, unreadSnapshot) => {
     const watches = listInFlightWatches(db, row.assistant_id);
     const activeContactTurn = projectActiveContactTurn(activeContactTurnsFor(row.assistant_id));
     const preview = latestMessagePreview !== undefined
       ? latestMessagePreview
       : getLatestContactMessagePreview(db, row.assistant_id);
+    const unread = unreadSnapshot !== undefined && unreadSnapshot !== null
+      ? unreadSnapshot
+      : (getContactUnreadSnapshots(db, [row.assistant_id]).get(row.assistant_id) ?? {
+        unreadCount: 0,
+        readWatermark: getContactReadWatermark(db, row.assistant_id),
+        readTip: getContactReadTip(db, row.assistant_id),
+      });
     return {
       id: row.assistant_id,
       revision: row.revision,
@@ -315,6 +338,12 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
       // Contact-transcript list desc: authoritative last visible bubble (not
       // defaultPrompt / updatedAt). null when the contact has no list-visible rows.
       latestMessagePreview: preview ?? null,
+      // Shared multi-client unread: countable assistant/peer replies after watermark.
+      unreadCount: Number(unread.unreadCount) || 0,
+      // Persisted shared watermark (generation + keyset). Clients POST this tip safely.
+      readWatermark: unread.readWatermark,
+      // Highest readable tip for safe mark-read report (transcript head + generation).
+      readTip: unread.readTip,
       createdAt: row.created_at,
       updatedAt: row.updated_at,
       tombstoneAt: row.tombstone_at,
@@ -380,6 +409,9 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
     const legacy = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='assistant'").get();
     if (legacy) { const columns = new Set(db.prepare("SELECT name FROM pragma_table_info('assistant')").all().map((column) => column.name)); for (const row of db.prepare('SELECT * FROM assistant').all()) { let sessionID = row.current_session_id ?? null; if (!sessionID && columns.has('inbox_topic_id') && row.inbox_topic_id) sessionID = db.prepare('SELECT session_id FROM assistant_topic WHERE topic_id=?').get(row.inbox_topic_id)?.session_id ?? null; if (!sessionID) sessionID = db.prepare("SELECT session_id FROM assistant_operation WHERE topic_id IN (SELECT topic_id FROM assistant_topic WHERE assistant_id=?) AND state='completed' AND session_id IS NOT NULL ORDER BY updated_at DESC LIMIT 1").get(row.assistant_id)?.session_id ?? db.prepare('SELECT session_id FROM assistant_turn WHERE topic_id IN (SELECT topic_id FROM assistant_topic WHERE assistant_id=?) AND session_id IS NOT NULL ORDER BY created_at DESC LIMIT 1').get(row.assistant_id)?.session_id ?? null; const mode = columns.has('mode') && row.mode === 'stateless' ? 'stateless' : 'continuous'; db.prepare('INSERT OR IGNORE 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(row.assistant_id, row.revision, row.enabled, row.name, row.default_prompt, managedConfig(row.workspace_path, row.assistant_id), row.provider_id, row.model_id, row.agent, null, mode, sessionID, Math.max(0, row.session_generation ?? 0), row.created_at, row.updated_at, row.tombstone_at); } }
     for (const row of db.prepare('SELECT assistant_id,workspace_path FROM assistant_v2 WHERE workspace_path IS NOT NULL').all()) { const workspacePath = managedConfig(row.workspace_path, row.assistant_id); if (workspacePath === null) db.prepare('UPDATE assistant_v2 SET workspace_path=NULL WHERE assistant_id=?').run(row.assistant_id); }
+    // v13: shared contact read watermark. Legacy transcripts default to fully read
+    // so existing installs do not flash unread on upgrade; later messages count.
+    migrateContactReadStateDefaultRead(db, { updatedAt: now() });
     db.prepare("INSERT OR REPLACE INTO assistant_meta(key,value) VALUES ('schema_version',?)").run(String(SCHEMA_VERSION));
   };
   migrate();
@@ -454,8 +486,21 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
     const sessionID = properties?.sessionID || properties?.sessionId || properties?.info?.sessionID || properties?.info?.sessionId;
     return nonEmptyString(sessionID) ? sessionID : '';
   };
+  const isUserAbort = (error) => error?.name === 'MessageAbortedError';
+  const assignedResumes = new Map();
+  const contactControllers = new Map();
+  // Last UI locale seen from a client per assistant. Background notifications
+  // (assigned-session settle) have no request locale, so they recall this value.
+  const contactTurnLanguages = new Map();
+  const cancelAssignedResumes = ({ sessionID, assistantID }) => {
+    for (const resume of assignedResumes.values()) {
+      if (sessionID && resume.sessionID !== sessionID) continue;
+      if (assistantID && resume.assistantID !== assistantID) continue;
+      resume.controller.abort();
+    }
+  };
   const settleStatusFromEvent = (payload, properties) => {
-    if (payload.type === 'session.error') return 'error';
+    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') {
@@ -465,37 +510,40 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
     }
     return null;
   };
+  // Assigned-session complete/error 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) => {
+    if (status === 'cancelled') cancelAssignedResumes({ sessionID });
     const watches = listWatchesBySession(db, sessionID);
     if (watches.length === 0) return false;
     let changed = false;
+    const resumes = [];
     db.exec('BEGIN IMMEDIATE');
     try {
       for (const watch of watches) {
-        if (watch.status === status) continue;
+        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;
+        const updatedAt = now();
         updateSessionCardStatus(db, { assistantID: watch.assistantID, sessionID, status });
         upsertContactWatch(db, {
           assistantID: watch.assistantID,
           sessionID,
           directory: watch.directory,
           status,
-          updatedAt: now(),
+          updatedAt,
+          resumeAllowed: watch.resumeAllowed,
         });
-        const settleText = CONTACT_SETTLE_TEXT[status];
-        const settleID = `settle_${watch.assistantID}_${sessionID}_${status}`;
-        if (settleText && !db.prepare('SELECT 1 AS ok FROM assistant_contact_message WHERE message_id=?').get(settleID)) {
-          insertContactMessage(db, {
-            messageID: settleID,
+        // complete/error: hand result back to contact LLM. question: card only (worker waiting).
+        // Never insert oc.settle.* canned transcript bubbles.
+        if (watch.resumeAllowed && (status === 'complete' || status === 'error')) {
+          resumes.push({
             assistantID: watch.assistantID,
-            role: 'assistant',
-            turnID: `settle:${sessionID}`,
-            bubbleIndex: 0,
-            createdAt: now(),
-            ordinal: nextContactOrdinal(db, watch.assistantID),
-            status: 'complete',
-            parts: [{ type: 'text', text: settleText }],
+            sessionID,
+            status,
+            directory: watch.directory,
+            updatedAt,
           });
         }
         changed = true;
@@ -506,6 +554,10 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
       db.exec('ROLLBACK');
       throw error;
     }
+    // processEvent stays sync; resume runs on the contact turn lane asynchronously.
+    if (typeof assignedSessionResumeRef.schedule === 'function') {
+      for (const resume of resumes) assignedSessionResumeRef.schedule(resume);
+    }
     return changed;
   };
   const sessionStatusType = (session) => {
@@ -526,12 +578,12 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
     if (isMissing(getResult)) return 'complete';
     if (getResult?.error) return null;
     const session = getResult?.data;
-    if (session?.error) return 'error';
+    if (session?.error) return isUserAbort(session.error) ? 'cancelled' : 'error';
     const statusType = sessionStatusType(session);
     if (statusType === 'busy' || statusType === 'retry') return null;
     if (isMissing(messagesResult)) return 'complete';
     const assistant = messagesResult && !messagesResult.error ? lastAssistantInfo(messagesResult.data) : null;
-    if (assistant?.error) return 'error';
+    if (assistant?.error) return isUserAbort(assistant.error) ? 'cancelled' : 'error';
     if (statusType === 'idle' || session?.time?.completed) return 'complete';
     if (assistant?.time?.completed) return 'complete';
     return null;
@@ -585,7 +637,9 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
     if (payload.type === 'message.updated') {
       const info = properties.info; const sessionID = info?.sessionID;
       if (!nonEmptyString(sessionID) || !plainObject(info)) return 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 assistants.length > 0;
+      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;
@@ -994,6 +1048,23 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
       throw wrapped;
     }
   };
+  const loadContactModelContext = async (signal) => {
+    const [catalogResult, preferencesResult] = await Promise.allSettled([
+      loadAssignCatalog(signal),
+      awaitWithDeadline(Promise.resolve().then(() => readModelPreferences()), CONTACT_CATALOG_DEADLINE_MS, 'upstream_error'),
+    ]);
+    const catalog = catalogResult.status === 'fulfilled' ? catalogResult.value : null;
+    const providerNames = new Map((catalog?.providers || []).map((provider) => [provider.id, provider.name]));
+    const preferences = preferencesResult.status === 'fulfilled' ? preferencesResult.value : null;
+    return {
+      connectedModels: normalizeConnectedModels((catalog?.models || []).map((model) => ({ ...model, providerName: providerNames.get(model.providerID) }))),
+      modelCatalogAvailable: catalog !== null,
+      modelPreferences: preferences && typeof preferences === 'object' ? {
+        favoriteModels: Array.isArray(preferences.favoriteModels) ? preferences.favoriteModels.slice(0, 64) : [],
+        recentModels: Array.isArray(preferences.recentModels) ? preferences.recentModels.slice(0, 16) : [],
+      } : null,
+    };
+  };
   const loadRegisteredProjects = async () => {
     const listed = await awaitWithDeadline(listProjects(), CONTACT_CATALOG_DEADLINE_MS, 'upstream_error');
     if (!Array.isArray(listed)) {
@@ -1050,6 +1121,267 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
       return null;
     }
   };
+  /**
+   * Best-effort previous worker model for a reused sessionID.
+   * session.get → session.model, else newest message info.model. Never throws / never fails assign.
+   */
+  const lookupReusedSessionModel = async ({ sessionID, directory, signal } = {}) => {
+    if (typeof sessionID !== 'string' || !sessionID.trim()) return null;
+    const api = client();
+    const options = signal ? { signal } : undefined;
+    const dir = typeof directory === 'string' && directory.trim() ? directory.trim() : null;
+    try {
+      const got = await api.session.get({
+        sessionID,
+        ...(dir ? { directory: dir } : {}),
+      }, options);
+      if (got?.error) return null;
+      const sessionPayload = got?.data ?? got;
+      let messages = null;
+      const fromSession = extractAssignSessionModel({ session: sessionPayload });
+      if (fromSession) return fromSession;
+      try {
+        if (typeof api.session.messages !== 'function') return null;
+        const listed = await api.session.messages({
+          sessionID,
+          ...(dir ? { directory: dir } : {}),
+          limit: 40,
+        }, options);
+        if (listed?.error) return null;
+        messages = listed?.data ?? listed;
+      } catch {
+        return null;
+      }
+      return extractAssignSessionModel({ session: sessionPayload, messages });
+    } catch {
+      return null;
+    }
+  };
+  /**
+   * Find a session row in the OpenChamber session index (directory is index-authoritative).
+   * Index failure throws — never silent empty.
+   */
+  const findSessionInIndex = (sessionID) => {
+    if (!sessionIndexService || typeof sessionIndexService.snapshot !== 'function') {
+      return null;
+    }
+    let snapshot;
+    try {
+      snapshot = sessionIndexService.snapshot();
+    } catch (error) {
+      throw new AssignError(
+        ASSIGN_CODES.UPSTREAM,
+        typeof error?.message === 'string' && error.message.trim()
+          ? error.message.trim()
+          : 'Session index snapshot failed.',
+      );
+    }
+    if (!snapshot || !Array.isArray(snapshot.directories)) {
+      throw new AssignError(ASSIGN_CODES.UPSTREAM, 'Session index snapshot failed.');
+    }
+    for (const directory of snapshot.directories) {
+      const dir = typeof directory?.directory === 'string' ? directory.directory : '';
+      if (!dir) continue;
+      for (const session of Array.isArray(directory.sessions) ? directory.sessions : []) {
+        if (!session || typeof session.id !== 'string' || session.id !== sessionID) continue;
+        return {
+          sessionID,
+          directory: dir,
+          title: typeof session.title === 'string' ? session.title : null,
+          updatedAt: typeof session.time?.updated === 'number'
+            ? session.time.updated
+            : (typeof session.updatedAt === 'number' ? session.updatedAt : 0),
+        };
+      }
+    }
+    return null;
+  };
+  /**
+   * Resolve an existing OpenCode session for watch / stop / assign-reuse.
+   * Authority order: session index directory → session.get metadata → registered project.
+   * User-supplied directory/projectPath is a lookup hint only — never trusted as scope.
+   * Failures stay failures (not empty success).
+   */
+  const resolveReferencedSession = async ({
+    sessionID: rawSessionID,
+    directoryHint = null,
+    titleHint = null,
+    signal,
+    includeMessages = true,
+  } = {}) => {
+    const sessionID = typeof rawSessionID === 'string' ? rawSessionID.trim() : '';
+    if (!sessionID) {
+      throw new AssignError(ASSIGN_CODES.VALIDATION, 'sessionID is required.');
+    }
+    const options = signal ? { signal } : undefined;
+    const indexRow = findSessionInIndex(sessionID);
+    const hint = typeof directoryHint === 'string' && directoryHint.trim()
+      ? directoryHint.trim()
+      : null;
+    // Prefer index directory; user path is last-resort get hint only.
+    const getHints = [];
+    if (indexRow?.directory) getHints.push(indexRow.directory);
+    if (hint && !getHints.some((item) => directoryContained(item, hint) || directoryContained(hint, item))) {
+      getHints.push(hint);
+    }
+    if (getHints.length === 0) getHints.push(null);
+
+    let getResult = null;
+    let usedDirectoryHint = null;
+    let lastError = null;
+    for (const dir of getHints) {
+      try {
+        getResult = await client().session.get({
+          sessionID,
+          ...(dir ? { directory: dir } : {}),
+        }, options);
+        usedDirectoryHint = dir;
+        if (getResult && !getResult.error) break;
+        if (isMissing(getResult)) {
+          getResult = { missing: true, error: getResult?.error };
+          break;
+        }
+        // Non-404 error with a directory may be wrong scope — try next hint.
+        if (getResult?.error && dir) {
+          lastError = getResult.error;
+          getResult = null;
+          continue;
+        }
+        break;
+      } catch (error) {
+        lastError = error;
+        getResult = null;
+      }
+    }
+    if (!getResult) {
+      throw new AssignError(
+        ASSIGN_CODES.UPSTREAM,
+        typeof lastError?.message === 'string' && lastError.message.trim()
+          ? lastError.message.trim()
+          : 'Failed to load that coding session.',
+      );
+    }
+    if (getResult.missing || isMissing(getResult)) {
+      throw new AssignError(ASSIGN_CODES.NOT_FOUND, `No coding session ${sessionID} was found.`);
+    }
+    if (getResult.error) {
+      throw new AssignError(
+        ASSIGN_CODES.UPSTREAM,
+        typeof getResult.error?.message === 'string' && getResult.error.message.trim()
+          ? getResult.error.message.trim()
+          : 'Failed to load that coding session.',
+      );
+    }
+    const sessionPayload = getResult.data ?? getResult;
+    const metaDirectory = extractSessionDirectory(sessionPayload);
+    const directoryRaw = metaDirectory || indexRow?.directory || usedDirectoryHint;
+    if (!directoryRaw) {
+      throw new AssignError(
+        ASSIGN_CODES.VALIDATION,
+        'That session has no resolvable project directory.',
+      );
+    }
+    // Registered project scope = allowed roots (same gate as assign create).
+    // Reject managed assistant-workspaces and paths outside Settings projects.
+    let directory;
+    try {
+      directory = resolveAssignDirectory({
+        projectPath: directoryRaw,
+        directory: directoryRaw,
+        branch: null,
+        allowedRoots: getAllowedRoots(),
+        managedWorkspaceRoot: path.resolve(dataDir, 'assistant-workspaces'),
+        worktrees: [],
+      });
+    } catch (error) {
+      if (error instanceof AssignError) throw error;
+      throw new AssignError(
+        ASSIGN_CODES.WORKSPACE_FORBIDDEN,
+        'That session is not under a registered project. Add the project in Settings first.',
+      );
+    }
+
+    let messagesResult = null;
+    if (includeMessages && typeof client().session.messages === 'function') {
+      try {
+        messagesResult = await client().session.messages({
+          sessionID,
+          directory,
+          limit: 100,
+        }, options);
+        if (messagesResult?.error && !isMissing(messagesResult)) {
+          // Message fetch failure must not invent status; keep messages null.
+          messagesResult = null;
+        }
+      } catch {
+        messagesResult = null;
+      }
+    }
+    const messageRows = Array.isArray(messagesResult?.data)
+      ? messagesResult.data
+      : (Array.isArray(messagesResult) ? messagesResult : null);
+    const status = mapSessionToWatchStatus({
+      session: sessionPayload,
+      messages: messageRows,
+      missing: false,
+    });
+    const title = (typeof titleHint === 'string' && titleHint.trim() ? titleHint.trim() : null)
+      || extractSessionTitle(sessionPayload)
+      || indexRow?.title
+      || sessionID;
+    return {
+      sessionID,
+      directory,
+      title,
+      status,
+      session: sessionPayload,
+      messages: messageRows,
+    };
+  };
+  const readSessionWork = async (params = {}) => {
+    const limit = params.limit === undefined ? 20 : params.limit;
+    if (!Number.isInteger(limit) || limit < 1 || limit > 50) throw new AssignError(ASSIGN_CODES.VALIDATION, 'limit must be an integer from 1 to 50.');
+    if (params.before !== undefined && (typeof params.before !== 'string' || !params.before || params.before.length > 2048)) throw new AssignError(ASSIGN_CODES.VALIDATION, 'before must be an opaque cursor.');
+    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);
+    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;
+    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;
+    const text = (value) => {
+      if (typeof value !== 'string') return '';
+      const kept = value.slice(0, Math.min(4000, remaining));
+      remaining -= kept.length;
+      if (kept.length < value.length) partial = true;
+      return kept;
+    };
+    const messages = rows.slice(-limit).map((entry) => {
+      const info = entry.info ?? entry;
+      const parts = [];
+      const sourceParts = Array.isArray(entry.parts) ? entry.parts : [];
+      if (sourceParts.length > 20) partial = true;
+      for (const part of sourceParts.slice(0, 20)) {
+        if (part.type === 'text') parts.push({ type: 'text', text: text(part.text) });
+        else if (part.type === 'file') { parts.push({ type: 'file', mime: part.mime, filename: text(part.filename) }); partial = true; }
+        else if (part.type === 'tool') {
+          parts.push({ type: 'tool', tool: text(part.tool), status: part.state?.status, output: text(part.state?.output), error: text(part.state?.error) });
+          partial = true; // Inputs and binary details are intentionally omitted.
+        } else if (part.type !== 'step-start' && part.type !== 'step-finish') partial = true;
+      }
+      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;
+    return { sessionID: resolved.sessionID, directory: resolved.directory, title: resolved.title.slice(0, 500), messages, nextCursor, partial: partial || nextCursor !== null };
+  };
   const assignWork = async (row, params = {}) => {
     const fileParts = sanitizeAssignFileParts(params.fileParts || params.parts || []);
     const signal = params.signal;
@@ -1060,16 +1392,63 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
       || (typeof params.model === 'string' && params.model.trim())
       || (params.model && typeof params.model === 'object'),
     );
-    const needsCatalog = explicitModel || hasAssignImageParts(fileParts);
+    const reuseSessionID = typeof params.sessionID === 'string' && params.sessionID.trim()
+      ? params.sessionID.trim()
+      : '';
+    // Reuse: resolve directory/project from authoritative session metadata first.
+    // User projectPath/directory are hints only and never override scope.
+    let reuseScope = null;
+    if (reuseSessionID) {
+      const directoryHint = typeof params.directory === 'string' && params.directory.trim()
+        ? params.directory.trim()
+        : (typeof params.projectPath === 'string' && params.projectPath.trim()
+          ? params.projectPath.trim()
+          : null);
+      reuseScope = await resolveReferencedSession({
+        sessionID: reuseSessionID,
+        directoryHint,
+        titleHint: typeof params.title === 'string' ? params.title : null,
+        signal,
+        // Messages only needed when following session model without explicit selection.
+        includeMessages: !explicitModel,
+      });
+    }
+    // Reused session without explicit model may follow the session's last model (catalog-gated).
+    const followSessionModel = Boolean(reuseSessionID && !explicitModel);
+    const needsCatalog = explicitModel || hasAssignImageParts(fileParts) || followSessionModel;
     let catalog = null;
+    let sessionModel = null;
     if (needsCatalog) {
-      catalog = await loadAssignCatalog(signal);
+      if (followSessionModel && !explicitModel && !hasAssignImageParts(fileParts)) {
+        // Session-follow degrades on catalog failure; explicit/image stay fail-closed.
+        try {
+          catalog = await loadAssignCatalog(signal);
+        } catch {
+          catalog = null;
+        }
+      } else {
+        catalog = await loadAssignCatalog(signal);
+      }
+    }
+    if (followSessionModel && catalog && reuseScope) {
+      sessionModel = extractAssignSessionModel({
+        session: reuseScope.session,
+        messages: reuseScope.messages,
+      });
+      if (!sessionModel) {
+        sessionModel = await lookupReusedSessionModel({
+          sessionID: reuseSessionID,
+          directory: reuseScope.directory,
+          signal,
+        });
+      }
     }
     const workerModel = resolveAssignWorkerModel({
       providerID: params.providerID,
       modelID: params.modelID,
       model: params.model,
       fallback: { providerID: row.provider_id, modelID: row.model_id },
+      sessionModel,
       catalog,
     });
     let acceptsImages = workerModel.acceptsImages;
@@ -1083,6 +1462,16 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
     // Forward tool variant + AbortSignal; lookupMessage uses real SDK exact/list paths.
     return assignSession({
       ...params,
+      ...(reuseScope ? {
+        sessionID: reuseScope.sessionID,
+        directory: reuseScope.directory,
+        projectPath: reuseScope.directory,
+        // Drop untrusted branch when reusing — directory is already authoritative.
+        branch: undefined,
+        title: typeof params.title === 'string' && params.title.trim()
+          ? params.title.trim()
+          : reuseScope.title,
+      } : {}),
       fileParts,
       ...(params.variant !== undefined ? { variant: params.variant } : {}),
       ...(signal ? { signal } : {}),
@@ -1109,6 +1498,112 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
       messageID: params?.messageID || `msg_assign_${id()}`,
     });
   };
+  /** Watch an existing session only — no prompt. Baseline status avoids false settle resume. */
+  const watchSessionWork = async (_row, params = {}) => {
+    const sessionID = typeof params.sessionID === 'string' ? params.sessionID.trim() : '';
+    if (!sessionID) {
+      throw new AssignError(ASSIGN_CODES.VALIDATION, 'watch_session requires sessionID.');
+    }
+    const resolved = await resolveReferencedSession({
+      sessionID,
+      // directory/projectPath from the model are never trusted as scope authority.
+      directoryHint: null,
+      titleHint: typeof params.title === 'string' ? params.title : null,
+      signal: params.signal,
+      includeMessages: true,
+    });
+    return {
+      sessionID: resolved.sessionID,
+      directory: resolved.directory,
+      title: resolved.title,
+      status: resolved.status,
+      watched: true,
+      reused: true,
+    };
+  };
+  /** Abort an existing coding session via real OpenCode session.abort. */
+  const stopSessionWork = async (_row, params = {}) => {
+    const sessionID = typeof params.sessionID === 'string' ? params.sessionID.trim() : '';
+    if (!sessionID) {
+      throw new AssignError(ASSIGN_CODES.VALIDATION, 'stop_session requires sessionID.');
+    }
+    const resolved = await resolveReferencedSession({
+      sessionID,
+      directoryHint: null,
+      signal: params.signal,
+      // Abort does not need messages for baseline.
+      includeMessages: false,
+    });
+    const signal = params.signal;
+    signal?.throwIfAborted();
+    const sdkOptions = signal ? { signal } : undefined;
+    if (typeof client().session.abort !== 'function') {
+      throw new AssignError(ASSIGN_CODES.UPSTREAM, 'Session abort is unavailable.');
+    }
+    let result;
+    try {
+      result = await client().session.abort({
+        sessionID: resolved.sessionID,
+        directory: resolved.directory,
+      }, sdkOptions);
+    } catch (error) {
+      throw new AssignError(
+        ASSIGN_CODES.UPSTREAM,
+        typeof error?.message === 'string' && error.message.trim()
+          ? error.message.trim()
+          : 'Failed to abort that coding session.',
+      );
+    }
+    if (isMissing(result)) {
+      throw new AssignError(ASSIGN_CODES.NOT_FOUND, `No coding session ${resolved.sessionID} was found.`);
+    }
+    if (result?.error || result?.data === false) {
+      throw new AssignError(
+        ASSIGN_CODES.UPSTREAM,
+        typeof result.error?.message === 'string' && result.error.message.trim()
+          ? result.error.message.trim()
+          : 'Failed to abort that coding session.',
+      );
+    }
+    reportAssignedSession(resolved.sessionID, 'cancelled');
+    return {
+      sessionID: resolved.sessionID,
+      directory: resolved.directory,
+      title: resolved.title,
+      aborted: true,
+    };
+  };
+  // Resolve scope from the authoritative session, never model-supplied directories.
+  const mutateSessionWork = async (operation, params = {}) => {
+    const sessionID = typeof params.sessionID === 'string' ? params.sessionID.trim() : '';
+    if (!sessionID) throw new AssignError(ASSIGN_CODES.VALIDATION, `${operation} requires sessionID.`);
+    if (operation === 'steer' && (typeof params.text !== 'string' || !params.text.trim())) {
+      throw new AssignError(ASSIGN_CODES.VALIDATION, 'steer requires text.');
+    }
+    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() };
+    let result;
+    try {
+      result = await session[method](request, params.signal ? { signal: params.signal } : undefined);
+    } catch (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.
+      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 }) };
+  };
   const matchRegisteredProject = async (directory) => {
     const projects = await listProjects();
     const resolved = path.resolve(directory);
@@ -1338,6 +1833,401 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
       }),
     };
   };
+  const findAssignedSessionCardTitle = (assistantID, sessionID) => {
+    const rows = db.prepare(
+      'SELECT p.part_json FROM assistant_contact_part p JOIN assistant_contact_message m ON m.message_id=p.message_id WHERE m.assistant_id=?',
+    ).all(assistantID);
+    for (const row of rows) {
+      let part;
+      try { part = parseContactPart(parse(row.part_json)); } catch { continue; }
+      if (part?.type === 'card' && part.cardType === 'session' && part.sessionID === sessionID) {
+        return typeof part.title === 'string' && part.title.trim() ? part.title.trim() : null;
+      }
+    }
+    return null;
+  };
+  const extractLastWorkerAssistantText = (messages, maxChars = ASSIGNED_SESSION_RESUME_WORKER_TEXT_MAX) => {
+    if (!Array.isArray(messages)) return '';
+    const limit = Number.isFinite(maxChars) && maxChars > 0 ? Math.floor(maxChars) : ASSIGNED_SESSION_RESUME_WORKER_TEXT_MAX;
+    for (let index = messages.length - 1; index >= 0; index -= 1) {
+      const entry = messages[index];
+      const info = entry?.info ?? entry;
+      if (info?.role !== 'assistant') continue;
+      const parts = Array.isArray(entry?.parts)
+        ? entry.parts
+        : (Array.isArray(info?.parts) ? info.parts : []);
+      const chunks = [];
+      for (const part of parts) {
+        if (part?.type === 'text' && typeof part.text === 'string' && part.text.trim()) {
+          chunks.push(part.text.trim());
+        }
+      }
+      if (chunks.length === 0 && typeof info?.content === 'string' && info.content.trim()) {
+        chunks.push(info.content.trim());
+      }
+      if (chunks.length === 0) continue;
+      const joined = chunks.join('\n');
+      return joined.length > limit ? joined.slice(0, limit) : joined;
+    }
+    return '';
+  };
+  const buildAssignedSessionResumeUserText = ({ sessionID, status, title, workerText }) => {
+    const lines = [
+      '[Internal assigned-session resume — not a user message. Do not quote this block.]',
+      `sessionID: ${sessionID}`,
+      `status: ${status}`,
+    ];
+    if (title) lines.push(`cardTitle: ${title}`);
+    if (workerText) {
+      lines.push('lastWorkerAssistantText (bounded):');
+      lines.push(workerText);
+    } else {
+      lines.push('lastWorkerAssistantText: (unavailable)');
+    }
+    lines.push(
+      'Instructions:',
+      '- Never tell the user canned phrases like "会话已完成" / "Session finished" / "会话失败" / "Session failed".',
+      '- This is a read-only result notification, never authorization to create, restart, continue, steer, or otherwise mutate any session or file.',
+      '- Respect the latest user instructions in history, including stop/cancel. If work remains, report it and wait for an explicit user request.',
+      '- If no further work is needed, reply in one or two short sentences in the user\'s language summarizing the result or failure reason.',
+    );
+    return lines.join('\n');
+  };
+  /**
+   * After assigned worker complete/error: async contact-lane continuation.
+   * No user transcript row — only internal runContactTurn userText + assistant bubbles/cards.
+   */
+  const scheduleAssignedSessionResume = ({ assistantID, sessionID, status, directory, updatedAt }) => {
+    if (closed) return;
+    if (status !== 'complete' && status !== 'error') return;
+    const row = assistant(assistantID);
+    if (!row || row.tombstone_at) return;
+    const messageID = assignedSessionResumeMessageID(assistantID, sessionID, status, updatedAt);
+    const turnID = messageID;
+    // Idempotent: same watch status already resumed (bubbles or durable error).
+    if (
+      getContactMessage(db, `${messageID}:bubble:1`)
+      || getContactMessage(db, `${messageID}:error`)
+    ) return;
+
+    if (assignedResumes.has(messageID)) return;
+    const controller = new AbortController();
+    assignedResumes.set(messageID, { assistantID, sessionID, controller });
+    const finishCancelled = () => {
+      settleActiveContactTurn(assistantID, turnID, { bumpRevision: true });
+      emitContactTurnEvent('openchamber:contact-turn-end', { assistantID, turnID, status: 'cancelled' });
+      resolveContactTurnSettlement(messageID, { status: 'cancelled' });
+    };
+
+    rememberActiveContactTurn(assistantID, {
+      turnID,
+      messageID,
+      status: 'queued',
+      admittedAt: now(),
+    });
+    // Tip snapshot so list green dots / 3-dot row rehydrate without waiting for lane start.
+    bump();
+    emitContactTurnEvent('openchamber:contact-turn-start', {
+      assistantID,
+      turnID,
+      messageID,
+    });
+    contactTurnSettlement(messageID);
+
+    void inContactTurnLane(assistantID, async () => {
+      if (controller.signal.aborted) { finishCancelled(); return; }
+      if (closed) {
+        settleActiveContactTurn(assistantID, turnID, { bumpRevision: true });
+        resolveContactTurnSettlement(messageID, { status: 'error', error: 'closed' });
+        return;
+      }
+      const live = assistant(assistantID);
+      if (!live || live.tombstone_at) {
+        settleActiveContactTurn(assistantID, turnID, { bumpRevision: true });
+        resolveContactTurnSettlement(messageID, { status: 'error', error: 'not_found' });
+        return;
+      }
+      if (
+        getContactMessage(db, `${messageID}:bubble:1`)
+        || getContactMessage(db, `${messageID}:error`)
+      ) {
+        settleActiveContactTurn(assistantID, turnID, { bumpRevision: true });
+        resolveContactTurnSettlement(messageID, { status: 'complete', replayed: true });
+        return;
+      }
+      markActiveContactTurnRunning(assistantID, turnID);
+      const assistantSnapshot = output(live);
+      let registeredProjects = [];
+      try {
+        registeredProjects = filterRegisteredProjects(await loadRegisteredProjects());
+      } catch {
+        registeredProjects = [];
+      }
+      const modelContext = await loadContactModelContext(controller.signal);
+
+      let workerText = '';
+      try {
+        const watchDirectory = nonEmptyString(directory)
+          ? (() => {
+            try { return workspace(directory, assistantID); } catch { return null; }
+          })()
+          : null;
+        const resolvedDirectory = watchDirectory || (() => {
+          try { return effectiveWorkspace(live); } catch { return null; }
+        })();
+        if (resolvedDirectory) {
+          const messagesResult = await client().session.messages({
+            sessionID,
+            directory: resolvedDirectory,
+            limit: 100,
+          });
+          if (!messagesResult?.error) {
+            const rows = Array.isArray(messagesResult?.data)
+              ? messagesResult.data
+              : (Array.isArray(messagesResult) ? messagesResult : []);
+            if (isUserAbort(lastAssistantInfo(rows)?.error)) {
+              reportAssignedSession(sessionID, 'cancelled');
+              finishCancelled();
+              return;
+            }
+            workerText = extractLastWorkerAssistantText(rows);
+          }
+        }
+      } catch {
+        workerText = '';
+      }
+
+      if (controller.signal.aborted) { finishCancelled(); return; }
+      const title = findAssignedSessionCardTitle(assistantID, sessionID);
+      const userText = buildAssignedSessionResumeUserText({
+        sessionID,
+        status,
+        title,
+        workerText,
+      });
+      const history = contactHistoryForLlm(db, assistantID, {});
+      const assignedCards = [];
+      let contactResetThisTurn = false;
+      let contactHistoryClearedThisTurn = false;
+
+      try {
+        const executionHistory = await materializeContactHistory(
+          db,
+          dataDir,
+          assistantID,
+          history,
+          { budgetBytes: CONTACT_ATTACHMENT_TURN_BUDGET_BYTES },
+        );
+        const tools = createContactTools({
+          assignWork: (params) => assignWork(live, params),
+          watchSession: (params) => watchSessionWork(live, params),
+          stopSession: (params) => stopSessionWork(live, params),
+          steerSession: (params) => mutateSessionWork('steer', params),
+          archiveSession: (params) => mutateSessionWork('archive', params),
+          deleteSession: (params) => mutateSessionWork('delete', params),
+          createAssistant: (toolInput) => createAssistant(toolInput),
+          scheduleTask: (params) => scheduleWork(live, params),
+          deliverPeerMessage: (toolInput) => deliverPeerMessage(assistantID, toolInput),
+          clearContactMemory: () => {
+            const result = clearContactMemory(assistantID, {});
+            contactResetThisTurn = true;
+            return result;
+          },
+          resetContact: () => {
+            const result = resetContact(assistantID, {});
+            contactResetThisTurn = true;
+            contactHistoryClearedThisTurn = true;
+            return result;
+          },
+          listAssistants: () => db.prepare('SELECT * FROM assistant_v2 WHERE tombstone_at IS NULL ORDER BY created_at').all().map(output),
+          listProjects: async () => loadRegisteredProjects(),
+          listSessions: (params) => listSessionsWork(params),
+          readSession: (params) => readSessionWork(params),
+          readAssistantSettings: (input = {}) => {
+            const targetID = typeof input?.assistantID === 'string' && input.assistantID.trim()
+              ? input.assistantID.trim()
+              : assistantID;
+            return output(editable(targetID));
+          },
+          updateAssistantSettings: async (patch = {}) => {
+            const normalizePrompt = (value) => {
+              if (typeof value !== 'string') fail('validation_error');
+              if (value.length > 200_000) fail('validation_error');
+              return value.trim();
+            };
+            const targetID = typeof patch?.assistantID === 'string' && patch.assistantID.trim()
+              ? patch.assistantID.trim()
+              : assistantID;
+            let lastError = null;
+            for (let attempt = 0; attempt < 2; attempt++) {
+              const current = output(editable(targetID));
+              if (!Object.prototype.hasOwnProperty.call(patch, 'defaultPrompt')) {
+                fail('validation_error');
+              }
+              const nextPrompt = normalizePrompt(patch.defaultPrompt);
+              if (current.defaultPrompt === nextPrompt) {
+                return {
+                  updated: false,
+                  unchanged: true,
+                  defaultPrompt: current.defaultPrompt,
+                  assistant: current,
+                };
+              }
+              await Promise.resolve();
+              try {
+                const updated = await updateAssistant(targetID, {
+                  expectedRevision: current.revision,
+                  defaultPrompt: nextPrompt,
+                });
+                return {
+                  updated: true,
+                  defaultPrompt: updated.defaultPrompt,
+                  assistant: updated,
+                };
+              } catch (error) {
+                lastError = error;
+                if (error?.code !== 'revision_conflict') throw error;
+              }
+            }
+            throw lastError;
+          },
+          currentAssistant: assistantSnapshot,
+          onCard: (card) => assignedCards.push(card),
+          turnFileParts: [],
+          turnAttachmentScope: attachmentScopeKey([]),
+        });
+        controller.signal.throwIfAborted();
+        const generated = await runContactTurn({
+          signal: controller.signal,
+          readOnly: true,
+          assistant: assistantSnapshot,
+          history: executionHistory,
+          userText,
+          userParts: [{ type: 'text', text: userText }],
+          language: contactTurnLanguages.get(assistantID) ?? '',
+          createChatCompletion,
+          tools,
+          projects: registeredProjects,
+          ...modelContext,
+          globalEventHub,
+          onBubbleDelta: (bubbleIndex, delta, done) => {
+            if (controller.signal.aborted) return;
+            emitContactTurnEvent('openchamber:contact-bubble-delta', {
+              assistantID,
+              turnID,
+              bubbleIndex,
+              delta: typeof delta === 'string' ? delta : '',
+              done: Boolean(done),
+            });
+          },
+        });
+        if (controller.signal.aborted) { finishCancelled(); return; }
+        if (closed) {
+          settleActiveContactTurn(assistantID, turnID, { bumpRevision: true });
+          resolveContactTurnSettlement(messageID, { status: 'error', error: 'closed' });
+          return;
+        }
+        const resetThisTurn = contactResetThisTurn || generated?.reset === true;
+        const historyClearedThisTurn = contactHistoryClearedThisTurn
+          || contactTurnClearedChatHistory(generated?.messages)
+          || generated?.historyCleared === true;
+        const preferredConfirm = historyClearedThisTurn
+          ? CLEAR_CHAT_HISTORY_CONFIRM_BUBBLE
+          : NEW_CONVERSATION_CONFIRM_BUBBLE;
+        const bubbles = resetThisTurn
+          ? confirmBubbleAfterContactReset(generated?.bubbles, preferredConfirm)
+          : (Array.isArray(generated?.bubbles) ? generated.bubbles.filter((item) => typeof item === 'string' && item.trim()) : []);
+        const cards = resetThisTurn
+          ? []
+          : [
+            ...assignedCards,
+            ...(Array.isArray(generated?.cards) ? generated.cards : []),
+          ].filter((card, index, list) => list.findIndex((item) => contactCardIdentity(item) === contactCardIdentity(card)) === index);
+        if (bubbles.length === 0 && cards.length === 0) {
+          const detail = 'Assistant returned no text';
+          try {
+            persistContactTurnFailure(assistantID, {
+              userMessageID: messageID,
+              turnID,
+              error: detail,
+            });
+            settleActiveContactTurn(assistantID, turnID);
+          } catch {
+            settleActiveContactTurn(assistantID, turnID, { bumpRevision: true });
+          }
+          emitContactTurnEvent('openchamber:contact-turn-end', {
+            assistantID,
+            turnID,
+            status: 'error',
+            error: detail,
+          });
+          notifyContactTurn({
+            assistantID,
+            name: assistantSnapshot.name,
+            turnID,
+            status: 'error',
+            body: detail,
+          });
+          resolveContactTurnSettlement(messageID, { status: 'error', error: detail });
+          return;
+        }
+        // No user row for resume — only assistant bubbles/cards (userMessageID is id prefix).
+        persistContactAssistantReply(assistantID, {
+          userMessageID: messageID,
+          bubbles: bubbles.length > 0 ? bubbles : [ASSIGNED_SESSION_FALLBACK_BUBBLE],
+          cards,
+          turnID,
+        });
+        settleActiveContactTurn(assistantID, turnID);
+        emitContactTurnEvent('openchamber:contact-turn-end', {
+          assistantID,
+          turnID,
+          status: 'complete',
+        });
+        const spoken = bubbles.filter((text) => typeof text === 'string' && text.trim() && !text.startsWith('oc.settle.'));
+        notifyContactTurn({
+          assistantID,
+          name: assistantSnapshot.name,
+          turnID,
+          status: 'complete',
+          body: spoken.join('\n') || cards[0]?.title || '',
+        });
+        resolveContactTurnSettlement(messageID, { status: 'complete' });
+      } catch (error) {
+        if (controller.signal.aborted) { finishCancelled(); return; }
+        const detail = typeof error?.message === 'string' && error.message.trim()
+          ? error.message.trim()
+          : (error?.code || 'upstream_error');
+        const statusCode = error?.code === 'no_provider' ? 'no_provider' : (error?.code || 'upstream_error');
+        try {
+          persistContactTurnFailure(assistantID, {
+            userMessageID: messageID,
+            turnID,
+            error: detail,
+          });
+          settleActiveContactTurn(assistantID, turnID);
+        } catch {
+          settleActiveContactTurn(assistantID, turnID, { bumpRevision: true });
+        }
+        emitContactTurnEvent('openchamber:contact-turn-end', {
+          assistantID,
+          turnID,
+          status: 'error',
+          error: detail,
+          ...(statusCode !== detail ? { code: statusCode } : {}),
+        });
+        notifyContactTurn({
+          assistantID,
+          name: assistantSnapshot.name,
+          turnID,
+          status: 'error',
+          body: detail,
+        });
+        resolveContactTurnSettlement(messageID, { status: 'error', error: detail, code: statusCode });
+      }
+    }).finally(() => { assignedResumes.delete(messageID); });
+  };
+  assignedSessionResumeRef.schedule = scheduleAssignedSessionResume;
   /**
    * Contact composer send: validate → admit user (202) → async turn.
    * Does not await the LLM. Live bubble tokens use openchamber:contact-bubble-delta
@@ -1349,7 +2239,9 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
     const messageID = string(input.messageID, 256, true);
     const userText = extractUserText(input);
     if (!userText) fail('validation_error');
+    const language = typeof input.language === 'string' ? input.language.trim().slice(0, 64) : '';
     const row = active(assistantID);
+    if (language) contactTurnLanguages.set(row.assistant_id, language);
     const userParts = await userContactParts(row.assistant_id, input, userText);
     if (typeof createChatCompletion !== 'function' && runContactTurn === defaultRunContactTurn) fail('upstream_error');
     let registeredProjects = [];
@@ -1379,12 +2271,24 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
         replayed: true,
       };
     }
+    cancelAssignedResumes({ assistantID: row.assistant_id });
+    // A new user turn supersedes pending background notifications as well as running ones.
+    // Explicit assign/watch admission rearms only its own watch. Keep live card status intact.
+    db.prepare('UPDATE assistant_contact_watch SET resume_allowed=0 WHERE assistant_id=?').run(row.assistant_id);
     admitContactUser(row.assistant_id, {
       userMessageID: messageID,
       userText,
       userParts,
       turnID,
     });
+    const controller = new AbortController();
+    contactControllers.set(messageID, { assistantID: row.assistant_id, controller });
+    const finishCancelled = () => {
+      settleActiveContactTurn(row.assistant_id, turnID, { bumpRevision: true });
+      emitContactTurnEvent('openchamber:contact-turn-end', { assistantID: row.assistant_id, turnID, status: 'cancelled' });
+      resolveContactTurnSettlement(messageID, { status: 'cancelled' });
+      contactControllers.delete(messageID);
+    };
     rememberActiveContactTurn(row.assistant_id, {
       turnID,
       messageID,
@@ -1399,6 +2303,7 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
     contactTurnSettlement(messageID);
     const kickTurn = () => {
       void inContactTurnLane(row.assistant_id, async () => {
+        if (controller.signal.aborted) { finishCancelled(); return; }
         if (closed) {
           settleActiveContactTurn(row.assistant_id, turnID, { bumpRevision: true });
           resolveContactTurnSettlement(messageID, { status: 'error', error: 'closed' });
@@ -1421,15 +2326,7 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
         const assignedCards = [];
         let contactResetThisTurn = false;
         let contactHistoryClearedThisTurn = false;
-        let connectedModels = [];
-        try {
-          const catalog = await loadAssignCatalog(undefined);
-          connectedModels = normalizeConnectedModels(catalog?.models);
-        } catch {
-          // Catalog failure must not block default-model contact turns.
-          // Explicit worker model / image capability checks still fail closed inside assignWork.
-          connectedModels = [];
-        }
+        const modelContext = await loadContactModelContext(controller.signal);
         try {
           // Materialize inside turn try so failures durable-error + settle working.
           // DB/UI keep descriptors; harness + assign get execution-time data URLs under budget.
@@ -1454,6 +2351,11 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
           const turnAttachmentScope = attachmentScopeKey(turnFileParts);
           const tools = createContactTools({
             assignWork: (params) => assignWork(row, params),
+            watchSession: (params) => watchSessionWork(row, params),
+            stopSession: (params) => stopSessionWork(row, params),
+            steerSession: (params) => mutateSessionWork('steer', params),
+            archiveSession: (params) => mutateSessionWork('archive', params),
+            deleteSession: (params) => mutateSessionWork('delete', params),
             createAssistant: (toolInput) => createAssistant(toolInput),
             scheduleTask: (params) => scheduleWork(row, params),
             deliverPeerMessage: (toolInput) => deliverPeerMessage(row.assistant_id, toolInput),
@@ -1479,22 +2381,79 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
             listAssistants: () => db.prepare('SELECT * FROM assistant_v2 WHERE tombstone_at IS NULL ORDER BY created_at').all().map(output),
             listProjects: async () => loadRegisteredProjects(),
             listSessions: (params) => listSessionsWork(params),
+            readSession: (params) => readSessionWork(params),
+            // Live DB read — not the turn-start assistantSnapshot.
+            // Optional assistantID targets another live row; omitted → this contact.
+            readAssistantSettings: (input = {}) => {
+              const assistantID = typeof input?.assistantID === 'string' && input.assistantID.trim()
+                ? input.assistantID.trim()
+                : row.assistant_id;
+              return output(editable(assistantID));
+            },
+            // Persist defaultPrompt via updateAssistant CAS; one revision_conflict retry.
+            updateAssistantSettings: async (patch = {}) => {
+              const normalizePrompt = (value) => {
+                if (typeof value !== 'string') fail('validation_error');
+                if (value.length > 200_000) fail('validation_error');
+                return value.trim();
+              };
+              const assistantID = typeof patch?.assistantID === 'string' && patch.assistantID.trim()
+                ? patch.assistantID.trim()
+                : row.assistant_id;
+              let lastError = null;
+              for (let attempt = 0; attempt < 2; attempt++) {
+                const current = output(editable(assistantID));
+                if (!Object.prototype.hasOwnProperty.call(patch, 'defaultPrompt')) {
+                  fail('validation_error');
+                }
+                const nextPrompt = normalizePrompt(patch.defaultPrompt);
+                if (current.defaultPrompt === nextPrompt) {
+                  return {
+                    updated: false,
+                    unchanged: true,
+                    defaultPrompt: current.defaultPrompt,
+                    assistant: current,
+                  };
+                }
+                // Yield so a concurrent UI PATCH can land before CAS (and tests can inject).
+                await Promise.resolve();
+                try {
+                  const updated = await updateAssistant(assistantID, {
+                    expectedRevision: current.revision,
+                    defaultPrompt: nextPrompt,
+                  });
+                  return {
+                    updated: true,
+                    defaultPrompt: updated.defaultPrompt,
+                    assistant: updated,
+                  };
+                } catch (error) {
+                  lastError = error;
+                  if (error?.code !== 'revision_conflict') throw error;
+                }
+              }
+              throw lastError;
+            },
             currentAssistant: assistantSnapshot,
             onCard: (card) => assignedCards.push(card),
             turnFileParts,
             turnAttachmentScope,
           });
+          controller.signal.throwIfAborted();
           const generated = await runContactTurn({
+            signal: controller.signal,
             assistant: assistantSnapshot,
             history: executionHistory,
             userText,
             userParts: executionParts,
+            language,
             createChatCompletion,
             tools,
             projects: registeredProjects,
-            connectedModels,
+            ...modelContext,
             globalEventHub,
             onBubbleDelta: (bubbleIndex, delta, done) => {
+              if (controller.signal.aborted) return;
               emitContactTurnEvent('openchamber:contact-bubble-delta', {
                 assistantID: row.assistant_id,
                 turnID,
@@ -1504,6 +2463,7 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
               });
             },
           });
+          if (controller.signal.aborted) { finishCancelled(); return; }
           if (closed) {
             settleActiveContactTurn(row.assistant_id, turnID, { bumpRevision: true });
             resolveContactTurnSettlement(messageID, { status: 'error', error: 'closed' });
@@ -1590,6 +2550,7 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
           });
           resolveContactTurnSettlement(messageID, { status: 'complete' });
         } catch (error) {
+          if (controller.signal.aborted) { finishCancelled(); return; }
           const detail = typeof error?.message === 'string' && error.message.trim()
             ? error.message.trim()
             : (error?.code || 'upstream_error');
@@ -1619,6 +2580,8 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
             body: detail,
           });
           resolveContactTurnSettlement(messageID, { status: 'error', error: detail, code: statusCode });
+        } finally {
+          contactControllers.delete(messageID);
         }
       });
     };
@@ -1698,6 +2661,9 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
       deleteContactMessages(db, row.assistant_id, {
         ...(upToOrdinal !== undefined ? { upToOrdinal } : {}),
       });
+      // Rebind read watermark to the new generation at empty cursor so post-wipe
+      // confirm bubbles can surface as unread; stale generation mark-read fails closed.
+      resetContactReadWatermarkForGeneration(db, row.assistant_id, generation, { updatedAt: now() });
       // Active contact turns stay until settle — wipe must not drop the green
       // dot while the clearing turn is still running.
       bump();
@@ -1708,6 +2674,48 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
       throw error;
     }
   };
+  /**
+   * Advance the shared contact read watermark (multi-client).
+   * Body: { generation, ordinal, messageID } — must match live generation;
+   * only monotonic forward moves bump revision / assistants-changed.
+   * Idempotent no-op when unchanged (no broadcast).
+   */
+  const markContactRead = (assistantID, input = {}) => {
+    const row = editable(assistantID);
+    if (!plainObject(input)) fail('validation_error');
+    db.exec('BEGIN IMMEDIATE');
+    try {
+      let advanced;
+      try {
+        advanced = advanceContactReadWatermark(db, row.assistant_id, {
+          generation: input.generation,
+          ordinal: input.ordinal,
+          messageID: input.messageID,
+        }, { updatedAt: now() });
+      } catch (error) {
+        if (error?.code === 'contact_generation_conflict' || error?.code === 'validation_error') {
+          fail(error.code, error.message);
+        }
+        throw error;
+      }
+      let tipRevision = revision();
+      if (advanced.changed) {
+        tipRevision = bump();
+      }
+      db.exec('COMMIT');
+      return {
+        assistantID: row.assistant_id,
+        changed: advanced.changed,
+        unreadCount: advanced.unreadCount,
+        readWatermark: advanced.readWatermark,
+        readTip: advanced.readTip,
+        revision: tipRevision,
+      };
+    } catch (error) {
+      db.exec('ROLLBACK');
+      throw error;
+    }
+  };
   const appendContactCard = (assistantID, input) => {
     const row = active(assistantID);
     const card = parseContactCard({ type: 'card', ...input, cardType: input?.cardType || 'session' });
@@ -1819,7 +2827,28 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
     };
     return mode === 'stateless' ? inStatelessLane(deliveryTarget.assistantID, submit) : submit();
   };
-  const abort = 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'); const result = await client().session.abort({ sessionID: row.current_session_id, directory: effectiveWorkspace(row) }); if (isMissing(result)) fail('not_found'); if (result.error) fail('upstream_error'); return { binding: binding(row), aborted: true }; };
+  const abort = async (assistantID, input) => {
+    const row = active(assistantID);
+    if (!plainObject(input) || input.sessionID !== row.current_session_id || input.sessionGeneration !== row.session_generation) fail('revision_conflict');
+    let interrupted = false;
+    for (const turn of contactControllers.values()) {
+      if (turn.assistantID !== assistantID) continue;
+      turn.controller.abort();
+      interrupted = true;
+    }
+    for (const turn of assignedResumes.values()) {
+      if (turn.assistantID !== assistantID) continue;
+      turn.controller.abort();
+      interrupted = true;
+    }
+    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) });
+    if (isMissing(result)) fail('not_found');
+    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; } };
@@ -1886,12 +2915,19 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
   });
   const snapshot = () => {
     const rows = db.prepare('SELECT * FROM assistant_v2 WHERE tombstone_at IS NULL ORDER BY created_at').all();
+    const assistantIDs = rows.map((row) => row.assistant_id);
     // Per-assistant indexed LIMIT probes + one parts batch (catalog ≤100).
-    const previews = getLatestContactMessagePreviews(db, rows.map((row) => row.assistant_id));
+    const previews = getLatestContactMessagePreviews(db, assistantIDs);
+    // Batch unread/watermark/tip — no per-assistant N+1 on snapshot.
+    const unreadByID = getContactUnreadSnapshots(db, assistantIDs);
     return {
       revision: revision(),
       enabled: enabled(),
-      assistants: rows.map((row) => output(row, previews.get(row.assistant_id) ?? null)),
+      assistants: rows.map((row) => output(
+        row,
+        previews.get(row.assistant_id) ?? null,
+        unreadByID.get(row.assistant_id) ?? null,
+      )),
     };
   };
   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) => {
@@ -1905,7 +2941,9 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
       db.prepare('DELETE FROM assistant_message_backfill WHERE assistant_id=?').run(assistantID);
       db.prepare('DELETE FROM assistant_scheduled_task WHERE assistant_id=?').run(assistantID);
       deleteContactMessages(db, assistantID);
+      deleteContactReadState(db, assistantID);
       clearActiveContactTurns(assistantID);
+      contactTurnLanguages.delete(assistantID);
       bump();
       db.exec('COMMIT');
       return { assistantID, tombstoneAt: now() };
@@ -1913,11 +2951,14 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
       db.exec('ROLLBACK');
       throw error;
     }
-  }, ensure, createNew, compact, send, whenContactTurnSettled, abort, captureQueueDeliveryTarget, sendWithCapturedConfig, share, shareOperation, historicalMessages, contactMessages, clearContactMemory, resetContact, appendContactCard, deliverPeerMessage, listAssistantScheduledTasks, putAssistantContactAttachment, getAssistantContactAttachment, migrateContactAttachments, processEvent, reportAssignedSessionSettle: reportAssignedSession, reconcile,   close: () => {
+  }, 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({});
+    for (const turn of contactControllers.values()) turn.controller.abort();
     if (!closed) {
       closed = true;
       try { contactAttachmentMigration.controller.abort(); } catch { /* ignore */ }
       clearActiveContactTurns();
+      contactTurnLanguages.clear();
       unsubscribeEvents?.();
       clearIntervalFn(timer);
       db.close();