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

package/server/lib/assistants/contact-tools.test.js

@@ -6,12 +6,20 @@ import {
   CLEAR_CHAT_HISTORY_CONFIRM_BUBBLE,
   CLEAR_CHAT_HISTORY_TOOL_NAME,
   CREATE_ASSISTANT_TOOL_NAME,
+  GET_ASSISTANT_SETTINGS_TOOL_NAME,
   LIST_PROJECTS_TOOL_NAME,
   LIST_SESSIONS_TOOL_NAME,
   MESSAGE_ASSISTANT_TOOL_NAME,
   NEW_CONVERSATION_CONFIRM_BUBBLE,
   NEW_CONVERSATION_TOOL_NAME,
   SCHEDULE_TASK_TOOL_NAME,
+  STOP_SESSION_TOOL_NAME,
+  STOPPED_SESSION_FALLBACK_BUBBLE,
+  UPDATE_DEFAULT_PROMPT_CONFIRM_BUBBLE,
+  UPDATE_DEFAULT_PROMPT_TOOL_NAME,
+  UPDATE_DEFAULT_PROMPT_UNCHANGED_BUBBLE,
+  WATCH_SESSION_TOOL_NAME,
+  WATCHED_SESSION_FALLBACK_BUBBLE,
   confirmBubbleAfterContactReset,
   contactTurnHasSuccessfulReset,
   createContactTools,
@@ -31,11 +39,45 @@ import {
 import { attachmentScopeKey } from './assign.js';
 
 describe('contact tool protocol', () => {
+  it('shows current-instance models with ordered favorites and recents using exact ids', () => {
+    const prompt = formatConnectedModelsPrompt([
+      { providerID: 'p', providerName: 'Connected Provider', modelID: 'claude-sonnet-4-6', name: 'Claude Sonnet 4.6' },
+      { providerID: 'q', modelID: 'gpt-5.4', name: 'GPT 5.4' },
+    ], { preferences: {
+      favoriteModels: [{ providerID: 'q', modelID: 'gpt-5.4', variant: 'high' }, { providerID: 'gone', modelID: 'offline' }],
+      recentModels: [{ providerID: 'p', modelID: 'claude-sonnet-4-6' }, { providerID: 'q', modelID: 'gpt-5.4' }],
+    } })
+    expect(prompt).toContain('Connected Provider')
+    expect(prompt).toContain('Favorite models (saved order)')
+    expect(prompt).toContain('Recent models (most recent first)')
+    expect(prompt).toContain('variant="high"')
+    expect(prompt).not.toContain('offline')
+    const recent = prompt.split('Recent models (most recent first)')[1]
+    expect(recent.indexOf('claude-sonnet-4-6')).toBeLessThan(recent.indexOf('gpt-5.4'))
+  })
+
+  it('distinguishes unavailable model preferences from successfully empty lists', () => {
+    expect(formatConnectedModelsPrompt([], { preferences: null })).toContain('preferences unavailable')
+    expect(formatConnectedModelsPrompt([], { preferences: { favoriteModels: [], recentModels: [] } })).toContain('Favorite models (saved order): none')
+    expect(formatConnectedModelsPrompt([], { catalogAvailable: false })).toContain('catalog unavailable')
+  })
+
+  it('parses watch_session and stop_session fences', () => {
+    const watchText = '```openchamber-tool\n{"name":"watch_session","arguments":{"sessionID":"ses_w"}}\n```';
+    expect(parseContactToolCalls(watchText, [WATCH_SESSION_TOOL_NAME, STOP_SESSION_TOOL_NAME]).toolCalls).toEqual([
+      { name: WATCH_SESSION_TOOL_NAME, arguments: { sessionID: 'ses_w' } },
+    ]);
+    const stopText = '好的 {"name":"stop_session","arguments":{"sessionID":"ses_s"}}';
+    expect(parseContactToolCalls(stopText, [WATCH_SESSION_TOOL_NAME, STOP_SESSION_TOOL_NAME]).toolCalls).toEqual([
+      { name: STOP_SESSION_TOOL_NAME, arguments: { sessionID: 'ses_s' } },
+    ]);
+  });
+
   it('parses an assign_session fence and strips it from chat text', () => {
     const text = 'On it.\n\n```openchamber-tool\n{"name":"assign_session","arguments":{"prompt":"Fix login","projectPath":"/repo"}}\n```';
     const parsed = parseContactToolCalls(text, [ASSIGN_SESSION_TOOL_NAME]);
     expect(parsed.chatText).toBe('On it.');
-    expect(parsed.toolCall).toEqual({
+    expect(parsed.toolCalls[0]).toEqual({
       name: ASSIGN_SESSION_TOOL_NAME,
       arguments: { prompt: 'Fix login', projectPath: '/repo' },
     });
@@ -48,7 +90,7 @@ describe('contact tool protocol', () => {
       [CREATE_ASSISTANT_TOOL_NAME, SCHEDULE_TASK_TOOL_NAME, ASSIGN_SESSION_TOOL_NAME],
     );
     expect(create.chatText).toBe('好。');
-    expect(create.toolCall).toEqual({
+    expect(create.toolCalls[0]).toEqual({
       name: CREATE_ASSISTANT_TOOL_NAME,
       arguments: { name: 'FlowQA', model: 'opencode-go/deepseek-v4-flash' },
     });
@@ -60,11 +102,11 @@ describe('contact tool protocol', () => {
       '```openchamber-tool\n{"name":"message_assistant","arguments":{"to":"PeerQA","text":"hello-from-assistant 写好了"}}\n```',
       [MESSAGE_ASSISTANT_TOOL_NAME],
     );
-    expect(peer.toolCall).toEqual({
+    expect(peer.toolCalls[0]).toEqual({
       name: MESSAGE_ASSISTANT_TOOL_NAME,
       arguments: { to: 'PeerQA', text: 'hello-from-assistant 写好了' },
     });
-    expect(schedule.toolCall).toEqual({
+    expect(schedule.toolCalls[0]).toEqual({
       name: SCHEDULE_TASK_TOOL_NAME,
       arguments: { name: 'Daily ping', prompt: 'ping', time: '18:00', timezone: 'Asia/Shanghai' },
     });
@@ -75,7 +117,7 @@ describe('contact tool protocol', () => {
       '好的，我来直接创建这个助理，不开编码会话。\n{"name":"create_assistant","arguments":{"name":"FlowNL","model":"opencode-go/deepseek-v4-flash"}}',
       [CREATE_ASSISTANT_TOOL_NAME, ASSIGN_SESSION_TOOL_NAME],
     );
-    expect(parsed.toolCall).toEqual({
+    expect(parsed.toolCalls[0]).toEqual({
       name: CREATE_ASSISTANT_TOOL_NAME,
       arguments: { name: 'FlowNL', model: 'opencode-go/deepseek-v4-flash' },
     });
@@ -83,15 +125,107 @@ describe('contact tool protocol', () => {
     expect(parsed.chatText).not.toContain('create_assistant');
   });
 
+  it('accepts the existing single-call fence without a newline', () => {
+    expect(parseContactToolCalls('```openchamber-tool {"name":"read","arguments":{"path":"sample.md"}}```', ['read']).toolCalls)
+      .toEqual([{ name: 'read', arguments: { path: 'sample.md' } }]);
+  });
+
+  it('does not execute tool-shaped JSON inside other protocol or example fences', () => {
+    const text = '```openchamber-final\n{"status":"complete","text":"done","example":{"name":"bash","arguments":{"command":"pwd"}}}\n```';
+    expect(parseContactToolCalls(text, ['bash'])).toEqual({ chatText: text, toolCalls: [] });
+  });
+
+  it.each(['json\n', '\n', ''])('preserves complete tool payloads in generic fences: %s', (header) => {
+    const call = { name: 'read', arguments: { path: 'sample.md' } };
+    const result = parseContactToolCalls(`Before \`\`\`${header}${JSON.stringify(call)}\`\`\` After`, ['read']);
+    expect(result.toolCalls).toEqual([call]);
+    expect(result.chatText).toBe('Before  After');
+  });
+
+  it('does not run nested or partial tool examples in generic fences', () => {
+    const text = '```json\n{"example":{"name":"bash","arguments":{"command":"pwd"}}}\n```';
+    expect(parseContactToolCalls(text, ['bash'])).toEqual({ chatText: text, toolCalls: [] });
+    const prose = '```\nExample: {"name":"bash","arguments":{"command":"pwd"}}\n```';
+    expect(parseContactToolCalls(prose, ['bash'])).toEqual({ chatText: prose, toolCalls: [] });
+  });
+
+  it('retains every tool call in order across fenced and embedded JSON', () => {
+    const calls = [
+      { name: 'read', arguments: { path: 'sample.md' } },
+      { name: 'bash', arguments: { command: 'date +%F' } },
+      { name: 'write', arguments: { path: 'result.md', content: 'done' } },
+    ];
+    const text = `Before ${JSON.stringify(calls[0])}\n\n\`\`\`openchamber-tool\n${JSON.stringify(calls[1])}\n\`\`\`\nAfter ${JSON.stringify(calls[2])}`;
+    const result = parseContactToolCalls(text, ['read', 'bash', 'write']);
+    expect(result.toolCalls).toEqual(calls);
+    expect(result.chatText).toContain('Before');
+    expect(result.chatText).toContain('After');
+    expect(result.chatText).not.toContain('arguments');
+    expect(result.protocolError).toBeUndefined();
+  });
+
+  it('keeps markdown fences and escaped quotes inside JSON string arguments', () => {
+    const calls = [
+      { name: 'write', arguments: { path: 'note.md', content: '```json\n{"quoted": "value"}\n```' } },
+      { name: 'read', arguments: { path: 'note.md' } },
+    ];
+    const text = calls.map((call) => `\`\`\`openchamber-tool\n${JSON.stringify(call)}\n\`\`\``).join('\n');
+    expect(parseContactToolCalls(text, ['read', 'write'])).toEqual({ chatText: '', toolCalls: calls });
+  });
+
+  it('preserves both calls from the observed read-sample and bash-date response', () => {
+    const calls = [
+      { name: 'read', arguments: { path: 'notes/sample.md' } },
+      { name: 'bash', arguments: { command: 'date +%F' } },
+    ];
+    const text = calls.map((call) => `\`\`\`openchamber-tool\n${JSON.stringify(call)}\n\`\`\``).join('\n\n');
+    expect(parseContactToolCalls(text, ['read', 'bash'])).toEqual({ chatText: '', toolCalls: calls });
+  });
+
+  it.each([
+    '{bad json}',
+    '{"name":"unknown","arguments":{}}',
+    '{"name":"read","arguments":[]}',
+    '',
+  ])('rejects the complete batch when an explicit tool fence is invalid: %s', (invalid) => {
+    const valid = '\`\`\`openchamber-tool\n{"name":"read","arguments":{"path":"sample.md"}}\n\`\`\`';
+    const result = parseContactToolCalls(`${valid}\n\`\`\`openchamber-tool\n${invalid}\n\`\`\``, ['read']);
+    expect(result.toolCalls).toEqual([]);
+    expect(result.protocolError).toEqual(expect.any(String));
+  });
+
+  it('rejects a truncated explicit tool fence without executing an earlier call', () => {
+    const result = parseContactToolCalls('{"name":"read","arguments":{"path":"sample.md"}}\n\`\`\`openchamber-tool\n{"name":"read"', ['read']);
+    expect(result.toolCalls).toEqual([]);
+    expect(result.protocolError).toEqual(expect.any(String));
+  });
+
+  it.each(['', '{"name":"read","arguments":{"path":"sample.md"}}\n'])('rejects an unclosed outer JSON object without executing a nested call or valid prefix', (prefix) => {
+    const result = parseContactToolCalls(prefix + '{"example": {"name":"bash","arguments":{"command":"pwd"}}', ['read', 'bash']);
+    expect(result.toolCalls).toEqual([]);
+    expect(result.protocolError).toEqual(expect.any(String));
+  });
+
+  it('does not discover nested JSON arguments or strings as additional tool calls', () => {
+    const nested = { name: 'bash', arguments: { command: 'pwd' } };
+    const call = { name: 'write', arguments: { path: 'result.json', content: JSON.stringify(nested), metadata: nested } };
+    expect(parseContactToolCalls(JSON.stringify(call), ['write', 'bash']).toolCalls).toEqual([call]);
+    expect(parseContactToolCalls(JSON.stringify({ example: nested }), ['bash']).toolCalls).toEqual([]);
+  });
+
   it('detects 建助理 without treating 不要开编码 session as assign_session', () => {
     const tools = [
       NEW_CONVERSATION_TOOL_NAME,
       CLEAR_CHAT_HISTORY_TOOL_NAME,
       LIST_PROJECTS_TOOL_NAME,
       LIST_SESSIONS_TOOL_NAME,
+      GET_ASSISTANT_SETTINGS_TOOL_NAME,
+      UPDATE_DEFAULT_PROMPT_TOOL_NAME,
       CREATE_ASSISTANT_TOOL_NAME,
       SCHEDULE_TASK_TOOL_NAME,
       MESSAGE_ASSISTANT_TOOL_NAME,
+      WATCH_SESSION_TOOL_NAME,
+      STOP_SESSION_TOOL_NAME,
       ASSIGN_SESSION_TOOL_NAME,
     ];
     expect(detectRequestedContactTools('帮我新建一个助理，名叫 FlowNL，不要开编码 session', tools)).toEqual([
@@ -100,6 +234,14 @@ describe('contact tool protocol', () => {
     expect(detectRequestedContactTools('每天 18:00 排一个 ping 定时任务', tools)).toEqual([SCHEDULE_TASK_TOOL_NAME]);
     expect(detectRequestedContactTools('建会话写一个文件', tools)).toEqual([ASSIGN_SESSION_TOOL_NAME]);
     expect(detectRequestedContactTools('对，你直接派给那个项目组，再建个会话去修这个问题', tools)).toEqual([ASSIGN_SESSION_TOOL_NAME]);
+    expect(detectRequestedContactTools('继续这个会话修 login', tools)).toEqual([ASSIGN_SESSION_TOOL_NAME]);
+    expect(detectRequestedContactTools('监听这个会话', tools)).toEqual([WATCH_SESSION_TOOL_NAME]);
+    expect(detectRequestedContactTools('watch this session', tools)).toEqual([WATCH_SESSION_TOOL_NAME]);
+    expect(detectRequestedContactTools('停止这个会话', tools)).toEqual([STOP_SESSION_TOOL_NAME]);
+    expect(detectRequestedContactTools('stop that session', tools)).toEqual([STOP_SESSION_TOOL_NAME]);
+    // Plain @session reference is context only — not auto watch/assign/stop.
+    expect(detectRequestedContactTools('看看 @session:ses_abc 里上次说了啥', tools)).toEqual([]);
+    expect(detectRequestedContactTools('@session:ses_abc', tools)).toEqual([]);
     expect(detectRequestedContactTools('写一个文件', tools)).toEqual([]);
     expect(detectRequestedContactTools('pwd', tools)).toEqual([]);
     expect(detectRequestedContactTools('给 PeerQA 说一声 hello-from-assistant 写好了', tools)).toEqual([
@@ -118,6 +260,11 @@ describe('contact tool protocol', () => {
     expect(detectRequestedContactTools('找项目 openchamber yee', tools)).toEqual([LIST_PROJECTS_TOOL_NAME]);
     expect(detectRequestedContactTools('看看现有对话', tools)).toEqual([LIST_SESSIONS_TOOL_NAME]);
     expect(detectRequestedContactTools('list sessions in that project', tools)).toEqual([LIST_SESSIONS_TOOL_NAME]);
+    expect(detectRequestedContactTools('看看我的默认提示词', tools)).toEqual([GET_ASSISTANT_SETTINGS_TOOL_NAME]);
+    expect(detectRequestedContactTools('看看 OpenCode 配置助手的默认提示词', tools)).toEqual([GET_ASSISTANT_SETTINGS_TOOL_NAME]);
+    expect(detectRequestedContactTools('把默认提示词改成简洁中文', tools)).toEqual([UPDATE_DEFAULT_PROMPT_TOOL_NAME]);
+    expect(detectRequestedContactTools('改 OpenCode 配置助手的默认提示词', tools)).toEqual([UPDATE_DEFAULT_PROMPT_TOOL_NAME]);
+    expect(detectRequestedContactTools('update default prompt to be terse', tools)).toEqual([UPDATE_DEFAULT_PROMPT_TOOL_NAME]);
     expect(detectRequestedContactTools('开新对话', tools)).not.toContain(ASSIGN_SESSION_TOOL_NAME);
     expect(detectRequestedContactTools('开新对话', tools)).not.toContain(CLEAR_CHAT_HISTORY_TOOL_NAME);
     expect(detectRequestedContactTools('不要开编码 session', tools)).toEqual([]);
@@ -130,14 +277,14 @@ describe('contact tool protocol', () => {
 
   it('parses bash fences when the pi coding tools are allowed', () => {
     const text = '```openchamber-tool\n{"name":"bash","arguments":{"command":"pwd"}}\n```';
-    expect(parseContactToolCalls(text, ['bash', ASSIGN_SESSION_TOOL_NAME]).toolCall).toEqual({
+    expect(parseContactToolCalls(text, ['bash', ASSIGN_SESSION_TOOL_NAME]).toolCalls[0]).toEqual({
       name: 'bash',
       arguments: { command: 'pwd' },
     });
     expect(parseContactToolCalls(
       '```openchamber-tool\n{"name":"glob","arguments":{"pattern":"*"}}\n```',
       ['glob', 'bash'],
-    ).toolCall).toBeNull();
+    ).toolCalls).toEqual([]);
   });
 
   it('tells DeepSeek to call tools from natural language, not slash commands', () => {
@@ -146,20 +293,31 @@ describe('contact tool protocol', () => {
     expect(prompt).toContain('clear_chat_history');
     expect(prompt).toContain('list_projects');
     expect(prompt).toContain('list_sessions');
+    expect(prompt).toContain('get_assistant_settings');
+    expect(prompt).toContain('update_default_prompt');
     expect(prompt).toContain('create_assistant');
     expect(prompt).toContain('schedule_task');
     expect(prompt).toContain('message_assistant');
     expect(prompt).toContain('assign_session');
+    expect(prompt).toContain('watch_session');
+    expect(prompt).toContain('stop_session');
     expect(prompt).toContain('开新对话');
     expect(prompt).toContain('清除记忆');
     expect(prompt).toContain('清空聊天记录');
     expect(prompt).toContain('找项目');
     expect(prompt).toContain('现有对话');
+    expect(prompt).toContain('默认提示词');
+    expect(prompt).toContain('助手设定');
     expect(prompt).toContain('建助理');
     expect(prompt).toContain('排定时任务');
     expect(prompt).toContain('说一声');
+    expect(prompt).toContain('监听会话');
+    expect(prompt).toContain('停止会话');
+    expect(prompt).toContain('plain @session:id reference alone is context');
     expect(prompt).toContain('session/new');
     expect(prompt).toContain('LLM memory only');
+    expect(prompt).toContain('Persists');
+    expect(prompt).toContain('later turns');
     expect(prompt).not.toContain('/card');
     expect(prompt).not.toContain('/dm');
     expect(prompt).toContain('A reply without the tool call does nothing');
@@ -273,10 +431,18 @@ describe('createContactTools', () => {
       CLEAR_CHAT_HISTORY_TOOL_NAME,
       LIST_PROJECTS_TOOL_NAME,
       LIST_SESSIONS_TOOL_NAME,
+      'read_session',
+      GET_ASSISTANT_SETTINGS_TOOL_NAME,
+      UPDATE_DEFAULT_PROMPT_TOOL_NAME,
       CREATE_ASSISTANT_TOOL_NAME,
       SCHEDULE_TASK_TOOL_NAME,
       MESSAGE_ASSISTANT_TOOL_NAME,
       ASSIGN_SESSION_TOOL_NAME,
+      WATCH_SESSION_TOOL_NAME,
+      STOP_SESSION_TOOL_NAME,
+      'steer_session',
+      'archive_session',
+      'delete_session',
     ]);
     expect(tools.some((tool) => ['bash', 'edit', 'read', 'write'].includes(tool.name))).toBe(false);
 
@@ -355,6 +521,91 @@ describe('createContactTools', () => {
     expect(onCard).toHaveBeenCalledTimes(3);
   });
 
+  it.each(['assign_session', 'watch_session'])('%s forwards AbortSignal and drops a late card after cancellation', async (name) => {
+    const controller = new AbortController();
+    const onCard = vi.fn();
+    const action = vi.fn(async input => {
+      expect(input.signal).toBe(controller.signal);
+      controller.abort();
+      return { sessionID: 'ses_late', directory: '/project', title: 'Late', status: 'busy' };
+    });
+    const tools = createContactTools({ assignWork: action, watchSession: action, onCard });
+    const tool = tools.find(t => t.name === name);
+    const result = await tool.execute('call', { sessionID: 'ses_late', prompt: 'work' }, controller.signal);
+    expect(result.details.error).toBeDefined();
+    expect(onCard).not.toHaveBeenCalled();
+    await tool.execute('call2', { sessionID: 'ses_late', prompt: 'work' }, controller.signal);
+    expect(action).toHaveBeenCalledTimes(1);
+  });
+
+  it('recognizes explicit session mutation requests and forwards cancellation signals', async () => {
+    const action = vi.fn(async () => ({ admitted: true }));
+    const tools = createContactTools({ steerSession: action, archiveSession: action, deleteSession: action });
+    expect(detectRequestedContactTools('取消这个 session', tools.map(t => t.name))).toEqual(['stop_session']);
+    expect(detectRequestedContactTools('归档这个会话', tools.map(t => t.name))).toEqual(['archive_session']);
+    expect(detectRequestedContactTools('删除这个 session', tools.map(t => t.name))).toEqual(['delete_session']);
+    expect(detectRequestedContactTools('给这个会话插话：先运行测试', tools.map(t => t.name))).toEqual(['steer_session']);
+    const controller = new AbortController();
+    const result = await tools.find(t => t.name === 'steer_session').execute('call', { sessionID: 'ses_exact', text: '先运行测试' }, controller.signal);
+    expect(action).toHaveBeenCalledWith({ sessionID: 'ses_exact', text: '先运行测试', signal: controller.signal });
+    expect(result.terminate).toBe(true);
+    expect(result.isError).not.toBe(true);
+    const invalid = await tools.find(t => t.name === 'steer_session').execute('call2', { sessionID: 'ses_exact', text: ' ' });
+    expect(invalid.details.error).toBe('validation_error');
+    expect(action).toHaveBeenCalledTimes(1);
+  });
+
+  it('watch_session emits a baseline session card and stop_session returns true abort results', async () => {
+    const onCard = vi.fn();
+    const watchSession = vi.fn(async () => ({
+      sessionID: 'ses_watch',
+      directory: '/repo',
+      title: 'Watched',
+      status: 'complete',
+      watched: true,
+      reused: true,
+    }));
+    const stopSession = vi.fn(async () => ({
+      sessionID: 'ses_watch',
+      directory: '/repo',
+      title: 'Watched',
+      aborted: true,
+    }));
+    const tools = createContactTools({ watchSession, stopSession, onCard });
+    const watched = await tools.find((tool) => tool.name === WATCH_SESSION_TOOL_NAME).execute('call_w', {
+      sessionID: 'ses_watch',
+    });
+    expect(watchSession).toHaveBeenCalledWith({ sessionID: 'ses_watch' });
+    expect(watched.terminate).toBe(true);
+    expect(watched.content[0].text).toBe(WATCHED_SESSION_FALLBACK_BUBBLE);
+    expect(watched.details.card).toMatchObject({
+      type: 'card',
+      cardType: 'session',
+      sessionID: 'ses_watch',
+      status: 'complete',
+    });
+    expect(onCard).toHaveBeenCalledTimes(1);
+
+    const stopped = await tools.find((tool) => tool.name === STOP_SESSION_TOOL_NAME).execute('call_s', {
+      sessionID: 'ses_watch',
+    });
+    expect(stopSession).toHaveBeenCalledWith({ sessionID: 'ses_watch' });
+    expect(stopped.terminate).toBe(true);
+    expect(stopped.content[0].text).toBe(STOPPED_SESSION_FALLBACK_BUBBLE);
+    expect(stopped.details.stopped).toMatchObject({ aborted: true, sessionID: 'ses_watch' });
+
+    const failedStop = createContactTools({
+      stopSession: async () => {
+        throw new AssignError(ASSIGN_CODES.UPSTREAM, 'abort refused');
+      },
+    });
+    const failed = await failedStop.find((tool) => tool.name === STOP_SESSION_TOOL_NAME).execute('call_f', {
+      sessionID: 'ses_watch',
+    });
+    expect(failed.details.error).toBe('upstream_error');
+    expect(failed.content[0].text).toContain('abort refused');
+  });
+
   it('forwards server turn file parts on assign and keeps model selection in the tool args', async () => {
     const image = { type: 'file', mime: 'image/png', url: 'data:image/png;base64,aa', filename: 'shot.png' };
     const assignWork = vi.fn(async (params) => ({
@@ -535,6 +786,138 @@ describe('createContactTools', () => {
     expect(failed.content[0].text).toContain('Session index is unavailable');
     expect(failed.details.sessions).toBeUndefined();
   });
+
+  it('reads assistant settings via live callback and formats empty defaultPrompt', async () => {
+    const readAssistantSettings = vi.fn(async () => ({
+      id: 'asst_host',
+      name: 'DeepSeekQA',
+      defaultPrompt: '',
+      providerID: 'p',
+      modelID: 'm',
+      agent: null,
+      variant: null,
+      mode: 'continuous',
+      workspacePath: null,
+      enabled: true,
+    }));
+    const tools = createContactTools({ readAssistantSettings });
+    const result = await tools.find((tool) => tool.name === GET_ASSISTANT_SETTINGS_TOOL_NAME).execute('call_get', {});
+    expect(readAssistantSettings).toHaveBeenCalledTimes(1);
+    expect(result.details.settings).toMatchObject({
+      id: 'asst_host',
+      name: 'DeepSeekQA',
+      defaultPrompt: '',
+      providerID: 'p',
+      modelID: 'm',
+      enabled: true,
+    });
+    expect(result.content[0].text).toContain('defaultPrompt: (empty)');
+    expect(result.terminate).toBe(false);
+  });
+
+  it('updates default prompt, no-ops when unchanged, and reports callback failures', async () => {
+    const updateAssistantSettings = vi.fn(async ({ defaultPrompt }) => {
+      if (defaultPrompt === 'same') {
+        return { updated: false, unchanged: true, defaultPrompt: 'same' };
+      }
+      return { updated: true, defaultPrompt };
+    });
+    const tools = createContactTools({ updateAssistantSettings });
+    const update = tools.find((tool) => tool.name === UPDATE_DEFAULT_PROMPT_TOOL_NAME);
+
+    const saved = await update.execute('call_set', { prompt: 'Be terse.' });
+    expect(updateAssistantSettings).toHaveBeenCalledWith({ defaultPrompt: 'Be terse.' });
+    expect(saved.details).toEqual({ updated: true, defaultPrompt: 'Be terse.' });
+    expect(saved.content[0].text).toBe(UPDATE_DEFAULT_PROMPT_CONFIRM_BUBBLE);
+    expect(saved.terminate).toBe(false);
+
+    const cleared = await update.execute('call_clear', { prompt: '' });
+    expect(updateAssistantSettings).toHaveBeenCalledWith({ defaultPrompt: '' });
+    expect(cleared.details).toEqual({ updated: true, defaultPrompt: '' });
+    expect(cleared.terminate).toBe(false);
+
+    const unchanged = await update.execute('call_same', { prompt: 'same' });
+    expect(unchanged.details).toEqual({ updated: false, unchanged: true, defaultPrompt: 'same' });
+    expect(unchanged.content[0].text).toBe(UPDATE_DEFAULT_PROMPT_UNCHANGED_BUBBLE);
+    expect(unchanged.terminate).toBe(false);
+
+    const missing = await update.execute('call_missing', {});
+    expect(missing.details.error).toBe('validation_error');
+    expect(missing.terminate).toBe(true);
+
+    updateAssistantSettings.mockRejectedValueOnce(Object.assign(new Error('revision_conflict'), { code: 'revision_conflict' }));
+    const conflicted = await update.execute('call_conflict', { prompt: 'X' });
+    expect(conflicted.details.error).toBe('revision_conflict');
+    expect(conflicted.terminate).toBe(true);
+
+    updateAssistantSettings.mockRejectedValueOnce(Object.assign(new Error('sqlite busy'), { code: 'upstream_error' }));
+    const storageFailed = await update.execute('call_storage', { prompt: 'Y' });
+    expect(storageFailed.details.error).toBe('upstream_error');
+    expect(storageFailed.terminate).toBe(true);
+  });
+
+  it('reads and updates another assistant defaultPrompt by name without changing self', async () => {
+    const peer = {
+      id: 'asst_peer',
+      name: 'OpenCode 配置助手',
+      defaultPrompt: 'old peer',
+      providerID: 'p',
+      modelID: 'm',
+      agent: null,
+      variant: null,
+      mode: 'continuous',
+      workspacePath: null,
+      enabled: true,
+    };
+    const host = {
+      id: 'asst_host',
+      name: 'Host',
+      defaultPrompt: 'host prompt',
+      providerID: 'p',
+      modelID: 'm',
+      agent: null,
+      variant: null,
+      mode: 'continuous',
+      workspacePath: null,
+      enabled: true,
+    };
+    const readAssistantSettings = vi.fn(async (input) => (
+      input?.assistantID === 'asst_peer' ? peer : host
+    ));
+    const updateAssistantSettings = vi.fn(async (patch) => ({
+      updated: true,
+      defaultPrompt: patch.defaultPrompt,
+    }));
+    const listAssistants = vi.fn(async () => [host, peer]);
+    const tools = createContactTools({
+      readAssistantSettings,
+      updateAssistantSettings,
+      listAssistants,
+      currentAssistant: host,
+    });
+
+    const got = await tools.find((tool) => tool.name === GET_ASSISTANT_SETTINGS_TOOL_NAME)
+      .execute('call_peer_get', { to: 'OpenCode 配置助手' });
+    expect(readAssistantSettings).toHaveBeenCalledWith({ assistantID: 'asst_peer' });
+    expect(got.details.settings).toMatchObject({ id: 'asst_peer', name: 'OpenCode 配置助手', defaultPrompt: 'old peer' });
+
+    const saved = await tools.find((tool) => tool.name === UPDATE_DEFAULT_PROMPT_TOOL_NAME)
+      .execute('call_peer_set', { to: 'OpenCode 配置助手', prompt: 'new peer persona' });
+    expect(updateAssistantSettings).toHaveBeenCalledWith({
+      defaultPrompt: 'new peer persona',
+      assistantID: 'asst_peer',
+    });
+    expect(saved.details).toMatchObject({
+      updated: true,
+      defaultPrompt: 'new peer persona',
+      assistantID: 'asst_peer',
+      name: 'OpenCode 配置助手',
+    });
+
+    const missing = await tools.find((tool) => tool.name === UPDATE_DEFAULT_PROMPT_TOOL_NAME)
+      .execute('call_missing_peer', { to: '没有这个助手', prompt: 'x' });
+    expect(missing.details.error).toBe('not_found');
+  });
 });
 
 describe('confirmBubbleAfterContactReset', () => {

package/server/lib/assistants/contracts.js

@@ -28,10 +28,41 @@ export const assistantContractFixtures = Object.freeze({
       text: 'Fixture reply',
       fallbackKind: null,
     }),
+    /** Countable assistant/peer replies after the shared read watermark. */
+    unreadCount: 0,
+    /** Persisted shared read watermark (multi-client). */
+    readWatermark: Object.freeze({
+      generation: 0,
+      ordinal: 2,
+      messageID: 'msg_contact_fixture',
+    }),
+    /** Highest safe mark-read tip (transcript head + generation). */
+    readTip: Object.freeze({
+      generation: 0,
+      ordinal: 2,
+      messageID: 'msg_contact_fixture',
+    }),
     createdAt: 1234,
     updatedAt: 1234,
     tombstoneAt: null,
   }),
+  /** Frozen POST /assistants/:id/contact/read response. */
+  contactReadResponse: Object.freeze({
+    assistantID: 'assistant_fixture',
+    changed: true,
+    unreadCount: 0,
+    readWatermark: Object.freeze({
+      generation: 0,
+      ordinal: 2,
+      messageID: 'msg_contact_fixture',
+    }),
+    readTip: Object.freeze({
+      generation: 0,
+      ordinal: 2,
+      messageID: 'msg_contact_fixture',
+    }),
+    revision: 4,
+  }),
   sessionBinding: Object.freeze({ sessionID: 'ses_fixture', directory: '/workspace', sessionGeneration: 4 }),
   compactResponse: Object.freeze({ binding: Object.freeze({ sessionID: 'ses_fixture', directory: '/workspace', sessionGeneration: 4 }), summarized: true }),
   messageAdmission: Object.freeze({ binding: Object.freeze({ sessionID: 'ses_fixture', directory: '/workspace', sessionGeneration: 4 }), messageID: 'msg_fixture', admitted: true, revision: 4 }),