@openchambery/web 1.19.12 → 1.19.13-beta.2

package/server/lib/assistants/service.test.js

@@ -12,10 +12,53 @@ import {
 
 const require = createRequire(import.meta.url);
 const root = () => fs.mkdtempSync(path.join(os.tmpdir(), 'assistants-'));
+/** Minimal valid 1×1 PNG (strict data-URL / image magic fixtures). */
+const FIXTURE_PNG = Buffer.from([
+  0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a,
+  0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
+  0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+  0x08, 0x02, 0x00, 0x00, 0x00, 0x90, 0x77, 0x53,
+  0xde, 0x00, 0x00, 0x00, 0x0c, 0x49, 0x44, 0x41,
+  0x54, 0x08, 0xd7, 0x63, 0xf8, 0xcf, 0xc0, 0x00,
+  0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x05, 0xfe,
+  0xd4, 0xef, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45,
+  0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
+]);
+const FIXTURE_PNG_DATA_URL = `data:image/png;base64,${FIXTURE_PNG.toString('base64')}`;
+/** Valid text/plain data URL body "x". */
+const FIXTURE_TEXT_DATA_URL = 'data:text/plain;base64,eA==';
 // Behavioral tests enable the global switch after boot; pass enabled:false to assert the fresh-install default.
 const setup = (directory = root(), client = {}, options = {}) => {
   const { enabled = true, ...serviceOptions } = options;
-  const service = createAssistantsService({ dbPath: path.join(directory, 'assistants.sqlite'), dataDir: directory, getAllowedRoots: () => [directory], buildOpenCodeUrl: () => 'http://127.0.0.1:1', getOpenCodeAuthHeaders: () => ({}), clientFactory: () => ({ session: { create: async () => ({ data: { id: crypto.randomUUID() } }), get: async () => ({ data: { id: 'present' } }), update: async () => ({ data: { id: 'archived' } }), promptAsync: async () => ({ data: { info: { id: 'msg_1' } } }), summarize: async () => ({ data: true }), ...client } }), runContactTurn: serviceOptions.runContactTurn ?? (async ({ userText }) => ({ text: `reply:${userText}`, bubbles: [`reply:${userText}`] })), ...serviceOptions });
+  const {
+    provider = undefined,
+    config = undefined,
+    session: sessionOverrides = {},
+    ...sessionClient
+  } = client && typeof client === 'object' ? client : {};
+  const service = createAssistantsService({
+    dbPath: path.join(directory, 'assistants.sqlite'),
+    dataDir: directory,
+    getAllowedRoots: () => [directory],
+    buildOpenCodeUrl: () => 'http://127.0.0.1:1',
+    getOpenCodeAuthHeaders: () => ({}),
+    clientFactory: () => ({
+      session: {
+        create: async () => ({ data: { id: crypto.randomUUID() } }),
+        get: async () => ({ data: { id: 'present' } }),
+        update: async () => ({ data: { id: 'archived' } }),
+        promptAsync: async () => ({ data: { info: { id: 'msg_1' } } }),
+        summarize: async () => ({ data: true }),
+        delete: async () => ({ data: true }),
+        ...sessionClient,
+        ...sessionOverrides,
+      },
+      ...(provider ? { provider } : {}),
+      ...(config ? { config } : {}),
+    }),
+    runContactTurn: serviceOptions.runContactTurn ?? (async ({ userText }) => ({ text: `reply:${userText}`, bubbles: [`reply:${userText}`] })),
+    ...serviceOptions,
+  });
   if (enabled) {
     const snapshot = service.snapshot();
     if (!snapshot.enabled) service.setEnabled({ enabled: true, expectedRevision: snapshot.revision });
@@ -83,7 +126,7 @@ describe('assistants service', () => {
     const assistant = service.createAssistant(assistantInput);
     const current = await service.ensure(assistant.id);
     const sent = await service.send(assistant.id, { ...current, messageID: 'client_1', parts: [{ type: 'text', text: 'hello' }] });
-    expect(sent).toEqual({ binding: current, messageID: 'client_1', admitted: true });
+    expect(sent).toEqual({ binding: current, messageID: 'client_1', admitted: true, revision: expect.any(Number) });
     // Admission resolves before the async turn persists assistant bubbles.
     expect(service.contactMessages(assistant.id, { limit: 50 }).messages.map((message) => ({ role: message.role, text: message.text }))).toEqual([
       { role: 'user', text: 'hello' },
@@ -101,6 +144,80 @@ describe('assistants service', () => {
     service.close();
   });
 
+  it('exposes latestMessagePreview on create/update/snapshot from contact transcript', async () => {
+    const directory = root();
+    const service = setup(directory, {}, {
+      runContactTurn: async ({ userText }) => ({ text: `ok ${userText}`, bubbles: [`ok ${userText}`] }),
+    });
+    const created = service.createAssistant(assistantInput);
+    expect(created.latestMessagePreview).toBeNull();
+    expect(service.snapshot().assistants[0].latestMessagePreview).toBeNull();
+
+    await settleSend(service, created.id, { messageID: 'prev_u1', parts: [{ type: 'text', text: 'hello preview' }] });
+    const afterUser = service.snapshot().assistants[0].latestMessagePreview;
+    // After turn settle the assistant reply is newest.
+    expect(afterUser).toMatchObject({
+      role: 'assistant',
+      text: 'ok hello preview',
+      fallbackKind: null,
+    });
+    expect(typeof afterUser.messageID).toBe('string');
+    expect(Number.isFinite(afterUser.ordinal)).toBe(true);
+
+    const updated = await service.updateAssistant(created.id, {
+      expectedRevision: service.snapshot().assistants[0].revision,
+      name: 'Renamed',
+    });
+    expect(updated.latestMessagePreview).toMatchObject({ text: 'ok hello preview', role: 'assistant' });
+
+    // Clear-memory keeps transcript → preview stays on last bubble.
+    const memServiceClose = service;
+    // use existing service with clear tool path
+    memServiceClose.close();
+    const service2 = setup(directory, {}, {
+      runContactTurn: async ({ userText, tools }) => {
+        if (userText === '开新对话') {
+          await tools.find((item) => item.name === 'new_conversation').execute('mem', {});
+          return { text: NEW_CONVERSATION_CONFIRM_BUBBLE, bubbles: [NEW_CONVERSATION_CONFIRM_BUBBLE], reset: true };
+        }
+        if (userText === '清空聊天记录') {
+          const tool = tools.find((item) => item.name === 'clear_chat_history');
+          const result = await tool.execute('wipe', {});
+          return {
+            text: result.content[0].text,
+            bubbles: [result.content[0].text],
+            reset: true,
+            historyCleared: true,
+            messages: [{ role: 'toolResult', toolName: 'clear_chat_history', details: result.details }],
+          };
+        }
+        return { text: `ok ${userText}`, bubbles: [`ok ${userText}`] };
+      },
+    });
+    const id = service2.snapshot().assistants[0].id;
+    expect(service2.snapshot().assistants[0].latestMessagePreview?.text).toBe('ok hello preview');
+    await settleSend(service2, id, { messageID: 'prev_mem', parts: [{ type: 'text', text: '开新对话' }] });
+    expect(service2.snapshot().assistants[0].latestMessagePreview?.text).toBe(NEW_CONVERSATION_CONFIRM_BUBBLE);
+    // Transcript still has older rows after clear-memory.
+    expect(service2.contactMessages(id, { limit: 50 }).messages.some((m) => m.text === 'hello preview')).toBe(true);
+
+    await settleSend(service2, id, { messageID: 'prev_wipe', parts: [{ type: 'text', text: '清空聊天记录' }] });
+    expect(service2.snapshot().assistants[0].latestMessagePreview).toMatchObject({
+      text: CLEAR_CHAT_HISTORY_CONFIRM_BUBBLE,
+      role: 'assistant',
+    });
+    expect(service2.contactMessages(id, { limit: 50 }).messages.some((m) => m.text === 'hello preview')).toBe(false);
+
+    service2.close();
+    const cold = setup(directory, {}, {
+      runContactTurn: async ({ userText }) => ({ text: `ok ${userText}`, bubbles: [`ok ${userText}`] }),
+    });
+    expect(cold.snapshot().assistants[0].latestMessagePreview).toMatchObject({
+      text: CLEAR_CHAT_HISTORY_CONFIRM_BUBBLE,
+    });
+    cold.close();
+  });
+
   it('new_conversation clears LLM memory while keeping the full transcript', async () => {
     const directory = root();
     let creates = 0;
@@ -169,8 +286,8 @@ describe('assistants service', () => {
       messageID: 'attach_1',
       parts: [
         { type: 'text', text: 'look at these' },
-        { type: 'file', mime: 'image/png', url: 'data:image/png;base64,aa', filename: 'dot.png' },
-        { type: 'file', mime: 'text/plain', url: 'data:text/plain;base64,eA==', filename: 'note.txt' },
+        { type: 'file', mime: 'image/png', url: FIXTURE_PNG_DATA_URL, filename: 'dot.png' },
+        { type: 'file', mime: 'text/plain', url: FIXTURE_TEXT_DATA_URL, filename: 'note.txt' },
       ],
     });
     await settleSend(service, assistant.id, { messageID: 'reset_leftover', parts: [{ type: 'text', text: '开新对话' }] });
@@ -222,11 +339,13 @@ describe('assistants service', () => {
       assistantID: assistant.id,
       reset: true,
       historyCleared: true,
+      generation: 1,
     });
     expect(creates).toBe(1);
     expect(service.contactMessages(assistant.id, { limit: 50 })).toMatchObject({
       messages: [],
       complete: true,
+      generation: 1,
     });
     await settleSend(service, assistant.id, { messageID: 'again_1', parts: [{ type: 'text', text: 'hello again' }] });
     await settleSend(service, assistant.id, { messageID: 'wipe_1', parts: [{ type: 'text', text: '清空聊天记录' }] });
@@ -249,22 +368,26 @@ describe('assistants service', () => {
     service.close();
   });
 
-  it('rejects malicious clear_chat_history without explicit wipe intent and keeps transcript', async () => {
+  it('clear_chat_history executes when the model calls it without a user-text auth gate', async () => {
     const directory = root();
     const wipeAttempts = [];
     const service = setup(directory, {}, {
       runContactTurn: async ({ userText, tools }) => {
-        if (userText === '清除记忆' || userText === '不要清除聊天记录') {
+        if (userText === '请处理一下') {
           const tool = tools.find((item) => item.name === 'clear_chat_history');
-          const result = await tool.execute(`malicious_${userText}`, {});
+          const result = await tool.execute('model_chose_wipe', {});
           wipeAttempts.push({
-            userText,
             error: result.details?.error || null,
+            denied: result.details?.denied === true,
             historyCleared: result.details?.historyCleared === true,
+            terminate: result.terminate,
+            text: result.content?.[0]?.text,
           });
           return {
-            text: `blocked:${userText}`,
-            bubbles: [`blocked:${userText}`],
+            text: result.content[0].text,
+            bubbles: [result.content[0].text],
+            reset: true,
+            historyCleared: true,
             messages: [{
               role: 'toolResult',
               toolName: 'clear_chat_history',
@@ -277,17 +400,187 @@ describe('assistants service', () => {
     });
     const assistant = service.createAssistant(assistantInput);
     await settleSend(service, assistant.id, { messageID: 'seed_keep', parts: [{ type: 'text', text: 'keep-me' }] });
-    await settleSend(service, assistant.id, { messageID: 'bad_memory', parts: [{ type: 'text', text: '清除记忆' }] });
-    await settleSend(service, assistant.id, { messageID: 'bad_negation', parts: [{ type: 'text', text: '不要清除聊天记录' }] });
-    expect(wipeAttempts).toEqual([
-      { userText: '清除记忆', error: 'validation_error', historyCleared: false },
-      { userText: '不要清除聊天记录', error: 'validation_error', historyCleared: false },
-    ]);
+    await settleSend(service, assistant.id, { messageID: 'model_wipe', parts: [{ type: 'text', text: '请处理一下' }] });
+    expect(wipeAttempts).toEqual([{
+      error: null,
+      denied: false,
+      historyCleared: true,
+      terminate: true,
+      text: CLEAR_CHAT_HISTORY_CONFIRM_BUBBLE,
+    }]);
     const texts = service.contactMessages(assistant.id, { limit: 50 }).messages.map((message) => message.text);
-    expect(texts).toContain('keep-me');
-    expect(texts).toContain('清除记忆');
-    expect(texts).toContain('不要清除聊天记录');
-    expect(texts).not.toContain(CLEAR_CHAT_HISTORY_CONFIRM_BUBBLE);
+    expect(texts).not.toContain('keep-me');
+    expect(texts).toEqual(['请处理一下', CLEAR_CHAT_HISTORY_CONFIRM_BUBBLE]);
+    expect(texts.some((text) => /not cleared|denied|new_conversation instead/i.test(text))).toBe(false);
+    service.close();
+  });
+
+  it('tool wipe keeps later-admitted queued B and replays B only once', async () => {
+    const directory = root();
+    const turnRuns = [];
+    let aReachedTurn;
+    const aReachedGate = new Promise((resolve) => { aReachedTurn = resolve; });
+    let bAdmitted;
+    const bAdmittedGate = new Promise((resolve) => { bAdmitted = resolve; });
+    const service = setup(directory, {}, {
+      runContactTurn: async ({ userText, tools }) => {
+        turnRuns.push(userText);
+        if (userText === '清空聊天记录') {
+          aReachedTurn();
+          await bAdmittedGate;
+          const tool = tools.find((item) => item.name === 'clear_chat_history');
+          const result = await tool.execute('wipe_queue_a', {});
+          return {
+            text: result.content[0].text,
+            bubbles: [result.content[0].text],
+            reset: true,
+            historyCleared: true,
+            messages: [{
+              role: 'toolResult',
+              toolName: 'clear_chat_history',
+              details: result.details,
+            }],
+          };
+        }
+        return { text: `reply:${userText}`, bubbles: [`reply:${userText}`] };
+      },
+    });
+    const assistant = service.createAssistant(assistantInput);
+    await settleSend(service, assistant.id, { messageID: 'seed_queue', parts: [{ type: 'text', text: 'seed before wipe' }] });
+    // A pause -> B admission -> A wipe -> B complete -> replay B once.
+    const aSend = service.send(assistant.id, { messageID: 'wipe_a', parts: [{ type: 'text', text: '清空聊天记录' }] });
+    await aReachedGate;
+    const bSend = service.send(assistant.id, { messageID: 'queued_b', parts: [{ type: 'text', text: 'queued B keep me' }] });
+    await bSend;
+    bAdmitted();
+    await aSend;
+    await service.whenContactTurnSettled('wipe_a');
+    await service.whenContactTurnSettled('queued_b');
+    // Same messageID + payload replays admission only — no second lane run.
+    const replay = await service.send(assistant.id, { messageID: 'queued_b', parts: [{ type: 'text', text: 'queued B keep me' }] });
+    expect(replay).toMatchObject({ admitted: true, replayed: true, messageID: 'queued_b' });
+    const page = service.contactMessages(assistant.id, { limit: 50 });
+    const texts = page.messages.map((message) => message.text);
+    expect(texts).not.toContain('seed before wipe');
+    expect(texts).toContain('queued B keep me');
+    expect(texts).toContain('reply:queued B keep me');
+    expect(texts).toContain(CLEAR_CHAT_HISTORY_CONFIRM_BUBBLE);
+    // Wipe user kept in place (no re-admit reorder before B).
+    const wipeIdx = page.messages.findIndex((message) => message.messageID === 'wipe_a');
+    const bIdx = page.messages.findIndex((message) => message.messageID === 'queued_b');
+    expect(wipeIdx).toBeGreaterThanOrEqual(0);
+    expect(bIdx).toBeGreaterThan(wipeIdx);
+    expect(turnRuns.filter((text) => text === 'queued B keep me')).toHaveLength(1);
+    expect(page.messages.filter((message) => message.messageID === 'queued_b')).toHaveLength(1);
+    service.close();
+  });
+
+  it('tool wipe drops late prior-lane assistant/cards after reverse admit order and keeps C once', async () => {
+    const directory = root();
+    const turnRuns = [];
+    const cHistories = [];
+    let aReachedTurn;
+    const aReachedGate = new Promise((resolve) => { aReachedTurn = resolve; });
+    let lateWritten;
+    const lateWrittenGate = new Promise((resolve) => { lateWritten = resolve; });
+    let wipeMayRun;
+    const wipeMayRunGate = new Promise((resolve) => { wipeMayRun = resolve; });
+    const service = setup(directory, {}, {
+      runContactTurn: async ({ history, userText, tools }) => {
+        turnRuns.push(userText);
+        if (userText === 'ordinary A still running') {
+          aReachedTurn();
+          await lateWrittenGate;
+          // A completes after wipe already ran — its returned bubbles must not
+          // resurrect deleted late residue (wipe already cleared transcript).
+          return { text: 'late-A-final-bubble-should-not-matter', bubbles: ['late-A-final-bubble-should-not-matter'] };
+        }
+        if (userText === '清空聊天记录') {
+          await wipeMayRunGate;
+          const tool = tools.find((item) => item.name === 'clear_chat_history');
+          const result = await tool.execute('wipe_reverse', {});
+          return {
+            text: result.content[0].text,
+            bubbles: [result.content[0].text],
+            reset: true,
+            historyCleared: true,
+            messages: [{
+              role: 'toolResult',
+              toolName: 'clear_chat_history',
+              details: result.details,
+            }],
+          };
+        }
+        if (userText === 'queued C keep me') {
+          cHistories.push(history.map((item) => item.content));
+        }
+        return { text: `reply:${userText}`, bubbles: [`reply:${userText}`] };
+      },
+    });
+    const assistant = service.createAssistant(assistantInput);
+    await settleSend(service, assistant.id, { messageID: 'seed_rev', parts: [{ type: 'text', text: 'seed secret reverse' }] });
+    // A pause -> wipe B admit -> C admit -> late A reply/card/watch -> B wipe -> C.
+    const aSend = service.send(assistant.id, { messageID: 'ord_a', parts: [{ type: 'text', text: 'ordinary A still running' }] });
+    await aReachedGate;
+    const bSend = service.send(assistant.id, { messageID: 'wipe_b', parts: [{ type: 'text', text: '清空聊天记录' }] });
+    await bSend;
+    const cSend = service.send(assistant.id, { messageID: 'queued_c', parts: [{ type: 'text', text: 'queued C keep me' }] });
+    await cSend;
+    // Late residue from A while still paused (ordinal after wipe+C users).
+    service.appendContactCard(assistant.id, {
+      cardType: 'session',
+      sessionID: 'ses_late_a',
+      directory: directory,
+      title: 'late A card residue',
+      status: 'busy',
+      messageID: 'late_a_card',
+    });
+    const Database = require('better-sqlite3');
+    const db = new Database(path.join(directory, 'assistants.sqlite'));
+    const ordinal = Number(db.prepare(
+      'SELECT COALESCE(MAX(ordinal), 0) + 1 AS next FROM assistant_contact_message WHERE assistant_id=?',
+    ).get(assistant.id).next);
+    db.prepare(
+      'INSERT INTO assistant_contact_message(message_id,assistant_id,role,turn_id,bubble_index,created_at,ordinal,status) VALUES (?,?,?,?,?,?,?,?)',
+    ).run('late_a_reply', assistant.id, 'assistant', 'ord_a', 0, Date.now(), ordinal, 'complete');
+    db.prepare(
+      'INSERT INTO assistant_contact_part(message_id,part_id,ordinal,part_json) VALUES (?,?,?,?)',
+    ).run('late_a_reply', 'p1', 1, JSON.stringify({ type: 'text', text: 'late-A-reply-residue' }));
+    db.close();
+    lateWritten();
+    wipeMayRun();
+    await aSend;
+    await service.whenContactTurnSettled('ord_a');
+    await service.whenContactTurnSettled('wipe_b');
+    await service.whenContactTurnSettled('queued_c');
+    const replay = await service.send(assistant.id, { messageID: 'queued_c', parts: [{ type: 'text', text: 'queued C keep me' }] });
+    expect(replay).toMatchObject({ admitted: true, replayed: true, messageID: 'queued_c' });
+    const page = service.contactMessages(assistant.id, { limit: 50 });
+    const texts = page.messages.map((message) => message.text);
+    expect(texts).not.toContain('seed secret reverse');
+    expect(texts).not.toContain('late-A-reply-residue');
+    expect(texts).not.toContain('late-A-final-bubble-should-not-matter');
+    expect(page.messages.some((message) => (message.cards || []).some((card) => card.sessionID === 'ses_late_a'))).toBe(false);
+    expect(texts).toContain('queued C keep me');
+    expect(texts).toContain('reply:queued C keep me');
+    expect(texts).toContain(CLEAR_CHAT_HISTORY_CONFIRM_BUBBLE);
+    // Wipe user kept before C (no re-admit reorder).
+    const wipeIdx = page.messages.findIndex((message) => message.messageID === 'wipe_b');
+    const cIdx = page.messages.findIndex((message) => message.messageID === 'queued_c');
+    expect(wipeIdx).toBeGreaterThanOrEqual(0);
+    expect(cIdx).toBeGreaterThan(wipeIdx);
+    expect(turnRuns.filter((text) => text === 'queued C keep me')).toHaveLength(1);
+    expect(page.messages.filter((message) => message.messageID === 'queued_c')).toHaveLength(1);
+    // C LLM history must not see late A residue or pre-wipe seed.
+    const cHist = cHistories[0] || [];
+    expect(cHist.some((content) => String(content).includes('late-A'))).toBe(false);
+    expect(cHist.some((content) => String(content).includes('seed secret reverse'))).toBe(false);
+    const dbAfter = new Database(path.join(directory, 'assistants.sqlite'));
+    const watches = dbAfter.prepare(
+      'SELECT session_id FROM assistant_contact_watch WHERE assistant_id=?',
+    ).all(assistant.id);
+    expect(watches).toEqual([]);
+    dbAfter.close();
     service.close();
   });
 
@@ -457,8 +750,8 @@ describe('assistants service', () => {
   it('persists mixed text+image+file parts and forwards them to the contact harness', async () => {
     const directory = root();
     let harness;
-    const image = { type: 'file', mime: 'image/png', url: 'data:image/png;base64,aa', filename: 'shot.png' };
-    const file = { type: 'file', mime: 'text/plain', url: 'data:text/plain;base64,eA==', filename: 'notes.txt' };
+    const image = { type: 'file', mime: 'image/png', url: FIXTURE_PNG_DATA_URL, filename: 'shot.png' };
+    const file = { type: 'file', mime: 'text/plain', url: FIXTURE_TEXT_DATA_URL, filename: 'notes.txt' };
     const service = setup(directory, {}, {
       runContactTurn: async (input) => {
         harness = input;
@@ -471,11 +764,17 @@ describe('assistants service', () => {
       parts: [{ type: 'text', text: 'look' }, image, file],
     });
     expect(harness.userText).toBe('look');
-    expect(harness.userParts).toEqual([{ type: 'text', text: 'look' }, image, file]);
+    // Harness sees materialized data URLs; DB stores attachment descriptors (no raw url).
+    expect(harness.userParts[0]).toEqual({ type: 'text', text: 'look' });
+    expect(harness.userParts[1]).toMatchObject({ type: 'file', mime: 'image/png', filename: 'shot.png', url: expect.stringMatching(/^data:image\/png;base64,/) });
+    expect(harness.userParts[2]).toMatchObject({ type: 'file', mime: 'text/plain', filename: 'notes.txt', url: expect.stringMatching(/^data:text\/plain;base64,/) });
     expect(service.contactMessages(assistant.id, { limit: 50 }).messages[0]).toMatchObject({
       role: 'user',
-      text: 'look',
-      parts: [{ type: 'text', text: 'look' }, image, file],
+      parts: [
+        { type: 'text', text: 'look' },
+        { type: 'file', mime: 'image/png', filename: 'shot.png', attachmentID: expect.stringMatching(/^att_/) },
+        { type: 'file', mime: 'text/plain', filename: 'notes.txt', attachmentID: expect.stringMatching(/^att_/) },
+      ],
     });
     service.close();
     const restarted = setup(directory, {}, {
@@ -483,14 +782,14 @@ describe('assistants service', () => {
     });
     expect(restarted.contactMessages(assistant.id, { limit: 50 }).messages[0].parts).toEqual([
       { type: 'text', text: 'look' },
-      image,
-      file,
+      expect.objectContaining({ type: 'file', mime: 'image/png', filename: 'shot.png', attachmentID: expect.stringMatching(/^att_/) }),
+      expect.objectContaining({ type: 'file', mime: 'text/plain', filename: 'notes.txt', attachmentID: expect.stringMatching(/^att_/) }),
     ]);
     restarted.close();
   });
 
   it('admits a file-only contact send and stores the file part without a fake text row', async () => {
-    const image = { type: 'file', mime: 'image/png', url: 'data:image/png;base64,aa', filename: 'shot.png' };
+    const image = { type: 'file', mime: 'image/png', url: FIXTURE_PNG_DATA_URL, filename: 'shot.png' };
     let harness;
     const service = setup(root(), {}, {
       runContactTurn: async (input) => {
@@ -501,9 +800,14 @@ describe('assistants service', () => {
     const assistant = service.createAssistant(assistantInput);
     await settleSend(service, assistant.id, { messageID: 'file_only_1', parts: [image] });
     expect(harness.userText).toBe('[attachment]');
-    expect(harness.userParts).toEqual([image]);
+    expect(harness.userParts).toEqual([
+      expect.objectContaining({ type: 'file', mime: 'image/png', filename: 'shot.png', url: expect.stringMatching(/^data:image\/png;base64,/) }),
+    ]);
     const user = service.contactMessages(assistant.id).messages.find((message) => message.role === 'user');
-    expect(user.parts).toEqual([image]);
+    expect(user.parts).toEqual([
+      expect.objectContaining({ type: 'file', mime: 'image/png', filename: 'shot.png', attachmentID: expect.stringMatching(/^att_/) }),
+    ]);
+    expect(user.parts[0].url).toBeUndefined();
     expect(user.text).toBe('');
     service.close();
   });
@@ -512,7 +816,7 @@ describe('assistants service', () => {
     const service = setup(root(), { promptAsync: async () => ({ response: { status: 204 } }) }); const assistant = service.createAssistant(assistantInput); const current = await service.ensure(assistant.id);
     expect(await service.compact(assistant.id, current)).toEqual({ binding: current, summarized: true });
     expect(await settleSend(service, assistant.id, { ...current, messageID: 'client_204', parts: [{ type: 'text', text: 'hello' }] })).toMatchObject({ binding: current, messageID: 'client_204', admitted: true });
-    expect(Object.keys(assistantContractFixtures.assistant)).toContain('managedWorkspacePath'); expect(Object.keys(assistantContractFixtures.assistant)).not.toContain('skillRoots'); expect(Object.keys(assistantContractFixtures.compactResponse).sort()).toEqual(['binding', 'summarized']); expect(Object.keys(assistantContractFixtures.messageAdmission).sort()).toEqual(['admitted', 'binding', 'messageID']); service.close();
+    expect(Object.keys(assistantContractFixtures.assistant)).toContain('managedWorkspacePath'); expect(Object.keys(assistantContractFixtures.assistant)).not.toContain('skillRoots'); expect(Object.keys(assistantContractFixtures.compactResponse).sort()).toEqual(['binding', 'summarized']); expect(Object.keys(assistantContractFixtures.messageAdmission).sort()).toEqual(['admitted', 'binding', 'messageID', 'revision']); service.close();
   });
 
   it('admits 33-part direct messages and 129-part shares', async () => {
@@ -1203,6 +1507,314 @@ describe('assistants service', () => {
     service.close();
   });
 
+  it.each([
+    { error: { status: 404 } },
+    { data: { info: { id: 'different_message' }, parts: [] } },
+    { data: { parts: [] } },
+  ])('preserves ambiguous admission until lookup identifies the exact message: %j', async (lookupResult) => {
+    const directory = root();
+    const project = path.join(directory, 'app');
+    fs.mkdirSync(project, { recursive: true });
+    const creates = [];
+    const prompts = [];
+    const deletes = [];
+    const lookups = [];
+    let promptCalls = 0;
+    const service = setup(directory, {
+      create: async (input) => {
+        creates.push(input);
+        return { data: { id: 'ses_lookup' } };
+      },
+      promptAsync: async (input) => {
+        prompts.push(input);
+        promptCalls += 1;
+        if (promptCalls === 1) {
+          const error = new TypeError('fetch failed');
+          error.code = 'ECONNRESET';
+          throw error;
+        }
+        return { response: { status: 204 } };
+      },
+      delete: async (input) => {
+        deletes.push(input);
+        return { data: true };
+      },
+      message: async (input) => {
+        lookups.push(input);
+        // Each response leaves the requested message unconfirmed.
+        return lookupResult;
+      },
+    }, {
+      runContactTurn: async ({ tools }) => {
+        const assign = tools.find((tool) => tool.name === 'assign_session');
+        const first = await assign.execute('call_1', {
+          prompt: 'Fix',
+          projectPath: project,
+          variant: 'fast',
+        });
+        expect(first.details).toMatchObject({
+          error: 'prompt_ambiguous',
+          ambiguous: true,
+          sessionID: 'ses_lookup',
+        });
+        expect(typeof first.details.messageID).toBe('string');
+        expect(deletes).toEqual([]);
+        const second = await assign.execute('call_2', {
+          prompt: 'Fix',
+          projectPath: project,
+          variant: 'fast',
+        });
+        expect(second.details.assigned.sessionID).toBe('ses_lookup');
+        return {
+          text: second.content[0].text,
+          bubbles: [second.content[0].text],
+          cards: second.details.card ? [second.details.card] : [],
+        };
+      },
+    });
+    const assistant = service.createAssistant({ ...assistantInput, variant: 'fast' });
+    await settleSend(service, assistant.id, {
+      messageID: 'client_assign_lookup',
+      parts: [{ type: 'text', text: 'Fix' }],
+    });
+    expect(creates).toHaveLength(1);
+    expect(prompts[0]).toMatchObject({
+      sessionID: 'ses_lookup',
+      variant: 'fast',
+    });
+    // Retry reuses the same worker session (no second create).
+    expect(prompts.length).toBeGreaterThanOrEqual(2);
+    expect(prompts.every((item) => item.sessionID === 'ses_lookup')).toBe(true);
+    expect(lookups.length).toBeGreaterThanOrEqual(1);
+    expect(deletes).toEqual([]);
+    service.close();
+  });
+
+  it('assign forwards current-turn images and explicit worker model into promptAsync without changing the contact', async () => {
+    const directory = root();
+    const project = path.join(directory, 'app');
+    fs.mkdirSync(project, { recursive: true });
+    const image = { type: 'file', mime: 'image/png', url: FIXTURE_PNG_DATA_URL, filename: 'card.png' };
+    const creates = [];
+    const prompts = [];
+    const deletes = [];
+    const service = setup(directory, {
+      create: async (input) => {
+        creates.push(input);
+        return { data: { id: `ses_${creates.length}` } };
+      },
+      promptAsync: async (input) => {
+        prompts.push(input);
+        return { response: { status: 204 } };
+      },
+      delete: async (input) => {
+        deletes.push(input);
+        return { data: true };
+      },
+      provider: {
+        list: async () => ({ data: { connected: ['xai', 'opencode-go'] } }),
+      },
+      config: {
+        providers: async () => ({
+          data: {
+            providers: [
+              {
+                id: 'xai',
+                name: 'xAI',
+                models: {
+                  'grok-4.6': {
+                    id: 'grok-4.6',
+                    name: 'Grok 4.6',
+                    modalities: { input: ['text', 'image'] },
+                  },
+                },
+              },
+              {
+                id: 'opencode-go',
+                name: 'OpenCode Go',
+                models: {
+                  'deepseek-v4-flash': { id: 'deepseek-v4-flash', name: 'deepseek-v4-flash' },
+                },
+              },
+            ],
+          },
+        }),
+      },
+    }, {
+      runContactTurn: async ({ tools, userText, connectedModels }) => {
+        expect(connectedModels.some((entry) => entry.providerID === 'xai' && entry.modelID === 'grok-4.6' && entry.acceptsImages)).toBe(true);
+        const assign = tools.find((tool) => tool.name === 'assign_session');
+        const result = await assign.execute('call_1', {
+          prompt: userText,
+          projectPath: project,
+          title: 'Card width',
+          model: 'xai/grok-4.6',
+        });
+        return {
+          text: result.content[0].text,
+          bubbles: [result.content[0].text],
+          cards: result.details.card ? [result.details.card] : [],
+          tools,
+        };
+      },
+    });
+    const assistant = service.createAssistant(assistantInput);
+    expect(assistant.providerID).toBe('p');
+    expect(assistant.modelID).toBe('m');
+    const sent = await settleSend(service, assistant.id, {
+      messageID: 'client_assign_image_model',
+      parts: [{ type: 'text', text: '修移动端卡片宽度' }, image],
+    });
+    expect(sent.settled.status).toBe('complete');
+    expect(creates).toHaveLength(1);
+    expect(prompts).toEqual([expect.objectContaining({
+      sessionID: 'ses_1',
+      model: { providerID: 'xai', modelID: 'grok-4.6' },
+      parts: [
+        { type: 'text', text: '修移动端卡片宽度' },
+        expect.objectContaining({
+          type: 'file',
+          mime: 'image/png',
+          filename: 'card.png',
+          url: expect.stringMatching(/^data:image\/png;base64,/),
+        }),
+      ],
+    })]);
+    expect(deletes).toEqual([]);
+    expect(service.snapshot().assistants[0]).toMatchObject({
+      id: assistant.id,
+      providerID: 'p',
+      modelID: 'm',
+    });
+    service.close();
+  });
+
+  it('invalid explicit worker model fails closed with no session create', async () => {
+    const directory = root();
+    const project = path.join(directory, 'app');
+    fs.mkdirSync(project, { recursive: true });
+    const creates = [];
+    const service = setup(directory, {
+      create: async (input) => {
+        creates.push(input);
+        return { data: { id: `ses_${creates.length}` } };
+      },
+      promptAsync: async () => ({ response: { status: 204 } }),
+      provider: {
+        list: async () => ({ data: { connected: ['xai'] } }),
+      },
+      config: {
+        providers: async () => ({
+          data: {
+            providers: [{
+              id: 'xai',
+              name: 'xAI',
+              models: { 'grok-4.6': { id: 'grok-4.6', name: 'Grok 4.6', modalities: { input: ['text', 'image'] } } },
+            }],
+          },
+        }),
+      },
+    }, {
+      runContactTurn: async ({ tools }) => {
+        const assign = tools.find((tool) => tool.name === 'assign_session');
+        const result = await assign.execute('call_1', {
+          prompt: 'Fix width',
+          projectPath: project,
+          model: 'missing/not-real',
+        });
+        expect(result.details.error).toBe('model_not_found');
+        return {
+          text: result.content[0].text,
+          bubbles: [result.content[0].text],
+          cards: [],
+          tools,
+        };
+      },
+    });
+    const assistant = service.createAssistant(assistantInput);
+    await settleSend(service, assistant.id, {
+      messageID: 'client_assign_bad_model',
+      parts: [{ type: 'text', text: '用 missing 模型建会话' }],
+    });
+    expect(creates).toEqual([]);
+    expect(service.snapshot().assistants[0]).toMatchObject({ providerID: 'p', modelID: 'm' });
+    service.close();
+  });
+
+  it('cleans up the worker session when create succeeds but promptAsync fails definitively (4xx)', async () => {
+    const directory = root();
+    const project = path.join(directory, 'app');
+    fs.mkdirSync(project, { recursive: true });
+    const creates = [];
+    const deletes = [];
+    const service = setup(directory, {
+      create: async (input) => {
+        creates.push(input);
+        return { data: { id: 'ses_fail_prompt' } };
+      },
+      promptAsync: async () => ({ error: { status: 400 }, response: { status: 400 } }),
+      delete: async (input) => {
+        deletes.push(input);
+        return { data: true };
+      },
+    }, {
+      runContactTurn: async ({ tools, userText }) => {
+        const assign = tools.find((tool) => tool.name === 'assign_session');
+        const result = await assign.execute('call_1', { prompt: userText, projectPath: project });
+        expect(result.details.error).toBe('upstream_error');
+        return {
+          text: result.content[0].text,
+          bubbles: [result.content[0].text],
+          cards: [],
+          tools,
+        };
+      },
+    });
+    const assistant = service.createAssistant(assistantInput);
+    await settleSend(service, assistant.id, {
+      messageID: 'client_assign_prompt_fail',
+      parts: [{ type: 'text', text: 'Fix after create' }],
+    });
+    expect(creates).toHaveLength(1);
+    expect(deletes).toEqual([expect.objectContaining({ sessionID: 'ses_fail_prompt' })]);
+    service.close();
+  });
+
+  it('keeps default-model assign behavior when no explicit worker model is requested', async () => {
+    const directory = root();
+    const project = path.join(directory, 'app');
+    fs.mkdirSync(project, { recursive: true });
+    const prompts = [];
+    const service = setup(directory, {
+      create: async () => ({ data: { id: 'ses_default' } }),
+      promptAsync: async (input) => {
+        prompts.push(input);
+        return { response: { status: 204 } };
+      },
+    }, {
+      runContactTurn: async ({ tools, userText }) => {
+        const assign = tools.find((tool) => tool.name === 'assign_session');
+        const result = await assign.execute('call_1', { prompt: userText, projectPath: project });
+        return {
+          text: result.content[0].text,
+          bubbles: [result.content[0].text],
+          cards: result.details.card ? [result.details.card] : [],
+          tools,
+        };
+      },
+    });
+    const assistant = service.createAssistant(assistantInput);
+    await settleSend(service, assistant.id, {
+      messageID: 'client_assign_default_model',
+      parts: [{ type: 'text', text: '建会话修一下' }],
+    });
+    expect(prompts).toEqual([expect.objectContaining({
+      model: { providerID: 'p', modelID: 'm' },
+      parts: [{ type: 'text', text: '建会话修一下' }],
+    })]);
+    service.close();
+  });
+
   it('creates another assistant from create_assistant and persists the assistant card', async () => {
     const directory = root();
     const service = setup(directory, {}, {
@@ -1576,7 +2188,9 @@ describe('assistants service', () => {
     });
     expect(service.snapshot().assistants[0]).toMatchObject({
       assignedSessionIDs: ['ses_work'],
-      working: true,
+      // assigned busy keeps the session card in flight; list green dot is contact-turn only
+      working: false,
+      activeContactTurn: null,
     });
     expect(service.processEvent({ type: 'session.idle', properties: { sessionID: 'ses_work' } })).toBe(true);
     const page = service.contactMessages(assistant.id);
@@ -1609,7 +2223,8 @@ describe('assistants service', () => {
     });
     expect(first.snapshot().assistants[0]).toMatchObject({
       assignedSessionIDs: ['ses_missed'],
-      working: true,
+      working: false,
+      activeContactTurn: null,
     });
     first.close();
 
@@ -1647,7 +2262,8 @@ describe('assistants service', () => {
       title: 'Follow-up',
       status: 'busy',
     });
-    expect(service.snapshot().assistants[0].working).toBe(true);
+    expect(service.snapshot().assistants[0].working).toBe(false);
+    expect(service.snapshot().assistants[0].assignedSessionIDs).toEqual(['ses_timer']);
     await tick();
     page = service.contactMessages(assistant.id);
     expect(page.messages.find((message) => message.parts.some((part) => part.type === 'card' && part.sessionID === 'ses_timer'))?.parts[0].status).toBe('complete');
@@ -1751,7 +2367,7 @@ describe('assistants service', () => {
     });
     expect(service.contactMessages(assistant.id).messages.filter((message) => message.text === 'oc.settle.complete')).toHaveLength(1);
     expect(service.snapshot().assistants[0].assignedSessionIDs.sort()).toEqual(['ses_busy', 'ses_down']);
-    expect(service.snapshot().assistants[0].working).toBe(true);
+    expect(service.snapshot().assistants[0].working).toBe(false);
     service.close();
   });
 
@@ -1997,11 +2613,24 @@ describe('assistants service', () => {
       binding: expect.objectContaining({ sessionID: null, sessionGeneration: 0 }),
       messageID: 'turn_stream_1',
       admitted: true,
+      revision: expect.any(Number),
     });
     expect(sent).not.toHaveProperty('settled');
+    expect(service.snapshot().assistants[0]).toMatchObject({
+      working: true,
+      activeContactTurn: expect.objectContaining({
+        turnID: 'turn_stream_1',
+        messageID: 'turn_stream_1',
+        status: expect.stringMatching(/^(queued|running)$/),
+      }),
+    });
     const settled = await service.whenContactTurnSettled('turn_stream_1');
     expect(settled).toMatchObject({ status: 'complete' });
     await new Promise((resolve) => setImmediate(resolve));
+    expect(service.snapshot().assistants[0]).toMatchObject({
+      working: false,
+      activeContactTurn: null,
+    });
     const types = events.map((event) => event.type);
     expect(types[0]).toBe('openchamber:contact-turn-start');
     expect(events[0].properties).toMatchObject({
@@ -2034,6 +2663,179 @@ describe('assistants service', () => {
     service.close();
   });
 
+  it('replays same messageID+payload admission once and conflicts on payload mismatch', async () => {
+    const directory = root();
+    let release;
+    const blocked = new Promise((resolve) => { release = resolve; });
+    let runs = 0;
+    const service = setup(directory, {}, {
+      runContactTurn: async () => {
+        runs += 1;
+        await blocked;
+        return { text: 'once', bubbles: ['once'] };
+      },
+    });
+    const assistant = service.createAssistant(assistantInput);
+    const first = await service.send(assistant.id, {
+      messageID: 'idem_1',
+      parts: [{ type: 'text', text: 'same' }],
+    });
+    expect(first).toMatchObject({ admitted: true, messageID: 'idem_1', revision: expect.any(Number) });
+    const replay = await service.send(assistant.id, {
+      messageID: 'idem_1',
+      parts: [{ type: 'text', text: 'same' }],
+    });
+    expect(replay).toMatchObject({ admitted: true, messageID: 'idem_1', replayed: true });
+    await expect(service.send(assistant.id, {
+      messageID: 'idem_1',
+      parts: [{ type: 'text', text: 'different' }],
+    })).rejects.toMatchObject({ code: 'idempotency_conflict' });
+    release();
+    await service.whenContactTurnSettled('idem_1');
+    expect(runs).toBe(1);
+    const after = await service.send(assistant.id, {
+      messageID: 'idem_1',
+      parts: [{ type: 'text', text: 'same' }],
+    });
+    expect(after).toMatchObject({ admitted: true, replayed: true });
+    expect(runs).toBe(1);
+    service.close();
+  });
+
+  it('persists a durable contact error bubble so query recovery works without SSE', async () => {
+    const service = setup(root(), {}, {
+      runContactTurn: async () => {
+        const error = new Error('No connected model');
+        error.code = 'no_provider';
+        throw error;
+      },
+    });
+    const assistant = service.createAssistant(assistantInput);
+    await service.send(assistant.id, {
+      messageID: 'fail_persist_1',
+      parts: [{ type: 'text', text: 'hi' }],
+    });
+    await service.whenContactTurnSettled('fail_persist_1');
+    const page = service.contactMessages(assistant.id);
+    expect(page.messages.map((message) => ({ role: message.role, status: message.status, text: message.text }))).toEqual([
+      { role: 'user', status: 'complete', text: 'hi' },
+      { role: 'assistant', status: 'error', text: 'No connected model' },
+    ]);
+    expect(service.snapshot().assistants[0]).toMatchObject({ working: false, activeContactTurn: null });
+    service.close();
+  });
+
+  it('bumps revision when queued contact turn becomes running', async () => {
+    const directory = root();
+    let release;
+    const blocked = new Promise((resolve) => { release = resolve; });
+    const tips = [];
+    const service = setup(directory, {}, {
+      onRevisionTip: (tip) => tips.push(tip),
+      runContactTurn: async () => {
+        await blocked;
+        return { text: 'ok', bubbles: ['ok'] };
+      },
+    });
+    const assistant = service.createAssistant(assistantInput);
+    const before = service.snapshot().revision;
+    await service.send(assistant.id, {
+      messageID: 'run_bump_1',
+      parts: [{ type: 'text', text: 'hi' }],
+    });
+    await new Promise((resolve) => setImmediate(resolve));
+    await new Promise((resolve) => setImmediate(resolve));
+    expect(service.snapshot().assistants[0].activeContactTurn?.status).toBe('running');
+    expect(service.snapshot().revision).toBeGreaterThan(before);
+    release();
+    await service.whenContactTurnSettled('run_bump_1');
+    expect(tips.length).toBeGreaterThan(0);
+    service.close();
+  });
+
+  it('keeps snapshot working authoritative until settle and clears it on server process restart', async () => {
+    const directory = root();
+    let releaseTurn;
+    const blocked = new Promise((resolve) => { releaseTurn = resolve; });
+    const service = setup(directory, {}, {
+      runContactTurn: async () => {
+        await blocked;
+        return { text: 'done', bubbles: ['done'] };
+      },
+    });
+    const assistant = service.createAssistant(assistantInput);
+    await service.send(assistant.id, {
+      messageID: 'turn_auth_1',
+      parts: [{ type: 'text', text: 'hold' }],
+    });
+    expect(service.snapshot().assistants[0]).toMatchObject({
+      working: true,
+      activeContactTurn: {
+        turnID: 'turn_auth_1',
+        messageID: 'turn_auth_1',
+        status: expect.stringMatching(/^(queued|running)$/),
+        admittedAt: expect.any(Number),
+      },
+    });
+    // Same process: snapshot is the APP-restart recovery source.
+    expect(service.snapshot().assistants[0].working).toBe(true);
+    releaseTurn();
+    await service.whenContactTurnSettled('turn_auth_1');
+    expect(service.snapshot().assistants[0]).toMatchObject({
+      working: false,
+      activeContactTurn: null,
+    });
+    service.close();
+
+    // New process (server restart): process-local activity is gone — never permanently green.
+    const restarted = setup(directory, {}, {
+      runContactTurn: async () => ({ text: 'again', bubbles: ['again'] }),
+    });
+    expect(restarted.snapshot().assistants[0]).toMatchObject({
+      working: false,
+      activeContactTurn: null,
+    });
+    restarted.close();
+  });
+
+  it('isolates contact working per assistant and clears working on harness error', async () => {
+    const directory = root();
+    let releaseA;
+    const blockedA = new Promise((resolve) => { releaseA = resolve; });
+    const service = setup(directory, {}, {
+      runContactTurn: async ({ userText }) => {
+        if (userText === 'hold-a') {
+          await blockedA;
+          return { text: 'a-done', bubbles: ['a-done'] };
+        }
+        const error = new Error('No connected model');
+        error.code = 'no_provider';
+        throw error;
+      },
+    });
+    const first = service.createAssistant({ ...assistantInput, name: 'A' });
+    const second = service.createAssistant({ ...assistantInput, name: 'B' });
+    await service.send(first.id, {
+      messageID: 'turn_a',
+      parts: [{ type: 'text', text: 'hold-a' }],
+    });
+    await service.send(second.id, {
+      messageID: 'turn_b',
+      parts: [{ type: 'text', text: 'fail-b' }],
+    });
+    const snap = () => Object.fromEntries(service.snapshot().assistants.map((item) => [item.id, item]));
+    expect(snap()[first.id].working).toBe(true);
+    expect(snap()[first.id].activeContactTurn?.turnID).toBe('turn_a');
+    await service.whenContactTurnSettled('turn_b');
+    expect(snap()[second.id].working).toBe(false);
+    expect(snap()[second.id].activeContactTurn).toBeNull();
+    expect(snap()[first.id].working).toBe(true);
+    releaseA();
+    await service.whenContactTurnSettled('turn_a');
+    expect(snap()[first.id].working).toBe(false);
+    service.close();
+  });
+
   it('admits the user then broadcasts turn-end error when the harness fails', async () => {
     const events = [];
     const service = setup(root(), {}, {
@@ -2051,17 +2853,25 @@ describe('assistants service', () => {
     });
     expect(sent).toMatchObject({ admitted: true, messageID: 'client_no_provider' });
     expect(service.contactMessages(assistant.id).messages.map((message) => message.role)).toEqual(['user']);
+    expect(service.snapshot().assistants[0].working).toBe(true);
     const settled = await service.whenContactTurnSettled('client_no_provider');
     expect(settled).toMatchObject({ status: 'error', code: 'no_provider' });
     await new Promise((resolve) => setImmediate(resolve));
+    expect(service.snapshot().assistants[0]).toMatchObject({
+      working: false,
+      activeContactTurn: null,
+    });
     expect(events.some((event) => event.type === 'openchamber:contact-turn-start')).toBe(true);
     expect(events.some((event) => (
       event.type === 'openchamber:contact-turn-end'
       && event.properties?.status === 'error'
       && event.properties?.turnID === 'client_no_provider'
     ))).toBe(true);
-    // User row stays; no assistant bubble on failure.
-    expect(service.contactMessages(assistant.id).messages.map((message) => message.role)).toEqual(['user']);
+    // User row stays; durable error bubble enables query recovery without SSE.
+    expect(service.contactMessages(assistant.id).messages.map((message) => ({ role: message.role, status: message.status }))).toEqual([
+      { role: 'user', status: 'complete' },
+      { role: 'assistant', status: 'error' },
+    ]);
     service.close();
   });
 
@@ -2089,4 +2899,93 @@ describe('assistants service', () => {
     db.close();
     service.close();
   });
+
+  it('pages contact messages 20/20/5 with generation+revision and exact messageID admission', async () => {
+    const directory = root();
+    const service = setup(directory, {}, {
+      runContactTurn: async ({ userText }) => ({ text: `r:${userText}`, bubbles: [`r:${userText}`] }),
+    });
+    const assistant = service.createAssistant(assistantInput);
+    const other = service.createAssistant({ ...assistantInput, name: 'B' });
+    // 45 user admits → 45 user + 45 assistant = 90 rows; page three windows of 20/20/5 on users alone
+    // Seed via direct store through many settled turns would be slow; insert via contactMessages path
+    // by settling 22 turns (44 rows) then more via appendContactCard for density.
+    for (let i = 0; i < 22; i += 1) {
+      await settleSend(service, assistant.id, {
+        messageID: `page_u_${i}`,
+        parts: [{ type: 'text', text: `u-${i}` }],
+      });
+    }
+    // 22 users + 22 assistants = 44; add one more card-only for 45th
+    service.appendContactCard(assistant.id, {
+      cardType: 'session',
+      sessionID: 'ses_page_extra',
+      directory,
+      title: 'extra',
+      status: 'complete',
+      messageID: 'page_card_45',
+    });
+
+    // Newest window first (chat tail), ascending within the page.
+    const defaultPage = service.contactMessages(assistant.id);
+    expect(defaultPage.messages).toHaveLength(20);
+    expect(defaultPage.complete).toBe(false);
+    expect(defaultPage.generation).toBe(0);
+    expect(defaultPage.revision).toEqual(expect.any(Number));
+    expect(defaultPage.messages.at(-1).messageID).toBe('page_card_45');
+
+    const second = service.contactMessages(assistant.id, { before: defaultPage.nextCursor, limit: 20 });
+    expect(second.messages).toHaveLength(20);
+    expect(second.complete).toBe(false);
+
+    const third = service.contactMessages(assistant.id, { before: second.nextCursor, limit: 20 });
+    expect(third.messages.length).toBeGreaterThanOrEqual(5);
+    expect(third.complete).toBe(true);
+    expect(third.nextCursor).toBeNull();
+    expect(third.messages[0].text).toBe('u-0');
+
+    // Concurrent append does not break a prior cursor keyset for older pages.
+    await settleSend(service, assistant.id, {
+      messageID: 'page_concurrent',
+      parts: [{ type: 'text', text: 'concurrent-append' }],
+    });
+    const stillSecond = service.contactMessages(assistant.id, { before: defaultPage.nextCursor, limit: 20 });
+    expect(stillSecond.messages[0].messageID).toBe(second.messages[0].messageID);
+
+    // Exact admission: deep/old message still found; missing / cross-assistant empty.
+    const deepID = third.messages[0].messageID;
+    const exact = service.contactMessages(assistant.id, { messageID: deepID });
+    expect(exact).toMatchObject({ nextCursor: null, complete: true, generation: 0 });
+    expect(exact.messages).toHaveLength(1);
+    expect(exact.messages[0].messageID).toBe(deepID);
+    expect(service.contactMessages(assistant.id, { messageID: 'nope' }).messages).toEqual([]);
+    expect(service.contactMessages(other.id, { messageID: deepID }).messages).toEqual([]);
+
+    // clear-memory keeps generation + cursor validity
+    const beforeGen = service.contactMessages(assistant.id).generation;
+    service.clearContactMemory(assistant.id);
+    expect(service.contactMessages(assistant.id, { before: defaultPage.nextCursor, limit: 5 }).generation).toBe(beforeGen);
+
+    // reset bumps generation → old cursor conflicts
+    const wiped = service.resetContact(assistant.id);
+    expect(wiped.generation).toBe(1);
+    expect(() => service.contactMessages(assistant.id, { before: defaultPage.nextCursor })).toThrowError(
+      expect.objectContaining({ code: 'contact_generation_conflict' }),
+    );
+    expect(service.contactMessages(assistant.id)).toMatchObject({
+      messages: [],
+      complete: true,
+      generation: 1,
+    });
+
+    // invalid cursor
+    expect(() => service.contactMessages(assistant.id, { before: '%%%' })).toThrowError(
+      expect.objectContaining({ code: 'validation_error' }),
+    );
+    expect(() => service.contactMessages(assistant.id, { before: 'x', messageID: 'y' })).toThrowError(
+      expect.objectContaining({ code: 'validation_error' }),
+    );
+
+    service.close();
+  });
 });