@openchambery/web 1.19.9 → 1.19.10-beta.2

package/server/lib/assistants/contact-store.js

@@ -37,6 +37,14 @@ export const CONTACT_SCHEMA_SQL = `
   );
   CREATE INDEX IF NOT EXISTS assistant_contact_watch_session
     ON assistant_contact_watch(session_id, status);
+  -- Per-assistant LLM context watermark. Messages with ordinal <= after_ordinal
+  -- stay in the transcript UI but are excluded from contactHistoryForLlm.
+  -- Survives restart. Cleared only when the transcript is fully deleted.
+  CREATE TABLE IF NOT EXISTS assistant_contact_context_boundary (
+    assistant_id TEXT PRIMARY KEY,
+    after_ordinal INTEGER NOT NULL,
+    updated_at INTEGER NOT NULL
+  );
 `;
 
 export const CONTACT_SETTLE_TEXT = Object.freeze({
@@ -154,6 +162,48 @@ export function deleteContactMessages(db, assistantID) {
   }
   db.prepare('DELETE FROM assistant_contact_message WHERE assistant_id=?').run(assistantID);
   db.prepare('DELETE FROM assistant_contact_watch WHERE assistant_id=?').run(assistantID);
+  db.prepare('DELETE FROM assistant_contact_context_boundary WHERE assistant_id=?').run(assistantID);
+}
+
+/** Durable LLM context watermark for one assistant (0 = no boundary). */
+export function getContactContextBoundary(db, assistantID) {
+  const row = db.prepare(
+    'SELECT after_ordinal FROM assistant_contact_context_boundary WHERE assistant_id=?',
+  ).get(assistantID);
+  if (!row || !Number.isFinite(Number(row.after_ordinal))) return 0;
+  return Number(row.after_ordinal);
+}
+
+/**
+ * Clear LLM memory only: keep every transcript row, advance the watermark so
+ * later contactHistoryForLlm drops prior turns.
+ *
+ * Prefer `upToOrdinal` (the clearing turn's user ordinal). Using global MAX
+ * would swallow later-admitted queued user rows and permanently exclude them
+ * from subsequent LLM windows. API/direct callers without a turn ceiling may
+ * omit `upToOrdinal` and clear through the current max.
+ * Never lowers an existing boundary. Failed callers must roll back the
+ * surrounding transaction to keep the old boundary.
+ */
+export function clearContactMemory(db, assistantID, { updatedAt = Date.now(), upToOrdinal = null } = {}) {
+  const current = getContactContextBoundary(db, assistantID);
+  const parsedCeiling = upToOrdinal == null || upToOrdinal === ''
+    ? NaN
+    : Number(upToOrdinal);
+  let afterOrdinal;
+  if (Number.isFinite(parsedCeiling)) {
+    afterOrdinal = parsedCeiling;
+  } else {
+    afterOrdinal = Number(db.prepare(
+      'SELECT COALESCE(MAX(ordinal), 0) AS max FROM assistant_contact_message WHERE assistant_id=?',
+    ).get(assistantID).max);
+  }
+  if (!Number.isFinite(afterOrdinal)) afterOrdinal = 0;
+  afterOrdinal = Math.max(afterOrdinal, current);
+  db.prepare(
+    'INSERT INTO assistant_contact_context_boundary(assistant_id, after_ordinal, updated_at) VALUES (?,?,?) ON CONFLICT(assistant_id) DO UPDATE SET after_ordinal=excluded.after_ordinal, updated_at=excluded.updated_at',
+  ).run(assistantID, afterOrdinal, updatedAt);
+  return { assistantID, afterOrdinal, memoryCleared: true };
 }
 
 export function upsertContactWatch(db, { assistantID, sessionID, directory, status, updatedAt }) {
@@ -202,14 +252,18 @@ export function updateSessionCardStatus(db, { assistantID, sessionID, status })
 }
 
 /**
- * LLM-only contact window. SQLite and the transcript UI may keep older bubbles;
- * this budget is the only model context. There is no summarizer and no
- * user-facing compress / continuous / stateless control on this path.
+ * LLM-only contact window. SQLite and the transcript UI may keep older bubbles
+ * (including rows before the durable context boundary). This budget is the only
+ * model context. There is no summarizer and no user-facing compress /
+ * continuous / stateless control on this path.
  *
  * A turn is a user message plus the assistant replies that follow it until the
  * next user. Newest turn is always kept, even when it exceeds the char budget.
  * Char estimate is text length plus CONTACT_LLM_FILE_CHAR_WEIGHT per file part
  * (CJK counts as one char; no tokenizer).
+ *
+ * clearContactMemory advances assistant_contact_context_boundary.after_ordinal;
+ * only messages with ordinal > that watermark enter this window.
  */
 export const CONTACT_LLM_MAX_TURNS = 8;
 export const CONTACT_LLM_MAX_CHARS = 6_000;
@@ -276,9 +330,40 @@ export function trimContactHistoryForLlm(messages, {
   return kept.reverse().flat();
 }
 
-export function contactHistoryForLlm(db, assistantID) {
+/**
+ * LLM window for one contact turn.
+ * - after_ordinal watermark drops cleared memory.
+ * - excludeMessageIDs drops the current admitted user row (prompt still gets userText).
+ * - beforeOrdinal is the current turn's user message ordinal. Later-admitted user
+ *   rows (queued turns) must not be injected into this turn; assistant rows written
+ *   after that ordinal by a prior completed lane turn still enter the window.
+ */
+export function contactHistoryForLlm(db, assistantID, { excludeMessageIDs = [], beforeOrdinal = null } = {}) {
+  const afterOrdinal = getContactContextBoundary(db, assistantID);
+  const exclude = new Set(
+    (Array.isArray(excludeMessageIDs) ? excludeMessageIDs : [])
+      .filter((id) => typeof id === 'string' && id),
+  );
+  // null/undefined must not become 0 via Number(null) — that would drop every user row.
+  const parsedCeiling = beforeOrdinal == null || beforeOrdinal === ''
+    ? NaN
+    : Number(beforeOrdinal);
+  const userOrdinalCeiling = Number.isFinite(parsedCeiling) ? parsedCeiling : null;
   const page = listContactMessages(db, assistantID, { limit: CONTACT_LLM_FETCH_LIMIT });
-  return trimContactHistoryForLlm(page.messages);
+  const messages = page.messages.filter((message) => {
+    if (exclude.has(message.messageID)) return false;
+    if (!(message.ordinal > afterOrdinal)) return false;
+    // Queued user admits after this turn's ordinal belong to later lane work.
+    if (
+      userOrdinalCeiling != null
+      && message.role === 'user'
+      && message.ordinal > userOrdinalCeiling
+    ) {
+      return false;
+    }
+    return true;
+  });
+  return trimContactHistoryForLlm(messages);
 }
 
 export { parseContactCard };

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

@@ -9,9 +9,11 @@ import {
   CONTACT_LLM_FILE_CHAR_WEIGHT,
   CONTACT_LLM_MAX_CHARS,
   CONTACT_LLM_MAX_TURNS,
+  clearContactMemory,
   contactHistoryForLlm,
   deleteContactMessages,
   ensureContactSchema,
+  getContactContextBoundary,
   insertContactMessage,
   listContactMessages,
   nextContactOrdinal,
@@ -30,6 +32,7 @@ const openDb = () => {
 
 const insert = (db, assistantID, { role, text = '', parts, status = 'complete', fromAssistantID = null, fromAssistantName = null }) => {
   const messageID = crypto.randomUUID();
+  const ordinal = nextContactOrdinal(db, assistantID);
   insertContactMessage(db, {
     messageID,
     assistantID,
@@ -37,13 +40,13 @@ const insert = (db, assistantID, { role, text = '', parts, status = 'complete',
     turnID: messageID,
     bubbleIndex: 0,
     createdAt: Date.now(),
-    ordinal: nextContactOrdinal(db, assistantID),
+    ordinal,
     status,
     parts: parts || (text ? [{ type: 'text', text }] : [{ type: 'text', text: '' }]),
     fromAssistantID,
     fromAssistantName,
   });
-  return messageID;
+  return { messageID, ordinal };
 };
 
 describe('contact LLM history trim', () => {
@@ -118,6 +121,25 @@ describe('contact LLM history trim', () => {
     ]);
   });
 
+  it('excludes later-admitted user rows past beforeOrdinal while keeping later assistant rows', () => {
+    const db = openDb();
+    const assistantID = 'asst_ceiling';
+    insert(db, assistantID, { role: 'user', text: 'prior-user' });
+    insert(db, assistantID, { role: 'assistant', text: 'prior-assistant' });
+    const current = insert(db, assistantID, { role: 'user', text: 'current-turn' });
+    insert(db, assistantID, { role: 'user', text: 'queued-later-user' });
+    insert(db, assistantID, { role: 'assistant', text: 'prior-lane-assistant-after-admit' });
+    expect(contactHistoryForLlm(db, assistantID, {
+      excludeMessageIDs: [current.messageID],
+      beforeOrdinal: current.ordinal,
+    })).toEqual([
+      { role: 'user', content: 'prior-user' },
+      { role: 'assistant', content: 'prior-assistant' },
+      { role: 'assistant', content: 'prior-lane-assistant-after-admit' },
+    ]);
+    db.close();
+  });
+
   it('clears LLM history after deleteContactMessages', () => {
     const db = openDb();
     const assistantID = 'asst_reset';
@@ -126,6 +148,109 @@ describe('contact LLM history trim', () => {
     deleteContactMessages(db, assistantID);
     expect(contactHistoryForLlm(db, assistantID)).toEqual([]);
     expect(listContactMessages(db, assistantID, { limit: 50 }).messages).toEqual([]);
+    expect(getContactContextBoundary(db, assistantID)).toBe(0);
+    db.close();
+  });
+
+  it('clearContactMemory keeps transcript rows and only advances the LLM boundary', () => {
+    const db = openDb();
+    const assistantID = 'asst_memory';
+    insert(db, assistantID, { role: 'user', text: 'secret-before' });
+    insert(db, assistantID, { role: 'assistant', text: 'remembered' });
+    const cleared = clearContactMemory(db, assistantID, { updatedAt: 42 });
+    expect(cleared).toMatchObject({ assistantID, memoryCleared: true, afterOrdinal: 2 });
+    expect(getContactContextBoundary(db, assistantID)).toBe(2);
+    expect(listContactMessages(db, assistantID, { limit: 50 }).messages.map((message) => message.text)).toEqual([
+      'secret-before',
+      'remembered',
+    ]);
+    expect(contactHistoryForLlm(db, assistantID)).toEqual([]);
+    insert(db, assistantID, { role: 'user', text: 'after-clear' });
+    insert(db, assistantID, { role: 'assistant', text: 'fresh-reply' });
+    expect(contactHistoryForLlm(db, assistantID)).toEqual([
+      { role: 'user', content: 'after-clear' },
+      { role: 'assistant', content: 'fresh-reply' },
+    ]);
+    db.close();
+  });
+
+  it('clearContactMemory upToOrdinal does not swallow later-admitted queued users', () => {
+    const db = openDb();
+    const assistantID = 'asst_queue_waterline';
+    insert(db, assistantID, { role: 'user', text: 'seed-secret' });
+    insert(db, assistantID, { role: 'assistant', text: 'seed-reply' });
+    const clearTurn = insert(db, assistantID, { role: 'user', text: '开新对话' });
+    const queued = insert(db, assistantID, { role: 'user', text: 'queued-after-admit' });
+    // Wrong: MAX would set afterOrdinal to queued.ordinal and permanently drop it.
+    const cleared = clearContactMemory(db, assistantID, {
+      updatedAt: 99,
+      upToOrdinal: clearTurn.ordinal,
+    });
+    expect(cleared.afterOrdinal).toBe(clearTurn.ordinal);
+    expect(getContactContextBoundary(db, assistantID)).toBe(clearTurn.ordinal);
+    expect(contactHistoryForLlm(db, assistantID)).toEqual([
+      { role: 'user', content: 'queued-after-admit' },
+    ]);
+    insert(db, assistantID, { role: 'assistant', text: 'queued-reply' });
+    insert(db, assistantID, { role: 'user', text: 'later-follow-up' });
+    const later = contactHistoryForLlm(db, assistantID);
+    expect(later.some((item) => item.content.includes('seed-secret'))).toBe(false);
+    expect(later.some((item) => item.content === 'queued-after-admit')).toBe(true);
+    expect(later.some((item) => item.content === 'queued-reply')).toBe(true);
+    expect(later.some((item) => item.content === 'later-follow-up')).toBe(true);
+    expect(queued.ordinal).toBeGreaterThan(clearTurn.ordinal);
+    db.close();
+  });
+
+  it('isolates context boundaries per assistant and survives reopen', () => {
+    const directory = fs.mkdtempSync(path.join(os.tmpdir(), 'contact-boundary-'));
+    const Database = require('better-sqlite3');
+    const dbPath = path.join(directory, 'contact.sqlite');
+    const db = new Database(dbPath);
+    ensureContactSchema(db);
+    insert(db, 'asst_a', { role: 'user', text: 'a-secret' });
+    insert(db, 'asst_a', { role: 'assistant', text: 'a-reply' });
+    insert(db, 'asst_b', { role: 'user', text: 'b-secret' });
+    insert(db, 'asst_b', { role: 'assistant', text: 'b-reply' });
+    clearContactMemory(db, 'asst_a', { updatedAt: 1 });
+    expect(contactHistoryForLlm(db, 'asst_a')).toEqual([]);
+    expect(contactHistoryForLlm(db, 'asst_b')).toEqual([
+      { role: 'user', content: 'b-secret' },
+      { role: 'assistant', content: 'b-reply' },
+    ]);
+    db.close();
+    const reopened = new Database(dbPath);
+    ensureContactSchema(reopened);
+    expect(getContactContextBoundary(reopened, 'asst_a')).toBe(2);
+    expect(contactHistoryForLlm(reopened, 'asst_a')).toEqual([]);
+    expect(listContactMessages(reopened, 'asst_a', { limit: 50 }).messages).toHaveLength(2);
+    expect(contactHistoryForLlm(reopened, 'asst_b')).toEqual([
+      { role: 'user', content: 'b-secret' },
+      { role: 'assistant', content: 'b-reply' },
+    ]);
+    reopened.close();
+  });
+
+  it('keeps the previous boundary when clearContactMemory write fails inside a transaction', () => {
+    const db = openDb();
+    const assistantID = 'asst_fail';
+    insert(db, assistantID, { role: 'user', text: 'first' });
+    clearContactMemory(db, assistantID, { updatedAt: 10 });
+    expect(getContactContextBoundary(db, assistantID)).toBe(1);
+    insert(db, assistantID, { role: 'user', text: 'second' });
+    insert(db, assistantID, { role: 'assistant', text: 'second-reply' });
+    db.exec('BEGIN IMMEDIATE');
+    try {
+      clearContactMemory(db, assistantID, { updatedAt: 20 });
+      throw new Error('forced_write_failure');
+    } catch {
+      db.exec('ROLLBACK');
+    }
+    expect(getContactContextBoundary(db, assistantID)).toBe(1);
+    expect(contactHistoryForLlm(db, assistantID)).toEqual([
+      { role: 'user', content: 'second' },
+      { role: 'assistant', content: 'second-reply' },
+    ]);
     db.close();
   });
 });

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

@@ -27,11 +27,15 @@ export const CREATE_ASSISTANT_TOOL_NAME = 'create_assistant';
 export const SCHEDULE_TASK_TOOL_NAME = 'schedule_task';
 export const MESSAGE_ASSISTANT_TOOL_NAME = 'message_assistant';
 export const NEW_CONVERSATION_TOOL_NAME = 'new_conversation';
+export const CLEAR_CHAT_HISTORY_TOOL_NAME = 'clear_chat_history';
 export const LIST_PROJECTS_TOOL_NAME = 'list_projects';
 export const LIST_SESSIONS_TOOL_NAME = 'list_sessions';
 const CONTACT_TOOL_FENCE = 'openchamber-tool';
 export const ASSIGNED_SESSION_FALLBACK_BUBBLE = 'Opened a coding session.';
-export const NEW_CONVERSATION_CONFIRM_BUBBLE = 'Started a new conversation. Previous contact messages are cleared.';
+/** Clear-memory confirm: transcript rows stay; only the LLM window resets. */
+export const NEW_CONVERSATION_CONFIRM_BUBBLE = 'Memory cleared. Previous messages stay in the chat; I will not use them as context.';
+/** Explicit transcript wipe confirm (clear_chat_history / POST contact/reset). */
+export const CLEAR_CHAT_HISTORY_CONFIRM_BUBBLE = 'Chat history cleared.';
 const LIST_SESSIONS_LIMIT_DEFAULT = 20;
 const LIST_SESSIONS_LIMIT_MAX = 50;
 
@@ -43,13 +47,18 @@ export const MISSED_TOOL_FAILURE_BUBBLE = 'I could not complete that. No tool ra
 
 const CREATE_ASSISTANT_INTENT = /建助理|新建[^。\n!]{0,24}助理|创建[^。\n!]{0,24}助理|加一个助理|create (?:an |a new )?assistant|new assistant/iu;
 const SCHEDULE_TASK_INTENT = /排定时任务|排个?定时任务|定时任务|schedule (?:a )?(?:daily )?(?:task|ping)|scheduled task|排个?(?:每日)?(?:任务|ping)/iu;
-const ASSIGN_SESSION_INTENT = /建会话|开会话|开(?:一个)?(?:编码\s*)?(?:session|会话)|open (?:a )?(?:coding )?session|assign_session/giu;
+const ASSIGN_SESSION_INTENT = /(?:建|开)(?:一个|个)?(?:新)?(?:编码\s*)?(?:session|会话)|open (?:a )?(?:coding )?session|assign_session/giu;
 const MESSAGE_ASSISTANT_INTENT = /给[^。\n]{1,40}说(?:一声)?|跟[^。\n]{1,24}说(?:一声)?|告诉(?!我)[^。\n]{1,40}|说一声|message (?:the )?(?:assistant|peer)|(?:tell|message)\s+[A-Za-z0-9._-]+|send (?:a )?message to/iu;
-const NEW_CONVERSATION_INTENT = /开新对话|新对话|清空(?:聊天|对话)|clear chat|new conversation|start over/iu;
+// Explicit wipe only — must stay stricter than the safe clear-memory intent.
+// `g` so hasClearChatHistoryIntent can walk matches and honor nearby negation.
+const CLEAR_CHAT_HISTORY_INTENT = /(?:清空|清除|删除)(?:聊天|对话)记录|wipe (?:the )?chat(?: history)?|delete (?:the )?(?:chat|conversation) history|clear (?:the )?(?:chat|conversation) history/giu;
+// Default safe semantics: fresh LLM context, keep the transcript UI.
+const NEW_CONVERSATION_INTENT = /开新对话|新对话|清除记忆|清空(?:聊天|对话)(?!记录)|clear memory|clear chat(?! history)|new conversation|start over|forget (?:everything|this|what we|what i)/giu;
 const LIST_PROJECTS_INTENT = /找项目|查项目|看看项目|有哪些项目|项目列表|list projects|find project|registered project|which project/iu;
 const LIST_SESSIONS_INTENT = /现有对话|现有会话|查会话|找会话|会话列表|有哪些会话|list sessions|find (?:a )?session|existing (?:conversation|session|chat)|active (?:conversation|session)/iu;
 const INTENT_NEGATION = /不要|别|不用|不开|don't|do\s+not/iu;
 const newConversationParameters = typeboxObject({});
+const clearChatHistoryParameters = typeboxObject({});
 
 const assignParameters = typeboxObject({
   prompt: typeboxString('Coding prompt to kick into the worker OpenCode session.'),
@@ -276,16 +285,29 @@ export function parseContactToolCalls(text, allowedNames = []) {
 
 const isNegatedAt = (text, index) => INTENT_NEGATION.test(text.slice(Math.max(0, index - 12), index));
 
-const hasAssignSessionIntent = (text) => {
-  ASSIGN_SESSION_INTENT.lastIndex = 0;
-  let match = ASSIGN_SESSION_INTENT.exec(text);
+const hasIntentMatch = (regex, text) => {
+  regex.lastIndex = 0;
+  let match = regex.exec(text);
   while (match) {
     if (!isNegatedAt(text, match.index)) return true;
-    match = ASSIGN_SESSION_INTENT.exec(text);
+    match = regex.exec(text);
   }
   return false;
 };
 
+const hasAssignSessionIntent = (text) => hasIntentMatch(ASSIGN_SESSION_INTENT, text);
+
+/**
+ * True when userText has an explicit, non-negated transcript-wipe phrase.
+ * Server core uses this to authorize clear_chat_history / resetContact — the
+ * model cannot self-authorize through tool parameters.
+ */
+export function userTextAuthorizesClearChatHistory(userText) {
+  return hasIntentMatch(CLEAR_CHAT_HISTORY_INTENT, typeof userText === 'string' ? userText : '');
+}
+
+const hasNewConversationIntent = (text) => hasIntentMatch(NEW_CONVERSATION_INTENT, text);
+
 /** Which attached tools the user asked for in natural language. */
 export function detectRequestedContactTools(userText, allowedNames = []) {
   const allowed = new Set(
@@ -295,7 +317,12 @@ export function detectRequestedContactTools(userText, allowedNames = []) {
   );
   const text = typeof userText === 'string' ? userText : '';
   const requested = [];
-  if (allowed.has(NEW_CONVERSATION_TOOL_NAME) && NEW_CONVERSATION_INTENT.test(text)) {
+  // Prefer explicit wipe over the safe clear-memory default when both could match.
+  // Negation (不要清除聊天记录) must not authorize delete.
+  const wantsClearHistory = allowed.has(CLEAR_CHAT_HISTORY_TOOL_NAME) && userTextAuthorizesClearChatHistory(text);
+  if (wantsClearHistory) {
+    requested.push(CLEAR_CHAT_HISTORY_TOOL_NAME);
+  } else if (allowed.has(NEW_CONVERSATION_TOOL_NAME) && hasNewConversationIntent(text)) {
     requested.push(NEW_CONVERSATION_TOOL_NAME);
   }
   if (allowed.has(LIST_PROJECTS_TOOL_NAME) && LIST_PROJECTS_INTENT.test(text)) {
@@ -394,7 +421,8 @@ export function formatContactToolsPrompt(tools) {
   if (list.length === 0) return '';
   return [
     'The user talks in natural language (including Chinese). Never ask them to type slash commands.',
-    'When they want a fresh contact chat (开新对话 / new conversation / clear chat), call new_conversation. That clears this contact transcript only. It is not OpenCode session/new and does not open a coding session.',
+    'When they want a fresh model context (开新对话 / new conversation / 清除记忆 / clear memory / clear chat), call new_conversation. That clears LLM memory only — chat history stays visible. It is not OpenCode session/new and does not open a coding session.',
+    'When they explicitly want to delete the stored chat (清空聊天记录 / clear chat history / delete chat history), call clear_chat_history. Do not use clear_chat_history for ordinary 开新对话 / new conversation wording.',
     'When they want to find a registered project (找项目 / list projects / "openchamber yee"), call list_projects or use the Registered projects block already in context.',
     'When they want existing conversations in a project (现有对话 / list sessions), call list_sessions.',
     'When they want another assistant (建助理 / create an assistant), call create_assistant.',
@@ -406,6 +434,9 @@ export function formatContactToolsPrompt(tools) {
     `{"name":"${NEW_CONVERSATION_TOOL_NAME}","arguments":{}}`,
     '```',
     `\`\`\`${CONTACT_TOOL_FENCE}`,
+    `{"name":"${CLEAR_CHAT_HISTORY_TOOL_NAME}","arguments":{}}`,
+    '```',
+    `\`\`\`${CONTACT_TOOL_FENCE}`,
     `{"name":"${LIST_PROJECTS_TOOL_NAME}","arguments":{"query":"openchamber yee"}}`,
     '```',
     `\`\`\`${CONTACT_TOOL_FENCE}`,
@@ -423,8 +454,9 @@ export function formatContactToolsPrompt(tools) {
     `\`\`\`${CONTACT_TOOL_FENCE}`,
     `{"name":"${ASSIGN_SESSION_TOOL_NAME}","arguments":{"prompt":"...","projectPath":"..."}}`,
     '```',
-    'If the user asked for more than one of these, do them in that order across turns: new_conversation, then list_projects, then list_sessions, then create_assistant, then schedule_task, then message_assistant, then assign_session.',
-    'new_conversation deletes this contact\'s stored messages and watches. It never calls session/new or createNew.',
+    'If the user asked for more than one of these, do them in that order across turns: new_conversation or clear_chat_history, then list_projects, then list_sessions, then create_assistant, then schedule_task, then message_assistant, then assign_session.',
+    'new_conversation advances this contact\'s LLM context boundary only. Stored messages and watches remain. It never calls session/new or createNew.',
+    'clear_chat_history deletes this contact\'s stored messages, parts, and watches. Use only for explicit wipe intent.',
     'You already receive the registered project catalog each turn. Prefer matching label/path yourself; list_projects refreshes or filters. Never claim you cannot see projects; never ask for a raw path when a name matches.',
     'list_sessions searches the OpenChamber session index for existing chats in a project. A failure is not an empty list — surface the error.',
     'assign_session opens a real OpenChamber/OpenCode session on a registered project (or reuses sessionID). You are not the worker.',
@@ -441,21 +473,45 @@ export function formatContactToolsPrompt(tools) {
   ].join('\n');
 }
 
+const isSuccessfulContextResetResult = (message) => (
+  message?.role === 'toolResult'
+  && !message.details?.error
+  && (
+    message.toolName === NEW_CONVERSATION_TOOL_NAME
+    || message.toolName === CLEAR_CHAT_HISTORY_TOOL_NAME
+    || message.details?.reset === true
+    || message.details?.memoryCleared === true
+    || message.details?.historyCleared === true
+  )
+);
+
 export function contactTurnHasSuccessfulReset(messages) {
+  return (Array.isArray(messages) ? messages : []).some(isSuccessfulContextResetResult);
+}
+
+/** True when this turn wiped the stored transcript (not just LLM memory). */
+export function contactTurnClearedChatHistory(messages) {
   return (Array.isArray(messages) ? messages : []).some((message) => (
-    message?.role === 'toolResult'
-    && (message.toolName === NEW_CONVERSATION_TOOL_NAME || message.details?.reset === true)
-    && !message.details?.error
+    isSuccessfulContextResetResult(message)
+    && (
+      message.toolName === CLEAR_CHAT_HISTORY_TOOL_NAME
+      || message.details?.historyCleared === true
+    )
   ));
 }
 
 /** After reset, keep only the short confirm — leftover pre-reset model text is discarded. */
-export function confirmBubbleAfterContactReset(bubbles) {
+export function confirmBubbleAfterContactReset(bubbles, preferredConfirm = NEW_CONVERSATION_CONFIRM_BUBBLE) {
   const list = (Array.isArray(bubbles) ? bubbles : [])
     .filter((item) => typeof item === 'string' && item.trim())
     .map((item) => item.trim());
-  const confirm = list.find((item) => item === NEW_CONVERSATION_CONFIRM_BUBBLE);
-  return [confirm || NEW_CONVERSATION_CONFIRM_BUBBLE];
+  const fallback = preferredConfirm === CLEAR_CHAT_HISTORY_CONFIRM_BUBBLE
+    ? CLEAR_CHAT_HISTORY_CONFIRM_BUBBLE
+    : NEW_CONVERSATION_CONFIRM_BUBBLE;
+  const confirm = list.find((item) => (
+    item === NEW_CONVERSATION_CONFIRM_BUBBLE || item === CLEAR_CHAT_HISTORY_CONFIRM_BUBBLE
+  ));
+  return [confirm || fallback];
 }
 
 export function extractContactCardsFromMessages(messages) {
@@ -485,6 +541,7 @@ export function createContactTools({
   createAssistant,
   scheduleTask,
   deliverPeerMessage,
+  clearContactMemory,
   resetContact,
   listAssistants,
   listProjects,
@@ -501,24 +558,50 @@ export function createContactTools({
       name: NEW_CONVERSATION_TOOL_NAME,
       label: 'New conversation',
       description: [
-        'Clear this assistant contact transcript (messages, parts, and watches).',
-        'Use when the user says 开新对话, new conversation, or clear chat.',
-        'Does not call OpenCode session/new or create a worker session.',
+        'Clear this assistant\'s LLM memory only. Chat history stays in the transcript UI.',
+        'Use when the user says 开新对话, new conversation, 清除记忆, clear memory, or clear chat.',
+        'Does not delete stored messages. Does not call OpenCode session/new.',
       ].join(' '),
       parameters: newConversationParameters,
+      execute: async () => {
+        try {
+          if (typeof clearContactMemory !== 'function') {
+            throw new AssignError('upstream_error', 'Clearing contact memory is unavailable.');
+          }
+          await clearContactMemory();
+          return {
+            content: [{ type: 'text', text: NEW_CONVERSATION_CONFIRM_BUBBLE }],
+            details: { reset: true, memoryCleared: true },
+            terminate: true,
+          };
+        } catch (error) {
+          return toolFailure(error, 'new_conversation_failed', 'Could not clear contact memory.');
+        }
+      },
+    },
+    {
+      name: CLEAR_CHAT_HISTORY_TOOL_NAME,
+      label: 'Clear chat history',
+      description: [
+        'Delete this assistant contact transcript (messages, parts, and watches).',
+        'Use only when the user explicitly says 清空聊天记录, clear chat history, or delete chat history.',
+        'Ordinary 开新对话 / new conversation must use new_conversation instead.',
+        'Does not call OpenCode session/new or create a worker session.',
+      ].join(' '),
+      parameters: clearChatHistoryParameters,
       execute: async () => {
         try {
           if (typeof resetContact !== 'function') {
-            throw new AssignError('upstream_error', 'Resetting this conversation is unavailable.');
+            throw new AssignError('upstream_error', 'Clearing chat history is unavailable.');
           }
           await resetContact();
           return {
-            content: [{ type: 'text', text: NEW_CONVERSATION_CONFIRM_BUBBLE }],
-            details: { reset: true },
+            content: [{ type: 'text', text: CLEAR_CHAT_HISTORY_CONFIRM_BUBBLE }],
+            details: { reset: true, historyCleared: true },
             terminate: true,
           };
         } catch (error) {
-          return toolFailure(error, 'new_conversation_failed', 'Could not start a new conversation.');
+          return toolFailure(error, 'clear_chat_history_failed', 'Could not clear chat history.');
         }
       },
     },