@openchambery/web 1.19.7-beta.13 → 1.19.7-beta.14

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

@@ -0,0 +1,36 @@
+import { describe, expect, it } from 'vitest'
+import { isContactSpokenPreamble, splitContactBubbles } from './bubbles.js'
+
+describe('splitContactBubbles', () => {
+  it('splits on blank lines into short bubbles', () => {
+    expect(splitContactBubbles('Hey.\n\nWant me to open the login session?')).toEqual([
+      'Hey.',
+      'Want me to open the login session?',
+    ])
+  })
+
+  it('keeps a single paragraph together', () => {
+    expect(splitContactBubbles('Just one bubble.')).toEqual(['Just one bubble.'])
+  })
+
+  it('returns an empty list for blank text', () => {
+    expect(splitContactBubbles('   \n\n  ')).toEqual([])
+  })
+})
+
+describe('isContactSpokenPreamble', () => {
+  it('accepts a short spoken line', () => {
+    expect(isContactSpokenPreamble('我去找一下')).toBe(true)
+    expect(isContactSpokenPreamble('On it.')).toBe(true)
+  })
+
+  it('rejects chain-of-thought and tool narration', () => {
+    expect(isContactSpokenPreamble('Let me think — I should match the project and call assign_session.')).toBe(false)
+    expect(isContactSpokenPreamble('I need to list_projects first.')).toBe(false)
+  })
+
+  it('rejects long or multi-bubble text', () => {
+    expect(isContactSpokenPreamble('a'.repeat(81))).toBe(false)
+    expect(isContactSpokenPreamble('先找项目。\n\n再开会话。')).toBe(false)
+  })
+})

package/server/lib/assistants/cards.js

@@ -0,0 +1,148 @@
+export const CONTACT_CARD_TYPES = Object.freeze(['session', 'assistant', 'schedule']);
+const CARD_TYPES = new Set(CONTACT_CARD_TYPES);
+// Assign / create_assistant / schedule_task auto-insert these cards.
+// project | worktree | watch MUST reuse this slot. Do not invent a second card system.
+
+const isRecord = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
+const string = (value) => (typeof value === 'string' && value.trim() ? value.trim() : '');
+
+const parseSessionCard = (value) => {
+  const sessionID = string(value.sessionID);
+  const directory = string(value.directory);
+  if (!sessionID || !directory) return null;
+  return {
+    type: 'card',
+    cardType: 'session',
+    sessionID,
+    directory,
+    title: string(value.title) || null,
+    status: string(value.status) || null,
+    branch: string(value.branch) || null,
+  };
+};
+
+const parseAssistantCard = (value) => {
+  const assistantID = string(value.assistantID);
+  const name = string(value.name);
+  const providerID = string(value.providerID);
+  const modelID = string(value.modelID);
+  if (!assistantID || !name || !providerID || !modelID) return null;
+  const mode = string(value.mode) === 'stateless' ? 'stateless' : 'continuous';
+  return {
+    type: 'card',
+    cardType: 'assistant',
+    assistantID,
+    name,
+    providerID,
+    modelID,
+    mode,
+  };
+};
+
+const parseScheduleCard = (value) => {
+  const taskID = string(value.taskID);
+  const projectID = string(value.projectID);
+  const name = string(value.name);
+  if (!taskID || !projectID || !name) return null;
+  return {
+    type: 'card',
+    cardType: 'schedule',
+    taskID,
+    projectID,
+    name,
+    kind: string(value.kind) || null,
+    time: string(value.time) || null,
+    timezone: string(value.timezone) || null,
+    prompt: string(value.prompt) || null,
+  };
+};
+
+/**
+ * First-class in-transcript card. Extensible via `cardType`.
+ * Session cards navigate with the existing session route, not markdown links.
+ */
+export function parseContactCard(value) {
+  if (!isRecord(value)) return null;
+  const cardType = string(value.cardType);
+  if (!CARD_TYPES.has(cardType)) return null;
+  if (cardType === 'session') return parseSessionCard(value);
+  if (cardType === 'assistant') return parseAssistantCard(value);
+  if (cardType === 'schedule') return parseScheduleCard(value);
+  return null;
+}
+
+function parseContactFilePart(value) {
+  if (!isRecord(value) || value.type !== 'file') return null;
+  const mime = string(value.mime);
+  const url = typeof value.url === 'string' && value.url.trim() ? value.url.trim() : '';
+  if (!mime || !url) return null;
+  const filename = string(value.filename);
+  return filename ? { type: 'file', mime, url, filename } : { type: 'file', mime, url };
+}
+
+export function parseContactPart(value) {
+  if (!isRecord(value)) return null;
+  if (value.type === 'text' && typeof value.text === 'string') {
+    return { type: 'text', text: value.text };
+  }
+  if (value.type === 'file') {
+    return parseContactFilePart(value);
+  }
+  if (value.type === 'card') {
+    return parseContactCard(value);
+  }
+  return null;
+}
+
+export function serializeContactPart(part, index) {
+  return {
+    id: part.id || `oc_contact_part:${index + 1}`,
+    ...part,
+  };
+}
+
+export function contactCardIdentity(card) {
+  if (!card || card.type !== 'card') return '';
+  if (card.cardType === 'session') return `session:${card.sessionID}:${card.directory}`;
+  if (card.cardType === 'assistant') return `assistant:${card.assistantID}`;
+  if (card.cardType === 'schedule') return `schedule:${card.projectID}:${card.taskID}`;
+  return card.cardType;
+}
+
+const createCardPart = (cardType, input, requiredMessage) => {
+  const card = parseContactCard({ type: 'card', cardType, ...input });
+  if (!card) {
+    const error = new Error(requiredMessage);
+    error.code = 'validation_error';
+    throw error;
+  }
+  return card;
+};
+
+/** Build a session card. Throws so insert paths fail closed. */
+export function createSessionCardPart(input) {
+  if (!string(input?.sessionID)) {
+    const error = new Error('sessionID is required');
+    error.code = 'validation_error';
+    throw error;
+  }
+  return createCardPart('session', input, 'Invalid session card');
+}
+
+export function createAssistantCardPart(input) {
+  if (!string(input?.assistantID)) {
+    const error = new Error('assistantID is required');
+    error.code = 'validation_error';
+    throw error;
+  }
+  return createCardPart('assistant', input, 'Invalid assistant card');
+}
+
+export function createScheduleCardPart(input) {
+  if (!string(input?.taskID) || !string(input?.projectID)) {
+    const error = new Error('taskID and projectID are required');
+    error.code = 'validation_error';
+    throw error;
+  }
+  return createCardPart('schedule', input, 'Invalid schedule card');
+}

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

@@ -0,0 +1,116 @@
+import { describe, expect, it } from 'vitest'
+import { CONTACT_CARD_TYPES, createSessionCardPart, parseContactCard, parseContactPart } from './cards.js'
+
+describe('contact cards', () => {
+  it('creates an extensible session card part', () => {
+    const part = createSessionCardPart({
+      sessionID: 'ses_1',
+      directory: '/tmp/project',
+      title: 'Fix login',
+      status: 'idle',
+      branch: 'feat-login',
+    })
+    expect(part).toEqual({
+      type: 'card',
+      cardType: 'session',
+      sessionID: 'ses_1',
+      directory: '/tmp/project',
+      title: 'Fix login',
+      status: 'idle',
+      branch: 'feat-login',
+    })
+    expect(CONTACT_CARD_TYPES).toContain('session')
+    expect(CONTACT_CARD_TYPES).toContain('assistant')
+    expect(CONTACT_CARD_TYPES).toContain('schedule')
+  })
+
+  it('creates assistant and schedule cards in the same slot', () => {
+    expect(parseContactCard({
+      cardType: 'assistant',
+      assistantID: 'asst_flow',
+      name: 'FlowQA',
+      providerID: 'opencode-go',
+      modelID: 'deepseek-v4-flash',
+    })).toEqual({
+      type: 'card',
+      cardType: 'assistant',
+      assistantID: 'asst_flow',
+      name: 'FlowQA',
+      providerID: 'opencode-go',
+      modelID: 'deepseek-v4-flash',
+      mode: 'continuous',
+    })
+    expect(parseContactCard({
+      cardType: 'schedule',
+      taskID: 'task_1',
+      projectID: 'proj_1',
+      name: 'Daily ping',
+      kind: 'daily',
+      time: '18:00',
+      timezone: 'Asia/Shanghai',
+      prompt: 'ping',
+    })).toMatchObject({
+      type: 'card',
+      cardType: 'schedule',
+      taskID: 'task_1',
+      projectID: 'proj_1',
+      name: 'Daily ping',
+      kind: 'daily',
+      time: '18:00',
+    })
+  })
+
+  it('rejects unknown card types so later types reuse this slot', () => {
+    expect(parseContactCard({
+      cardType: 'not-a-card',
+      sessionID: 'ses_1',
+      directory: '/tmp/project',
+    })).toBeNull()
+  })
+
+  it('parses contact file parts with optional filename', () => {
+    expect(parseContactPart({
+      type: 'file',
+      mime: 'image/png',
+      url: 'data:image/png;base64,aa',
+      filename: 'shot.png',
+    })).toEqual({
+      type: 'file',
+      mime: 'image/png',
+      url: 'data:image/png;base64,aa',
+      filename: 'shot.png',
+    })
+    expect(parseContactPart({
+      type: 'file',
+      mime: 'text/plain',
+      url: 'data:text/plain;base64,eA==',
+    })).toEqual({
+      type: 'file',
+      mime: 'text/plain',
+      url: 'data:text/plain;base64,eA==',
+    })
+    expect(parseContactPart({ type: 'file', mime: 'image/png' })).toBeNull()
+  })
+
+  it('requires a sessionID for session cards', () => {
+    expect(() => createSessionCardPart({ directory: '/tmp/project' })).toThrow(/sessionID/)
+  })
+
+  it('treats omitted branch as null so older persisted cards still parse', () => {
+    expect(parseContactCard({
+      cardType: 'session',
+      sessionID: 'ses_1',
+      directory: '/tmp/project',
+      title: 'Fix login',
+      status: 'idle',
+    })).toEqual({
+      type: 'card',
+      cardType: 'session',
+      sessionID: 'ses_1',
+      directory: '/tmp/project',
+      title: 'Fix login',
+      status: 'idle',
+      branch: null,
+    })
+  })
+})

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

@@ -0,0 +1,284 @@
+import { parseContactCard, parseContactPart, serializeContactPart } from './cards.js';
+
+const json = (value) => JSON.stringify(value);
+const parse = (value) => JSON.parse(value);
+
+export const CONTACT_SCHEMA_SQL = `
+  CREATE TABLE IF NOT EXISTS assistant_contact_message (
+    message_id TEXT PRIMARY KEY,
+    assistant_id TEXT NOT NULL,
+    role TEXT NOT NULL,
+    turn_id TEXT NOT NULL,
+    bubble_index INTEGER NOT NULL DEFAULT 0,
+    created_at INTEGER NOT NULL,
+    ordinal INTEGER NOT NULL,
+    status TEXT NOT NULL DEFAULT 'complete',
+    from_assistant_id TEXT,
+    from_assistant_name TEXT
+  );
+  CREATE INDEX IF NOT EXISTS assistant_contact_message_page
+    ON assistant_contact_message(assistant_id, ordinal, message_id);
+  CREATE TABLE IF NOT EXISTS assistant_contact_part (
+    message_id TEXT NOT NULL,
+    part_id TEXT NOT NULL,
+    ordinal INTEGER NOT NULL,
+    part_json TEXT NOT NULL,
+    PRIMARY KEY (message_id, part_id)
+  );
+  CREATE INDEX IF NOT EXISTS assistant_contact_part_message
+    ON assistant_contact_part(message_id, ordinal, part_id);
+  CREATE TABLE IF NOT EXISTS assistant_contact_watch (
+    assistant_id TEXT NOT NULL,
+    session_id TEXT NOT NULL,
+    directory TEXT,
+    status TEXT NOT NULL,
+    updated_at INTEGER NOT NULL,
+    PRIMARY KEY (assistant_id, session_id)
+  );
+  CREATE INDEX IF NOT EXISTS assistant_contact_watch_session
+    ON assistant_contact_watch(session_id, status);
+`;
+
+export const CONTACT_SETTLE_TEXT = Object.freeze({
+  complete: 'oc.settle.complete',
+  error: 'oc.settle.error',
+  question: 'oc.settle.question',
+});
+
+const IN_FLIGHT_WATCH = new Set(['busy', 'question']);
+
+export function ensureContactSchema(db) {
+  db.exec(CONTACT_SCHEMA_SQL);
+  const columns = new Set(db.prepare("SELECT name FROM pragma_table_info('assistant_contact_message')").all().map((column) => column.name));
+  if (!columns.has('from_assistant_id')) db.exec('ALTER TABLE assistant_contact_message ADD COLUMN from_assistant_id TEXT');
+  if (!columns.has('from_assistant_name')) db.exec('ALTER TABLE assistant_contact_message ADD COLUMN from_assistant_name TEXT');
+}
+
+const decodeCursor = (value) => {
+  if (value == null || value === '') return null;
+  const parsed = JSON.parse(Buffer.from(String(value), 'base64url').toString('utf8'));
+  if (!Number.isSafeInteger(parsed?.ordinal) || typeof parsed?.messageID !== 'string') return null;
+  return parsed;
+};
+
+const encodeCursor = (row) => Buffer.from(json({ ordinal: row.ordinal, messageID: row.message_id })).toString('base64url');
+
+const hydrateMessage = (db, row) => {
+  const parts = db.prepare(
+    'SELECT part_json FROM assistant_contact_part WHERE message_id=? ORDER BY ordinal ASC, part_id ASC',
+  ).all(row.message_id).map((part) => parse(part.part_json)).map(parseContactPart).filter(Boolean);
+  const fromAssistantID = typeof row.from_assistant_id === 'string' && row.from_assistant_id.trim() ? row.from_assistant_id : null;
+  const storedName = typeof row.from_assistant_name === 'string' && row.from_assistant_name.trim() ? row.from_assistant_name : null;
+  let liveName = null;
+  if (fromAssistantID) {
+    try {
+      liveName = db.prepare('SELECT name FROM assistant_v2 WHERE assistant_id=?').get(fromAssistantID)?.name;
+    } catch {
+      liveName = null;
+    }
+  }
+  return {
+    messageID: row.message_id,
+    assistantID: row.assistant_id,
+    role: row.role,
+    turnID: row.turn_id,
+    bubbleIndex: row.bubble_index,
+    createdAt: row.created_at,
+    ordinal: row.ordinal,
+    status: row.status,
+    fromAssistantID,
+    fromAssistantName: storedName || (typeof liveName === 'string' && liveName.trim() ? liveName : null),
+    parts,
+    text: parts.filter((part) => part.type === 'text').map((part) => part.text).join(''),
+    cards: parts.filter((part) => part.type === 'card'),
+  };
+};
+
+export function nextContactOrdinal(db, assistantID) {
+  return Number(db.prepare(
+    'SELECT COALESCE(MAX(ordinal), 0) + 1 AS next FROM assistant_contact_message WHERE assistant_id=?',
+  ).get(assistantID).next);
+}
+
+export function insertContactMessage(db, {
+  messageID,
+  assistantID,
+  role,
+  turnID,
+  bubbleIndex = 0,
+  createdAt,
+  ordinal,
+  status = 'complete',
+  parts,
+  fromAssistantID = null,
+  fromAssistantName = null,
+}) {
+  db.prepare(
+    'INSERT INTO assistant_contact_message(message_id,assistant_id,role,turn_id,bubble_index,created_at,ordinal,status,from_assistant_id,from_assistant_name) VALUES (?,?,?,?,?,?,?,?,?,?)',
+  ).run(messageID, assistantID, role, turnID, bubbleIndex, createdAt, ordinal, status, fromAssistantID, fromAssistantName);
+  parts.forEach((part, index) => {
+    const serialized = serializeContactPart(part, index);
+    db.prepare(
+      'INSERT INTO assistant_contact_part(message_id,part_id,ordinal,part_json) VALUES (?,?,?,?)',
+    ).run(messageID, serialized.id, index + 1, json(serialized));
+  });
+}
+
+export function listContactMessages(db, assistantID, { before, limit = 50 } = {}) {
+  const cursor = before == null || before === '' ? null : decodeCursor(before);
+  if (before && !cursor) {
+    const error = new Error('validation_error');
+    error.code = 'validation_error';
+    throw error;
+  }
+  const rows = cursor
+    ? db.prepare(
+      'SELECT * FROM assistant_contact_message WHERE assistant_id=? AND (ordinal<? OR (ordinal=? AND message_id<?)) ORDER BY ordinal DESC, message_id DESC LIMIT ?',
+    ).all(assistantID, cursor.ordinal, cursor.ordinal, cursor.messageID, limit + 1)
+    : db.prepare(
+      'SELECT * FROM assistant_contact_message WHERE assistant_id=? ORDER BY ordinal DESC, message_id DESC LIMIT ?',
+    ).all(assistantID, limit + 1);
+  const page = rows.slice(0, limit);
+  const nextCursor = rows.length > limit && page[page.length - 1] ? encodeCursor(page[page.length - 1]) : null;
+  return {
+    messages: [...page].reverse().map((row) => hydrateMessage(db, row)),
+    nextCursor,
+    complete: nextCursor === null,
+  };
+}
+
+export function deleteContactMessages(db, assistantID) {
+  const ids = db.prepare('SELECT message_id FROM assistant_contact_message WHERE assistant_id=?').all(assistantID).map((row) => row.message_id);
+  for (const messageID of ids) {
+    db.prepare('DELETE FROM assistant_contact_part WHERE message_id=?').run(messageID);
+  }
+  db.prepare('DELETE FROM assistant_contact_message WHERE assistant_id=?').run(assistantID);
+  db.prepare('DELETE FROM assistant_contact_watch WHERE assistant_id=?').run(assistantID);
+}
+
+export function upsertContactWatch(db, { assistantID, sessionID, directory, status, updatedAt }) {
+  db.prepare(
+    'INSERT INTO assistant_contact_watch(assistant_id,session_id,directory,status,updated_at) VALUES (?,?,?,?,?) ON CONFLICT(assistant_id,session_id) DO UPDATE SET directory=excluded.directory,status=excluded.status,updated_at=excluded.updated_at',
+  ).run(assistantID, sessionID, directory || null, status, updatedAt);
+}
+
+export function listWatchesBySession(db, sessionID) {
+  return db.prepare('SELECT assistant_id, session_id, directory, status FROM assistant_contact_watch WHERE session_id=?').all(sessionID)
+    .map((row) => ({
+      assistantID: row.assistant_id,
+      sessionID: row.session_id,
+      directory: row.directory,
+      status: row.status,
+    }));
+}
+
+export function listInFlightWatches(db, assistantID) {
+  const rows = typeof assistantID === 'string' && assistantID
+    ? db.prepare('SELECT assistant_id, session_id, directory, status FROM assistant_contact_watch WHERE assistant_id=?').all(assistantID)
+    : db.prepare('SELECT assistant_id, session_id, directory, status FROM assistant_contact_watch').all();
+  return rows
+    .filter((row) => IN_FLIGHT_WATCH.has(row.status))
+    .map((row) => ({
+      assistantID: row.assistant_id,
+      sessionID: row.session_id,
+      directory: row.directory,
+      status: row.status,
+    }));
+}
+
+export function updateSessionCardStatus(db, { assistantID, sessionID, status }) {
+  const rows = db.prepare(
+    'SELECT p.message_id, p.part_id, p.ordinal, p.part_json FROM assistant_contact_part p JOIN assistant_contact_message m ON m.message_id=p.message_id WHERE m.assistant_id=?',
+  ).all(assistantID);
+  let updated = 0;
+  for (const row of rows) {
+    const part = parseContactPart(parse(row.part_json));
+    if (!part || part.type !== 'card' || part.cardType !== 'session' || part.sessionID !== sessionID) continue;
+    const next = { ...part, status };
+    db.prepare('UPDATE assistant_contact_part SET part_json=? WHERE message_id=? AND part_id=?').run(json(serializeContactPart(next, row.ordinal - 1)), row.message_id, row.part_id);
+    updated += 1;
+  }
+  return updated;
+}
+
+/**
+ * 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.
+ *
+ * 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).
+ */
+export const CONTACT_LLM_MAX_TURNS = 8;
+export const CONTACT_LLM_MAX_CHARS = 6_000;
+export const CONTACT_LLM_FETCH_LIMIT = 40;
+export const CONTACT_LLM_FILE_CHAR_WEIGHT = 80;
+
+const estimateLlmChars = (item) => {
+  const text = typeof item.content === 'string' ? item.content.length : 0;
+  const files = Array.isArray(item.parts) ? item.parts.length * CONTACT_LLM_FILE_CHAR_WEIGHT : 0;
+  return text + files;
+};
+
+const toLlmHistoryItem = (message) => {
+  const files = message.parts.filter((part) => part.type === 'file');
+  const content = message.text.trim() || (files.length > 0 ? '[attachment]' : '');
+  return files.length > 0 ? { role: message.role, content, parts: files } : { role: message.role, content };
+};
+
+const isLlmEligibleContactMessage = (message) => {
+  if (message.role !== 'user' && message.role !== 'assistant') return false;
+  if (message.status === 'error') return false;
+  // Peer DMs are read-only inbox rows. They must not become harness turns.
+  if (message.role === 'peer' || message.fromAssistantID) return false;
+  const hasText = Boolean(message.text?.trim());
+  const hasFiles = Array.isArray(message.parts) && message.parts.some((part) => part.type === 'file');
+  // Drop pure-card, tool-trace, and thinking-only rows. Process text is not
+  // persisted as contact bubbles; card-only rows have neither text nor files.
+  return hasText || hasFiles;
+};
+
+/** Turn-aware keep of recent user+assistant text pairs for the model only. */
+export function trimContactHistoryForLlm(messages, {
+  maxTurns = CONTACT_LLM_MAX_TURNS,
+  maxChars = CONTACT_LLM_MAX_CHARS,
+} = {}) {
+  const eligible = (Array.isArray(messages) ? messages : [])
+    .filter(isLlmEligibleContactMessage)
+    .map(toLlmHistoryItem)
+    .filter((item) => item.content.trim().length > 0);
+
+  const turns = [];
+  let current = [];
+  for (let index = eligible.length - 1; index >= 0; index -= 1) {
+    const item = eligible[index];
+    if (item.role === 'user') {
+      current.unshift(item);
+      turns.push(current);
+      current = [];
+    } else {
+      current.unshift(item);
+    }
+  }
+  if (current.length > 0) turns.push(current);
+
+  const kept = [];
+  let chars = 0;
+  for (const turn of turns) {
+    const turnChars = turn.reduce((sum, item) => sum + estimateLlmChars(item), 0);
+    if (kept.length >= maxTurns) break;
+    if (kept.length > 0 && chars + turnChars > maxChars) break;
+    kept.push(turn);
+    chars += turnChars;
+  }
+  return kept.reverse().flat();
+}
+
+export function contactHistoryForLlm(db, assistantID) {
+  const page = listContactMessages(db, assistantID, { limit: CONTACT_LLM_FETCH_LIMIT });
+  return trimContactHistoryForLlm(page.messages);
+}
+
+export { parseContactCard };