@openchambery/web 1.19.15 → 1.19.16

package/server/lib/assistants/memory.js

@@ -0,0 +1,124 @@
+import { createHash } from 'node:crypto';
+import { getContactAssistantContextBoundary, getContactContextBoundary, getContactGeneration } from './contact-store.js';
+
+const SCAN_LIMIT = 200;
+const fail = (code) => { throw Object.assign(new Error(code), { code }); };
+const paramsObject = (value, keys) => {
+  if (!value || typeof value !== 'object' || Array.isArray(value) || Object.keys(value).some((key) => !keys.includes(key))) fail('validation_error');
+};
+const integer = (value, fallback, min, max) => {
+  if (value === undefined) return fallback;
+  if (!Number.isSafeInteger(value) || value < min || value > max) fail('validation_error');
+  return value;
+};
+const time = (value) => {
+  if (value === undefined) return null;
+  if (typeof value !== 'string' || !/^\d{4}-\d{2}-\d{2}T.+(?:Z|[+-]\d{2}:\d{2})$/u.test(value)) fail('validation_error');
+  const result = Date.parse(value);
+  if (!Number.isFinite(result)) fail('validation_error');
+  return result;
+};
+
+// Project only authored text, ordered exactly as the contact transcript.
+// Attachment bodies, URLs, peer DMs, diagnostics and tool payloads never leave this reader.
+const textRows = (count) => `
+  WITH text_parts AS (
+    SELECT message_id, json_extract(part_json, '$.text') AS text
+    FROM assistant_contact_part
+    WHERE message_id IN (${Array(count).fill('?').join(',')})
+      AND json_extract(part_json, '$.type') = 'text'
+      AND substr(json_extract(part_json, '$.text'), 1, 10) <> 'oc.settle.'
+    ORDER BY message_id, ordinal, part_id
+  ), texts AS (
+    SELECT message_id, group_concat(text, '') AS text FROM text_parts GROUP BY message_id
+  )`;
+
+/** One contact turn's read-only view, fenced again against live memory state on every call. */
+export function createContactMemoryReader(db, assistantID, { beforeOrdinal = null, assertAvailable = () => {} } = {}) {
+  const boundary = getContactContextBoundary(db, assistantID);
+  const assistantBoundary = getContactAssistantContextBoundary(db, assistantID);
+  const generation = getContactGeneration(db, assistantID);
+  const ceiling = Number(db.prepare('SELECT COALESCE(MAX(ordinal), 0) AS value FROM assistant_contact_message WHERE assistant_id=?').get(assistantID).value);
+  const eligible = (row) => row.role !== 'peer' && ['user', 'assistant'].includes(row.role)
+    && row.status === 'complete' && !row.from_assistant_id
+    && (row.role !== 'assistant' || row.ordinal > assistantBoundary)
+    && (row.role !== 'user' || beforeOrdinal === null || row.ordinal < beforeOrdinal);
+  const check = () => {
+    assertAvailable();
+    if (getContactGeneration(db, assistantID) !== generation || getContactContextBoundary(db, assistantID) !== boundary
+      || getContactAssistantContextBoundary(db, assistantID) !== assistantBoundary) fail('memory_scope_changed');
+  };
+  return {
+    search(params = {}) {
+      check();
+      paramsObject(params, ['query', 'from', 'to', 'limit', 'cursor']);
+      const query = params.query === undefined ? '' : params.query;
+      if (typeof query !== 'string' || query.length > 256) fail('validation_error');
+      const from = time(params.from);
+      const to = time(params.to);
+      if (from !== null && to !== null && from > to) fail('validation_error');
+      const limit = integer(params.limit, 10, 1, 20);
+      const scope = createHash('sha256').update(JSON.stringify([assistantID, boundary, assistantBoundary, generation, ceiling, beforeOrdinal, query, from, to])).digest('hex');
+      let cursor = null;
+      if (params.cursor !== undefined) {
+        if (typeof params.cursor !== 'string' || params.cursor.length > 2048 || !/^[A-Za-z0-9_-]+$/u.test(params.cursor)) fail('invalid_memory_cursor');
+        try { cursor = JSON.parse(Buffer.from(params.cursor, 'base64url').toString('utf8')); } catch { fail('invalid_memory_cursor'); }
+        if (cursor?.v !== 1 || cursor.scope !== scope || !Number.isSafeInteger(cursor.ordinal)
+          || cursor.ordinal <= boundary || cursor.ordinal > ceiling || typeof cursor.messageID !== 'string'
+          || !cursor.messageID || cursor.messageID.length > 512) fail('invalid_memory_cursor');
+      }
+      const rows = db.prepare(`SELECT message_id, role, created_at, ordinal, status, from_assistant_id
+        FROM assistant_contact_message WHERE assistant_id=? AND ordinal>? AND ordinal<=?
+        ${cursor ? 'AND (ordinal, message_id) < (?, ?)' : ''}
+        ORDER BY ordinal DESC, message_id DESC LIMIT ?`).all(
+        assistantID, boundary, ceiling, ...(cursor ? [cursor.ordinal, cursor.messageID] : []), SCAN_LIMIT + 1,
+      );
+      const candidates = rows.slice(0, SCAN_LIMIT);
+      const ids = candidates.filter((row) => eligible(row)
+        && (from === null || row.created_at >= from) && (to === null || row.created_at <= to)).map((row) => row.message_id);
+      const snippets = ids.length === 0 ? [] : db.prepare(`${textRows(ids.length)}
+        SELECT message_id, substr(text, max(instr(lower(text), lower(?)) - 80, 1), 400) AS snippet,
+          max(instr(lower(text), lower(?)) - 81, 0) AS snippet_offset, length(text) AS total_chars
+        FROM texts WHERE length(trim(text)) > 0 AND (? = '' OR instr(lower(text), lower(?)) > 0)
+      `).all(...ids, query, query, query, query);
+      const byID = new Map(snippets.map((row) => [row.message_id, row]));
+      const matches = [];
+      let scanned = 0;
+      for (const row of candidates) {
+        scanned += 1;
+        const snippet = byID.get(row.message_id);
+        if (snippet) matches.push({
+          messageID: row.message_id, role: row.role, createdAt: row.created_at,
+          snippet: snippet.snippet, offset: snippet.snippet_offset, totalChars: snippet.total_chars,
+        });
+        if (matches.length === limit) break;
+      }
+      const last = candidates[scanned - 1];
+      const hasMore = scanned < rows.length;
+      const nextCursor = hasMore && last ? Buffer.from(JSON.stringify({
+        v: 1, scope, ordinal: last.ordinal, messageID: last.message_id,
+      })).toString('base64url') : null;
+      return { matches, nextCursor, complete: nextCursor === null, scanned };
+    },
+    read(params = {}) {
+      check();
+      paramsObject(params, ['messageID', 'offset', 'maxChars']);
+      if (typeof params.messageID !== 'string' || !params.messageID || params.messageID.length > 512) fail('validation_error');
+      const offset = integer(params.offset, 0, 0, Number.MAX_SAFE_INTEGER);
+      const maxChars = integer(params.maxChars, 4000, 1, 8000);
+      const row = db.prepare(`SELECT message_id, role, created_at, ordinal, status, from_assistant_id
+        FROM assistant_contact_message WHERE assistant_id=? AND message_id=? AND ordinal>? AND ordinal<=?`).get(
+        assistantID, params.messageID, boundary, ceiling,
+      );
+      if (!row || !eligible(row)) fail('memory_not_found');
+      const content = db.prepare(`${textRows(1)} SELECT substr(text, ?, ?) AS text, length(text) AS total_chars FROM texts`).get(row.message_id, offset + 1, maxChars);
+      if (!content || !content.total_chars) fail('memory_not_found');
+      if (offset > content.total_chars) fail('validation_error');
+      const nextOffset = offset + maxChars < content.total_chars ? offset + maxChars : null;
+      return {
+        messageID: row.message_id, role: row.role, createdAt: row.created_at,
+        text: content.text, offset, totalChars: content.total_chars, nextOffset, complete: nextOffset === null,
+      };
+    },
+  };
+}

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

@@ -0,0 +1,159 @@
+import { createRequire } from 'node:module';
+import { afterEach, describe, expect, it } from 'vitest';
+import { createContactMemoryReader } from './memory.js';
+import { bumpContactGeneration, clearContactMemory, contactHistoryForLlm, deleteContactMessages, ensureContactSchema, insertContactMessage } from './contact-store.js';
+
+const Database = createRequire(import.meta.url)('better-sqlite3');
+const databases = [];
+afterEach(() => { while (databases.length) databases.pop().close(); });
+const fixture = () => {
+  const db = new Database(':memory:');
+  databases.push(db);
+  ensureContactSchema(db);
+  let ordinal = 0;
+  const insert = (messageID, text, { assistantID = 'a', role = 'user', turnID = messageID, ...extra } = {}) => {
+    insertContactMessage(db, {
+      messageID, assistantID, role, turnID, ordinal: ++ordinal, createdAt: 1_700_000_000_000 + ordinal,
+      parts: [{ type: 'text', text }], ...extra,
+    });
+    return ordinal;
+  };
+  return { db, insert };
+};
+
+describe('contact memory boundaries', () => {
+  it('forgets a preceding turn late reply while preserving queued users after clear-memory admission', () => {
+    const { db, insert } = fixture();
+    insert('prior', 'Old decision');
+    const clearing = insert('clearing', 'Clear memory');
+    insert('queued', 'New topic');
+    insert('late-prior', 'Old decision details', { role: 'assistant', turnID: 'prior' });
+    clearContactMemory(db, 'a', { upToOrdinal: clearing });
+    insert('reset-confirm', 'Ready for a new topic', { role: 'assistant', turnID: 'clearing' });
+    const reader = createContactMemoryReader(db, 'a');
+    expect(reader.search().matches.map((m) => m.messageID)).toEqual(['reset-confirm', 'queued']);
+    expect(() => reader.read({ messageID: 'late-prior' })).toThrow('memory_not_found');
+    expect(contactHistoryForLlm(db, 'a').map((m) => m.content)).toEqual(['New topic', 'Ready for a new topic']);
+  });
+
+  it('scopes exact reads, search and cursors to one assistant and rejects target overrides', () => {
+    const { db, insert } = fixture();
+    insert('a1', 'needle own'); insert('a2', 'needle own later');
+    insert('b1', 'needle other', { assistantID: 'b' });
+    const a = createContactMemoryReader(db, 'a');
+    const b = createContactMemoryReader(db, 'b');
+    expect(a.search({ query: 'needle' }).matches.map((m) => m.messageID)).toEqual(['a2', 'a1']);
+    expect(() => a.read({ messageID: 'b1' })).toThrow('memory_not_found');
+    expect(() => a.search({ assistantID: 'b' })).toThrow('validation_error');
+    expect(() => b.search({ query: 'needle', cursor: a.search({ query: 'needle', limit: 1 }).nextCursor })).toThrow('invalid_memory_cursor');
+  });
+
+  it('bounds scans and exposes empty partial pages until an older match is reached', () => {
+    const { db, insert } = fixture();
+    insert('old', 'rare decision');
+    for (let i = 0; i < 410; i++) insert(`filler-${i}`, 'ordinary');
+    const reader = createContactMemoryReader(db, 'a');
+    let page = reader.search({ query: 'rare' });
+    expect(page).toMatchObject({ matches: [], complete: false, scanned: 200 });
+    page = reader.search({ query: 'rare', cursor: page.nextCursor });
+    expect(page).toMatchObject({ matches: [], complete: false, scanned: 200 });
+    page = reader.search({ query: 'rare', cursor: page.nextCursor });
+    expect(page.matches.map((m) => m.messageID)).toEqual(['old']);
+    expect(page.complete).toBe(true);
+    expect(page.scanned).toBe(11);
+  });
+
+  it('paginates matching rows without gaps and returns literal, dated snippets', () => {
+    const { db, insert } = fixture();
+    for (let i = 0; i < 7; i++) insert(`match-${i}`, `100%_literal ${i}`);
+    const reader = createContactMemoryReader(db, 'a');
+    const ids = [];
+    let cursor;
+    do {
+      const page = reader.search({ query: '%_', limit: 2, ...(cursor ? { cursor } : {}) });
+      ids.push(...page.matches.map((m) => m.messageID));
+      cursor = page.nextCursor;
+    } while (cursor);
+    expect(ids).toEqual(['match-6', 'match-5', 'match-4', 'match-3', 'match-2', 'match-1', 'match-0']);
+    const page = reader.search({ from: new Date(1_700_000_000_003).toISOString(), to: new Date(1_700_000_000_004).toISOString() });
+    expect(page.matches.map((m) => m.messageID)).toEqual(['match-3', 'match-2']);
+  });
+
+  it('reads long Unicode messages by character offsets, including a match beyond the first chunk', () => {
+    const { db, insert } = fixture();
+    const text = '你好🙂'.repeat(2000) + 'rare ending';
+    insert('long', text);
+    const reader = createContactMemoryReader(db, 'a');
+    const found = reader.search({ query: 'rare' }).matches[0];
+    expect(found.snippet).toContain('rare ending');
+    expect(found.offset).toBeGreaterThan(4000);
+    let offset = 0;
+    let recovered = '';
+    do {
+      const page = reader.read({ messageID: 'long', offset, maxChars: 997 });
+      recovered += page.text;
+      offset = page.nextOffset;
+    } while (offset !== null);
+    expect(recovered).toBe(text);
+    expect(() => reader.read({ messageID: 'long', offset: 99999 })).toThrow('validation_error');
+  });
+
+  it('invalidates captured readers and cursors on clear and wipe, retaining visible history only for clear', () => {
+    const { db, insert } = fixture();
+    insert('old-1', 'old'); insert('old-2', 'old');
+    const reader = createContactMemoryReader(db, 'a');
+    const cursor = reader.search({ limit: 1 }).nextCursor;
+    clearContactMemory(db, 'a');
+    expect(() => reader.search({ cursor })).toThrow('memory_scope_changed');
+    expect(() => reader.read({ messageID: 'old-1' })).toThrow('memory_scope_changed');
+    const fresh = createContactMemoryReader(db, 'a');
+    expect(fresh.search().matches).toEqual([]);
+    expect(() => fresh.read({ messageID: 'old-1' })).toThrow('memory_not_found');
+    expect(() => fresh.search({ cursor })).toThrow('invalid_memory_cursor');
+    deleteContactMessages(db, 'a'); bumpContactGeneration(db, 'a');
+    expect(() => fresh.search()).toThrow('memory_scope_changed');
+    expect(createContactMemoryReader(db, 'a').search().matches).toEqual([]);
+  });
+
+  it('excludes peers, errors, internal markers, attachment bodies and later queued admissions', () => {
+    const { db, insert } = fixture();
+    insert('visible', 'visible');
+    const current = insert('current', 'current question');
+    insert('queued', 'queued secret');
+    insert('error', 'error secret', { role: 'assistant', status: 'error' });
+    insert('peer', 'peer secret', { role: 'peer', fromAssistantID: 'b' });
+    insert('internal', 'oc.settle.complete', { role: 'assistant' });
+    insert('file', '', { parts: [{ type: 'file', mime: 'text/plain', url: 'data:text/plain;base64,c2VjcmV0', filename: 'private.txt' }] });
+    const reader = createContactMemoryReader(db, 'a', { beforeOrdinal: current });
+    insert('future', 'future secret');
+    expect(reader.search().matches.map((m) => m.messageID)).toEqual(['visible']);
+    for (const id of ['current', 'queued', 'error', 'peer', 'internal', 'file', 'future']) expect(() => reader.read({ messageID: id })).toThrow('memory_not_found');
+  });
+
+  it('rejects malformed arguments and changed-filter cursors while database failures remain errors', () => {
+    const { db, insert } = fixture();
+    insert('one', 'needle'); insert('two', 'needle');
+    const reader = createContactMemoryReader(db, 'a');
+    for (const params of [{ limit: 21 }, { query: 1 }, { from: 'yesterday' }, { cursor: '{}' }, { cursor: 'bnVsbA' }]) expect(() => reader.search(params)).toThrow();
+    const cursor = reader.search({ query: 'needle', limit: 1 }).nextCursor;
+    expect(() => reader.search({ query: 'different', cursor })).toThrow('invalid_memory_cursor');
+    db.exec('DROP TABLE assistant_contact_part');
+    expect(() => reader.search()).toThrow();
+    expect(() => reader.read({ messageID: 'one' })).toThrow();
+  });
+
+  it('migrates existing boundaries and rolls both watermarks back on failed transactions', () => {
+    const { db, insert } = fixture();
+    insert('old', 'old text');
+    db.exec('ALTER TABLE assistant_contact_context_boundary DROP COLUMN assistant_after_ordinal');
+    db.prepare('INSERT INTO assistant_contact_context_boundary VALUES (?,?,?)').run('a', 1, 1);
+    ensureContactSchema(db);
+    insert('new', 'new text');
+    const reader = createContactMemoryReader(db, 'a');
+    expect(reader.search().matches.map((m) => m.messageID)).toEqual(['new']);
+    db.exec('BEGIN');
+    clearContactMemory(db, 'a');
+    db.exec('ROLLBACK');
+    expect(reader.search().matches.map((m) => m.messageID)).toEqual(['new']);
+  });
+});

package/server/lib/assistants/service.js

@@ -5,6 +5,7 @@ import path from 'node:path';
 import { createOpencodeClient } from '@opencode-ai/sdk/v2';
 import { validAssistantDeliveryParts } from '../assistant-delivery-parts.js';
 import { reduceBackfillState } from './history-state.js';
+import { createContactMemoryReader } from './memory.js';
 import { getWorktrees as defaultListWorktrees } from '../git/service.js';
 import { contactCardIdentity, parseContactCard, parseContactPart } from './cards.js';
 import {
@@ -2240,7 +2241,10 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
           history,
           { budgetBytes: CONTACT_ATTACHMENT_TURN_BUDGET_BYTES },
         );
+        const memory = createContactMemoryReader(db, assistantID, { assertAvailable: () => editable(assistantID) });
         const tools = createContactTools({
+          searchMemory: memory.search,
+          readMemory: memory.read,
           assignWork: (params) => assignWork(live, params),
           watchSession: (params) => watchSessionWork(live, params),
           stopSession: (params) => stopSessionWork(live, params),
@@ -2570,7 +2574,12 @@ export const createAssistantsService = ({ dbPath, dataDir, buildOpenCodeUrl, get
             (Array.isArray(executionParts) ? executionParts : []).filter((part) => part?.type === 'file'),
           );
           const turnAttachmentScope = attachmentScopeKey(turnFileParts);
+          const memory = createContactMemoryReader(db, row.assistant_id, {
+            beforeOrdinal, assertAvailable: () => editable(row.assistant_id),
+          });
           const tools = createContactTools({
+            searchMemory: memory.search,
+            readMemory: memory.read,
             assignWork: (params) => assignWork(row, params),
             watchSession: (params) => watchSessionWork(row, params),
             stopSession: (params) => stopSessionWork(row, params),