@openchambery/web 1.19.13-beta.3 → 1.19.13

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

@@ -3,7 +3,7 @@ import os from 'node:os';
 import path from 'node:path';
 import { describe, expect, it, vi } from 'vitest';
 import { createRequire } from 'node:module';
-import { createAssistantsService } from './service.js';
+import { assignedSessionResumeMessageID, createAssistantsService } from './service.js';
 import { assistantContractFixtures } from './contracts.js';
 import {
   CLEAR_CHAT_HISTORY_CONFIRM_BUBBLE,
@@ -1815,6 +1815,218 @@ describe('assistants service', () => {
     service.close();
   });
 
+  const sessionFollowCatalog = {
+    provider: {
+      list: async () => ({ data: { connected: ['xai', 'openai', 'p'] } }),
+    },
+    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: 'openai',
+              name: 'OpenAI',
+              models: {
+                'gpt-4o': { id: 'gpt-4o', name: 'GPT-4o', modalities: { input: ['text', 'image'] } },
+              },
+            },
+            {
+              id: 'p',
+              name: 'P',
+              models: { m: { id: 'm', name: 'M' } },
+            },
+          ],
+        },
+      }),
+    },
+  };
+
+  it('reused sessionID without explicit model follows session.model when in catalog', async () => {
+    const directory = root();
+    const project = path.join(directory, 'app');
+    fs.mkdirSync(project, { recursive: true });
+    const prompts = [];
+    const gets = [];
+    const service = setup(directory, {
+      create: async () => ({ data: { id: 'ses_should_not_create' } }),
+      get: async (input) => {
+        gets.push(input);
+        return { data: { id: input.sessionID, model: { providerID: 'xai', id: 'grok-4.6' } } };
+      },
+      promptAsync: async (input) => {
+        prompts.push(input);
+        return { response: { status: 204 } };
+      },
+      ...sessionFollowCatalog,
+    }, {
+      runContactTurn: async ({ tools, userText }) => {
+        const assign = tools.find((tool) => tool.name === 'assign_session');
+        const result = await assign.execute('call_1', {
+          prompt: userText,
+          sessionID: 'ses_reuse',
+          projectPath: project,
+        });
+        return {
+          text: result.content[0].text,
+          bubbles: [result.content[0].text],
+          cards: result.details.card ? [result.details.card] : [],
+        };
+      },
+    });
+    const assistant = service.createAssistant(assistantInput);
+    await settleSend(service, assistant.id, {
+      messageID: 'client_assign_session_model',
+      parts: [{ type: 'text', text: '继续修' }],
+    });
+    expect(gets.some((item) => item.sessionID === 'ses_reuse')).toBe(true);
+    expect(prompts).toEqual([expect.objectContaining({
+      sessionID: 'ses_reuse',
+      model: { providerID: 'xai', modelID: 'grok-4.6' },
+    })]);
+    expect(service.snapshot().assistants[0]).toMatchObject({ providerID: 'p', modelID: 'm' });
+    service.close();
+  });
+
+  it('reused session falls back to assistant model when session model is not in catalog', 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_no' } }),
+      get: async (input) => ({
+        data: { id: input.sessionID, model: { providerID: 'missing', modelID: 'gone' } },
+      }),
+      promptAsync: async (input) => {
+        prompts.push(input);
+        return { response: { status: 204 } };
+      },
+      ...sessionFollowCatalog,
+    }, {
+      runContactTurn: async ({ tools, userText }) => {
+        const assign = tools.find((tool) => tool.name === 'assign_session');
+        const result = await assign.execute('call_1', {
+          prompt: userText,
+          sessionID: 'ses_stale',
+          projectPath: project,
+        });
+        return {
+          text: result.content[0].text,
+          bubbles: [result.content[0].text],
+          cards: result.details.card ? [result.details.card] : [],
+        };
+      },
+    });
+    const assistant = service.createAssistant(assistantInput);
+    await settleSend(service, assistant.id, {
+      messageID: 'client_assign_session_stale',
+      parts: [{ type: 'text', text: '继续' }],
+    });
+    expect(prompts).toEqual([expect.objectContaining({
+      sessionID: 'ses_stale',
+      model: { providerID: 'p', modelID: 'm' },
+    })]);
+    service.close();
+  });
+
+  it('reused session falls back to assistant model when session.get fails', 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_no' } }),
+      get: async () => {
+        throw new Error('session get failed');
+      },
+      promptAsync: async (input) => {
+        prompts.push(input);
+        return { response: { status: 204 } };
+      },
+      ...sessionFollowCatalog,
+    }, {
+      runContactTurn: async ({ tools, userText }) => {
+        const assign = tools.find((tool) => tool.name === 'assign_session');
+        const result = await assign.execute('call_1', {
+          prompt: userText,
+          sessionID: 'ses_get_fail',
+          projectPath: project,
+        });
+        expect(result.details.error).toBeUndefined();
+        return {
+          text: result.content[0].text,
+          bubbles: [result.content[0].text],
+          cards: result.details.card ? [result.details.card] : [],
+        };
+      },
+    });
+    const assistant = service.createAssistant(assistantInput);
+    const sent = await settleSend(service, assistant.id, {
+      messageID: 'client_assign_session_get_fail',
+      parts: [{ type: 'text', text: '继续' }],
+    });
+    expect(sent.settled.status).toBe('complete');
+    expect(prompts).toEqual([expect.objectContaining({
+      sessionID: 'ses_get_fail',
+      model: { providerID: 'p', modelID: 'm' },
+    })]);
+    service.close();
+  });
+
+  it('explicit model still overrides reused session model', 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_no' } }),
+      get: async (input) => ({
+        data: { id: input.sessionID, model: { providerID: 'xai', id: 'grok-4.6' } },
+      }),
+      promptAsync: async (input) => {
+        prompts.push(input);
+        return { response: { status: 204 } };
+      },
+      ...sessionFollowCatalog,
+    }, {
+      runContactTurn: async ({ tools, userText }) => {
+        const assign = tools.find((tool) => tool.name === 'assign_session');
+        const result = await assign.execute('call_1', {
+          prompt: userText,
+          sessionID: 'ses_explicit',
+          projectPath: project,
+          model: 'openai/gpt-4o',
+        });
+        return {
+          text: result.content[0].text,
+          bubbles: [result.content[0].text],
+          cards: result.details.card ? [result.details.card] : [],
+        };
+      },
+    });
+    const assistant = service.createAssistant(assistantInput);
+    await settleSend(service, assistant.id, {
+      messageID: 'client_assign_session_explicit',
+      parts: [{ type: 'text', text: '用 gpt' }],
+    });
+    expect(prompts).toEqual([expect.objectContaining({
+      sessionID: 'ses_explicit',
+      model: { providerID: 'openai', modelID: 'gpt-4o' },
+    })]);
+    service.close();
+  });
+
   it('creates another assistant from create_assistant and persists the assistant card', async () => {
     const directory = root();
     const service = setup(directory, {}, {
@@ -1848,6 +2060,177 @@ describe('assistants service', () => {
     service.close();
   });
 
+  it('reads and persists defaultPrompt via get_assistant_settings / update_default_prompt', async () => {
+    const directory = root();
+    const tips = [];
+    const harnessTurns = [];
+    let phase = 'read';
+    const service = setup(directory, {}, {
+      onRevisionTip: (tip) => tips.push(tip),
+      runContactTurn: async ({ tools, assistant }) => {
+        harnessTurns.push({
+          phase,
+          defaultPrompt: assistant.defaultPrompt,
+          toolNames: tools.map((tool) => tool.name),
+        });
+        if (phase === 'read') {
+          const get = tools.find((tool) => tool.name === 'get_assistant_settings');
+          const result = await get.execute('call_get', {});
+          expect(result.details.settings).toMatchObject({
+            id: assistant.id,
+            name: 'A',
+            defaultPrompt: 'Base persona',
+            providerID: 'p',
+            modelID: 'm',
+            enabled: true,
+          });
+          expect(result.content[0].text).toContain('Base persona');
+          phase = 'write';
+          return { text: 'Current default prompt loaded.', bubbles: ['Current default prompt loaded.'] };
+        }
+        if (phase === 'write') {
+          const update = tools.find((tool) => tool.name === 'update_default_prompt');
+          const unchanged = await update.execute('call_same', { prompt: 'Base persona' });
+          expect(unchanged.details).toMatchObject({ updated: false, unchanged: true, defaultPrompt: 'Base persona' });
+          const beforeRevision = service.snapshot().assistants.find((item) => item.id === assistant.id).revision;
+          const saved = await update.execute('call_set', { prompt: 'Reply only in Chinese.' });
+          expect(saved.details).toMatchObject({ updated: true, defaultPrompt: 'Reply only in Chinese.' });
+          expect(saved.terminate).toBe(false);
+          const after = service.snapshot().assistants.find((item) => item.id === assistant.id);
+          expect(after.defaultPrompt).toBe('Reply only in Chinese.');
+          expect(after.revision).toBe(beforeRevision + 1);
+          phase = 'next';
+          return { text: 'Default prompt saved.', bubbles: ['Default prompt saved.'] };
+        }
+        // Next turn: harness must see the persisted defaultPrompt from DB snapshot.
+        expect(assistant.defaultPrompt).toBe('Reply only in Chinese.');
+        const get = tools.find((tool) => tool.name === 'get_assistant_settings');
+        const live = await get.execute('call_live', {});
+        expect(live.details.settings.defaultPrompt).toBe('Reply only in Chinese.');
+        return { text: 'Confirmed.', bubbles: ['Confirmed.'] };
+      },
+    });
+    const host = service.createAssistant({ ...assistantInput, defaultPrompt: 'Base persona' });
+    expect(host.defaultPrompt).toBe('Base persona');
+    const tipBeforeWrite = tips.length;
+
+    await settleSend(service, host.id, {
+      messageID: 'client_settings_read',
+      parts: [{ type: 'text', text: '看看我的默认提示词' }],
+    });
+    await settleSend(service, host.id, {
+      messageID: 'client_settings_write',
+      parts: [{ type: 'text', text: '把默认提示词改成只用中文回复' }],
+    });
+    const tipAfterWrite = tips.length;
+    expect(tipAfterWrite).toBeGreaterThan(tipBeforeWrite);
+    expect(service.snapshot().assistants.find((item) => item.id === host.id).defaultPrompt).toBe('Reply only in Chinese.');
+
+    await settleSend(service, host.id, {
+      messageID: 'client_settings_next',
+      parts: [{ type: 'text', text: '确认一下默认提示词' }],
+    });
+    expect(harnessTurns.some((turn) => turn.phase === 'next' && turn.defaultPrompt === 'Reply only in Chinese.')).toBe(true);
+    expect(harnessTurns[0].toolNames).toEqual(expect.arrayContaining([
+      'get_assistant_settings',
+      'update_default_prompt',
+    ]));
+    service.close();
+  });
+
+  it('updates another assistant defaultPrompt by name without changing the host', async () => {
+    const directory = root();
+    const service = setup(directory, {}, {
+      runContactTurn: async ({ tools }) => {
+        const get = tools.find((tool) => tool.name === 'get_assistant_settings');
+        const update = tools.find((tool) => tool.name === 'update_default_prompt');
+        const seen = await get.execute('call_peer_get', { to: 'OpenCode 配置助手' });
+        expect(seen.details.settings).toMatchObject({
+          name: 'OpenCode 配置助手',
+          defaultPrompt: 'peer persona',
+        });
+        const saved = await update.execute('call_peer_set', {
+          to: 'OpenCode 配置助手',
+          prompt: 'new peer persona',
+        });
+        expect(saved.details).toMatchObject({
+          updated: true,
+          defaultPrompt: 'new peer persona',
+          name: 'OpenCode 配置助手',
+        });
+        return { text: 'Updated peer.', bubbles: ['Updated peer.'] };
+      },
+    });
+    const host = service.createAssistant({ ...assistantInput, name: 'Host', defaultPrompt: 'host persona' });
+    const peer = service.createAssistant({
+      ...assistantInput,
+      name: 'OpenCode 配置助手',
+      defaultPrompt: 'peer persona',
+    });
+    await settleSend(service, host.id, {
+      messageID: 'client_peer_prompt',
+      parts: [{ type: 'text', text: '改 OpenCode 配置助手的默认提示词' }],
+    });
+    expect(service.snapshot().assistants.find((item) => item.id === host.id).defaultPrompt).toBe('host persona');
+    expect(service.snapshot().assistants.find((item) => item.id === peer.id).defaultPrompt).toBe('new peer persona');
+    service.close();
+  });
+
+  it('retries update_default_prompt once on revision_conflict and reports persistent conflict', async () => {
+    const directory = root();
+    let host;
+    let mode = 'retry_success';
+    const service = setup(directory, {}, {
+      runContactTurn: async ({ tools }) => {
+        const update = tools.find((tool) => tool.name === 'update_default_prompt');
+        if (mode === 'retry_success') {
+          // Concurrent name write lands during the pre-CAS yield → first CAS conflicts, retry succeeds.
+          const pending = update.execute('call_retry', { prompt: 'After conflict retry' });
+          await service.updateAssistant(host.id, {
+            expectedRevision: service.snapshot().assistants.find((item) => item.id === host.id).revision,
+            name: 'ConcurrentRename',
+          });
+          const result = await pending;
+          expect(result.details).toMatchObject({ updated: true, defaultPrompt: 'After conflict retry' });
+          expect(result.details.error).toBeUndefined();
+          mode = 'retry_fail';
+          return { text: 'Retried ok.', bubbles: ['Retried ok.'] };
+        }
+        // Two concurrent writes during attempt 0 and attempt 1 yields → both CAS fail.
+        const pending = update.execute('call_fail', { prompt: 'Should fail' });
+        await service.updateAssistant(host.id, {
+          expectedRevision: service.snapshot().assistants.find((item) => item.id === host.id).revision,
+          name: 'BumpOne',
+        });
+        await Promise.resolve();
+        await service.updateAssistant(host.id, {
+          expectedRevision: service.snapshot().assistants.find((item) => item.id === host.id).revision,
+          name: 'BumpTwo',
+        });
+        const failed = await pending;
+        expect(failed.details.error).toBe('revision_conflict');
+        expect(failed.terminate).toBe(true);
+        return { text: 'Conflict reported.', bubbles: ['Conflict reported.'] };
+      },
+    });
+    host = service.createAssistant({ ...assistantInput, defaultPrompt: 'Original' });
+    await settleSend(service, host.id, {
+      messageID: 'client_prompt_retry',
+      parts: [{ type: 'text', text: '改默认提示词' }],
+    });
+    expect(service.snapshot().assistants.find((item) => item.id === host.id)).toMatchObject({
+      defaultPrompt: 'After conflict retry',
+      name: 'ConcurrentRename',
+    });
+    await settleSend(service, host.id, {
+      messageID: 'client_prompt_conflict',
+      parts: [{ type: 'text', text: '再改默认提示词' }],
+    });
+    // Persistent conflict must not apply the failed write.
+    expect(service.snapshot().assistants.find((item) => item.id === host.id).defaultPrompt).toBe('After conflict retry');
+    service.close();
+  });
+
   it('creates a scheduled task from schedule_task and persists the schedule card', async () => {
     const directory = root();
     const upserts = [];
@@ -2175,9 +2558,24 @@ describe('assistants service', () => {
     service.close();
   });
 
-  it('subscribes assigned sessions so idle updates the card, appends a settle message, and clears working', () => {
+  it('subscribes assigned sessions so idle updates the card, resumes contact LLM, and skips canned settle bubbles', async () => {
     const directory = root();
-    const service = setup(directory);
+    let time = 5_000;
+    const resumes = [];
+    const service = setup(directory, {
+      messages: async () => ({
+        data: [{
+          info: { id: 'msg_worker', role: 'assistant' },
+          parts: [{ type: 'text', text: 'Worker finished login fix.' }],
+        }],
+      }),
+    }, {
+      clock: () => time,
+      runContactTurn: async ({ userText }) => {
+        resumes.push(userText);
+        return { text: '登录修复已完成。', bubbles: ['登录修复已完成。'] };
+      },
+    });
     const assistant = service.createAssistant(assistantInput);
     service.appendContactCard(assistant.id, {
       cardType: 'session',
@@ -2193,6 +2591,8 @@ describe('assistants service', () => {
       activeContactTurn: null,
     });
     expect(service.processEvent({ type: 'session.idle', properties: { sessionID: 'ses_work' } })).toBe(true);
+    const resumeID = assignedSessionResumeMessageID(assistant.id, 'ses_work', 'complete', 5_000);
+    await service.whenContactTurnSettled(resumeID);
     const page = service.contactMessages(assistant.id);
     expect(page.messages.find((message) => message.parts.some((part) => part.type === 'card'))?.parts[0]).toMatchObject({
       type: 'card',
@@ -2200,17 +2600,27 @@ describe('assistants service', () => {
       sessionID: 'ses_work',
       status: 'complete',
     });
-    expect(page.messages.filter((message) => message.text === 'oc.settle.complete')).toHaveLength(1);
+    expect(page.messages.filter((message) => message.text === 'oc.settle.complete')).toHaveLength(0);
+    expect(page.messages.some((message) => message.text === '登录修复已完成。')).toBe(true);
+    expect(page.messages.some((message) => message.role === 'user' && message.messageID === resumeID)).toBe(false);
+    expect(resumes).toHaveLength(1);
+    expect(resumes[0]).toContain('ses_work');
+    expect(resumes[0]).toContain('complete');
+    expect(resumes[0]).toContain('Login');
+    expect(resumes[0]).toContain('Worker finished login fix.');
     expect(service.snapshot().assistants[0]).toMatchObject({
       assignedSessionIDs: [],
       working: false,
+      activeContactTurn: null,
     });
+    // Same complete watch → changed=false → no second resume.
     expect(service.processEvent({ type: 'session.idle', properties: { sessionID: 'ses_work' } })).toBe(false);
-    expect(service.contactMessages(assistant.id).messages.filter((message) => message.text === 'oc.settle.complete')).toHaveLength(1);
+    expect(resumes).toHaveLength(1);
+    expect(service.contactMessages(assistant.id).messages.filter((message) => message.text === '登录修复已完成。')).toHaveLength(1);
     service.close();
   });
 
-  it('reconciles a missed assigned-session idle on boot and the 60s timer', async () => {
+  it('reconciles a missed assigned-session idle on boot and the 60s timer with resume and no canned settle', async () => {
     const directory = root();
     const first = setup(directory);
     const assistant = first.createAssistant(assistantInput);
@@ -2229,6 +2639,8 @@ describe('assistants service', () => {
     first.close();
 
     let tick;
+    let time = 7_000;
+    const resumes = [];
     const service = setup(directory, {
       get: async ({ sessionID }) => (
         sessionID === 'ses_missed' || sessionID === 'ses_timer'
@@ -2237,24 +2649,38 @@ describe('assistants service', () => {
       ),
       messages: async ({ sessionID }) => (
         sessionID === 'ses_missed' || sessionID === 'ses_timer'
-          ? { data: [{ info: { id: `msg_${sessionID}`, role: 'assistant', time: { completed: 1 } } }] }
+          ? {
+            data: [{
+              info: { id: `msg_${sessionID}`, role: 'assistant', time: { completed: 1 } },
+              parts: [{ type: 'text', text: `done:${sessionID}` }],
+            }],
+          }
           : { data: [] }
       ),
     }, {
+      clock: () => time,
       setIntervalFn: (fn) => {
         tick = fn;
         return 1;
       },
+      runContactTurn: async ({ userText }) => {
+        resumes.push(userText);
+        const label = userText.includes('ses_timer') ? 'timer-done' : 'missed-done';
+        return { text: label, bubbles: [label] };
+      },
     });
     await service.reconcile();
+    await service.whenContactTurnSettled(assignedSessionResumeMessageID(assistant.id, 'ses_missed', 'complete', 7_000));
     let page = service.contactMessages(assistant.id);
     expect(page.messages.find((message) => message.parts.some((part) => part.type === 'card'))?.parts[0].status).toBe('complete');
-    expect(page.messages.filter((message) => message.text === 'oc.settle.complete')).toHaveLength(1);
+    expect(page.messages.filter((message) => message.text === 'oc.settle.complete')).toHaveLength(0);
+    expect(page.messages.some((message) => message.text === 'missed-done')).toBe(true);
     expect(service.snapshot().assistants[0]).toMatchObject({
       assignedSessionIDs: [],
       working: false,
     });
 
+    time = 8_000;
     service.appendContactCard(assistant.id, {
       cardType: 'session',
       sessionID: 'ses_timer',
@@ -2265,15 +2691,20 @@ describe('assistants service', () => {
     expect(service.snapshot().assistants[0].working).toBe(false);
     expect(service.snapshot().assistants[0].assignedSessionIDs).toEqual(['ses_timer']);
     await tick();
+    await service.whenContactTurnSettled(assignedSessionResumeMessageID(assistant.id, 'ses_timer', 'complete', 8_000));
     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');
-    expect(page.messages.filter((message) => message.text === 'oc.settle.complete')).toHaveLength(2);
+    expect(page.messages.filter((message) => message.text === 'oc.settle.complete')).toHaveLength(0);
+    expect(page.messages.some((message) => message.text === 'timer-done')).toBe(true);
+    expect(resumes).toHaveLength(2);
     expect(service.snapshot().assistants[0].working).toBe(false);
     service.close();
   });
 
-  it('reconciles a missing assigned session as complete and an assistant error as failed', async () => {
+  it('reconciles a missing assigned session as complete and an assistant error as failed without settle bubbles', async () => {
     const directory = root();
+    let time = 9_000;
+    const resumes = [];
     const service = setup(directory, {
       get: async ({ sessionID }) => {
         if (sessionID === 'ses_gone') return { error: { status: 404 } };
@@ -2281,9 +2712,25 @@ describe('assistants service', () => {
         return { data: { id: sessionID } };
       },
       messages: async ({ sessionID }) => {
-        if (sessionID === 'ses_fail') return { data: [{ info: { id: 'msg_fail', role: 'assistant', error: { message: 'boom' } } }] };
+        if (sessionID === 'ses_fail') {
+          return {
+            data: [{
+              info: { id: 'msg_fail', role: 'assistant', error: { message: 'boom' } },
+              parts: [{ type: 'text', text: 'worker boom' }],
+            }],
+          };
+        }
         return { data: [] };
       },
+    }, {
+      clock: () => time,
+      runContactTurn: async ({ userText }) => {
+        resumes.push(userText);
+        return {
+          text: userText.includes('error') ? '失败摘要' : '完成摘要',
+          bubbles: [userText.includes('error') ? '失败摘要' : '完成摘要'],
+        };
+      },
     });
     const assistant = service.createAssistant(assistantInput);
     service.appendContactCard(assistant.id, {
@@ -2301,26 +2748,37 @@ describe('assistants service', () => {
       status: 'busy',
     });
     await service.reconcile();
+    await Promise.all([
+      service.whenContactTurnSettled(assignedSessionResumeMessageID(assistant.id, 'ses_gone', 'complete', 9_000)),
+      service.whenContactTurnSettled(assignedSessionResumeMessageID(assistant.id, 'ses_fail', 'error', 9_000)),
+    ]);
     const cards = service.contactMessages(assistant.id).messages
       .filter((message) => message.parts.some((part) => part.type === 'card'))
       .map((message) => message.parts[0]);
     expect(cards.find((card) => card.sessionID === 'ses_gone')?.status).toBe('complete');
     expect(cards.find((card) => card.sessionID === 'ses_fail')?.status).toBe('error');
     const texts = service.contactMessages(assistant.id).messages.map((message) => message.text);
-    expect(texts.filter((text) => text === 'oc.settle.complete')).toHaveLength(1);
-    expect(texts.filter((text) => text === 'oc.settle.error')).toHaveLength(1);
+    expect(texts.filter((text) => text === 'oc.settle.complete')).toHaveLength(0);
+    expect(texts.filter((text) => text === 'oc.settle.error')).toHaveLength(0);
+    expect(texts).toEqual(expect.arrayContaining(['完成摘要', '失败摘要']));
+    expect(resumes.some((text) => text.includes('ses_gone') && text.includes('complete'))).toBe(true);
+    expect(resumes.some((text) => text.includes('ses_fail') && text.includes('error'))).toBe(true);
     expect(service.snapshot().assistants[0]).toMatchObject({
       assignedSessionIDs: [],
       working: false,
     });
+    const resumeCount = resumes.length;
     await service.reconcile();
-    expect(service.contactMessages(assistant.id).messages.filter((message) => message.text === 'oc.settle.complete')).toHaveLength(1);
-    expect(service.contactMessages(assistant.id).messages.filter((message) => message.text === 'oc.settle.error')).toHaveLength(1);
+    expect(resumes).toHaveLength(resumeCount);
+    expect(service.contactMessages(assistant.id).messages.filter((message) => message.text === 'oc.settle.complete')).toHaveLength(0);
+    expect(service.contactMessages(assistant.id).messages.filter((message) => message.text === 'oc.settle.error')).toHaveLength(0);
     service.close();
   });
 
   it('does not settle in-flight watches on fetch failure or while the session is still running', async () => {
     const directory = root();
+    let time = 10_000;
+    const resumes = [];
     const service = setup(directory, {
       get: async ({ sessionID }) => {
         if (sessionID === 'ses_down') throw new Error('network');
@@ -2329,10 +2787,23 @@ describe('assistants service', () => {
         return { data: { id: sessionID } };
       },
       messages: async ({ sessionID }) => {
-        if (sessionID === 'ses_idle') return { data: [{ info: { id: 'msg_idle', role: 'assistant', time: { completed: 1 } } }] };
+        if (sessionID === 'ses_idle') {
+          return {
+            data: [{
+              info: { id: 'msg_idle', role: 'assistant', time: { completed: 1 } },
+              parts: [{ type: 'text', text: 'idle worker' }],
+            }],
+          };
+        }
         if (sessionID === 'ses_busy') return { data: [{ info: { id: 'msg_busy', role: 'assistant' } }] };
         throw new Error('should not settle from messages after get failure');
       },
+    }, {
+      clock: () => time,
+      runContactTurn: async ({ userText }) => {
+        resumes.push(userText);
+        return { text: 'idle-resume', bubbles: ['idle-resume'] };
+      },
     });
     const assistant = service.createAssistant(assistantInput);
     service.appendContactCard(assistant.id, {
@@ -2357,6 +2828,7 @@ describe('assistants service', () => {
       status: 'busy',
     });
     await service.reconcile();
+    await service.whenContactTurnSettled(assignedSessionResumeMessageID(assistant.id, 'ses_idle', 'complete', 10_000));
     const cards = Object.fromEntries(service.contactMessages(assistant.id).messages
       .filter((message) => message.parts.some((part) => part.type === 'card'))
       .map((message) => [message.parts[0].sessionID, message.parts[0].status]));
@@ -2365,7 +2837,9 @@ describe('assistants service', () => {
       ses_busy: 'busy',
       ses_idle: 'complete',
     });
-    expect(service.contactMessages(assistant.id).messages.filter((message) => message.text === 'oc.settle.complete')).toHaveLength(1);
+    expect(service.contactMessages(assistant.id).messages.filter((message) => message.text === 'oc.settle.complete')).toHaveLength(0);
+    expect(service.contactMessages(assistant.id).messages.some((message) => message.text === 'idle-resume')).toBe(true);
+    expect(resumes).toHaveLength(1);
     expect(service.snapshot().assistants[0].assignedSessionIDs.sort()).toEqual(['ses_busy', 'ses_down']);
     expect(service.snapshot().assistants[0].working).toBe(false);
     service.close();
@@ -2374,13 +2848,26 @@ describe('assistants service', () => {
   it('does not rewrite a reconciled session.error as complete on a later idle poll', async () => {
     const directory = root();
     let idle = false;
+    let time = 11_000;
+    const resumes = [];
     const service = setup(directory, {
       get: async ({ sessionID }) => (
         sessionID === 'ses_err'
           ? { data: idle ? { id: 'ses_err', status: { type: 'idle' } } : { id: 'ses_err', error: { message: 'boom' } } }
           : { data: { id: sessionID } }
       ),
-      messages: async () => ({ data: [{ info: { id: 'msg_err', role: 'assistant', time: { completed: 1 } } }] }),
+      messages: async () => ({
+        data: [{
+          info: { id: 'msg_err', role: 'assistant', time: { completed: 1 } },
+          parts: [{ type: 'text', text: 'err body' }],
+        }],
+      }),
+    }, {
+      clock: () => time,
+      runContactTurn: async ({ userText }) => {
+        resumes.push(userText);
+        return { text: 'error-resume', bubbles: ['error-resume'] };
+      },
     });
     const assistant = service.createAssistant(assistantInput);
     service.appendContactCard(assistant.id, {
@@ -2391,12 +2878,19 @@ describe('assistants service', () => {
       status: 'busy',
     });
     await service.reconcile();
+    await service.whenContactTurnSettled(assignedSessionResumeMessageID(assistant.id, 'ses_err', 'error', 11_000));
     expect(service.contactMessages(assistant.id).messages.find((message) => message.parts.some((part) => part.type === 'card'))?.parts[0].status).toBe('error');
-    expect(service.contactMessages(assistant.id).messages.some((message) => message.text === 'oc.settle.error')).toBe(true);
+    expect(service.contactMessages(assistant.id).messages.some((message) => message.text === 'oc.settle.error')).toBe(false);
+    expect(service.contactMessages(assistant.id).messages.some((message) => message.text === 'error-resume')).toBe(true);
+    expect(resumes).toHaveLength(1);
+    expect(resumes[0]).toContain('error');
     idle = true;
+    time = 12_000;
     await service.reconcile();
     expect(service.contactMessages(assistant.id).messages.find((message) => message.parts.some((part) => part.type === 'card'))?.parts[0].status).toBe('error');
     expect(service.contactMessages(assistant.id).messages.some((message) => message.text === 'oc.settle.complete')).toBe(false);
+    // Later idle must not resume complete after error.
+    expect(resumes).toHaveLength(1);
     expect(service.snapshot().assistants[0]).toMatchObject({
       assignedSessionIDs: [],
       working: false,
@@ -2404,9 +2898,17 @@ describe('assistants service', () => {
     service.close();
   });
 
-  it('accepts a session-goal settle into the same card without mutating the worker', () => {
+  it('accepts a session-goal settle into the same card without mutating the worker or writing settle text', async () => {
     const directory = root();
-    const service = setup(directory);
+    let time = 13_000;
+    const resumes = [];
+    const service = setup(directory, {}, {
+      clock: () => time,
+      runContactTurn: async ({ userText }) => {
+        resumes.push(userText);
+        return { text: 'goal-resume', bubbles: ['goal-resume'] };
+      },
+    });
     const assistant = service.createAssistant(assistantInput);
     service.appendContactCard(assistant.id, {
       cardType: 'session',
@@ -2416,16 +2918,27 @@ describe('assistants service', () => {
       status: 'busy',
     });
     expect(service.reportAssignedSessionSettle('ses_goal', 'complete')).toBe(true);
+    await service.whenContactTurnSettled(assignedSessionResumeMessageID(assistant.id, 'ses_goal', 'complete', 13_000));
     const page = service.contactMessages(assistant.id);
     expect(page.messages.find((message) => message.parts.some((part) => part.type === 'card'))?.parts[0].status).toBe('complete');
-    expect(page.messages.some((message) => message.text === 'oc.settle.complete')).toBe(true);
+    expect(page.messages.some((message) => message.text === 'oc.settle.complete')).toBe(false);
+    expect(page.messages.some((message) => message.text === 'goal-resume')).toBe(true);
+    expect(resumes).toHaveLength(1);
     expect(service.snapshot().assistants[0].working).toBe(false);
     service.close();
   });
 
-  it('maps question and error onto the same card and does not rewrite error as complete', () => {
+  it('maps question and error onto the same card and does not rewrite error as complete', async () => {
     const directory = root();
-    const service = setup(directory);
+    let time = 14_000;
+    const resumes = [];
+    const service = setup(directory, {}, {
+      clock: () => time,
+      runContactTurn: async ({ userText }) => {
+        resumes.push(userText);
+        return { text: 'ask-error-resume', bubbles: ['ask-error-resume'] };
+      },
+    });
     const assistant = service.createAssistant(assistantInput);
     service.appendContactCard(assistant.id, {
       cardType: 'session',
@@ -2437,20 +2950,27 @@ describe('assistants service', () => {
     expect(service.processEvent({ type: 'question.asked', properties: { sessionID: 'ses_ask' } })).toBe(true);
     let page = service.contactMessages(assistant.id);
     expect(page.messages.find((message) => message.parts.some((part) => part.type === 'card'))?.parts[0].status).toBe('question');
-    expect(page.messages.some((message) => message.text === 'oc.settle.question')).toBe(true);
+    // question: card only — no canned settle bubble and no contact resume.
+    expect(page.messages.some((message) => message.text === 'oc.settle.question')).toBe(false);
+    expect(resumes).toHaveLength(0);
     expect(service.snapshot().assistants[0]).toMatchObject({
       assignedSessionIDs: ['ses_ask'],
       working: false,
     });
     expect(service.processEvent({ type: 'session.error', properties: { sessionID: 'ses_ask' } })).toBe(true);
+    await service.whenContactTurnSettled(assignedSessionResumeMessageID(assistant.id, 'ses_ask', 'error', 14_000));
     page = service.contactMessages(assistant.id);
     expect(page.messages.find((message) => message.parts.some((part) => part.type === 'card'))?.parts[0].status).toBe('error');
-    expect(page.messages.some((message) => message.text === 'oc.settle.error')).toBe(true);
+    expect(page.messages.some((message) => message.text === 'oc.settle.error')).toBe(false);
+    expect(page.messages.some((message) => message.text === 'ask-error-resume')).toBe(true);
+    expect(resumes).toHaveLength(1);
+    expect(resumes[0]).toContain('error');
     expect(service.processEvent({ type: 'session.idle', properties: { sessionID: 'ses_ask' } })).toBe(false);
     expect(service.processEvent({ type: 'session.status', properties: { sessionID: 'ses_ask', status: { type: 'idle' } } })).toBe(false);
     page = service.contactMessages(assistant.id);
     expect(page.messages.find((message) => message.parts.some((part) => part.type === 'card'))?.parts[0].status).toBe('error');
     expect(page.messages.some((message) => message.text === 'oc.settle.complete')).toBe(false);
+    expect(resumes).toHaveLength(1);
     expect(service.snapshot().assistants[0]).toMatchObject({
       assignedSessionIDs: [],
       working: false,