@openchambery/web 1.19.13 → 1.19.15-beta.1

package/server/lib/assistants/service.js

@@ -10,22 +10,30 @@ import { contactCardIdentity, parseContactCard, parseContactPart } from './cards
 import {
   CONTACT_PAGE_DEFAULT_LIMIT,
   CONTACT_PAGE_MAX_LIMIT,
+  advanceContactReadWatermark,
   bumpContactGeneration,
   clearContactMemory as clearContactMemoryStore,
   contactHistoryForLlm,
   createActiveContactTurn,
   deleteContactMessages,
+  deleteContactReadState,
+  deleteContactTurnAssistantOutputs,
   ensureContactSchema,
   contactPartsFingerprint,
   getContactMessage,
+  getContactReadTip,
+  getContactReadWatermark,
+  getContactUnreadSnapshots,
   getLatestContactMessagePreview,
   getLatestContactMessagePreviews,
   insertContactMessage,
   listContactMessages,
   listInFlightWatches,
   listWatchesBySession,
+  migrateContactReadStateDefaultRead,
   nextContactOrdinal,
   projectActiveContactTurn,
+  resetContactReadWatermarkForGeneration,
   updateSessionCardStatus,
   upsertContactWatch,
 } from './contact-store.js';
@@ -63,7 +71,10 @@ import {
   ASSIGN_CODES,
   assignSession,
   attachmentScopeKey,
+  extractSessionDirectory,
+  extractSessionTitle,
   hasAssignImageParts,
+  mapSessionToWatchStatus,
   resolveAssignDirectory,
   extractAssignSessionModel,
   resolveAssignWorkerModel,
@@ -73,7 +84,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();
@@ -130,10 +141,11 @@ const promptAdmitted = (result) => !result?.error && (result?.response?.status =
 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. */
+/** Stable resume turn/message id for assigned-session complete/error/cancelled continuation. */
 export const assignedSessionResumeMessageID = (assistantID, sessionID, status, updatedAt) => (
   `resume_${assistantID}_${sessionID}_${status}_${updatedAt}`
 );
+const assignedSessionResumeStatus = (status) => status === 'complete' || status === 'error' || status === 'cancelled';
 const awaitWithDeadline = async (work, ms = CONTACT_CATALOG_DEADLINE_MS, code = 'upstream_error') => {
   let timer = null;
   try {
@@ -152,7 +164,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 });
@@ -289,12 +301,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,
@@ -321,6 +340,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,
@@ -386,6 +411,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();
@@ -460,8 +488,43 @@ 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, statuses } = {}) => {
+    for (const resume of assignedResumes.values()) {
+      if (sessionID && resume.sessionID !== sessionID) continue;
+      if (assistantID && resume.assistantID !== assistantID) continue;
+      if (statuses && !statuses.includes(resume.status)) continue;
+      resume.controller.abort();
+    }
+  };
+  // Abort-request lifecycle only (stop_session). Concurrent same-session aborts share one promise.
+  // Observed SSE terminals are stashed until abort settles so resume=true cannot beat resume=false.
+  const sessionAbortInflight = new Map();
+  const abortTerminalRank = (status) => {
+    if (status === 'cancelled') return 3;
+    if (status === 'error') return 2;
+    if (status === 'complete') return 1;
+    return 0;
+  };
+  const stashSessionAbortTerminal = (entry, status, resume) => {
+    if (!entry || typeof status !== 'string' || !status) return;
+    const nextRank = abortTerminalRank(status);
+    if (nextRank <= 0) return;
+    const prev = entry.observed;
+    const prevRank = prev ? abortTerminalRank(prev.status) : -1;
+    // cancelled wins over complete/error; error wins over complete; equal rank keeps latest.
+    if (nextRank > prevRank || (nextRank === prevRank && (status === 'cancelled' || nextRank > 0))) {
+      entry.observed = { status, resume: resume !== false };
+      if (status === 'cancelled') entry.observed.resume = resume !== false;
+    }
+  };
   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') {
@@ -471,10 +534,20 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
     }
     return null;
   };
-  // Assigned-session complete/error resumes the contact LLM (no canned settle bubble).
+  // 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) => {
+  const reportAssignedSession = (sessionID, status, resume = true) => {
+    const inflight = sessionAbortInflight.get(sessionID);
+    if (inflight) {
+      // Defer watch terminal + continuation until stop_session abort settles.
+      stashSessionAbortTerminal(inflight, status, resume);
+      return false;
+    }
+    // Drop complete/error notifies for this worker. Do not abort a cancelled
+    // interrupt notify — duplicate cancelled reports (boot+timer, error+message.updated)
+    // must still reach the contact LLM.
+    if (status === 'cancelled') cancelAssignedResumes({ sessionID, statuses: ['complete', 'error'] });
     const watches = listWatchesBySession(db, sessionID);
     if (watches.length === 0) return false;
     let changed = false;
@@ -482,7 +555,7 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
     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();
@@ -493,10 +566,12 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
           directory: watch.directory,
           status,
           updatedAt,
+          resumeAllowed: watch.resumeAllowed,
         });
-        // complete/error: hand result back to contact LLM. question: card only (worker waiting).
+        // complete/error/user-interrupt cancelled: hand result back to contact LLM.
+        // question: card only (worker waiting). stop_session passes resume=false.
         // Never insert oc.settle.* canned transcript bubbles.
-        if (status === 'complete' || status === 'error') {
+        if (resume && watch.resumeAllowed && assignedSessionResumeStatus(status)) {
           resumes.push({
             assistantID: watch.assistantID,
             sessionID,
@@ -537,12 +612,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;
@@ -596,7 +671,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;
@@ -835,7 +912,7 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
     if (parts.length === 0 && userText) parts.push({ type: 'text', text: userText });
     return parts;
   };
-  /** Admit the user row only — HTTP 202 returns here; assistant bubbles persist later. */
+  /** Admit the user row only — HTTP 202 returns here; assistant bubbles persist as they publish. */
   const admitContactUser = (assistantID, { userMessageID, userText, userParts, turnID }) => {
     db.exec('BEGIN IMMEDIATE');
     try {
@@ -882,13 +959,135 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
       throw writeError;
     }
   };
-  /** Persist assistant bubbles/cards for an already-admitted user turn (no user row). */
-  const persistContactAssistantReply = (assistantID, { userMessageID, bubbles, cards = [], turnID }) => {
+  const contactBubbleMessageID = (userMessageID, bubbleIndex) => `${userMessageID}:bubble:${bubbleIndex + 1}`;
+  const contactCardMessageID = (userMessageID, index) => `${userMessageID}:card:${index + 1}`;
+
+  const persistPublishedContactBubble = (assistantID, { userMessageID, turnID, bubbleIndex, text }) => {
+    const trimmed = typeof text === 'string' ? text.trim() : '';
+    if (!trimmed || trimmed.startsWith('oc.settle.')) return false;
+    const bubbleID = contactBubbleMessageID(userMessageID, bubbleIndex);
+    if (getContactMessage(db, bubbleID)) return false;
+    db.exec('BEGIN IMMEDIATE');
+    try {
+      if (getContactMessage(db, bubbleID)) {
+        db.exec('COMMIT');
+        return false;
+      }
+      insertContactMessage(db, {
+        messageID: bubbleID,
+        assistantID,
+        role: 'assistant',
+        turnID,
+        bubbleIndex,
+        createdAt: now(),
+        ordinal: nextContactOrdinal(db, assistantID),
+        status: 'complete',
+        parts: [{ type: 'text', text: trimmed }],
+      });
+      bump();
+      db.exec('COMMIT');
+      return true;
+    } catch (error) {
+      db.exec('ROLLBACK');
+      throw error;
+    }
+  };
+
+  const persistPublishedContactCard = (assistantID, { userMessageID, turnID, index, card: cardInput }) => {
+    const card = parseContactCard({ type: 'card', cardType: cardInput?.cardType || 'session', ...cardInput });
+    if (!card) return false;
+    const cardID = contactCardMessageID(userMessageID, index);
+    if (getContactMessage(db, cardID)) return false;
+    db.exec('BEGIN IMMEDIATE');
+    try {
+      if (getContactMessage(db, cardID)) {
+        db.exec('COMMIT');
+        return false;
+      }
+      insertContactMessage(db, {
+        messageID: cardID,
+        assistantID,
+        role: 'assistant',
+        turnID,
+        bubbleIndex: 0,
+        createdAt: now(),
+        ordinal: nextContactOrdinal(db, assistantID),
+        status: 'complete',
+        parts: [card],
+      });
+      if (card.cardType === 'session' && 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(),
+        });
+      }
+      bump();
+      db.exec('COMMIT');
+      return true;
+    } catch (error) {
+      db.exec('ROLLBACK');
+      throw error;
+    }
+  };
+
+  const publishContactBubbleDelta = ({
+    assistantID, turnID, userMessageID, spokenByIndex, bubbleIndex, delta, done, signal,
+  }) => {
+    if (signal?.aborted) return;
+    const chunk = typeof delta === 'string' ? delta : '';
+    if (chunk) spokenByIndex.set(bubbleIndex, `${spokenByIndex.get(bubbleIndex) || ''}${chunk}`);
+    emitContactTurnEvent('openchamber:contact-bubble-delta', {
+      assistantID,
+      turnID,
+      bubbleIndex,
+      delta: chunk,
+      done: Boolean(done),
+    });
+    if (!done) return;
+    try {
+      persistPublishedContactBubble(assistantID, {
+        userMessageID,
+        turnID,
+        bubbleIndex,
+        text: spokenByIndex.get(bubbleIndex) || '',
+      });
+    } catch {
+      // Publishing a spoken bubble must not abort the live turn.
+    }
+  };
+
+  const rememberPublishedContactCard = (assistantID, { userMessageID, turnID, assignedCards, card }) => {
+    assignedCards.push(card);
+    try {
+      persistPublishedContactCard(assistantID, {
+        userMessageID,
+        turnID,
+        index: assignedCards.length - 1,
+        card,
+      });
+    } catch {
+      // Publishing a card must not abort the live turn.
+    }
+  };
+
+  /** Persist remaining assistant bubbles/cards for an already-admitted user turn (no user row). */
+  const persistContactAssistantReply = (assistantID, {
+    userMessageID, bubbles, cards = [], turnID, reset = false,
+  }) => {
     db.exec('BEGIN IMMEDIATE');
     try {
+      // Successful new_conversation / clear_chat_history: drop this turn's pre-reset
+      // spoken/card rows so the unique confirm can own bubble:1 (same id is not skipped).
+      if (reset) {
+        deleteContactTurnAssistantOutputs(db, assistantID, turnID);
+      }
       let ordinal = nextContactOrdinal(db, assistantID);
       bubbles.forEach((text, index) => {
-        const bubbleID = `${userMessageID}:bubble:${index + 1}`;
+        const bubbleID = contactBubbleMessageID(userMessageID, index);
+        if (getContactMessage(db, bubbleID)) return;
         insertContactMessage(db, {
           messageID: bubbleID,
           assistantID,
@@ -905,8 +1104,10 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
       cards.forEach((cardInput, index) => {
         const card = parseContactCard({ type: 'card', cardType: cardInput?.cardType || 'session', ...cardInput });
         if (!card) return;
+        const cardID = contactCardMessageID(userMessageID, index);
+        if (getContactMessage(db, cardID)) return;
         insertContactMessage(db, {
-          messageID: `${userMessageID}:card:${index + 1}`,
+          messageID: cardID,
           assistantID,
           role: 'assistant',
           turnID,
@@ -1005,6 +1206,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)) {
@@ -1097,6 +1315,231 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
       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;
@@ -1110,6 +1553,24 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
     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;
@@ -1127,17 +1588,18 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
         catalog = await loadAssignCatalog(signal);
       }
     }
-    if (followSessionModel && catalog) {
-      const directoryHint = typeof params.directory === 'string' && params.directory.trim()
-        ? params.directory.trim()
-        : (typeof params.projectPath === 'string' && params.projectPath.trim()
-          ? params.projectPath.trim()
-          : null);
-      sessionModel = await lookupReusedSessionModel({
-        sessionID: reuseSessionID,
-        directory: directoryHint,
-        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,
@@ -1158,6 +1620,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 } : {}),
@@ -1184,6 +1656,160 @@ 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();
+    if (typeof client().session.abort !== 'function') {
+      throw new AssignError(ASSIGN_CODES.UPSTREAM, 'Session abort is unavailable.');
+    }
+    const targetID = resolved.sessionID;
+    // Share one abort lifecycle per worker session (register before await abort).
+    const existing = sessionAbortInflight.get(targetID);
+    if (existing?.promise) {
+      const shared = await existing.promise;
+      if (shared?.ok) {
+        return {
+          sessionID: targetID,
+          directory: resolved.directory,
+          title: resolved.title,
+          aborted: true,
+        };
+      }
+      throw shared?.error || new AssignError(ASSIGN_CODES.UPSTREAM, 'Failed to abort that coding session.');
+    }
+    const entry = { sessionID: targetID, observed: null, promise: null };
+    sessionAbortInflight.set(targetID, entry);
+    const failAbort = (code, message) => new AssignError(
+      code,
+      typeof message === 'string' && message.trim() ? message.trim() : 'Failed to abort that coding session.',
+    );
+    entry.promise = (async () => {
+      const sdkOptions = signal ? { signal } : undefined;
+      let result;
+      try {
+        signal?.throwIfAborted();
+        result = await client().session.abort({
+          sessionID: targetID,
+          directory: resolved.directory,
+        }, sdkOptions);
+      } catch (error) {
+        const observed = entry.observed;
+        if (sessionAbortInflight.get(targetID) === entry) sessionAbortInflight.delete(targetID);
+        if (observed) reportAssignedSession(targetID, observed.status, observed.resume !== false);
+        const wrapped = error?.name === 'AbortError' || signal?.aborted
+          ? error
+          : failAbort(
+            ASSIGN_CODES.UPSTREAM,
+            typeof error?.message === 'string' ? error.message : '',
+          );
+        return { ok: false, error: wrapped };
+      }
+      if (isMissing(result)) {
+        const observed = entry.observed;
+        if (sessionAbortInflight.get(targetID) === entry) sessionAbortInflight.delete(targetID);
+        if (observed) reportAssignedSession(targetID, observed.status, observed.resume !== false);
+        return { ok: false, error: failAbort(ASSIGN_CODES.NOT_FOUND, `No coding session ${targetID} was found.`) };
+      }
+      if (result?.error || result?.data === false) {
+        const observed = entry.observed;
+        if (sessionAbortInflight.get(targetID) === entry) sessionAbortInflight.delete(targetID);
+        if (observed) reportAssignedSession(targetID, observed.status, observed.resume !== false);
+        return {
+          ok: false,
+          error: failAbort(
+            ASSIGN_CODES.UPSTREAM,
+            typeof result.error?.message === 'string' ? result.error.message : '',
+          ),
+        };
+      }
+      // Success (including silent abort with no SSE): release map first so reporter applies.
+      if (sessionAbortInflight.get(targetID) === entry) sessionAbortInflight.delete(targetID);
+      cancelAssignedResumes({ sessionID: targetID });
+      // Assistant already owns this user turn; do not schedule a second cancelled notify.
+      reportAssignedSession(targetID, 'cancelled', false);
+      return { ok: true };
+    })();
+    try {
+      const outcome = await entry.promise;
+      if (outcome?.ok) {
+        return {
+          sessionID: targetID,
+          directory: resolved.directory,
+          title: resolved.title,
+          aborted: true,
+        };
+      }
+      throw outcome?.error || failAbort(ASSIGN_CODES.UPSTREAM, '');
+    } finally {
+      if (sessionAbortInflight.get(targetID) === entry) sessionAbortInflight.delete(targetID);
+    }
+  };
+  // 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);
@@ -1457,6 +2083,12 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
       `sessionID: ${sessionID}`,
       `status: ${status}`,
     ];
+    if (status === 'cancelled') {
+      lines.push(
+        'reason: user_interrupted',
+        'The user manually interrupted this assigned worker session (OpenCode session.abort / MessageAbortedError). This is not a model failure and not an assistant-initiated stop_session.',
+      );
+    }
     if (title) lines.push(`cardTitle: ${title}`);
     if (workerText) {
       lines.push('lastWorkerAssistantText (bounded):');
@@ -1466,19 +2098,28 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
     }
     lines.push(
       'Instructions:',
-      '- Never tell the user canned phrases like "会话已完成" / "Session finished" / "会话失败" / "Session failed".',
-      '- If more coding work is needed, call assign_session with the SAME sessionID and omit model args so the prior worker model is reused.',
-      '- If no further work is needed, reply in one or two short sentences in the user\'s language summarizing the result or failure reason.',
+      '- Never tell the user canned phrases like "会话已完成" / "Session finished" / "会话失败" / "Session failed" / "会话已取消" / "Session cancelled".',
+      '- 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 (status === 'cancelled') {
+      lines.push(
+        '- The user interrupted this worker themselves. In the user\'s language, acknowledge that interruption and decide the next spoken step (usually stop here and wait). Do not restart the worker unless history already asked you to.',
+      );
+    } else {
+      lines.push(
+        '- 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.
+   * After assigned worker complete/error/cancelled: 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;
+    if (!assignedSessionResumeStatus(status)) return;
     const row = assistant(assistantID);
     if (!row || row.tombstone_at) return;
     const messageID = assignedSessionResumeMessageID(assistantID, sessionID, status, updatedAt);
@@ -1489,6 +2130,15 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
       || getContactMessage(db, `${messageID}:error`)
     ) return;
 
+    if (assignedResumes.has(messageID)) return;
+    const controller = new AbortController();
+    assignedResumes.set(messageID, { assistantID, sessionID, status, 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,
@@ -1505,6 +2155,7 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
     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' });
@@ -1532,13 +2183,7 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
       } catch {
         registeredProjects = [];
       }
-      let connectedModels = [];
-      try {
-        const catalog = await loadAssignCatalog(undefined);
-        connectedModels = normalizeConnectedModels(catalog?.models);
-      } catch {
-        connectedModels = [];
-      }
+      const modelContext = await loadContactModelContext(controller.signal);
 
       let workerText = '';
       try {
@@ -1560,6 +2205,13 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
             const rows = Array.isArray(messagesResult?.data)
               ? messagesResult.data
               : (Array.isArray(messagesResult) ? messagesResult : []);
+            // complete/error that discovers a user abort becomes cancelled + notify.
+            // A cancelled resume must still run with reason: user_interrupted.
+            if (status !== 'cancelled' && isUserAbort(lastAssistantInfo(rows)?.error)) {
+              reportAssignedSession(sessionID, 'cancelled');
+              finishCancelled();
+              return;
+            }
             workerText = extractLastWorkerAssistantText(rows);
           }
         }
@@ -1567,6 +2219,7 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
         workerText = '';
       }
 
+      if (controller.signal.aborted) { finishCancelled(); return; }
       const title = findAssignedSessionCardTitle(assistantID, sessionID);
       const userText = buildAssignedSessionResumeUserText({
         sessionID,
@@ -1575,9 +2228,16 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
         workerText,
       });
       const history = contactHistoryForLlm(db, assistantID, {});
-      const assignedCards = [];
-      let contactResetThisTurn = false;
-      let contactHistoryClearedThisTurn = false;
+        const assignedCards = [];
+        const spokenByIndex = new Map();
+        let contactResetThisTurn = false;
+        let contactHistoryClearedThisTurn = false;
+        const markContactReset = (historyCleared = false) => {
+          contactResetThisTurn = true;
+          if (historyCleared) contactHistoryClearedThisTurn = true;
+          spokenByIndex.clear();
+          assignedCards.length = 0;
+        };
 
       try {
         const executionHistory = await materializeContactHistory(
@@ -1589,23 +2249,28 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
         );
         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;
+            markContactReset(false);
             return result;
           },
           resetContact: () => {
             const result = resetContact(assistantID, {});
-            contactResetThisTurn = true;
-            contactHistoryClearedThisTurn = true;
+            markContactReset(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()
@@ -1655,30 +2320,37 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
             throw lastError;
           },
           currentAssistant: assistantSnapshot,
-          onCard: (card) => assignedCards.push(card),
+          onCard: (card) => {
+            if (contactResetThisTurn) return;
+            rememberPublishedContactCard(assistantID, {
+              userMessageID: messageID, turnID, assignedCards, 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,
-          connectedModels,
+          ...modelContext,
           globalEventHub,
           onBubbleDelta: (bubbleIndex, delta, done) => {
-            emitContactTurnEvent('openchamber:contact-bubble-delta', {
-              assistantID,
-              turnID,
-              bubbleIndex,
-              delta: typeof delta === 'string' ? delta : '',
-              done: Boolean(done),
+            if (contactResetThisTurn) return;
+            publishContactBubbleDelta({
+              assistantID, turnID, userMessageID: messageID, spokenByIndex, bubbleIndex, delta, done, signal: controller.signal,
             });
           },
         });
+        if (controller.signal.aborted) { finishCancelled(); return; }
         if (closed) {
           settleActiveContactTurn(assistantID, turnID, { bumpRevision: true });
           resolveContactTurnSettlement(messageID, { status: 'error', error: 'closed' });
@@ -1734,6 +2406,7 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
           bubbles: bubbles.length > 0 ? bubbles : [ASSIGNED_SESSION_FALLBACK_BUBBLE],
           cards,
           turnID,
+          reset: resetThisTurn,
         });
         settleActiveContactTurn(assistantID, turnID);
         emitContactTurnEvent('openchamber:contact-turn-end', {
@@ -1751,6 +2424,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');
@@ -1781,7 +2455,7 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
         });
         resolveContactTurnSettlement(messageID, { status: 'error', error: detail, code: statusCode });
       }
-    });
+    }).finally(() => { assignedResumes.delete(messageID); });
   };
   assignedSessionResumeRef.schedule = scheduleAssignedSessionResume;
   /**
@@ -1795,7 +2469,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 = [];
@@ -1825,12 +2501,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,
@@ -1845,6 +2533,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' });
@@ -1865,17 +2554,16 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
           beforeOrdinal,
         });
         const assignedCards = [];
+        const spokenByIndex = new Map();
         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 markContactReset = (historyCleared = false) => {
+          contactResetThisTurn = true;
+          if (historyCleared) contactHistoryClearedThisTurn = true;
+          spokenByIndex.clear();
+          assignedCards.length = 0;
+        };
+        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.
@@ -1900,6 +2588,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),
@@ -1909,7 +2602,7 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
               const result = clearContactMemory(row.assistant_id, {
                 upToOrdinal: beforeOrdinal,
               });
-              contactResetThisTurn = true;
+              markContactReset(false);
               return result;
             },
             resetContact: () => {
@@ -1918,13 +2611,13 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
               const result = resetContact(row.assistant_id, {
                 upToOrdinal: beforeOrdinal,
               });
-              contactResetThisTurn = true;
-              contactHistoryClearedThisTurn = true;
+              markContactReset(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),
             // Live DB read — not the turn-start assistantSnapshot.
             // Optional assistantID targets another live row; omitted → this contact.
             readAssistantSettings: (input = {}) => {
@@ -1978,30 +2671,36 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
               throw lastError;
             },
             currentAssistant: assistantSnapshot,
-            onCard: (card) => assignedCards.push(card),
+            onCard: (card) => {
+              if (contactResetThisTurn) return;
+              rememberPublishedContactCard(row.assistant_id, {
+                userMessageID: messageID, turnID, assignedCards, 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) => {
-              emitContactTurnEvent('openchamber:contact-bubble-delta', {
-                assistantID: row.assistant_id,
-                turnID,
-                bubbleIndex,
-                delta: typeof delta === 'string' ? delta : '',
-                done: Boolean(done),
+              if (contactResetThisTurn) return;
+              publishContactBubbleDelta({
+                assistantID: row.assistant_id, turnID, userMessageID: messageID, spokenByIndex, bubbleIndex, delta, done, signal: controller.signal,
               });
             },
           });
+          if (controller.signal.aborted) { finishCancelled(); return; }
           if (closed) {
             settleActiveContactTurn(row.assistant_id, turnID, { bumpRevision: true });
             resolveContactTurnSettlement(messageID, { status: 'error', error: 'closed' });
@@ -2070,6 +2769,7 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
             bubbles: bubbles.length > 0 ? bubbles : [ASSIGNED_SESSION_FALLBACK_BUBBLE],
             cards,
             turnID,
+            reset: resetThisTurn,
           });
           // persistContactAssistantReply already bumps; clear activity without a second tip.
           settleActiveContactTurn(row.assistant_id, turnID);
@@ -2088,6 +2788,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');
@@ -2117,6 +2818,8 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
             body: detail,
           });
           resolveContactTurnSettlement(messageID, { status: 'error', error: detail, code: statusCode });
+        } finally {
+          contactControllers.delete(messageID);
         }
       });
     };
@@ -2196,6 +2899,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();
@@ -2206,6 +2912,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' });
@@ -2317,7 +3065,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; } };
@@ -2384,12 +3153,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) => {
@@ -2403,7 +3179,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() };
@@ -2411,11 +3189,15 @@ 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({});
+    sessionAbortInflight.clear();
+    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();