@devflow-tools/memory-engine 0.17.8 → 0.18.1

package/dist/memory-store.js

@@ -3,28 +3,20 @@ import * as sqliteVec from 'sqlite-vec';
 import { dirname, join } from 'node:path';
 import { existsSync, mkdirSync } from 'node:fs';
 import { createHash, randomUUID } from 'node:crypto';
-import { applyV2ToV3Migration } from './migrations/v2-to-v3.js';
-import { applyV3ToV4Migration } from './migrations/v3-to-v4.js';
-import { applyV4ToV5Migration } from './migrations/v4-to-v5.js';
-import { applyV6ToV7Migration } from './migrations/v6-to-v7.js';
-import { applyV7ToV8Migration } from './migrations/v7-to-v8.js';
-import { applyV8ToV9Migration } from './migrations/v8-to-v9.js';
-import { applyV9ToV10Migration } from './migrations/v9-to-v10.js';
-import { applyV10ToV11Migration } from './migrations/v10-to-v11.js';
-import { applyV11ToV12Migration } from './migrations/v11-to-v12.js';
-import { applyV12ToV13Migration } from './migrations/v12-to-v13.js';
+import { createMiniLmEmbeddingProfile, } from '@devflow-tools/sdk';
 import { observationDedupKey, } from './observation-types.js';
-import { analysesConflict, analyzePreference, analyzePreferenceObservation, } from './preference-conflicts.js';
-import { mergeSemanticEntities, normalizeEntityKey, normalizeSemanticMemory, } from './semantic-memory.js';
+import { mergeSemanticEntities, normalizeEntityKey, } from './semantic-memory.js';
 import { emitSemanticControlLog } from '@devflow-tools/telemetry';
-import { sanitizeDurableMemoryNarrative } from './durable-memory-text.js';
 // ── Schema ─────────────────────────────────────────────
-const SCHEMA_V2 = `
+const MEMORY_SCHEMA = `
 -- ============================================================
 -- Core: memories (expanded from v1)
 -- ============================================================
 CREATE TABLE IF NOT EXISTS memories (
   id                TEXT PRIMARY KEY,
+  project_id        TEXT NOT NULL,
+  memory_namespace  TEXT NOT NULL,
+  actor_id          TEXT NOT NULL,
   type              TEXT NOT NULL DEFAULT 'fact'
                     CHECK(type IN ('constraint','pattern','preference','lesson','fact',
                                    'semantic','episodic','procedural','failure_lesson',
@@ -43,7 +35,7 @@ CREATE TABLE IF NOT EXISTS memories (
   confidence        REAL NOT NULL DEFAULT 0.5,
   tags              TEXT NOT NULL DEFAULT '[]',
   scope             TEXT NOT NULL DEFAULT '',
-  session_id        TEXT,
+  session_id        TEXT NOT NULL,
   created_at        INTEGER NOT NULL,
   updated_at        INTEGER NOT NULL,
   last_reinforced_at INTEGER,
@@ -151,17 +143,26 @@ CREATE TABLE IF NOT EXISTS session_events (
   dialog_score REAL NOT NULL DEFAULT 0,
   user_message TEXT,
   kind         TEXT,
-  payload      TEXT
+  payload      TEXT,
+  maintenance_status TEXT NOT NULL DEFAULT 'active',
+  quarantine_reason TEXT
 );
 CREATE INDEX IF NOT EXISTS idx_session_events_session ON session_events(session_id);
 CREATE INDEX IF NOT EXISTS idx_session_events_project ON session_events(project);
 CREATE INDEX IF NOT EXISTS idx_session_events_processed ON session_events(processed);
+CREATE INDEX IF NOT EXISTS idx_session_events_maintenance
+  ON session_events(maintenance_status, processed, created_at);
+CREATE INDEX IF NOT EXISTS idx_session_events_reconciliation
+  ON session_events(session_id, processed, maintenance_status, created_at, id);
 
 -- ============================================================
 -- Observations (Summarizer output — intermediate layer)
 -- ============================================================
 CREATE TABLE IF NOT EXISTS observations (
   id               TEXT PRIMARY KEY,
+  project_id       TEXT NOT NULL,
+  memory_namespace TEXT NOT NULL,
+  actor_id         TEXT NOT NULL,
   session_id       TEXT NOT NULL,
   project          TEXT NOT NULL DEFAULT '',
   type             TEXT NOT NULL,
@@ -193,12 +194,35 @@ CREATE TABLE IF NOT EXISTS observations (
   entities TEXT NOT NULL DEFAULT '[]',
   temporal TEXT,
   reinforce_count INTEGER NOT NULL DEFAULT 0,
-  last_reinforced_at INTEGER
+  last_reinforced_at INTEGER,
+  quality_status TEXT NOT NULL DEFAULT 'accepted',
+  quarantine_reason TEXT,
+  quality_details TEXT,
+  quarantined_at INTEGER,
+  resolution_state TEXT NOT NULL DEFAULT 'current',
+  superseded_by_observation TEXT,
+  failure_category TEXT,
+  capsule TEXT NOT NULL DEFAULT '{}',
+  projection TEXT NOT NULL DEFAULT '{}',
+  extraction_version TEXT NOT NULL DEFAULT 'canonical.v1'
 );
 CREATE INDEX IF NOT EXISTS idx_observations_session ON observations(session_id);
 CREATE INDEX IF NOT EXISTS idx_observations_project ON observations(project);
 CREATE INDEX IF NOT EXISTS idx_observations_memory ON observations(memory_id);
 CREATE INDEX IF NOT EXISTS idx_observations_type ON observations(type);
+CREATE UNIQUE INDEX IF NOT EXISTS idx_observations_dedup ON observations(dedup_key);
+CREATE INDEX IF NOT EXISTS idx_observations_quality
+  ON observations(quality_status, resolution_state, timestamp);
+CREATE INDEX IF NOT EXISTS idx_observations_failure_category
+  ON observations(failure_category, timestamp);
+CREATE INDEX IF NOT EXISTS idx_observations_explicit_acceptance
+  ON observations(project, type, source, explicit_accepted_at);
+CREATE INDEX IF NOT EXISTS idx_observations_evidence
+  ON observations(project, source, evidence_status, resolution_state);
+CREATE INDEX IF NOT EXISTS idx_observations_semantic_key
+  ON observations(project, semantic_key, resolution_state, quality_status);
+CREATE INDEX IF NOT EXISTS idx_observations_facet_key
+  ON observations(project, facet_key, resolution_state, quality_status);
 
 CREATE TABLE IF NOT EXISTS turn_observation_lineage (
   turn_event_id TEXT NOT NULL,
@@ -240,6 +264,17 @@ CREATE TABLE IF NOT EXISTS embeddings (
 );
 CREATE INDEX IF NOT EXISTS idx_embeddings_source ON embeddings(source_type, source_id);
 
+CREATE TABLE IF NOT EXISTS embedding_profiles (
+  source_type TEXT NOT NULL CHECK(source_type IN ('memory','observation')),
+  source_id TEXT NOT NULL,
+  profile_hash TEXT NOT NULL,
+  generation INTEGER NOT NULL CHECK(generation > 0),
+  source_content_hash TEXT NOT NULL,
+  PRIMARY KEY (source_type, source_id)
+);
+CREATE INDEX IF NOT EXISTS idx_embedding_profiles_generation
+  ON embedding_profiles(source_type, profile_hash, generation);
+
 -- ============================================================
 -- Access log (drives reinforcement boost)
 -- ============================================================
@@ -248,6 +283,10 @@ CREATE TABLE IF NOT EXISTS access_log (
   memory_id   TEXT NOT NULL REFERENCES memories(id) ON DELETE CASCADE,
   access_type TEXT NOT NULL CHECK(access_type IN ('search_hit','user_view','agent_use','manual_ref')),
   session_id  TEXT,
+  query       TEXT,
+  purpose     TEXT,
+  rank        INTEGER,
+  score       REAL,
   timestamp   INTEGER NOT NULL
 );
 CREATE INDEX IF NOT EXISTS idx_access_log_memory ON access_log(memory_id);
@@ -282,6 +321,126 @@ CREATE TABLE IF NOT EXISTS signals (
 );
 CREATE INDEX IF NOT EXISTS idx_signals_session ON signals(session_id);
 CREATE INDEX IF NOT EXISTS idx_signals_type ON signals(type);
+
+CREATE TABLE IF NOT EXISTS distill_leases (
+  batch_id TEXT PRIMARY KEY,
+  event_ids TEXT NOT NULL,
+  session_ids TEXT NOT NULL,
+  event_count INTEGER NOT NULL,
+  created_at INTEGER NOT NULL,
+  expires_at INTEGER NOT NULL,
+  status TEXT NOT NULL CHECK(status IN ('pending','committed','expired'))
+);
+CREATE INDEX IF NOT EXISTS idx_leases_expires ON distill_leases(status, expires_at);
+
+CREATE TABLE IF NOT EXISTS distill_lease_pages (
+  batch_id TEXT NOT NULL,
+  page INTEGER NOT NULL,
+  total_pages INTEGER NOT NULL,
+  read_at INTEGER NOT NULL,
+  PRIMARY KEY (batch_id, page),
+  FOREIGN KEY (batch_id) REFERENCES distill_leases(batch_id) ON DELETE CASCADE
+);
+CREATE INDEX IF NOT EXISTS idx_distill_pages_batch ON distill_lease_pages(batch_id, page);
+
+CREATE TABLE IF NOT EXISTS distill_receipts (
+  receipt_id TEXT PRIMARY KEY,
+  batch_id TEXT NOT NULL UNIQUE,
+  status TEXT NOT NULL CHECK(status IN ('committed', 'committed_empty')),
+  observation_count INTEGER NOT NULL,
+  event_count INTEGER NOT NULL,
+  created_at INTEGER NOT NULL,
+  FOREIGN KEY (batch_id) REFERENCES distill_leases(batch_id) ON DELETE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS retrieval_access_log (
+  id TEXT PRIMARY KEY,
+  source_type TEXT NOT NULL CHECK(source_type IN ('memory','observation')),
+  source_id TEXT NOT NULL,
+  access_type TEXT NOT NULL CHECK(access_type IN ('selected','consumed','verified','rejected','positive_outcome','negative_outcome','unknown_outcome')),
+  session_id TEXT,
+  query TEXT,
+  purpose TEXT,
+  rank INTEGER,
+  score REAL,
+  timestamp INTEGER NOT NULL,
+  project TEXT NOT NULL DEFAULT '',
+  request_id TEXT,
+  execution_id TEXT,
+  workflow_run_id TEXT,
+  context_receipt TEXT,
+  tool_evidence TEXT,
+  outcome_reason TEXT,
+  verification_receipt TEXT,
+  idempotency_key TEXT
+);
+CREATE INDEX IF NOT EXISTS idx_retrieval_access_source
+  ON retrieval_access_log(source_type, source_id, timestamp);
+CREATE INDEX IF NOT EXISTS idx_retrieval_access_timestamp ON retrieval_access_log(timestamp);
+CREATE INDEX IF NOT EXISTS idx_retrieval_access_request
+  ON retrieval_access_log(project, request_id, execution_id, timestamp);
+CREATE UNIQUE INDEX IF NOT EXISTS idx_retrieval_access_idempotency
+  ON retrieval_access_log(idempotency_key) WHERE idempotency_key IS NOT NULL;
+CREATE INDEX IF NOT EXISTS idx_retrieval_access_outcome
+  ON retrieval_access_log(source_type, source_id, access_type, timestamp DESC);
+
+CREATE TABLE IF NOT EXISTS maintenance_checkpoints (
+  action TEXT PRIMARY KEY,
+  cursor TEXT,
+  details TEXT NOT NULL DEFAULT '{}',
+  updated_at INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS memory_maintenance_runs (
+  id TEXT PRIMARY KEY,
+  mode TEXT NOT NULL CHECK(mode IN ('dry-run','apply')),
+  actions TEXT NOT NULL,
+  manifest TEXT NOT NULL,
+  created_at INTEGER NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_memory_maintenance_runs_created
+  ON memory_maintenance_runs(created_at);
+
+CREATE TABLE IF NOT EXISTS event_processing_audit (
+  id TEXT PRIMARY KEY,
+  event_id TEXT NOT NULL,
+  disposition TEXT NOT NULL,
+  reason TEXT NOT NULL,
+  run_id TEXT,
+  timestamp INTEGER NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_event_processing_event
+  ON event_processing_audit(event_id, timestamp);
+CREATE INDEX IF NOT EXISTS idx_event_processing_run_disposition
+  ON event_processing_audit(run_id, disposition);
+
+CREATE TABLE IF NOT EXISTS event_duplicate_quarantine (
+  group_key TEXT PRIMARY KEY,
+  event_ids TEXT NOT NULL,
+  reason TEXT NOT NULL,
+  created_at INTEGER NOT NULL,
+  resolved_at INTEGER
+);
+
+CREATE TABLE IF NOT EXISTS observation_entities (
+  observation_id TEXT NOT NULL REFERENCES observations(id) ON DELETE CASCADE,
+  project TEXT NOT NULL,
+  normalized_entity TEXT NOT NULL,
+  display_entity TEXT NOT NULL,
+  PRIMARY KEY (observation_id, normalized_entity)
+);
+CREATE INDEX IF NOT EXISTS idx_observation_entities_lookup
+  ON observation_entities(project, normalized_entity, observation_id);
+
+CREATE TABLE IF NOT EXISTS observation_relations (
+  source_observation_id TEXT NOT NULL REFERENCES observations(id) ON DELETE CASCADE,
+  target_observation_id TEXT NOT NULL REFERENCES observations(id) ON DELETE CASCADE,
+  type TEXT NOT NULL CHECK(type IN ('related_to', 'supersedes', 'references', 'contradicts', 'continues')),
+  created_at INTEGER NOT NULL,
+  PRIMARY KEY (source_observation_id, target_observation_id, type)
+);
+CREATE INDEX IF NOT EXISTS idx_observation_relations_target
+  ON observation_relations(target_observation_id, type);
 `;
 const FTS_TRIGGERS = `
 CREATE TRIGGER IF NOT EXISTS memories_ai AFTER INSERT ON memories BEGIN
@@ -352,7 +511,6 @@ END;
 const MAX_OBSERVATION_FTS_QUERY_LENGTH = 512;
 const MAX_OBSERVATION_FTS_TERMS = 16;
 const MAX_OBSERVATION_FTS_TERM_LENGTH = 64;
-const OBSERVATION_FTS_SCHEMA_VERSION = 6;
 const OBSERVATION_EXCLUSION_CTE = `
   WITH excluded_observation_ids(id) AS (
     SELECT CAST(value AS TEXT) FROM json_each(?)
@@ -403,30 +561,18 @@ function normalizeObservationLexicalQuery(query) {
             : null,
     };
 }
-export function isRecoverableObservationFtsError(error) {
-    const candidate = error;
-    const code = typeof candidate?.code === 'string' ? candidate.code.toUpperCase() : '';
-    const message = typeof candidate?.message === 'string' ? candidate.message : '';
-    if (/^SQLITE_(?:BUSY|LOCKED|READONLY|IOERR|FULL|CANTOPEN|PERM)/.test(code))
-        return false;
-    if (code === 'SQLITE_CORRUPT_VTAB')
-        return true;
-    const referencesObservationFts = /observations_(?:terms_)?fts(?:_(?:data|idx|content|docsize|config))?/i
-        .test(message);
-    if (!referencesObservationFts)
-        return false;
-    if (/^SQLITE_CORRUPT(?:_|$)/.test(code))
-        return true;
-    return code === 'SQLITE_ERROR' && /no such table|malformed schema|vtable constructor failed/i.test(message);
-}
 // ── MemoryStore ─────────────────────────────────────────
 export class MemoryStore {
+    embeddingProfile;
+    projectIdentity;
     db;
     dbPath;
     defaultProjectRoot;
     leaseStore = null;
     retrievalRevision = 0;
-    constructor(rootPath) {
+    constructor(rootPath, embeddingProfile = createMiniLmEmbeddingProfile('memory_retrieval'), projectIdentity) {
+        this.embeddingProfile = embeddingProfile;
+        this.projectIdentity = projectIdentity;
         this.defaultProjectRoot = rootPath;
         const memDir = join(rootPath, '.devflow', 'memory');
         if (!existsSync(memDir))
@@ -437,22 +583,10 @@ export class MemoryStore {
         this.db.pragma('busy_timeout = 5000');
         this.db.pragma('foreign_keys = ON');
         sqliteVec.load(this.db);
-        this.db.exec(SCHEMA_V2);
+        this.assertCanonicalSchemaOrEmpty();
+        this.db.exec(MEMORY_SCHEMA);
+        this.db.exec(OBSERVATION_FTS_SCHEMA);
         this.db.exec(FTS_TRIGGERS);
-        this.dropOrphanedObservationFtsTriggers();
-        this.migrateV1ToV2();
-        applyV2ToV3Migration(this.db);
-        applyV3ToV4Migration(this.db);
-        applyV4ToV5Migration(this.db);
-        this.ensureObservationFts();
-        applyV6ToV7Migration(this.db);
-        applyV7ToV8Migration(this.db);
-        applyV8ToV9Migration(this.db);
-        applyV9ToV10Migration(this.db);
-        applyV10ToV11Migration(this.db);
-        applyV11ToV12Migration(this.db, rootPath);
-        applyV12ToV13Migration(this.db);
-        this.repairOrphanSessions(rootPath);
         emitSemanticControlLog({
             event: 'memory.engine.transitioned', identity: { projectRoot: this.defaultProjectRoot }, level: 'debug', timestamp: Date.now(),
             data: { stage: 'store_initialized', database: 'memories.db', tableCount: this.countTables() },
@@ -465,152 +599,42 @@ export class MemoryStore {
         const row = this.db.prepare("SELECT COUNT(*) as c FROM sqlite_master WHERE type='table'").get();
         return row.c;
     }
-    dropOrphanedObservationFtsTriggers() {
-        const ftsTables = this.db.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name IN ('observations_fts', 'observations_terms_fts')").all();
-        if (ftsTables.length === 2)
+    assertCanonicalSchemaOrEmpty() {
+        const memories = this.getTableColumns('memories');
+        if (memories.length === 0)
             return;
-        this.db.exec(`
-      DROP TRIGGER IF EXISTS observations_fts_ai;
-      DROP TRIGGER IF EXISTS observations_fts_ad;
-      DROP TRIGGER IF EXISTS observations_fts_au;
-    `);
-    }
-    ensureObservationFts(forceRebuild = false) {
-        this.db.transaction(() => {
-            const ftsTableCount = this.db.prepare("SELECT COUNT(*) AS count FROM sqlite_master WHERE type = 'table' AND name IN ('observations_fts', 'observations_terms_fts')").get().count;
-            const migrationApplied = this.db.prepare('SELECT 1 FROM schema_versions WHERE version = ?').get(OBSERVATION_FTS_SCHEMA_VERSION) !== undefined;
-            const triggersCurrent = this.db.prepare(`
-        SELECT COUNT(*) AS count
-        FROM sqlite_master
-        WHERE type = 'trigger'
-          AND name IN ('observations_fts_ai', 'observations_fts_ad', 'observations_fts_au')
-          AND sql LIKE '%observations_terms_fts%'
-      `).get().count === 3;
-            const needsRebuild = forceRebuild
-                || ftsTableCount !== 2
-                || !migrationApplied
-                || !triggersCurrent;
-            if (needsRebuild) {
-                this.db.exec(`
-          DROP TRIGGER IF EXISTS observations_fts_ai;
-          DROP TRIGGER IF EXISTS observations_fts_ad;
-          DROP TRIGGER IF EXISTS observations_fts_au;
-        `);
-            }
-            if (forceRebuild) {
-                this.db.exec(`
-          DROP TABLE IF EXISTS observations_fts;
-          DROP TABLE IF EXISTS observations_terms_fts;
-        `);
-            }
-            this.db.exec(OBSERVATION_FTS_SCHEMA);
-            if (!needsRebuild)
-                return;
-            this.db.exec(`
-        DELETE FROM observations_fts;
-        DELETE FROM observations_terms_fts;
-
-        INSERT INTO observations_fts(rowid, id, title, narrative, facts, concepts)
-        SELECT o.rowid, o.id, o.title, o.narrative, o.facts, o.concepts
-        FROM observations o
-        WHERE o.quality_status = 'accepted'
-          AND o.resolution_state = 'current';
-
-        INSERT INTO observations_terms_fts(rowid, id, title, narrative, facts, concepts)
-        SELECT o.rowid, o.id, o.title, o.narrative, o.facts, o.concepts
-        FROM observations o
-        WHERE o.quality_status = 'accepted'
-          AND o.resolution_state = 'current';
-      `);
-            this.db.prepare('INSERT OR REPLACE INTO schema_versions(version, applied_at) VALUES (?, ?)').run(OBSERVATION_FTS_SCHEMA_VERSION, Date.now());
-        })();
-    }
-    // ── V1 → V2 Migration ────────────────────────────
-    migrateV1ToV2() {
-        const tables = this.db.prepare("SELECT name FROM sqlite_master WHERE type='table'").all().map(r => r.name);
-        // If old 'events' table exists, migrate data to session_events
-        if (tables.includes('events') && tables.includes('session_events')) {
-            const count = this.db.prepare('SELECT COUNT(*) as c FROM events').get();
-            if (count.c > 0) {
-                try {
-                    this.db.exec(`
-            INSERT OR IGNORE INTO session_events
-              (id, session_id, project, tool, command, exit_code, stderr,
-               duration_ms, created_at, processed, l1_score, dialog_score, user_message)
-            SELECT id, session_id, '', tool, command, exit_code, stderr,
-                   duration_ms, created_at, processed,
-                   COALESCE(l1_score, 0), COALESCE(dialog_score, 0), user_message
-            FROM events
-          `);
-                    emitSemanticControlLog({
-                        event: 'memory.write.completed', identity: { projectRoot: this.defaultProjectRoot }, level: 'info', timestamp: Date.now(),
-                        data: { stage: 'event_migration', migrated: count.c },
-                    });
-                }
-                catch (err) {
-                    emitSemanticControlLog({
-                        event: 'memory.write.degraded', identity: { projectRoot: this.defaultProjectRoot }, level: 'warn', timestamp: Date.now(),
-                        data: { stage: 'event_migration', reason: memoryStoreErrorReason(err), fallback: 'existing_schema' },
-                    });
-                }
-            }
-        }
-        // Add new columns to memories table if missing
-        const memCols = this.getTableColumns('memories');
-        const newCols = [
-            { name: 'title', sql: "ALTER TABLE memories ADD COLUMN title TEXT NOT NULL DEFAULT ''" },
-            { name: 'type', sql: "ALTER TABLE memories ADD COLUMN type TEXT" },
-            { name: 'version', sql: 'ALTER TABLE memories ADD COLUMN version INTEGER NOT NULL DEFAULT 1' },
-            { name: 'supersedes', sql: 'ALTER TABLE memories ADD COLUMN supersedes TEXT' },
-            { name: 'superseded_by', sql: 'ALTER TABLE memories ADD COLUMN superseded_by TEXT' },
-            { name: 'tags', sql: "ALTER TABLE memories ADD COLUMN tags TEXT NOT NULL DEFAULT '[]'" },
-            { name: 'context', sql: "ALTER TABLE memories ADD COLUMN context TEXT NOT NULL DEFAULT ''" },
-            { name: 'strength', sql: 'ALTER TABLE memories ADD COLUMN strength REAL NOT NULL DEFAULT 0.5' },
-            { name: 'last_reinforced_at', sql: 'ALTER TABLE memories ADD COLUMN last_reinforced_at INTEGER' },
-            { name: 'reinforce_count', sql: 'ALTER TABLE memories ADD COLUMN reinforce_count INTEGER NOT NULL DEFAULT 0' },
-            { name: 'updated_at', sql: 'ALTER TABLE memories ADD COLUMN updated_at INTEGER NOT NULL DEFAULT 0' },
+        const requiredColumns = new Map([
+            ['memories', [
+                    'project_id', 'memory_namespace', 'actor_id', 'session_id',
+                    'type', 'title', 'status', 'updated_at', 'last_accessed_at',
+                ]],
+            ['session_events', ['project', 'kind', 'payload', 'maintenance_status', 'quarantine_reason']],
+            ['observations', [
+                    'project_id', 'memory_namespace', 'actor_id', 'session_id',
+                    'source', 'dedup_key', 'quality_status', 'resolution_state', 'evidence_status',
+                    'semantic_key', 'facet_key', 'entities', 'capsule', 'projection', 'extraction_version',
+                ]],
+            ['embedding_profiles', ['profile_hash', 'generation', 'source_content_hash']],
+            ['retrieval_access_log', [
+                    'project', 'request_id', 'execution_id', 'context_receipt', 'tool_evidence',
+                    'verification_receipt', 'idempotency_key',
+                ]],
+        ]);
+        const requiredTables = [
+            'distill_leases', 'distill_lease_pages', 'distill_receipts', 'maintenance_checkpoints',
+            'memory_maintenance_runs', 'event_processing_audit', 'event_duplicate_quarantine',
+            'observation_entities', 'observation_relations', 'observations_fts', 'observations_terms_fts',
         ];
-        for (const col of newCols) {
-            if (!memCols.includes(col.name)) {
-                try {
-                    this.db.exec(col.sql);
-                }
-                catch { /* column may already exist */ }
-            }
-        }
-        // Backfill: copy category→type, set title from first sentence of content
-        if (!memCols.includes('type') && memCols.includes('category')) {
-            try {
-                this.db.exec("UPDATE memories SET type = category WHERE type IS NULL");
-            }
-            catch { /* ignore */ }
-        }
-        if (!memCols.includes('title')) {
-            try {
-                this.db.exec("UPDATE memories SET title = COALESCE(title, '') WHERE title IS NULL OR title = ''");
-            }
-            catch { /* ignore */ }
-        }
-        if (!memCols.includes('updated_at')) {
-            try {
-                this.db.exec('UPDATE memories SET updated_at = created_at WHERE updated_at = 0');
-            }
-            catch { /* ignore */ }
-        }
-        // Add kind and payload columns to session_events if missing
-        const evtCols = this.getTableColumns('session_events');
-        if (!evtCols.includes('kind')) {
-            try {
-                this.db.exec('ALTER TABLE session_events ADD COLUMN kind TEXT');
-            }
-            catch { }
-        }
-        if (!evtCols.includes('payload')) {
-            try {
-                this.db.exec('ALTER TABLE session_events ADD COLUMN payload TEXT');
-            }
-            catch { }
-        }
+        const tables = new Set(this.db.prepare("SELECT name FROM sqlite_master WHERE type IN ('table', 'view')").all().map(row => row.name));
+        const invalid = [
+            ...requiredTables.filter(table => !tables.has(table)).map(table => `table:${table}`),
+            ...[...requiredColumns].flatMap(([table, columns]) => {
+                const actual = new Set(this.getTableColumns(table));
+                return columns.filter(column => !actual.has(column)).map(column => `column:${table}.${column}`);
+            }),
+        ];
+        if (invalid.length > 0)
+            throw new Error(`MEMORY_SCHEMA_UNSUPPORTED:${invalid.join(',')}`);
     }
     getTableColumns(table) {
         try {
@@ -623,18 +647,17 @@ export class MemoryStore {
     }
     // ── Memory CRUD ──────────────────────────────────
     add(entry) {
-        if (entry.sessionId) {
-            this.ensureSession(entry.sessionId, this.defaultProjectRoot);
-        }
+        this.ensureSession(entry.sessionId, this.projectIdentity.memoryNamespace);
         const id = entry.id ?? `mem:${Date.now()}:${randomUUID().slice(0, 8)}`;
         const now = Date.now();
-        const memType = entry.type ?? entry.category ?? 'fact';
+        const memType = entry.type ?? 'fact';
         const title = entry.title ?? entry.content.slice(0, 80);
         this.db.prepare(`
-      INSERT INTO memories (id, type, title, content, original_text, source, status,
+      INSERT INTO memories (id, project_id, memory_namespace, actor_id,
+        type, title, content, original_text, source, status,
         confidence, strength, scope, session_id, created_at, updated_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `).run(id, memType, title, entry.content, entry.originalText ?? null, entry.source ?? 'auto', entry.status ?? 'active', entry.confidence ?? 0.5, entry.strength ?? 0.5, entry.scope ?? '', entry.sessionId ?? null, now, now);
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(id, this.projectIdentity.projectId, this.projectIdentity.memoryNamespace, entry.actorId, memType, title, entry.content, entry.originalText ?? null, entry.source ?? 'auto', entry.status ?? 'active', entry.confidence ?? 0.5, entry.strength ?? 0.5, entry.scope ?? '', entry.sessionId, now, now);
         emitSemanticControlLog({
             event: 'memory.write.completed', identity: { projectRoot: this.defaultProjectRoot, sessionId: entry.sessionId }, level: 'info', timestamp: now,
             data: { stage: 'memory_add', memoryId: id, type: memType, status: entry.status ?? 'active' },
@@ -644,7 +667,10 @@ export class MemoryStore {
     get(id) {
         return this.db.prepare('SELECT * FROM memories WHERE id = ?').get(id) ?? null;
     }
-    update(id, updates) {
+    updateScoped(scope, updates) {
+        const invalidatesEmbedding = updates.title !== undefined
+            || updates.content !== undefined
+            || updates.context !== undefined;
         const sets = [];
         const vals = [];
         for (const [key, value] of Object.entries(updates)) {
@@ -658,20 +684,42 @@ export class MemoryStore {
         vals.push(Date.now());
         if (sets.length === 0)
             return;
-        vals.push(id);
-        this.db.prepare(`UPDATE memories SET ${sets.join(', ')} WHERE id = ?`).run(...vals);
+        vals.push(scope.id, scope.projectId, scope.memoryNamespace, scope.actorId, scope.sessionId);
+        this.db.transaction(() => {
+            const updated = this.db.prepare(`UPDATE memories SET ${sets.join(', ')}
+        WHERE id = ? AND project_id = ? AND memory_namespace = ? AND actor_id = ? AND session_id = ?`).run(...vals);
+            if (updated.changes !== 1)
+                throw new Error('MEMORY_SCOPE_MISMATCH');
+            if (invalidatesEmbedding) {
+                this.db.prepare('DELETE FROM memories_vec WHERE id = ?').run(scope.id);
+                this.db.prepare("DELETE FROM embeddings WHERE source_type = 'memory' AND source_id = ?").run(scope.id);
+                this.db.prepare("DELETE FROM embedding_profiles WHERE source_type = 'memory' AND source_id = ?").run(scope.id);
+            }
+        })();
         emitSemanticControlLog({
             event: 'memory.write.completed', identity: { projectRoot: this.defaultProjectRoot }, level: 'debug', timestamp: Date.now(),
-            data: { stage: 'memory_update', memoryId: id, fields: Object.keys(updates) },
+            data: { stage: 'memory_update', memoryId: scope.id, fields: Object.keys(updates) },
         });
     }
-    delete(id) {
-        this.db.prepare('DELETE FROM memories WHERE id = ?').run(id);
+    deleteScoped(scope) {
+        this.db.transaction(() => {
+            const exists = this.db.prepare(`SELECT id FROM memories
+        WHERE id = ? AND project_id = ? AND memory_namespace = ? AND actor_id = ? AND session_id = ?`)
+                .get(scope.id, scope.projectId, scope.memoryNamespace, scope.actorId, scope.sessionId);
+            if (!exists)
+                throw new Error('MEMORY_SCOPE_MISMATCH');
+            this.db.prepare('DELETE FROM memories_vec WHERE id = ?').run(scope.id);
+            this.db.prepare("DELETE FROM embeddings WHERE source_type = 'memory' AND source_id = ?").run(scope.id);
+            this.db.prepare("DELETE FROM embedding_profiles WHERE source_type = 'memory' AND source_id = ?").run(scope.id);
+            this.db.prepare(`DELETE FROM memories
+        WHERE id = ? AND project_id = ? AND memory_namespace = ? AND actor_id = ? AND session_id = ?`)
+                .run(scope.id, scope.projectId, scope.memoryNamespace, scope.actorId, scope.sessionId);
+        })();
     }
     list(filter) {
         let sql = 'SELECT * FROM memories WHERE superseded_by IS NULL';
         const vals = [];
-        const typeFilter = filter?.type ?? filter?.category;
+        const typeFilter = filter?.type;
         if (typeFilter) {
             sql += ' AND type = ?';
             vals.push(typeFilter);
@@ -703,23 +751,27 @@ export class MemoryStore {
         const placeholders = types.map(() => '?').join(',');
         return this.db.prepare(`SELECT * FROM memories WHERE type IN (${placeholders}) AND superseded_by IS NULL AND status IN ('active','approved') ORDER BY updated_at DESC LIMIT ?`).all(...types, limit);
     }
-    listByCategory(category, limit = 100) {
-        return this.listByType(category, limit);
-    }
     countByStatus(status) {
         const row = this.db.prepare('SELECT COUNT(*) as c FROM memories WHERE status = ?').get(status);
         return row?.c ?? 0;
     }
     // ── Embedding ────────────────────────────────────
     insertEmbedding(id, embedding) {
-        const buffer = Buffer.from(embedding.buffer);
-        this.db.prepare('INSERT OR REPLACE INTO memories_vec(id, embedding) VALUES (?, ?)').run(id, buffer);
-        this.db.prepare('INSERT OR REPLACE INTO embeddings(source_type, source_id, vector) VALUES (?, ?, ?)').run('memory', id, buffer);
+        this.assertEmbeddingProfile(embedding);
+        const buffer = Buffer.from(embedding.buffer, embedding.byteOffset, embedding.byteLength);
+        this.db.transaction(() => {
+            this.db.prepare('INSERT OR REPLACE INTO memories_vec(id, embedding) VALUES (?, ?)').run(id, buffer);
+            this.db.prepare('INSERT OR REPLACE INTO embeddings(source_type, source_id, vector) VALUES (?, ?, ?)')
+                .run('memory', id, buffer);
+            this.putEmbeddingProfile('memory', id);
+        })();
     }
     insertObservationEmbedding(obsId, embedding) {
+        this.assertEmbeddingProfile(embedding);
         const buffer = Buffer.from(embedding.buffer, embedding.byteOffset, embedding.byteLength);
         this.db.prepare('INSERT OR REPLACE INTO embeddings(source_type, source_id, vector) VALUES (?, ?, ?)').run('observation', obsId, buffer);
         this.db.prepare('UPDATE observations SET embedding = ? WHERE id = ?').run(buffer, obsId);
+        this.putEmbeddingProfile('observation', obsId);
         this.bumpRetrievalRevision();
     }
     insertObservationEmbeddings(entries) {
@@ -729,9 +781,11 @@ export class MemoryStore {
         const update = this.db.prepare('UPDATE observations SET embedding = ? WHERE id = ?');
         this.db.transaction(() => {
             for (const { id, embedding } of entries) {
+                this.assertEmbeddingProfile(embedding);
                 const buffer = Buffer.from(embedding.buffer, embedding.byteOffset, embedding.byteLength);
                 insert.run('observation', id, buffer);
                 update.run(buffer, id);
+                this.putEmbeddingProfile('observation', id);
             }
         })();
         this.bumpRetrievalRevision();
@@ -756,12 +810,14 @@ export class MemoryStore {
         const rows = this.db.prepare(`${OBSERVATION_EXCLUSION_CTE}
       SELECT o.*, vec_distance_cosine(o.embedding, ?) AS distance
       FROM observations o
+      JOIN embedding_profiles p ON p.source_type = 'observation' AND p.source_id = o.id
       WHERE o.embedding IS NOT NULL
+        AND p.profile_hash = ? AND p.generation = ?
         AND o.quality_status = 'accepted'
         AND o.resolution_state <> 'superseded'
         AND o.id NOT IN (SELECT id FROM excluded_observation_ids)
       ORDER BY distance LIMIT ?
-    `).all(excludedJson, buffer, limit);
+    `).all(excludedJson, buffer, this.embeddingProfile.profileHash, this.embeddingProfile.generation, limit);
         return rows.map(row => ({ observation: row, distance: row.distance }));
     }
     // ── Search ───────────────────────────────────────
@@ -790,27 +846,16 @@ export class MemoryStore {
             }
         };
         if (normalizedQuery.trigramQuery) {
-            addRanked(this.searchObservationFtsWithRecovery('observations_fts', normalizedQuery.trigramQuery, boundedLimit, excludedJson));
+            addRanked(this.searchObservationFts('observations_fts', normalizedQuery.trigramQuery, boundedLimit, excludedJson));
         }
         if (normalizedQuery.termQuery) {
-            addRanked(this.searchObservationFtsWithRecovery('observations_terms_fts', normalizedQuery.termQuery, boundedLimit, excludedJson));
+            addRanked(this.searchObservationFts('observations_terms_fts', normalizedQuery.termQuery, boundedLimit, excludedJson));
         }
         return [...scores]
             .map(([id, score]) => ({ id, rank: -score }))
             .sort((left, right) => left.rank - right.rank || left.id.localeCompare(right.id))
             .slice(0, boundedLimit);
     }
-    searchObservationFtsWithRecovery(table, query, limit, excludedJson) {
-        try {
-            return this.searchObservationFts(table, query, limit, excludedJson);
-        }
-        catch (error) {
-            if (!isRecoverableObservationFtsError(error))
-                throw error;
-            this.ensureObservationFts(true);
-            return this.searchObservationFts(table, query, limit, excludedJson);
-        }
-    }
     searchObservationFts(table, query, limit, excludedJson) {
         const sql = table === 'observations_fts' ? `${OBSERVATION_EXCLUSION_CTE}
       SELECT o.id, bm25(observations_fts) AS rank
@@ -835,14 +880,59 @@ export class MemoryStore {
         return this.db.prepare(sql).all(excludedJson, query, limit);
     }
     searchVector(embedding, limit = 20) {
-        const buffer = Buffer.from(embedding.buffer);
+        const buffer = Buffer.from(embedding.buffer, embedding.byteOffset, embedding.byteLength);
         return this.db.prepare(`
       SELECT v.id, vec_distance_cosine(v.embedding, ?) as distance
       FROM memories_vec v
       JOIN memories m ON m.id = v.id
+      JOIN embedding_profiles p ON p.source_type = 'memory' AND p.source_id = v.id
       WHERE m.status IN ('active','approved') AND m.superseded_by IS NULL
+        AND p.profile_hash = ? AND p.generation = ?
       ORDER BY distance LIMIT ?
-    `).all(buffer, limit);
+    `).all(buffer, this.embeddingProfile.profileHash, this.embeddingProfile.generation, limit);
+    }
+    getEmbeddingProfileState(sourceType) {
+        const totalTable = sourceType === 'memory' ? 'memories_vec' : 'observations';
+        const totalWhere = sourceType === 'memory' ? '' : ' WHERE embedding IS NOT NULL';
+        const total = Number(this.db.prepare(`SELECT COUNT(*) AS count FROM ${totalTable}${totalWhere}`).get().count);
+        const indexed = Number(this.db.prepare(`SELECT COUNT(*) AS count FROM embedding_profiles
+      WHERE source_type = ? AND profile_hash = ? AND generation = ?`).get(sourceType, this.embeddingProfile.profileHash, this.embeddingProfile.generation).count);
+        return {
+            status: this.embeddingProfile.dimension !== 384
+                ? 'dimension_mismatch'
+                : indexed < total ? 'backfill_pending' : 'ready',
+            profileHash: this.embeddingProfile.profileHash,
+            generation: this.embeddingProfile.generation,
+            indexed,
+            total,
+        };
+    }
+    putEmbeddingProfile(sourceType, sourceId) {
+        const sourceContentHash = sourceType === 'memory'
+            ? this.memoryEmbeddingSourceHash(sourceId)
+            : this.observationEmbeddingSourceHash(sourceId);
+        this.db.prepare(`INSERT OR REPLACE INTO embedding_profiles
+      (source_type, source_id, profile_hash, generation, source_content_hash) VALUES (?, ?, ?, ?, ?)`)
+            .run(sourceType, sourceId, this.embeddingProfile.profileHash, this.embeddingProfile.generation, sourceContentHash);
+    }
+    memoryEmbeddingSourceHash(id) {
+        const row = this.db.prepare('SELECT title, content, context FROM memories WHERE id = ?')
+            .get(id);
+        if (!row)
+            throw new Error(`EMBEDDING_SOURCE_MISSING:memory:${id}`);
+        return createHash('sha256').update(JSON.stringify(row)).digest('hex');
+    }
+    observationEmbeddingSourceHash(id) {
+        const row = this.db.prepare(`SELECT title, narrative, facts, files, tools, concepts
+      FROM observations WHERE id = ?`).get(id);
+        if (!row)
+            throw new Error(`EMBEDDING_SOURCE_MISSING:observation:${id}`);
+        return createHash('sha256').update(JSON.stringify(row)).digest('hex');
+    }
+    assertEmbeddingProfile(embedding) {
+        if (embedding.length !== this.embeddingProfile.dimension || embedding.length !== 384) {
+            throw new Error(`EMBEDDING_DIMENSION_MISMATCH:${embedding.length}:${this.embeddingProfile.dimension}`);
+        }
     }
     // ── Edges ────────────────────────────────────────
     addEdge(sourceId, targetId, type, weight = 0.5) {
@@ -1320,49 +1410,6 @@ export class MemoryStore {
     `).run(sessionId, normalizedProjectRoot, task, Date.now());
         return this.getSession(sessionId);
     }
-    repairOrphanSessions(projectRoot = this.defaultProjectRoot) {
-        const repair = this.db.transaction(() => {
-            const blankEvents = this.db.prepare(`
-        SELECT id FROM session_events WHERE TRIM(session_id) = '' ORDER BY created_at ASC
-      `).all();
-            const assignRecoveredSession = this.db.prepare('UPDATE session_events SET session_id = ? WHERE id = ? AND TRIM(session_id) = \'\'');
-            for (const event of blankEvents) {
-                assignRecoveredSession.run(`recovered:orphan:${event.id}`, event.id);
-            }
-            const orphanSessions = this.db.prepare(`
-        SELECT
-          e.session_id AS id,
-          COALESCE(NULLIF(MAX(e.project), ''), ?) AS project_root,
-          MIN(e.created_at) AS created_at,
-          MAX(e.created_at) AS closed_at,
-          COUNT(*) AS tool_count,
-          SUM(CASE WHEN e.exit_code IS NOT NULL AND e.exit_code <> 0 THEN 1 ELSE 0 END) AS error_count
-        FROM session_events e
-        LEFT JOIN sessions s ON s.id = e.session_id
-        WHERE s.id IS NULL
-        GROUP BY e.session_id
-      `).all(projectRoot);
-            const insertRecovered = this.db.prepare(`
-        INSERT OR IGNORE INTO sessions
-          (id, project_root, task, status, phase_summary, signal_summary,
-           tool_count, error_count, created_at, closed_at)
-        VALUES (?, ?, 'Recovered orphan session events', 'closed', ?, '[]', ?, ?, ?, ?)
-      `);
-            let repaired = 0;
-            for (const session of orphanSessions) {
-                repaired += insertRecovered.run(session.id, session.project_root || projectRoot, JSON.stringify(['recovered_orphan_events']), session.tool_count, session.error_count, session.created_at, session.closed_at).changes;
-            }
-            return repaired;
-        });
-        const repaired = repair();
-        if (repaired > 0) {
-            emitSemanticControlLog({
-                event: 'memory.engine.transitioned', identity: { projectRoot: this.defaultProjectRoot }, level: 'warn', timestamp: Date.now(),
-                data: { stage: 'orphan_session_repair', recovered: repaired },
-            });
-        }
-        return repaired;
-    }
     createSession(id, projectRoot, task = '') {
         this.ensureSession(id, projectRoot, task);
         emitSemanticControlLog({
@@ -1413,8 +1460,12 @@ export class MemoryStore {
         this.ensureSession(obs.sessionId, obs.project ?? this.defaultProjectRoot);
         const id = obs.id ?? `obs:${Date.now()}:${randomUUID().slice(0, 8)}`;
         const now = obs.timestamp ?? Date.now();
-        const dedupKey = obs.semantic?.semanticKey ?? observationDedupKey(obs.type, obs.title);
-        const duplicate = obs.semantic ? null : this.findObservationByDedupKey(dedupKey);
+        // A semantic projection is descriptive metadata, never an instance
+        // identity.  Only the command service may provide an explicit dedupKey
+        // (the receipt-bound fact instance id); legacy callers fall back to the
+        // non-semantic observation key.
+        const dedupKey = obs.dedupKey ?? observationDedupKey(obs.type, obs.title);
+        const duplicate = obs.dedupKey || obs.semantic ? null : this.findObservationByDedupKey(dedupKey);
         if (duplicate) {
             this.linkObservationToEvents(duplicate.id, obs.sourceEventIds ?? []);
             this.incrementObservationAccess(duplicate.id, now);
@@ -1423,15 +1474,16 @@ export class MemoryStore {
         }
         this.db.prepare(`
       INSERT INTO observations
-        (id, session_id, project, type, title, narrative, facts, files, tools, concepts,
+        (id, project_id, memory_namespace, actor_id, session_id, project,
+         type, title, narrative, facts, files, tools, concepts,
          importance, confidence, source, dedup_key, source_event_ids, timestamp, updated_at,
          quality_status, quarantine_reason, quality_details, quarantined_at,
          failure_category, resolution_state, evidence_status, evidence_details,
          semantic_subject, semantic_predicate, semantic_value, semantic_polarity,
          semantic_key, facet_key, entities, temporal, reinforce_count, last_reinforced_at,
          capsule, projection, extraction_version)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `).run(id, obs.sessionId, obs.project ?? this.defaultProjectRoot, obs.type, obs.title, obs.narrative ?? '', JSON.stringify(obs.facts ?? []), JSON.stringify(obs.files ?? []), JSON.stringify(obs.tools ?? []), JSON.stringify(obs.concepts ?? []), obs.importance ?? 5, obs.confidence ?? 0.5, obs.source ?? 'distill', dedupKey, JSON.stringify(obs.sourceEventIds ?? []), now, now, obs.qualityStatus ?? 'accepted', obs.quarantineReason ?? null, obs.qualityDetails ? JSON.stringify(obs.qualityDetails) : null, obs.qualityStatus === 'quarantined' ? now : null, obs.failureCategory ?? null, obs.resolutionState ?? 'current', obs.evidenceStatus
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(id, this.projectIdentity.projectId, this.projectIdentity.memoryNamespace, obs.actorId, obs.sessionId, obs.project ?? this.projectIdentity.memoryNamespace, obs.type, obs.title, obs.narrative ?? '', JSON.stringify(obs.facts ?? []), JSON.stringify(obs.files ?? []), JSON.stringify(obs.tools ?? []), JSON.stringify(obs.concepts ?? []), obs.importance ?? 5, obs.confidence ?? 0.5, obs.source ?? 'distill', dedupKey, JSON.stringify(obs.sourceEventIds ?? []), now, now, obs.qualityStatus ?? 'accepted', obs.quarantineReason ?? null, obs.qualityDetails ? JSON.stringify(obs.qualityDetails) : null, obs.qualityStatus === 'quarantined' ? now : null, obs.failureCategory ?? null, obs.resolutionState ?? 'current', obs.evidenceStatus
             ?? (obs.source === 'explicit_intent'
                 ? 'unverified'
                 : obs.source === 'manual' || (obs.sourceEventIds?.length ?? 0) > 0
@@ -1445,14 +1497,14 @@ export class MemoryStore {
             sourceEvidenceIds: obs.sourceEventIds ?? [],
             entities: obs.semantic?.entities ?? [],
             temporalStatus: obs.semantic?.temporal?.status ?? 'current',
-            extractionVersion: 'legacy-compatible.v1',
+            extractionVersion: 'memory-capsule.v1',
         }), JSON.stringify(obs.projection ?? {
             subject: obs.semantic?.subject ?? '',
             predicate: obs.semantic?.predicate ?? '',
             value: obs.semantic?.value ?? '',
             polarity: obs.semantic?.polarity ?? 'neutral',
             facet: obs.semantic?.facet ?? 'generic',
-        }), obs.capsule?.extractionVersion ?? 'legacy-compatible.v1');
+        }), obs.capsule?.extractionVersion ?? 'memory-capsule.v1');
         // Insert concept junction rows
         if (obs.concepts && obs.concepts.length > 0) {
             const insertConcept = this.db.prepare('INSERT OR IGNORE INTO observation_concepts (observation_id, concept) VALUES (?, ?)');
@@ -1471,117 +1523,23 @@ export class MemoryStore {
     acceptSemanticObservation(obs) {
         return this.db.transaction(() => {
             const project = obs.project ?? this.defaultProjectRoot;
-            const now = obs.timestamp ?? Date.now();
-            const exact = this.findCurrentObservationBySemanticKey(project, obs.semantic.semanticKey)
-                ?? this.findCurrentObservationByNarrative(project, obs.narrative ?? '')
-                ?? this.findCurrentObservationByDurableNarrative(project, obs.narrative ?? '');
-            if (exact) {
-                const sourceEventIds = uniqueStrings([
-                    ...parseStringArray(exact.source_event_ids),
-                    ...(obs.sourceEventIds ?? []),
-                ]);
-                const facts = uniqueStrings([...parseStringArray(exact.facts), ...(obs.facts ?? [])]);
-                const concepts = uniqueStrings([
-                    ...parseStringArray(exact.concepts),
-                    ...(obs.concepts ?? []),
-                    obs.semantic.subject,
-                    obs.semantic.predicate,
-                    obs.semantic.value,
-                    ...obs.semantic.entities.map(normalizeEntityKey),
-                ]);
-                const entities = mergeSemanticEntities(parseStringArray(exact.entities), obs.semantic.entities);
-                const narrative = obs.preferIncomingNarrative
-                    ? obs.narrative ?? exact.narrative
-                    : semanticRichness(obs.narrative ?? '') > semanticRichness(exact.narrative)
-                        ? obs.narrative ?? ''
-                        : exact.narrative;
-                const title = obs.preferIncomingNarrative
-                    ? obs.title
-                    : semanticRichness(obs.title) > semanticRichness(exact.title) ? obs.title : exact.title;
-                const contentChanged = exact.title !== title
-                    || exact.narrative !== narrative;
-                this.db.prepare(`
-          UPDATE observations
-          SET type = ?, title = ?, narrative = ?, facts = ?, concepts = ?, importance = MAX(importance, ?),
-            confidence = MAX(confidence, ?), source_event_ids = ?, updated_at = ?,
-            access_count = access_count + 1, reinforce_count = reinforce_count + 1, last_reinforced_at = ?,
-            source = CASE WHEN ? = 'explicit_intent' THEN 'explicit_intent' ELSE source END,
-            quality_status = CASE WHEN quality_status = 'quarantined' AND ? = 'accepted' THEN 'accepted' ELSE quality_status END,
-            quarantine_reason = CASE WHEN ? = 'accepted' THEN NULL ELSE quarantine_reason END,
-            resolution_state = 'current', superseded_by_observation = NULL,
-            semantic_subject = ?, semantic_predicate = ?, semantic_value = ?, semantic_polarity = ?,
-            semantic_key = ?, facet_key = ?, dedup_key = ?, entities = ?,
-            temporal = COALESCE(?, temporal), evidence_status = ?, evidence_details = ?,
-            embedding = CASE WHEN ? = 1 THEN NULL ELSE embedding END
-          WHERE id = ?
-        `).run(obs.type, title, narrative, JSON.stringify(facts), JSON.stringify(concepts), obs.importance ?? 5, obs.confidence ?? 0.5, JSON.stringify(sourceEventIds), now, now, obs.source ?? 'distill', obs.qualityStatus ?? 'accepted', obs.qualityStatus ?? 'accepted', obs.semantic.subject, obs.semantic.predicate, obs.semantic.value, obs.semantic.polarity, obs.semantic.semanticKey, obs.semantic.facetKey, obs.semantic.semanticKey, JSON.stringify(entities), obs.semantic.temporal ? JSON.stringify(obs.semantic.temporal) : null, strongerEvidenceStatus(exact.evidence_status, obs.evidenceStatus), JSON.stringify(mergeEvidenceDetails(exact.evidence_details, obs.evidenceDetails ?? [])), contentChanged ? 1 : 0, exact.id);
-                if (contentChanged) {
-                    this.db.prepare("DELETE FROM embeddings WHERE source_type = 'observation' AND source_id = ?").run(exact.id);
-                }
-                this.replaceObservationConcepts(exact.id, concepts);
-                this.replaceObservationEntities(exact.id, project, entities);
-                for (const eventId of obs.sourceEventIds ?? [])
-                    this.linkObservationToEvents(exact.id, [eventId]);
-                const supersededIds = this.supersedeSemanticFacetConflicts(project, exact.id, obs.semantic, now);
-                return { row: this.getObservation(exact.id), action: 'REINFORCE', supersededIds, linkedIds: [] };
-            }
             const row = this.addObservation(obs);
             if ((obs.qualityStatus ?? 'accepted') === 'quarantined') {
                 return { row, action: 'HOLD', supersededIds: [], linkedIds: [] };
             }
-            const supersededIds = this.supersedeSemanticFacetConflicts(project, row.id, obs.semantic, now);
-            const relatedIds = this.findCurrentObservationIdsByEntities(project, obs.semantic.entities, new Set([row.id, ...supersededIds])).slice(0, 12);
+            const relatedIds = this.findCurrentObservationIdsByEntities(project, obs.semantic.entities, new Set([row.id])).slice(0, 12);
+            const now = obs.timestamp ?? Date.now();
             for (const relatedId of relatedIds) {
                 this.addObservationRelation(row.id, relatedId, 'related_to', now);
             }
             return {
                 row: this.getObservation(row.id),
-                action: supersededIds.length > 0 ? 'SUPERSEDE' : relatedIds.length > 0 ? 'LINK' : 'ADD',
-                supersededIds,
+                action: relatedIds.length > 0 ? 'LINK' : 'ADD',
+                supersededIds: [],
                 linkedIds: relatedIds,
             };
         })();
     }
-    findCurrentObservationBySemanticKey(project, semanticKey) {
-        return this.db.prepare(`
-      SELECT * FROM observations
-      WHERE project = ? AND semantic_key = ?
-      ORDER BY CASE WHEN resolution_state = 'current' THEN 0 ELSE 1 END,
-        COALESCE(explicit_accepted_at, timestamp) DESC, id DESC
-      LIMIT 1
-    `).get(project, semanticKey) ?? null;
-    }
-    findCurrentObservationByNarrative(project, narrative) {
-        if (!narrative.trim())
-            return null;
-        return this.db.prepare(`
-      SELECT * FROM observations
-      WHERE project = ? AND narrative = ? AND resolution_state = 'current'
-        AND quality_status = 'accepted'
-      ORDER BY COALESCE(explicit_accepted_at, timestamp) DESC, id DESC
-      LIMIT 1
-    `).get(project, narrative) ?? null;
-    }
-    findCurrentObservationByDurableNarrative(project, narrative) {
-        const durableNarrative = sanitizeDurableMemoryNarrative(narrative);
-        if (!durableNarrative)
-            return null;
-        const candidates = this.db.prepare(`
-      SELECT * FROM observations
-      WHERE project = ? AND resolution_state = 'current'
-        AND quality_status = 'accepted'
-      ORDER BY COALESCE(explicit_accepted_at, timestamp) DESC, id DESC
-    `).all(project);
-        return candidates.find(candidate => sanitizeDurableMemoryNarrative(candidate.narrative) === durableNarrative) ?? null;
-    }
-    findCurrentObservationsByFacetKey(project, facetKey) {
-        return this.db.prepare(`
-      SELECT * FROM observations
-      WHERE project = ? AND facet_key = ? AND resolution_state = 'current'
-        AND quality_status = 'accepted'
-      ORDER BY COALESCE(explicit_accepted_at, timestamp) DESC, id DESC
-    `).all(project, facetKey);
-    }
     searchObservationEntities(project, entities, limit = 30) {
         const normalized = uniqueStrings(entities.map(normalizeEntityKey)).filter(Boolean);
         if (normalized.length === 0)
@@ -1654,22 +1612,6 @@ export class MemoryStore {
     addSemanticObservationRelation(sourceObservationId, targetObservationId, type, createdAt = Date.now()) {
         this.addObservationRelation(sourceObservationId, targetObservationId, type, createdAt);
     }
-    supersedeSemanticFacetConflicts(project, winnerId, semantic, now) {
-        const conflicts = this.findCurrentObservationsByFacetKey(project, semantic.facetKey)
-            .filter(candidate => candidate.id !== winnerId)
-            .filter(candidate => semanticObservationsConflict(candidate, semantic));
-        const supersededIds = [];
-        for (const conflict of conflicts) {
-            this.db.prepare(`
-        UPDATE observations
-        SET resolution_state = 'superseded', superseded_by_observation = ?, dedup_key = NULL, updated_at = ?
-        WHERE id = ? AND resolution_state = 'current'
-      `).run(winnerId, now, conflict.id);
-            this.addObservationRelation(winnerId, conflict.id, 'supersedes', now);
-            supersededIds.push(conflict.id);
-        }
-        return supersededIds;
-    }
     addObservationWithEmbedding(obs, embedding) {
         return this.db.transaction(() => {
             const row = this.addObservation(obs);
@@ -1677,230 +1619,13 @@ export class MemoryStore {
             return this.getObservation(row.id);
         })();
     }
-    acceptExplicitPreference(input) {
-        if (input.enrichment) {
-            this.ensureSession(input.sessionId, input.project);
-            const preferenceAnalysis = analyzePreference(input.content);
-            const hold = preferenceAnalysis.status === 'ambiguous';
-            const baseSemantic = semanticFromExplicitEnrichment(input.enrichment);
-            const semantic = hold
-                ? normalizeSemanticMemory({
-                    project: input.project,
-                    type: input.enrichment.type,
-                    title: input.enrichment.title,
-                    narrative: input.enrichment.narrative,
-                    subject: baseSemantic.subject,
-                    predicate: baseSemantic.predicate,
-                    value: input.content,
-                    polarity: 'neutral',
-                    entities: baseSemantic.entities,
-                    temporal: baseSemantic.temporal ?? undefined,
-                })
-                : baseSemantic;
-            const result = this.acceptSemanticObservation({
-                sessionId: input.sessionId,
-                project: input.project,
-                type: input.enrichment.type,
-                title: input.enrichment.title,
-                narrative: input.enrichment.narrative,
-                facts: input.enrichment.facts,
-                files: input.enrichment.files,
-                tools: input.enrichment.tools,
-                concepts: input.enrichment.concepts,
-                importance: 10,
-                confidence: 0.95,
-                source: 'explicit_intent',
-                sourceEventIds: input.sourceEventId ? [input.sourceEventId] : [],
-                qualityStatus: hold ? 'quarantined' : 'accepted',
-                quarantineReason: hold ? 'ambiguous_explicit_preference' : undefined,
-                evidenceStatus: 'verified',
-                evidenceDetails: [
-                    ...input.enrichment.evidence.map(item => ({ ...item })),
-                    ...(input.enrichment.evidence.length === 0 ? [{
-                            kind: 'source_event',
-                            source: input.sourceEventId ?? `explicit:${input.sessionId}`,
-                            summary: 'Observation was accepted from a direct explicit-memory request.',
-                        }] : []),
-                ],
-                semantic,
-            });
-            const latest = this.db.prepare(`
-        SELECT MAX(COALESCE(explicit_accepted_at, timestamp)) AS latest
-        FROM observations
-        WHERE project = ? AND source = 'explicit_intent'
-      `).get(input.project);
-            const acceptedAt = Math.max(Date.now(), (latest.latest ?? 0) + 1);
-            this.db.prepare(`
-        UPDATE observations
-        SET explicit_accepted_at = MAX(COALESCE(explicit_accepted_at, 0), ?), updated_at = MAX(updated_at, ?)
-        WHERE id = ?
-      `).run(acceptedAt, acceptedAt, result.row.id);
-            if (input.sourceEventId)
-                this.markEventsProcessed([input.sourceEventId]);
-            return this.getObservation(result.row.id);
-        }
-        return this.db.transaction(() => {
-            this.ensureSession(input.sessionId, input.project);
-            const latest = this.db.prepare(`
-        SELECT MAX(COALESCE(explicit_accepted_at, timestamp)) AS latest
-        FROM observations
-        WHERE project = ? AND type IN ('user_preference', 'project_convention', 'decision_made')
-          AND source = 'explicit_intent'
-      `).get(input.project);
-            const acceptedAt = Math.max(Date.now(), (latest.latest ?? 0) + 1);
-            const dedupKey = observationDedupKey('user_preference', input.title);
-            const exact = this.db.prepare('SELECT * FROM observations WHERE dedup_key = ? AND project = ?').get(dedupKey, input.project) ?? null;
-            let row;
-            if (exact) {
-                const contentChanged = exact.title !== input.title || exact.narrative !== input.content;
-                const sourceEventIds = new Set(parseStringArray(exact.source_event_ids));
-                if (input.sourceEventId)
-                    sourceEventIds.add(input.sourceEventId);
-                this.db.prepare(`
-          UPDATE observations
-          SET title = ?, narrative = ?, source = 'explicit_intent',
-            confidence = MAX(confidence, 0.95),
-            importance = MAX(importance, 10), quality_status = 'accepted',
-            quarantine_reason = NULL, quality_details = NULL, quarantined_at = NULL,
-            resolution_state = 'current', superseded_by_observation = NULL,
-            source_event_ids = ?, updated_at = ?, explicit_accepted_at = ?,
-            embedding = CASE WHEN ? = 1 THEN NULL ELSE embedding END
-          WHERE id = ?
-        `).run(input.title, input.content, JSON.stringify([...sourceEventIds]), acceptedAt, acceptedAt, contentChanged ? 1 : 0, exact.id);
-                if (contentChanged) {
-                    this.db.prepare("DELETE FROM embeddings WHERE source_type = 'observation' AND source_id = ?").run(exact.id);
-                }
-                this.incrementObservationAccess(exact.id, acceptedAt);
-                row = this.getObservation(exact.id);
-            }
-            else {
-                row = this.addObservation({
-                    sessionId: input.sessionId,
-                    project: input.project,
-                    type: 'user_preference',
-                    title: input.title,
-                    narrative: input.content,
-                    importance: 10,
-                    confidence: 0.95,
-                    source: 'explicit_intent',
-                    sourceEventIds: input.sourceEventId ? [input.sourceEventId] : [],
-                    timestamp: acceptedAt,
-                    qualityStatus: 'accepted',
-                });
-                this.db.prepare('UPDATE observations SET explicit_accepted_at = ? WHERE id = ?').run(acceptedAt, row.id);
-                row = this.getObservation(row.id);
-            }
-            this.supersedeConflictingExplicitPreferences(row, analyzePreference(input.content));
-            if (input.sourceEventId)
-                this.markEventsProcessed([input.sourceEventId]);
-            return this.getObservation(row.id);
-        })();
-    }
-    applyExplicitMemoryEnrichment(observationId, enrichment) {
-        return this.db.transaction(() => {
-            const current = this.getObservation(observationId);
-            if (!current)
-                throw new Error(`Observation ${observationId} not found`);
-            if (current.source !== 'explicit_intent') {
-                throw new Error(`Observation ${observationId} is not an explicit memory`);
-            }
-            const dedupKey = enrichment.semanticKey;
-            const collisions = this.db.prepare(`
-        SELECT id, timestamp, explicit_accepted_at FROM observations
-        WHERE project = ? AND dedup_key = ? AND id <> ?
-      `).all(current.project, dedupKey, observationId);
-            let dedupKeyForCurrent = dedupKey;
-            if (collisions.length > 0) {
-                const candidates = [
-                    {
-                        id: current.id,
-                        timestamp: current.timestamp,
-                        explicit_accepted_at: current.explicit_accepted_at,
-                    },
-                    ...collisions,
-                ].sort((left, right) => (right.explicit_accepted_at ?? right.timestamp) - (left.explicit_accepted_at ?? left.timestamp)
-                    || right.id.localeCompare(left.id));
-                const winner = candidates[0];
-                const now = Date.now();
-                const supersede = this.db.prepare(`
-          UPDATE observations
-          SET resolution_state = 'superseded', superseded_by_observation = ?,
-            dedup_key = NULL, updated_at = ?
-          WHERE id = ?
-        `);
-                for (const candidate of candidates.slice(1)) {
-                    supersede.run(winner.id, now, candidate.id);
-                }
-                this.db.prepare(`
-          UPDATE observations
-          SET resolution_state = 'current', superseded_by_observation = NULL,
-            dedup_key = ?, updated_at = ?
-          WHERE id = ?
-        `).run(dedupKey, now, winner.id);
-                dedupKeyForCurrent = winner.id === current.id ? dedupKey : null;
-            }
-            const nextFacts = JSON.stringify(enrichment.facts);
-            const nextFiles = JSON.stringify(enrichment.files);
-            const nextTools = JSON.stringify(enrichment.tools);
-            const nextConcepts = JSON.stringify(enrichment.concepts);
-            const semanticContentChanged = current.type !== enrichment.type
-                || current.title !== enrichment.title
-                || current.narrative !== enrichment.narrative
-                || current.facts !== nextFacts
-                || current.concepts !== nextConcepts;
-            const now = Date.now();
-            this.db.prepare(`
-        UPDATE observations
-        SET type = ?, title = ?, narrative = ?, facts = ?, files = ?, tools = ?, concepts = ?,
-          dedup_key = ?, evidence_status = ?, evidence_details = ?, updated_at = ?,
-          embedding = CASE WHEN ? = 1 THEN NULL ELSE embedding END,
-          semantic_subject = ?, semantic_predicate = ?, semantic_value = ?, semantic_polarity = ?,
-          semantic_key = ?, facet_key = ?, entities = ?, temporal = ?
-        WHERE id = ?
-      `).run(enrichment.type, enrichment.title, enrichment.narrative, nextFacts, nextFiles, nextTools, nextConcepts, dedupKeyForCurrent, enrichment.evidenceStatus, JSON.stringify(enrichment.evidence), now, semanticContentChanged ? 1 : 0, enrichment.subject, enrichment.predicate, enrichment.value, enrichment.polarity, enrichment.semanticKey, enrichment.facetKey, JSON.stringify(enrichment.entities), enrichment.temporal ? JSON.stringify(enrichment.temporal) : null, observationId);
-            if (semanticContentChanged) {
-                this.db.prepare("DELETE FROM embeddings WHERE source_type = 'observation' AND source_id = ?").run(observationId);
-            }
-            this.db.prepare('DELETE FROM observation_concepts WHERE observation_id = ?').run(observationId);
-            const insertConcept = this.db.prepare('INSERT OR IGNORE INTO observation_concepts (observation_id, concept) VALUES (?, ?)');
-            for (const concept of enrichment.concepts)
-                insertConcept.run(observationId, concept);
-            this.replaceObservationEntities(observationId, current.project, enrichment.entities);
-            this.reconcileExplicitPreferenceConflicts(current.project);
-            this.bumpRetrievalRevision();
-            return this.getObservation(observationId);
-        })();
-    }
-    reconcileExplicitPreferenceConflicts(project = this.defaultProjectRoot) {
-        return this.db.transaction(() => {
-            const rows = this.listCurrentExplicitPreferences(project).sort((left, right) => this.explicitPreferenceAcceptanceTime(left)
-                - this.explicitPreferenceAcceptanceTime(right)
-                || left.timestamp - right.timestamp
-                || left.id.localeCompare(right.id));
-            let superseded = 0;
-            const active = [];
-            for (const row of rows) {
-                const analysis = analyzePreferenceObservation(row);
-                if (analysis.status !== 'high_confidence') {
-                    active.push({ row, analysis });
-                    continue;
-                }
-                for (let index = active.length - 1; index >= 0; index--) {
-                    const previous = active[index];
-                    if (!analysesConflict(previous.analysis, analysis))
-                        continue;
-                    this.db.prepare(`
-            UPDATE observations
-            SET resolution_state = 'superseded', superseded_by_observation = ?
-            WHERE id = ? AND resolution_state = 'current'
-          `).run(row.id, previous.row.id);
-                    active.splice(index, 1);
-                    superseded += 1;
-                }
-                active.push({ row, analysis });
-            }
-            return superseded;
-        })();
+    markObservationExplicitlyAccepted(observationId, acceptedAt = Date.now()) {
+        this.db.prepare(`
+      UPDATE observations
+      SET explicit_accepted_at = MAX(COALESCE(explicit_accepted_at, 0), ?),
+        updated_at = MAX(updated_at, ?)
+      WHERE id = ? AND source = 'explicit_intent'
+    `).run(acceptedAt, acceptedAt, observationId);
     }
     listCurrentExplicitPreferences(project = this.defaultProjectRoot) {
         return this.db.prepare(`
@@ -1911,28 +1636,6 @@ export class MemoryStore {
       ORDER BY COALESCE(explicit_accepted_at, timestamp) DESC, timestamp DESC, id DESC
     `).all(project);
     }
-    explicitPreferenceAcceptanceTime(row) {
-        return row.explicit_accepted_at ?? row.timestamp;
-    }
-    supersedeConflictingExplicitPreferences(winner, winnerAnalysis) {
-        if (winnerAnalysis.status !== 'high_confidence')
-            return 0;
-        const update = this.db.prepare(`
-      UPDATE observations
-      SET resolution_state = 'superseded', superseded_by_observation = ?
-      WHERE id = ? AND resolution_state = 'current'
-    `);
-        let superseded = 0;
-        for (const candidate of this.listCurrentExplicitPreferences(winner.project)) {
-            if (candidate.id === winner.id)
-                continue;
-            const analysis = analyzePreferenceObservation(candidate);
-            if (!analysesConflict(analysis, winnerAnalysis))
-                continue;
-            superseded += update.run(winner.id, candidate.id).changes;
-        }
-        return superseded;
-    }
     getObservation(id) {
         return this.db.prepare('SELECT * FROM observations WHERE id = ?').get(id) ?? null;
     }
@@ -1970,13 +1673,14 @@ export class MemoryStore {
     `).get(type, cutoff, buffer, threshold, buffer) ?? null;
     }
     incrementObservationAccess(id, now = Date.now()) {
-        this.recordRetrievalAccess({
-            sourceType: 'observation',
-            sourceId: id,
-            accessType: 'adopted',
-            purpose: 'dedup_or_reinforcement',
-            timestamp: now,
-        });
+        const updated = this.db.prepare(`
+      UPDATE observations
+      SET access_count = access_count + 1, updated_at = ?
+      WHERE id = ?
+    `).run(now, id);
+        if (updated.changes !== 1)
+            throw new Error(`Observation ${id} not found`);
+        this.bumpRetrievalRevision();
     }
     promoteObservationToExplicitIntent(id, now = Date.now()) {
         this.db.prepare(`
@@ -2039,21 +1743,31 @@ export class MemoryStore {
     }
     listObservationsMissingEmbedding(limit = 32, afterId) {
         return this.db.prepare(`
-      SELECT * FROM observations
-      WHERE embedding IS NULL AND quality_status = 'accepted'
-        AND resolution_state <> 'superseded' AND (? IS NULL OR id > ?)
-      ORDER BY id LIMIT ?
-    `).all(afterId ?? null, afterId ?? null, limit);
+      SELECT o.* FROM observations o
+      LEFT JOIN embedding_profiles p ON p.source_type = 'observation' AND p.source_id = o.id
+        AND p.profile_hash = ? AND p.generation = ?
+      WHERE (o.embedding IS NULL OR p.source_id IS NULL) AND o.quality_status = 'accepted'
+        AND o.resolution_state <> 'superseded' AND (? IS NULL OR o.id > ?)
+      ORDER BY o.id LIMIT ?
+    `).all(this.embeddingProfile.profileHash, this.embeddingProfile.generation, afterId ?? null, afterId ?? null, limit);
     }
     countObservationVectors() {
         const row = this.db.prepare(`
       SELECT COUNT(*) AS observations,
         SUM(CASE WHEN quality_status = 'accepted' AND resolution_state <> 'superseded' THEN 1 ELSE 0 END) AS eligible,
-        SUM(CASE WHEN quality_status = 'accepted' AND resolution_state <> 'superseded' AND embedding IS NOT NULL THEN 1 ELSE 0 END) AS vectors,
-        SUM(CASE WHEN quality_status = 'accepted' AND resolution_state <> 'superseded' AND embedding IS NULL THEN 1 ELSE 0 END) AS missing,
+        SUM(CASE WHEN quality_status = 'accepted' AND resolution_state <> 'superseded'
+          AND embedding IS NOT NULL AND EXISTS (
+            SELECT 1 FROM embedding_profiles p WHERE p.source_type = 'observation'
+              AND p.source_id = observations.id AND p.profile_hash = ? AND p.generation = ?
+          ) THEN 1 ELSE 0 END) AS vectors,
+        SUM(CASE WHEN quality_status = 'accepted' AND resolution_state <> 'superseded'
+          AND (embedding IS NULL OR NOT EXISTS (
+            SELECT 1 FROM embedding_profiles p WHERE p.source_type = 'observation'
+              AND p.source_id = observations.id AND p.profile_hash = ? AND p.generation = ?
+          )) THEN 1 ELSE 0 END) AS missing,
         SUM(CASE WHEN quality_status = 'quarantined' THEN 1 ELSE 0 END) AS quarantined
       FROM observations
-    `).get();
+    `).get(this.embeddingProfile.profileHash, this.embeddingProfile.generation, this.embeddingProfile.profileHash, this.embeddingProfile.generation);
         return {
             observations: row.observations,
             eligible: row.eligible ?? 0,
@@ -2080,6 +1794,31 @@ export class MemoryStore {
       WHERE id = ?
     `).run(state, supersededBy ?? null, Date.now(), id);
     }
+    reinforceObservation(id, input = {}, now = Date.now()) {
+        const current = this.getObservation(id);
+        if (!current || current.resolution_state !== 'current') {
+            throw new Error(`MEMORY_FACT_NOT_CURRENT:${id}`);
+        }
+        const mergedSourceEventIds = uniqueStrings([
+            ...parseStringArray(current.source_event_ids),
+            ...(input.sourceEventIds ?? []),
+        ]);
+        const evidenceStatus = strongerEvidenceStatus(current.evidence_status, input.evidenceStatus);
+        const evidenceDetails = mergeEvidenceDetails(current.evidence_details, input.evidenceDetails ?? []);
+        this.db.prepare(`
+      UPDATE observations
+      SET source_event_ids = ?, reinforce_count = reinforce_count + 1,
+        source = CASE WHEN ? = 'explicit_intent' THEN 'explicit_intent' ELSE source END,
+        importance = MAX(importance, ?), confidence = MAX(confidence, ?),
+        evidence_status = ?, evidence_details = ?,
+        last_reinforced_at = ?, access_count = access_count + 1, updated_at = ?
+      WHERE id = ? AND resolution_state = 'current'
+    `).run(JSON.stringify(mergedSourceEventIds), input.source ?? current.source, input.importance ?? current.importance, input.confidence ?? current.confidence, evidenceStatus, JSON.stringify(evidenceDetails), now, now, id);
+        for (const eventId of input.sourceEventIds ?? [])
+            this.linkObservationToEvents(id, [eventId]);
+        this.bumpRetrievalRevision();
+        return this.getObservation(id);
+    }
     getObservationsByConcept(concept, limit = 50) {
         return this.listObservations({ concept, limit });
     }
@@ -2168,7 +1907,7 @@ export class MemoryStore {
         const timestamp = input.timestamp ?? Date.now();
         const id = `racc:${timestamp}:${randomUUID().slice(0, 8)}`;
         this.db.transaction(() => {
-            const accessType = input.accessType ?? 'exposed';
+            const accessType = input.accessType;
             const inserted = this.db.prepare(`
         INSERT OR IGNORE INTO retrieval_access_log
           (id, source_type, source_id, access_type, project, session_id, request_id,
@@ -2176,7 +1915,7 @@ export class MemoryStore {
            context_receipt, tool_evidence, outcome_reason, verification_receipt, idempotency_key)
         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
       `).run(id, input.sourceType, input.sourceId, accessType, input.project ?? this.defaultProjectRoot, input.sessionId ?? null, input.requestId ?? null, input.executionId ?? null, input.query ?? null, input.purpose ?? null, input.rank ?? null, input.score ?? null, timestamp, input.workflowRunId ?? null, input.contextReceipt ?? null, input.toolEvidence ? JSON.stringify([...new Set(input.toolEvidence)]) : null, input.outcomeReason ?? null, input.verificationReceipt ?? null, input.idempotencyKey ?? null).changes > 0;
-            const reinforces = accessType === 'adopted' && inserted;
+            const reinforces = accessType === 'consumed' && inserted;
             if (input.sourceType === 'memory' && reinforces) {
                 const updated = this.db.prepare(`
           UPDATE memories SET access_count = access_count + 1,
@@ -2212,21 +1951,17 @@ export class MemoryStore {
     `).get(sourceType, sourceId);
         return { positive: Number(row.positive ?? 0), negative: Number(row.negative ?? 0) };
     }
-    recordAccess(memoryId, accessType, sessionId) {
-        this.recordRetrievalAccess({
-            sourceType: 'memory',
-            sourceId: memoryId,
-            accessType,
-            sessionId,
-        });
-    }
     incrementAccess(id) {
-        this.recordRetrievalAccess({
-            sourceType: 'memory',
-            sourceId: id,
-            accessType: 'adopted',
-            purpose: 'reinforcement',
-        });
+        const now = Date.now();
+        const updated = this.db.prepare(`
+      UPDATE memories SET access_count = access_count + 1,
+        last_reinforced_at = COALESCE(last_reinforced_at, ?),
+        last_accessed_at = ?, updated_at = ?
+      WHERE id = ?
+    `).run(now, now, now, id);
+        if (updated.changes !== 1)
+            throw new Error(`Memory ${id} not found`);
+        this.bumpRetrievalRevision();
     }
     listRetrievalAccessLog(limit = 100) {
         return this.db.prepare(`
@@ -2478,26 +2213,6 @@ function uniqueStrings(values) {
     }
     return result;
 }
-function semanticRichness(value) {
-    const exactIdentifiers = value.match(/@[a-z0-9._-]+\/[a-z0-9._-]+|--[a-z0-9-]+|[a-z0-9]+(?:[-./][a-z0-9]+)+/giu)?.length ?? 0;
-    return [...value.normalize('NFKC').trim()].length + exactIdentifiers * 40;
-}
-function semanticObservationsConflict(existing, incoming) {
-    if (existing.semantic_key === incoming.semanticKey)
-        return false;
-    if (existing.semantic_polarity === 'neutral' || incoming.polarity === 'neutral')
-        return false;
-    const existingValue = normalizeEntityKey(existing.semantic_value);
-    const incomingValue = normalizeEntityKey(incoming.value);
-    if (existingValue === incomingValue)
-        return existing.semantic_polarity !== incoming.polarity;
-    const subject = normalizeEntityKey(incoming.subject);
-    if (new Set(['package manager', 'test runner', 'build tool']).has(subject))
-        return true;
-    if (incoming.predicate === 'version')
-        return true;
-    return ['use', 'prefer', 'require'].includes(incoming.predicate);
-}
 function strongerEvidenceStatus(existing, incoming) {
     return existing === 'verified' || incoming === 'verified' ? 'verified' : 'unverified';
 }
@@ -2521,19 +2236,6 @@ function mergeEvidenceDetails(existing, incoming) {
     }
     return result.slice(0, 64);
 }
-function semanticFromExplicitEnrichment(enrichment) {
-    return {
-        subject: enrichment.subject,
-        predicate: enrichment.predicate,
-        value: enrichment.value,
-        polarity: enrichment.polarity,
-        entities: enrichment.entities,
-        facet: enrichment.facet,
-        temporal: enrichment.temporal,
-        semanticKey: enrichment.semanticKey,
-        facetKey: enrichment.facetKey,
-    };
-}
 function camelToSnake(str) {
     return str.replace(/[A-Z]/g, letter => `_${letter.toLowerCase()}`);
 }