Skip to content

The ultimate harness for coding agents and beyond. All your agents. All your machines. One command center. Start with code, then follow your curiosity and build across disciplines: CAD, circuits, robots, games and music.

7.5 KB
Raw Blame
import { mkdtempSync, readFileSync, rmSync } from 'node:fs'
import { tmpdir } from 'node:os'
import { join } from 'node:path'
import { afterEach, beforeEach, expect, it } from 'vitest'
import { CodingMemoryStore } from './store.js'
import { builtinSqlite } from '../../../cli/src/lib/sqliteBuiltin.js'
import type { Database } from './database.js'
import type { MemoryRecord, MemoryDraft, SourceEvent } from './types.js'
import type { ActivityReceiver } from './receipts.js'

let directory: string, store: CodingMemoryStore, now: number, memory: MemoryRecord
const receiver: ActivityReceiver = { agentId: 'working-agent', engine: 'codex', sessionId: 'private_receiver_lemur' }
const source: SourceEvent = { id: 'source', profileId: 'owner', projectId: null, engine: 'claude',
  sessionId: 'source-session', nativeEventId: 'source', role: 'user', eligibility: 'coding', observedAt: 900,
  rootIds: ['source'], text: 'For regression fixes, start with a small failing test.' }
const draft: MemoryDraft = { kind: 'working_preference', facet: 'testing', assertionType: 'stated_preference',
  scope: { profileId: 'owner' }, claim: source.text, rationale: null, futureAction: 'Start with a small failing test.',
  applicability: { task: 'bug_fix' }, exceptions: [], retrievalCues: ['regression'], evidenceClass: 'user_stated',
  evidence: [{ sourceEventId: 'source', quote: source.text, paths: ['/claim', '/futureAction', '/applicability'] }],
  conflictKey: 'test-first', validity: { validFrom: null, validUntil: null, recheckWhen: [] } }
const access = { profileId: 'owner', projectIds: ['project'], includeProfile: true }
const activity = (selected = receiver.agentId, receivers = [receiver]) => store.libraryActivity('owner', receivers, { agentId: selected })
function recall(query = 'regression', recipient = receiver, route: 'mcp' | 'prompt_hook' = 'prompt_hook') {
  ++now
  return store.prepareRecall({ query, conditions: { task: 'bug_fix' } },
    { engine: recipient.engine, sessionId: recipient.sessionId, projectId: 'project', route }, access)
}
function sql(run: (db: Database) => void) {
  const DB = builtinSqlite() as unknown as new(path: string) => Database
  const db = new DB(join(directory, 'memory.sqlite'))
  try { run(db) } finally { db.close() }
}
beforeEach(() => {
  directory = mkdtempSync(join(tmpdir(), 'memory-activity-')); now = 1_000
  const opened = CodingMemoryStore.open({ directory, profileId: 'owner', now: () => now })
  if (!opened.ok) throw new Error(opened.reason)
  store = opened.store; store.registerProject('project'); store.setControls({ learn: true, recall: true })
  store.ingest(source); memory = store.propose(draft, access).record
})
afterEach(() => { store.close(); rmSync(directory, { recursive: true, force: true }) })

it('shows the exact current selection and conditions without claiming model delivery', () => {
  const prepared = recall('regression private_prompt_capuchin')
  expect(activity()).toMatchObject({ selectedAgentId: receiver.agentId,
    sessions: [{ preparedAt: now, selectedCount: 1, delivery: 'unverified', emittedAt: null }],
    items: [{ record: { id: memory.id, revision: 1, applicability: { task: 'bug_fix' } },
      recall: { receiptId: prepared.receipt!.id, canFeedback: true, delivery: 'unverified' } }] })
  expect(store.recallEmitted(prepared.receipt!.id, { engine: receiver.engine, sessionId: receiver.sessionId,
    projectId: 'project', route: 'prompt_hook' }, access)).toBe(true)
  expect(activity().sessions[0]).toMatchObject({ emittedAt: now, delivery: 'unverified' })
})

it('replaces a positive selection with the latest empty recall without inventing a new history receipt', () => {
  const earlier = recall()
  const empty = recall('orchids', receiver, 'mcp')
  expect(empty.receipt).toBeNull()
  expect(activity()).toMatchObject({ sessions: [{ status: 'ok', selectedCount: 0, receiptId: null, preparedAt: now }], items: [] })
  expect(store.libraryDetail('owner', memory.id)!.recalls[0].receiptId).toBe(earlier.receipt!.id)
  const bytes = readFileSync(join(directory, 'memory.sqlite'))
  expect(bytes.includes(Buffer.from(receiver.sessionId))).toBe(false)
  expect(bytes.includes(Buffer.from('orchids'))).toBe(false)
})

it('separates receiving sessions and engines and does not silently switch a selected session', () => {
  recall()
  const other = { ...receiver, agentId: 'other', engine: 'claude' as const }
  recall('orchids', other)
  expect(activity(receiver.agentId, [receiver, other]).items).toHaveLength(1)
  expect(activity('other', [receiver, other]).items).toEqual([])
  expect(activity('missing', [receiver, other])).toMatchObject({ selectedAgentId: 'missing', items: [] })
  expect(activity(receiver.agentId, [{ ...receiver, sessionId: 'resumed-conversation' }]).sessions).toEqual([])
  expect(() => store.libraryActivity('another-owner', [receiver])).toThrow('scope_denied')
  expect(() => store.libraryActivity('owner', Array(129).fill(receiver))).toThrow('invalid_input')
})

it.each(['source', 'receiver', 'project'] as const)('withholds %s privacy changes and does not resurrect receiver activity', which => {
  recall()
  if (which === 'source') store.setSessionIncluded('claude', source.sessionId, false)
  if (which === 'receiver') store.setSessionIncluded(receiver.engine, receiver.sessionId, false)
  if (which === 'project') store.setProjectIncluded('project', false)
  expect(activity().items).toEqual([])
  if (which !== 'source') {
    expect(activity().sessions).toEqual([])
    if (which === 'receiver') store.setSessionIncluded(receiver.engine, receiver.sessionId, true)
    else store.setProjectIncluded('project', true)
    expect(activity().sessions).toEqual([])
  }
})

it('honors privacy set by an earlier writer and clears the old activity when reincluded', () => {
  recall()
  sql(db => db.prepare('UPDATE projects SET included=0 WHERE id=?').run('project'))
  expect(activity().sessions).toEqual([])
  store.setProjectIncluded('project', true)
  expect(activity().sessions).toEqual([])
})

it('never displays a corrected revision as if it were the version recalled earlier', () => {
  recall()
  const preview = store.libraryPreview('owner', { kind: 'narrow', id: memory.id, revision: 1, projectId: 'project' })
  store.libraryApply('owner', preview.command, preview.version, false)
  expect(activity()).toMatchObject({ sessions: [{ selectedCount: 1 }], items: [] })
  recall()
  expect(activity().items[0].record.revision).toBe(2)
  store.libraryForget('owner', memory.id, 2)
  expect(activity().items).toEqual([])
})

it('keeps feedback available for an exact selection outside the per-memory ten-session history', () => {
  const prepared = recall()
  for (let i = 0; i < 15; i++) recall('regression', { ...receiver, agentId: `agent-${i}`, sessionId: `session-${i}` })
  expect(store.libraryDetail('owner', memory.id)!.recalls.some(r => r.receiptId === prepared.receipt!.id)).toBe(false)
  expect(activity().items[0].recall.receiptId).toBe(prepared.receipt!.id)
  const preview = store.libraryPreview('owner', { kind: 'feedback', id: memory.id, revision: 1,
    receiptId: prepared.receipt!.id, value: 'helpful', expected: 0 })
  store.libraryApply('owner', preview.command, preview.version, false)
  expect(activity().items[0].recall.feedback.value).toBe('helpful')
})

it('does not infer current activity from legacy positive-only history or expired attempts', () => {
  recall()
  sql(db => db.prepare('DELETE FROM memory_recall_latest').run())
  expect(store.libraryDetail('owner', memory.id)!.recalls).toHaveLength(1)
  expect(activity().sessions).toEqual([])
  recall(); now += 30 * 86_400_000
  expect(activity().sessions).toEqual([])
})