import { error as logError, log } from '../../logger' import { getDb } from '../../db/sqlite' import { publishSessionEvent } from '../transport' import { resolveSessionMemoryScope } from './scopes' import { createMemory, findSimilarPersonalMemory, updateMemory } from './store' import { parseMemoryFrontmatter } from './fileFormat' import { MemoryError, type MemoryWriteBackEntry, type SyncMemoriesResult, } from './types' /** * Memory write-back — agent → store ingest. * * Single responsibility: ingesting the memory files a bridge worker writes * back at turn end. Identity is derived from the session * (scopes.resolveSessionMemoryScope → owner_user_id) — caller-supplied * owner/team fields are ignored by design (anti-forgery, TDAM memory-bridge * lesson). Entries land in the owner's personal scope with * source_session_id provenance. * * Dedup: FTS recall over the owner's active personal memories by name; * a hit updates the existing row (content replace, version bump) instead * of inserting a near-duplicate. */ export function syncMemories( sessionId: string, entries: MemoryWriteBackEntry[], ): SyncMemoriesResult { const db = getDb() const { userId } = resolveSessionMemoryScope(db, sessionId) if (!userId) { throw new MemoryError( 'no_owner', 'Session has no user owner to attribute memories to', ) } const result: SyncMemoriesResult = { created: 0, updated: 0, skipped: 0 } for (const entry of entries) { const rel = entry.rel_path // Gate 1: skip working-layer scratch, dotfiles, non-markdown, and the // injected team/ subtree. Team memories were materialized INTO the pack; // a child edit to them must not fork a silent personal copy (team // memories change through the web UI / promote flow, never write-back). if ( rel === 'MEMORY.md' || rel === 'team/MEMORY.md' || rel.startsWith('team/') || rel.startsWith('.working/') || rel.includes('/.working/') || (rel.split('/').pop() ?? '').startsWith('.') || !rel.endsWith('.md') ) { result.skipped++ continue } const parsed = parseMemoryFrontmatter(entry.content) if (!parsed) { result.skipped++ continue } try { const existing = findSimilarPersonalMemory(db, userId, parsed.name) if (existing) { const updated = updateMemory(existing.id, { content: parsed.content, description: parsed.description ?? undefined, }) if (updated) result.updated++ } else { createMemory({ scopeKind: 'personal', ownerUserId: userId, name: parsed.name, description: parsed.description, type: parsed.type, content: parsed.content, layer: 'semantic', sourceSessionId: sessionId, }) result.created++ } } catch (err) { if (err instanceof MemoryError) { result.skipped++ } else { throw err } } } if (result.created + result.updated > 0) { try { publishSessionEvent( sessionId, 'memory_synced', { created: result.created, updated: result.updated }, 'outbound', ) } catch (err) { logError(`[memories] notify event failed session=${sessionId}:`, err) } log( `[memories] sync session=${sessionId} created=${result.created} updated=${result.updated} skipped=${result.skipped}`, ) } return result }