ai-memory-layer 2.0.0 → 3.0.0

package/dist/adapters/sqlite/index.js

@@ -2,11 +2,14 @@ import fs from 'fs';
 import path from 'path';
 import { createRequire } from 'module';
 import { normalizeScope, scopeValues } from '../../contracts/identity.js';
+import { UniqueConstraintError } from '../../contracts/storage.js';
+import { ConflictError } from '../../contracts/errors.js';
+import { compareTemporalIds, normalizeTemporalId } from '../../contracts/temporal.js';
 import { estimateTokens } from '../../core/tokens.js';
 import { emitMemoryEvent } from '../../core/telemetry.js';
 import { matchesKnowledgeSearchOptions } from '../../core/retrieval.js';
-import { assertArchiveInput, nowSeconds, validateContextMonitorUpsert, validateNewCompactionLog, validateNewKnowledgeCandidate, validateNewKnowledgeEvidence, validateNewKnowledgeMemoryAudit, validateNewKnowledgeMemory, validateNewWorkItem, validateTimeRange, validateNewTurn, validateNewWorkingMemory, } from '../../core/validation.js';
-import { rowToCompactionLog, rowToContextMonitor, rowToKnowledgeCandidate, rowToKnowledgeEvidence, rowToKnowledgeMemory, rowToKnowledgeMemoryAudit, rowToTurn, rowToWorkItem, rowToWorkingMemory, serializeNumberArray, serializeStringArray, } from './mappers.js';
+import { assertActorRef, assertArchiveInput, nowSeconds, validateContextMonitorUpsert, validateNewCompactionLog, validateNewKnowledgeCandidate, validateNewKnowledgeEvidence, validateNewKnowledgeMemoryAudit, validateNewKnowledgeMemory, validateNewWorkItem, validateTimeRange, validateNewTurn, validateNewWorkingMemory, } from '../../core/validation.js';
+import { rowToCompactionLog, rowToContextMonitor, rowToKnowledgeCandidate, rowToKnowledgeEvidence, rowToKnowledgeMemory, rowToKnowledgeMemoryAudit, rowToMemoryEvent, rowToAssociation, rowToTurn, rowToPlaybook, rowToPlaybookRevision, rowToSessionStateProjection, rowToTemporalProjectionWatermark, rowToWorkItem, rowToWorkingMemory, serializeObject, serializeNumberArray, serializeStringArray, } from './mappers.js';
 import { createSQLiteEmbeddingAdapter } from './embeddings.js';
 import { createSQLiteSchema } from './schema.js';
 const SCOPE_WHERE = 'tenant_id = ? AND system_id = ? AND workspace_id = ? AND collaboration_id = ? AND scope_id = ?';
@@ -20,29 +23,30 @@ function loadBetterSqlite3() {
     }
 }
 function scopeWhereForLevel(scope, level) {
-    const normalized = normalizeScope(scope);
     if (level === 'tenant')
         return 'tenant_id = ?';
     if (level === 'system')
         return 'tenant_id = ? AND system_id = ?';
-    if (level === 'workspace') {
-        return normalized.collaboration_id.length > 0
-            ? 'tenant_id = ? AND collaboration_id = ?'
-            : 'tenant_id = ? AND system_id = ? AND workspace_id = ?';
-    }
+    if (level === 'workspace')
+        return 'tenant_id = ? AND workspace_id = ?';
     return SCOPE_WHERE;
 }
+function scopeWhereForLevelWithPrefix(scope, level, prefix) {
+    return scopeWhereForLevel(scope, level)
+        .replaceAll('tenant_id', `${prefix}.tenant_id`)
+        .replaceAll('system_id', `${prefix}.system_id`)
+        .replaceAll('workspace_id', `${prefix}.workspace_id`)
+        .replaceAll('collaboration_id', `${prefix}.collaboration_id`)
+        .replaceAll('scope_id', `${prefix}.scope_id`);
+}
 function scopeParamsForLevel(scope, level) {
     const normalized = normalizeScope(scope);
     if (level === 'tenant')
         return [normalized.tenant_id];
     if (level === 'system')
         return [normalized.tenant_id, normalized.system_id];
-    if (level === 'workspace') {
-        return normalized.collaboration_id.length > 0
-            ? [normalized.tenant_id, normalized.collaboration_id]
-            : [normalized.tenant_id, normalized.system_id, normalized.workspace_id];
-    }
+    if (level === 'workspace')
+        return [normalized.tenant_id, normalized.workspace_id];
     return [...scopeValues(normalized)];
 }
 function timeRangeWhere(range, column = 'created_at') {
@@ -122,6 +126,20 @@ function resolvePaginationOptions(options) {
         cursor: options?.cursor ?? 0,
     };
 }
+function cloneValue(value) {
+    return structuredClone(value);
+}
+function resolveEventQuery(query) {
+    return {
+        sessionId: query?.sessionId ?? '',
+        entityKind: query?.entityKind ?? null,
+        entityId: query?.entityId ?? '',
+        startAt: query?.startAt ?? Number.NEGATIVE_INFINITY,
+        endAt: query?.endAt ?? Number.POSITIVE_INFINITY,
+        limit: query?.limit ?? 100,
+        cursor: query?.cursor != null ? normalizeTemporalId(query.cursor) : null,
+    };
+}
 export function createSQLiteAdapter(dbPath, telemetry) {
     const db = openSQLiteDatabase(dbPath);
     return createAdapterFromDatabase(db, telemetry);
@@ -145,6 +163,256 @@ function openSQLiteDatabase(dbPath) {
     return db;
 }
 function createAdapterFromDatabase(db, telemetry) {
+    function readTemporalWatermark(projectionName = 'temporal') {
+        const row = db
+            .prepare('SELECT * FROM projection_watermarks WHERE projection_name = ?')
+            .get(projectionName);
+        return row ? rowToTemporalProjectionWatermark(row) : null;
+    }
+    function writeTemporalWatermark(input) {
+        const lastEventId = normalizeTemporalId(input.last_event_id);
+        const updatedAt = input.updated_at ?? nowSeconds();
+        db.prepare(`INSERT INTO projection_watermarks
+        (projection_name, last_event_id, updated_at, cutover_at, metadata)
+       VALUES (?, ?, ?, ?, ?)
+       ON CONFLICT(projection_name) DO UPDATE SET
+         last_event_id = excluded.last_event_id,
+         updated_at = excluded.updated_at,
+         cutover_at = excluded.cutover_at,
+         metadata = excluded.metadata`).run(input.projection_name, lastEventId, updatedAt, input.cutover_at ?? null, serializeObject(input.metadata ?? null));
+        return readTemporalWatermark(input.projection_name);
+    }
+    function insertMemoryEventInternal(input) {
+        const normalized = normalizeScope(input);
+        const createdAt = input.created_at ?? nowSeconds();
+        const result = db
+            .prepare(`INSERT INTO memory_event_log
+          (tenant_id, system_id, workspace_id, collaboration_id, scope_id, session_id, actor_id,
+           actor_kind, actor_system_id, actor_display_name, actor_metadata,
+           entity_kind, entity_id, event_type, payload, causation_id, correlation_id, created_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+            .run(normalized.tenant_id, normalized.system_id, normalized.workspace_id, normalized.collaboration_id, normalized.scope_id, input.session_id ?? null, input.actor_id ?? null, input.actor_kind ?? null, input.actor_system_id ?? null, input.actor_display_name ?? null, input.actor_metadata ? JSON.stringify(input.actor_metadata) : null, input.entity_kind, input.entity_id, input.event_type, JSON.stringify(input.payload ?? {}), input.causation_id ?? null, input.correlation_id ?? null, createdAt);
+        const eventId = normalizeTemporalId(result.lastInsertRowid);
+        writeTemporalWatermark({
+            projection_name: 'temporal',
+            last_event_id: eventId,
+            updated_at: createdAt,
+            cutover_at: readTemporalWatermark('temporal')?.cutover_at ?? createdAt,
+            metadata: readTemporalWatermark('temporal')?.metadata ?? null,
+        });
+        const row = db
+            .prepare('SELECT * FROM memory_event_log WHERE event_id = ?')
+            .get(eventId);
+        return rowToMemoryEvent(row);
+    }
+    function insertMemoryEventsBatchInternal(inputs) {
+        if (inputs.length === 0)
+            return [];
+        const tx = db.transaction((batch) => {
+            const normalizedBatch = batch.map((input) => ({
+                normalized: normalizeScope(input),
+                input,
+                createdAt: input.created_at ?? nowSeconds(),
+            }));
+            const values = normalizedBatch.map(() => '(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)').join(', ');
+            const params = [];
+            for (const { normalized, input, createdAt } of normalizedBatch) {
+                params.push(normalized.tenant_id, normalized.system_id, normalized.workspace_id, normalized.collaboration_id, normalized.scope_id, input.session_id ?? null, input.actor_id ?? null, input.actor_kind ?? null, input.actor_system_id ?? null, input.actor_display_name ?? null, input.actor_metadata ? JSON.stringify(input.actor_metadata) : null, input.entity_kind, input.entity_id, input.event_type, JSON.stringify(input.payload ?? {}), input.causation_id ?? null, input.correlation_id ?? null, createdAt);
+            }
+            const result = db.prepare(`INSERT INTO memory_event_log
+          (tenant_id, system_id, workspace_id, collaboration_id, scope_id, session_id, actor_id,
+           actor_kind, actor_system_id, actor_display_name, actor_metadata,
+           entity_kind, entity_id, event_type, payload, causation_id, correlation_id, created_at)
+         VALUES ${values}`).run(...params);
+            const lastEventId = normalizeTemporalId(result.lastInsertRowid);
+            const firstEventId = normalizeTemporalId(BigInt(lastEventId) - BigInt(normalizedBatch.length) + 1n);
+            const records = db
+                .prepare(`SELECT * FROM memory_event_log
+             WHERE event_id BETWEEN ? AND ?
+             ORDER BY event_id ASC`)
+                .all(firstEventId, lastEventId).map(rowToMemoryEvent);
+            if (lastEventId != null) {
+                writeTemporalWatermark({
+                    projection_name: 'temporal',
+                    last_event_id: lastEventId,
+                    updated_at: normalizedBatch[normalizedBatch.length - 1].createdAt,
+                    cutover_at: readTemporalWatermark('temporal')?.cutover_at ??
+                        normalizedBatch[normalizedBatch.length - 1].createdAt,
+                    metadata: readTemporalWatermark('temporal')?.metadata ?? null,
+                });
+            }
+            return records;
+        });
+        return tx(inputs);
+    }
+    function listScopedMemoryEvents(scope, query) {
+        const resolved = resolveEventQuery(query);
+        const clauses = [SCOPE_WHERE, 'created_at >= ?', 'created_at <= ?'];
+        const params = [...scopeValues(scope), resolved.startAt, resolved.endAt];
+        if (resolved.cursor != null && compareTemporalIds(resolved.cursor, '0') > 0) {
+            clauses.push('event_id > ?');
+            params.push(resolved.cursor);
+        }
+        if (resolved.sessionId) {
+            clauses.push('session_id = ?');
+            params.push(resolved.sessionId);
+        }
+        if (resolved.entityKind) {
+            clauses.push('entity_kind = ?');
+            params.push(resolved.entityKind);
+        }
+        if (resolved.entityId) {
+            clauses.push('entity_id = ?');
+            params.push(resolved.entityId);
+        }
+        const rows = db
+            .prepare(`SELECT * FROM memory_event_log
+         WHERE ${clauses.join(' AND ')}
+         ORDER BY created_at ASC, event_id ASC
+         LIMIT ?`)
+            .all(...params, resolved.limit + 1);
+        const pageRows = rows.slice(0, resolved.limit).map(rowToMemoryEvent);
+        return {
+            events: pageRows,
+            nextCursor: rows.length > resolved.limit ? pageRows[pageRows.length - 1]?.event_id ?? null : null,
+        };
+    }
+    function listScopedMemoryEventsCrossScope(scope, level, query) {
+        const resolved = resolveEventQuery(query);
+        const clauses = [scopeWhereForLevel(scope, level), 'created_at >= ?', 'created_at <= ?'];
+        const params = [...scopeParamsForLevel(scope, level), resolved.startAt, resolved.endAt];
+        if (resolved.cursor != null && compareTemporalIds(resolved.cursor, '0') > 0) {
+            clauses.push('event_id > ?');
+            params.push(resolved.cursor);
+        }
+        if (resolved.sessionId) {
+            clauses.push('session_id = ?');
+            params.push(resolved.sessionId);
+        }
+        if (resolved.entityKind) {
+            clauses.push('entity_kind = ?');
+            params.push(resolved.entityKind);
+        }
+        if (resolved.entityId) {
+            clauses.push('entity_id = ?');
+            params.push(resolved.entityId);
+        }
+        const rows = db
+            .prepare(`SELECT * FROM memory_event_log
+         WHERE ${clauses.join(' AND ')}
+         ORDER BY created_at ASC, event_id ASC
+         LIMIT ?`)
+            .all(...params, resolved.limit + 1);
+        const pageRows = rows.slice(0, resolved.limit).map(rowToMemoryEvent);
+        return {
+            events: pageRows,
+            nextCursor: rows.length > resolved.limit ? pageRows[pageRows.length - 1]?.event_id ?? null : null,
+        };
+    }
+    function readSessionStateProjection(scope, sessionId) {
+        const row = db
+            .prepare(`SELECT * FROM session_state_current
+         WHERE ${SCOPE_WHERE} AND session_id = ?`)
+            .get(...scopeValues(scope), sessionId);
+        return row ? rowToSessionStateProjection(row) : null;
+    }
+    function writeSessionStateProjection(input) {
+        const normalized = normalizeScope(input);
+        db.prepare(`INSERT INTO session_state_current
+        (tenant_id, system_id, workspace_id, collaboration_id, scope_id, session_id,
+         current_objective, blockers, assumptions, pending_decisions, active_tools, recent_outputs,
+         updated_at, source_event_id)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(tenant_id, system_id, workspace_id, collaboration_id, scope_id, session_id) DO UPDATE SET
+         current_objective = excluded.current_objective,
+         blockers = excluded.blockers,
+         assumptions = excluded.assumptions,
+         pending_decisions = excluded.pending_decisions,
+         active_tools = excluded.active_tools,
+         recent_outputs = excluded.recent_outputs,
+         updated_at = excluded.updated_at,
+         source_event_id = excluded.source_event_id`).run(normalized.tenant_id, normalized.system_id, normalized.workspace_id, normalized.collaboration_id, normalized.scope_id, input.session_id, input.currentObjective, serializeStringArray(input.blockers), serializeStringArray(input.assumptions), serializeStringArray(input.pendingDecisions), serializeStringArray(input.activeTools), serializeStringArray(input.recentOutputs), input.updatedAt, input.source_event_id != null ? normalizeTemporalId(input.source_event_id) : null);
+        return readSessionStateProjection(normalized, input.session_id);
+    }
+    function serializeActorMetadata(actor) {
+        return [
+            actor.actor_kind,
+            actor.actor_id,
+            actor.system_id ?? null,
+            actor.display_name ?? null,
+            actor.metadata ? JSON.stringify(actor.metadata) : null,
+        ];
+    }
+    function parseActorRef(row, prefix = '') {
+        const value = (field) => row[`${prefix}${field}`];
+        let metadata = null;
+        if (value('actor_metadata') != null) {
+            try {
+                const parsed = JSON.parse(String(value('actor_metadata')));
+                metadata = parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+                    ? parsed
+                    : null;
+            }
+            catch {
+                metadata = null;
+            }
+        }
+        return {
+            actor_kind: String(value('actor_kind')),
+            actor_id: String(value('actor_id')),
+            system_id: value('actor_system_id') != null ? String(value('actor_system_id')) : null,
+            display_name: value('actor_display_name') != null ? String(value('actor_display_name')) : null,
+            metadata,
+        };
+    }
+    function mapWorkClaim(row) {
+        return {
+            id: Number(row.id),
+            tenant_id: String(row.tenant_id),
+            system_id: String(row.system_id),
+            workspace_id: String(row.workspace_id ?? ''),
+            collaboration_id: String(row.collaboration_id ?? ''),
+            scope_id: String(row.scope_id),
+            work_item_id: Number(row.work_item_id),
+            actor: parseActorRef(row),
+            session_id: row.session_id != null ? String(row.session_id) : null,
+            claim_token: String(row.claim_token),
+            status: String(row.status),
+            claimed_at: Number(row.claimed_at),
+            expires_at: Number(row.expires_at),
+            released_at: row.released_at != null ? Number(row.released_at) : null,
+            release_reason: row.release_reason != null ? String(row.release_reason) : null,
+            source_event_id: row.source_event_id != null ? String(row.source_event_id) : null,
+            visibility_class: row.visibility_class ?? 'private',
+            version: Number(row.version ?? 1),
+        };
+    }
+    function mapHandoff(row) {
+        return {
+            id: Number(row.id),
+            tenant_id: String(row.tenant_id),
+            system_id: String(row.system_id),
+            workspace_id: String(row.workspace_id ?? ''),
+            collaboration_id: String(row.collaboration_id ?? ''),
+            scope_id: String(row.scope_id),
+            work_item_id: Number(row.work_item_id),
+            from_actor: parseActorRef(row, 'from_'),
+            to_actor: parseActorRef(row, 'to_'),
+            session_id: row.session_id != null ? String(row.session_id) : null,
+            summary: String(row.summary),
+            context_bundle_ref: row.context_bundle_ref != null ? String(row.context_bundle_ref) : null,
+            status: String(row.status),
+            created_at: Number(row.created_at),
+            accepted_at: row.accepted_at != null ? Number(row.accepted_at) : null,
+            rejected_at: row.rejected_at != null ? Number(row.rejected_at) : null,
+            canceled_at: row.canceled_at != null ? Number(row.canceled_at) : null,
+            expires_at: row.expires_at != null ? Number(row.expires_at) : null,
+            decision_reason: row.decision_reason != null ? String(row.decision_reason) : null,
+            source_event_id: row.source_event_id != null ? String(row.source_event_id) : null,
+            visibility_class: row.visibility_class ?? 'private',
+            version: Number(row.version ?? 1),
+        };
+    }
     function getTurnById(id) {
         const row = db.prepare('SELECT * FROM turns WHERE id = ?').get(id);
         return row ? rowToTurn(row) : null;
@@ -155,6 +423,18 @@ function createAdapterFromDatabase(db, telemetry) {
             .get(id);
         return row ? rowToWorkingMemory(row) : null;
     }
+    function getExistingIds(table, ids) {
+        const uniqueIds = [...new Set(ids)];
+        if (uniqueIds.length === 0) {
+            return [];
+        }
+        const placeholders = uniqueIds.map(() => '?').join(', ');
+        const rows = db
+            .prepare(`SELECT id FROM ${table} WHERE id IN (${placeholders})`)
+            .all(...uniqueIds);
+        const existing = new Set(rows.map((row) => Number(row.id)));
+        return uniqueIds.filter((id) => existing.has(id));
+    }
     function getKnowledgeMemoryById(id) {
         const row = db
             .prepare('SELECT * FROM knowledge_memory WHERE id = ?')
@@ -207,7 +487,20 @@ function createAdapterFromDatabase(db, telemetry) {
           (session_id, tenant_id, system_id, workspace_id, collaboration_id, scope_id, actor, role, content, priority, token_estimate, created_at)
          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
             .run(input.session_id, scope.tenant_id, scope.system_id, scope.workspace_id, scope.collaboration_id, scope.scope_id, input.actor, input.role, input.content, input.priority ?? (input.role === 'system' ? 1.5 : 1), tokenEstimate, createdAt);
-        return getTurnById(Number(result.lastInsertRowid));
+        const turn = getTurnById(Number(result.lastInsertRowid));
+        insertMemoryEventInternal({
+            ...scope,
+            session_id: turn.session_id,
+            actor_id: turn.actor,
+            entity_kind: 'turn',
+            entity_id: String(turn.id),
+            event_type: 'turn.created',
+            payload: {
+                after: cloneValue(turn),
+            },
+            created_at: turn.created_at,
+        });
+        return turn;
     }
     function insertValidatedKnowledgeMemory(input) {
         const scope = validateNewKnowledgeMemory(input);
@@ -224,8 +517,140 @@ function createAdapterFromDatabase(db, telemetry) {
            contradiction_score, superseded_at, retired_at, created_at, last_accessed_at)
          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
             .run(scope.tenant_id, scope.system_id, scope.workspace_id, scope.collaboration_id, scope.scope_id, input.fact, input.fact_type, input.knowledge_state ?? 'trusted', input.knowledge_class ?? 'project_fact', input.fact_subject ?? null, input.fact_attribute ?? null, input.fact_value ?? null, input.normalized_fact ?? null, input.slot_key ?? null, input.is_negated ? 1 : 0, input.source, input.confidence, input.confidence_score ?? 0.5, input.grounding_strength ?? 'moderate', input.evidence_count ?? Math.max(1, (input.source_turn_ids ?? []).length), input.trust_score ?? (input.confidence_score ?? 0.5), input.verification_status ?? 'unverified', input.verification_notes ?? null, input.last_verified_at ?? null, input.next_reverification_at ?? null, input.last_confirmed_at ?? null, input.confirmation_count ?? 0, input.source_system_id ?? scope.system_id, input.source_scope_id ?? scope.scope_id, input.source_collaboration_id ?? scope.collaboration_id, input.source_working_memory_id ?? null, serializeNumberArray(input.source_turn_ids ?? []), input.successful_use_count ?? 0, input.failed_use_count ?? 0, input.disputed_at ?? null, input.dispute_reason ?? null, input.contradiction_score ?? 0, input.superseded_at ?? null, input.retired_at ?? null, createdAt, createdAt);
-        return getKnowledgeMemoryById(Number(result.lastInsertRowid));
+        const knowledge = getKnowledgeMemoryById(Number(result.lastInsertRowid));
+        insertMemoryEventInternal({
+            ...scope,
+            entity_kind: 'knowledge_memory',
+            entity_id: String(knowledge.id),
+            event_type: 'knowledge.created',
+            payload: {
+                after: cloneValue(knowledge),
+            },
+            created_at: knowledge.created_at,
+        });
+        return knowledge;
+    }
+    function bootstrapTemporalCutover() {
+        const existing = readTemporalWatermark('temporal');
+        if (existing?.cutover_at != null) {
+            return;
+        }
+        const cutoverAt = nowSeconds();
+        const correlationId = 'temporal-cutover-v1';
+        db.transaction(() => {
+            writeTemporalWatermark({
+                projection_name: 'temporal',
+                last_event_id: existing?.last_event_id ?? 0,
+                updated_at: cutoverAt,
+                cutover_at: cutoverAt,
+                metadata: {
+                    correlation_id: correlationId,
+                },
+            });
+            const turnRows = db.prepare('SELECT * FROM turns ORDER BY created_at ASC, id ASC').all();
+            for (const row of turnRows.map(rowToTurn)) {
+                insertMemoryEventInternal({
+                    ...normalizeScope(row),
+                    session_id: row.session_id,
+                    actor_id: row.actor,
+                    entity_kind: 'turn',
+                    entity_id: String(row.id),
+                    event_type: 'turn.seeded',
+                    payload: { after: cloneValue(row) },
+                    correlation_id: correlationId,
+                    created_at: cutoverAt,
+                });
+            }
+            const workingRows = db
+                .prepare('SELECT * FROM working_memory ORDER BY created_at ASC, id ASC')
+                .all();
+            for (const row of workingRows.map(rowToWorkingMemory)) {
+                insertMemoryEventInternal({
+                    ...normalizeScope(row),
+                    session_id: row.session_id,
+                    entity_kind: 'working_memory',
+                    entity_id: String(row.id),
+                    event_type: 'working_memory.seeded',
+                    payload: { after: cloneValue(row) },
+                    correlation_id: correlationId,
+                    created_at: cutoverAt,
+                });
+            }
+            const knowledgeRows = db
+                .prepare('SELECT * FROM knowledge_memory ORDER BY created_at ASC, id ASC')
+                .all();
+            for (const row of knowledgeRows.map(rowToKnowledgeMemory)) {
+                insertMemoryEventInternal({
+                    ...normalizeScope(row),
+                    entity_kind: 'knowledge_memory',
+                    entity_id: String(row.id),
+                    event_type: 'knowledge.seeded',
+                    payload: { after: cloneValue(row) },
+                    correlation_id: correlationId,
+                    created_at: cutoverAt,
+                });
+            }
+            const workItemRows = db
+                .prepare('SELECT * FROM work_items ORDER BY created_at ASC, id ASC')
+                .all();
+            for (const row of workItemRows.map(rowToWorkItem)) {
+                insertMemoryEventInternal({
+                    ...normalizeScope(row),
+                    session_id: row.session_id,
+                    entity_kind: 'work_item',
+                    entity_id: String(row.id),
+                    event_type: 'work_item.seeded',
+                    payload: { after: cloneValue(row) },
+                    correlation_id: correlationId,
+                    created_at: cutoverAt,
+                });
+            }
+            const associationRows = db
+                .prepare('SELECT * FROM associations ORDER BY created_at ASC, id ASC')
+                .all();
+            for (const row of associationRows.map((item) => rowToAssociation({
+                id: Number(item.id),
+                tenant_id: String(item.tenant_id),
+                system_id: String(item.system_id),
+                workspace_id: String(item.workspace_id ?? ''),
+                collaboration_id: String(item.collaboration_id ?? item.workspace_id ?? ''),
+                scope_id: String(item.scope_id),
+                visibility_class: item.visibility_class ?? 'private',
+                source_kind: item.source_kind,
+                source_id: Number(item.source_id),
+                target_kind: item.target_kind,
+                target_id: Number(item.target_id),
+                association_type: item.association_type,
+                confidence: Number(item.confidence ?? 0),
+                auto_generated: Number(item.auto_generated ?? 0) === 1,
+                created_at: Number(item.created_at),
+            }))) {
+                insertMemoryEventInternal({
+                    ...normalizeScope(row),
+                    entity_kind: 'association',
+                    entity_id: String(row.id),
+                    event_type: 'association.seeded',
+                    payload: { after: cloneValue(row) },
+                    correlation_id: correlationId,
+                    created_at: cutoverAt,
+                });
+            }
+            const playbookRows = db.prepare('SELECT * FROM playbooks ORDER BY created_at ASC, id ASC').all();
+            for (const row of playbookRows.map(rowToPlaybook)) {
+                insertMemoryEventInternal({
+                    ...normalizeScope(row),
+                    session_id: row.source_session_id,
+                    entity_kind: 'playbook',
+                    entity_id: String(row.id),
+                    event_type: 'playbook.seeded',
+                    payload: { after: cloneValue(row) },
+                    correlation_id: correlationId,
+                    created_at: cutoverAt,
+                });
+            }
+        })();
     }
+    bootstrapTemporalCutover();
     return {
         insertTurn(input) {
             return insertValidatedTurn(input);
@@ -272,17 +697,28 @@ function createAdapterFromDatabase(db, telemetry) {
         searchTurns(scope, query, options) {
             const startedAt = Date.now();
             const resolved = resolveSearchOptions(options);
+            const safeQuery = toSafeFtsQuery(query);
+            const executeSearch = (ftsQuery) => db.prepare(`SELECT turns.*, bm25(turns_fts) AS raw_rank
+           FROM turns_fts
+           JOIN turns ON turns_fts.rowid = turns.id
+           WHERE turns_fts MATCH ?
+             AND ${SCOPE_WHERE}
+             AND (? = 0 OR turns.archived_at IS NULL)
+           ORDER BY bm25(turns_fts)
+           LIMIT ?`).all(ftsQuery, ...scopeValues(scope), resolved.activeOnly ? 1 : 0, resolved.limit);
             try {
-                const rows = db
-                    .prepare(`SELECT turns.*, bm25(turns_fts) AS raw_rank
-             FROM turns_fts
-             JOIN turns ON turns_fts.rowid = turns.id
-             WHERE turns_fts MATCH ?
-               AND ${SCOPE_WHERE}
-               AND (? = 0 OR turns.archived_at IS NULL)
-             ORDER BY bm25(turns_fts)
-             LIMIT ?`)
-                    .all(query, ...scopeValues(scope), resolved.activeOnly ? 1 : 0, resolved.limit);
+                let rows;
+                try {
+                    rows = executeSearch(query);
+                }
+                catch (error) {
+                    if (safeQuery.length === 0 || safeQuery === query)
+                        throw error;
+                    rows = executeSearch(safeQuery);
+                }
+                if (rows.length === 0 && safeQuery.length > 0 && safeQuery !== query && !/["']/.test(query)) {
+                    rows = executeSearch(safeQuery);
+                }
                 const results = rows.map((row) => ({
                     item: rowToTurn(row),
                     rank: normalizeRank(row.raw_rank),
@@ -306,9 +742,30 @@ function createAdapterFromDatabase(db, telemetry) {
         },
         archiveTurn(id, archivedAt, compactionLogId) {
             assertArchiveInput(id, archivedAt, compactionLogId);
+            const before = getTurnById(id);
             db.prepare(`UPDATE turns
          SET archived_at = ?, compaction_log_id = ?
          WHERE id = ? AND archived_at IS NULL`).run(archivedAt, compactionLogId, id);
+            const after = getTurnById(id);
+            if (before && after && before.archived_at !== after.archived_at) {
+                insertMemoryEventInternal({
+                    ...normalizeScope(after),
+                    session_id: after.session_id,
+                    actor_id: after.actor,
+                    entity_kind: 'turn',
+                    entity_id: String(after.id),
+                    event_type: 'turn.archived',
+                    payload: {
+                        before: cloneValue(before),
+                        after: cloneValue(after),
+                        patch: {
+                            archived_at: archivedAt,
+                            compaction_log_id: compactionLogId,
+                        },
+                    },
+                    created_at: archivedAt,
+                });
+            }
         },
         getArchivedTurnRange(sessionId, startId, endId, scope) {
             const query = `SELECT * FROM turns
@@ -327,12 +784,27 @@ function createAdapterFromDatabase(db, telemetry) {
             const result = db
                 .prepare(`INSERT INTO working_memory
             (session_id, tenant_id, system_id, workspace_id, collaboration_id, scope_id, summary, key_entities, topic_tags,
-             turn_id_start, turn_id_end, turn_count, compaction_trigger, created_at, expires_at)
-           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
-                .run(input.session_id, scope.tenant_id, scope.system_id, scope.workspace_id, scope.collaboration_id, scope.scope_id, input.summary, serializeStringArray(input.key_entities), serializeStringArray(input.topic_tags), input.turn_id_start, input.turn_id_end, input.turn_count, input.compaction_trigger, createdAt, expiresAt);
-            return getWorkingMemoryById(Number(result.lastInsertRowid));
+             turn_id_start, turn_id_end, turn_count, compaction_trigger, created_at, expires_at, episode_recap)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+                .run(input.session_id, scope.tenant_id, scope.system_id, scope.workspace_id, scope.collaboration_id, scope.scope_id, input.summary, serializeStringArray(input.key_entities), serializeStringArray(input.topic_tags), input.turn_id_start, input.turn_id_end, input.turn_count, input.compaction_trigger, createdAt, expiresAt, input.episode_recap ? JSON.stringify(input.episode_recap) : null);
+            const workingMemory = getWorkingMemoryById(Number(result.lastInsertRowid));
+            insertMemoryEventInternal({
+                ...scope,
+                session_id: workingMemory.session_id,
+                entity_kind: 'working_memory',
+                entity_id: String(workingMemory.id),
+                event_type: 'working_memory.created',
+                payload: {
+                    after: cloneValue(workingMemory),
+                },
+                created_at: workingMemory.created_at,
+            });
+            return workingMemory;
         },
         getWorkingMemoryById,
+        getExistingWorkingMemoryIds(ids) {
+            return getExistingIds('working_memory', ids);
+        },
         getWorkingMemoryBySession(sessionId, scope) {
             const query = `SELECT * FROM working_memory
            WHERE session_id = ? AND ${SCOPE_WHERE}
@@ -375,10 +847,49 @@ function createAdapterFromDatabase(db, telemetry) {
             return rows.map(rowToWorkingMemory);
         },
         expireWorkingMemory(id) {
-            db.prepare('UPDATE working_memory SET expires_at = ? WHERE id = ?').run(nowSeconds(), id);
+            const before = getWorkingMemoryById(id);
+            const expiredAt = nowSeconds();
+            db.prepare('UPDATE working_memory SET expires_at = ? WHERE id = ?').run(expiredAt, id);
+            const after = getWorkingMemoryById(id);
+            if (before && after) {
+                insertMemoryEventInternal({
+                    ...normalizeScope(after),
+                    session_id: after.session_id,
+                    entity_kind: 'working_memory',
+                    entity_id: String(after.id),
+                    event_type: 'working_memory.expired',
+                    payload: {
+                        before: cloneValue(before),
+                        after: cloneValue(after),
+                        patch: {
+                            expires_at: expiredAt,
+                        },
+                    },
+                    created_at: expiredAt,
+                });
+            }
         },
         markWorkingMemoryPromoted(id, knowledgeMemoryId) {
+            const before = getWorkingMemoryById(id);
             db.prepare('UPDATE working_memory SET promoted_to_knowledge_id = ? WHERE id = ?').run(knowledgeMemoryId, id);
+            const after = getWorkingMemoryById(id);
+            if (before && after) {
+                insertMemoryEventInternal({
+                    ...normalizeScope(after),
+                    session_id: after.session_id,
+                    entity_kind: 'working_memory',
+                    entity_id: String(after.id),
+                    event_type: 'working_memory.promoted',
+                    payload: {
+                        before: cloneValue(before),
+                        after: cloneValue(after),
+                        refs: {
+                            knowledge_memory_id: knowledgeMemoryId,
+                        },
+                    },
+                    created_at: nowSeconds(),
+                });
+            }
         },
         insertKnowledgeMemory(input) {
             return insertValidatedKnowledgeMemory(input);
@@ -448,6 +959,9 @@ function createAdapterFromDatabase(db, telemetry) {
             return knowledge;
         },
         getKnowledgeMemoryById,
+        getExistingKnowledgeMemoryIds(ids) {
+            return getExistingIds('knowledge_memory', ids);
+        },
         getActiveKnowledgeMemory(scope) {
             const rows = db
                 .prepare(`SELECT * FROM knowledge_memory
@@ -695,6 +1209,7 @@ function createAdapterFromDatabase(db, telemetry) {
         getRecentKnowledgeMemoryAudits,
         getKnowledgeMemoryAuditsForKnowledge,
         updateKnowledgeMemory(id, patch) {
+            const before = getKnowledgeMemoryById(id);
             const assignments = [];
             const values = [];
             const push = (column, value) => {
@@ -736,7 +1251,22 @@ function createAdapterFromDatabase(db, telemetry) {
                 return getKnowledgeMemoryById(id);
             }
             db.prepare(`UPDATE knowledge_memory SET ${assignments.join(', ')} WHERE id = ?`).run(...values, id);
-            return getKnowledgeMemoryById(id);
+            const after = getKnowledgeMemoryById(id);
+            if (before && after) {
+                insertMemoryEventInternal({
+                    ...normalizeScope(after),
+                    entity_kind: 'knowledge_memory',
+                    entity_id: String(after.id),
+                    event_type: 'knowledge.updated',
+                    payload: {
+                        before: cloneValue(before),
+                        after: cloneValue(after),
+                        patch: cloneValue(patch),
+                    },
+                    created_at: nowSeconds(),
+                });
+            }
+            return after;
         },
         insertWorkItem(input) {
             const scope = validateNewWorkItem(input);
@@ -744,13 +1274,25 @@ function createAdapterFromDatabase(db, telemetry) {
             const result = db
                 .prepare(`INSERT INTO work_items
             (session_id, tenant_id, system_id, workspace_id, collaboration_id, scope_id, kind, title, detail, status,
-             source_working_memory_id, created_at, updated_at)
-           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
-                .run(input.session_id ?? null, scope.tenant_id, scope.system_id, scope.workspace_id, scope.collaboration_id, scope.scope_id, input.kind, input.title, input.detail ?? null, input.status ?? 'open', input.source_working_memory_id ?? null, createdAt, createdAt);
+             visibility_class, source_working_memory_id, version, created_at, updated_at)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+                .run(input.session_id ?? null, scope.tenant_id, scope.system_id, scope.workspace_id, scope.collaboration_id, scope.scope_id, input.kind, input.title, input.detail ?? null, input.status ?? 'open', input.visibility_class ?? 'private', input.source_working_memory_id ?? null, 1, createdAt, createdAt);
             const row = db
                 .prepare('SELECT * FROM work_items WHERE id = ?')
                 .get(Number(result.lastInsertRowid));
-            return rowToWorkItem(row);
+            const workItem = rowToWorkItem(row);
+            insertMemoryEventInternal({
+                ...scope,
+                session_id: workItem.session_id,
+                entity_kind: 'work_item',
+                entity_id: String(workItem.id),
+                event_type: 'work_item.created',
+                payload: {
+                    after: cloneValue(workItem),
+                },
+                created_at: workItem.created_at,
+            });
+            return workItem;
         },
         getActiveWorkItems(scope) {
             const rows = db
@@ -760,6 +1302,21 @@ function createAdapterFromDatabase(db, telemetry) {
                 .all(...scopeValues(scope));
             return rows.map(rowToWorkItem);
         },
+        getWorkItemById(id) {
+            const row = db.prepare('SELECT * FROM work_items WHERE id = ?').get(id);
+            return row ? rowToWorkItem(row) : null;
+        },
+        getExistingWorkItemIds(ids) {
+            return getExistingIds('work_items', ids);
+        },
+        getActiveWorkItemsCrossScope(scope, level) {
+            const rows = db
+                .prepare(`SELECT * FROM work_items
+           WHERE ${scopeWhereForLevel(scope, level)} AND status != 'done'
+           ORDER BY updated_at DESC`)
+                .all(...scopeParamsForLevel(scope, level));
+            return rows.map(rowToWorkItem);
+        },
         getWorkItemsByTimeRange(scope, range) {
             const time = timeRangeWhere(range, 'created_at');
             const rows = db
@@ -769,24 +1326,802 @@ function createAdapterFromDatabase(db, telemetry) {
                 .all(...scopeValues(scope), ...time.params);
             return rows.map(rowToWorkItem);
         },
+        getWorkItemsByTimeRangeCrossScope(scope, level, range) {
+            const time = timeRangeWhere(range, 'created_at');
+            const rows = db
+                .prepare(`SELECT * FROM work_items
+           WHERE ${scopeWhereForLevel(scope, level)}${time.clause}
+           ORDER BY created_at ASC`)
+                .all(...scopeParamsForLevel(scope, level), ...time.params);
+            return rows.map(rowToWorkItem);
+        },
         updateWorkItemStatus(id, status) {
-            db.prepare('UPDATE work_items SET status = ?, updated_at = ? WHERE id = ?').run(status, nowSeconds(), id);
+            const before = db
+                .prepare('SELECT * FROM work_items WHERE id = ?')
+                .get(id);
+            const updatedAt = nowSeconds();
+            db.prepare('UPDATE work_items SET status = ?, updated_at = ? WHERE id = ?').run(status, updatedAt, id);
+            const after = db
+                .prepare('SELECT * FROM work_items WHERE id = ?')
+                .get(id);
+            if (before && after) {
+                const afterItem = rowToWorkItem(after);
+                insertMemoryEventInternal({
+                    ...normalizeScope(afterItem),
+                    session_id: afterItem.session_id,
+                    entity_kind: 'work_item',
+                    entity_id: String(afterItem.id),
+                    event_type: 'work_item.status_changed',
+                    payload: {
+                        before: cloneValue(rowToWorkItem(before)),
+                        after: cloneValue(afterItem),
+                        patch: {
+                            status,
+                            updated_at: updatedAt,
+                        },
+                    },
+                    created_at: updatedAt,
+                });
+            }
+        },
+        updateWorkItem(id, patch, options) {
+            const before = db
+                .prepare('SELECT * FROM work_items WHERE id = ?')
+                .get(id);
+            if (!before)
+                return null;
+            const beforeItem = rowToWorkItem(before);
+            if (options?.expectedVersion != null && beforeItem.version !== options.expectedVersion) {
+                throw new ConflictError(`Work item ${id} version mismatch`);
+            }
+            const updatedAt = nowSeconds();
+            const next = {
+                title: patch.title ?? beforeItem.title,
+                detail: patch.detail !== undefined ? patch.detail : beforeItem.detail,
+                status: patch.status ?? beforeItem.status,
+                visibility_class: patch.visibility_class ?? beforeItem.visibility_class,
+            };
+            db.prepare(`UPDATE work_items
+         SET title = ?, detail = ?, status = ?, visibility_class = ?, version = version + 1, updated_at = ?
+         WHERE id = ?`).run(next.title, next.detail ?? null, next.status, next.visibility_class, updatedAt, id);
+            const after = db
+                .prepare('SELECT * FROM work_items WHERE id = ?')
+                .get(id);
+            if (!after)
+                return null;
+            const afterItem = rowToWorkItem(after);
+            insertMemoryEventInternal({
+                ...normalizeScope(afterItem),
+                session_id: afterItem.session_id,
+                entity_kind: 'work_item',
+                entity_id: String(afterItem.id),
+                event_type: patch.visibility_class !== undefined &&
+                    patch.title === undefined &&
+                    patch.detail === undefined &&
+                    patch.status === undefined
+                    ? 'work_item.visibility_changed'
+                    : 'work_item.updated',
+                payload: {
+                    before: cloneValue(beforeItem),
+                    after: cloneValue(afterItem),
+                    patch: cloneValue(patch),
+                },
+                created_at: updatedAt,
+            });
+            return afterItem;
         },
         deleteWorkItem(id) {
+            const before = db
+                .prepare('SELECT * FROM work_items WHERE id = ?')
+                .get(id);
             db.prepare('DELETE FROM work_items WHERE id = ?').run(id);
+            if (before) {
+                const item = rowToWorkItem(before);
+                insertMemoryEventInternal({
+                    ...normalizeScope(item),
+                    session_id: item.session_id,
+                    entity_kind: 'work_item',
+                    entity_id: String(item.id),
+                    event_type: 'work_item.deleted',
+                    payload: {
+                        before: cloneValue(item),
+                    },
+                    created_at: nowSeconds(),
+                });
+            }
+        },
+        claimWorkItem(input) {
+            assertActorRef(input.actor);
+            const workItemRow = db.prepare('SELECT * FROM work_items WHERE id = ?').get(input.work_item_id);
+            if (!workItemRow)
+                throw new ConflictError(`Work item ${input.work_item_id} does not exist`);
+            const workItem = rowToWorkItem(workItemRow);
+            if (workItem.status === 'done')
+                throw new ConflictError(`Work item ${input.work_item_id} is done`);
+            const now = input.claimed_at ?? nowSeconds();
+            const existingRow = db
+                .prepare('SELECT * FROM work_claims_current WHERE work_item_id = ?')
+                .get(input.work_item_id);
+            if (existingRow) {
+                const existing = mapWorkClaim(existingRow);
+                if (existing.status === 'active' && existing.expires_at > now) {
+                    if (existing.actor.actor_kind !== input.actor.actor_kind ||
+                        existing.actor.actor_id !== input.actor.actor_id) {
+                        throw new ConflictError(`Work item ${input.work_item_id} is already claimed`);
+                    }
+                    return this.renewWorkClaim(existing.id, input.actor, input.lease_seconds ?? 300);
+                }
+                db.prepare(`UPDATE work_claims_current
+           SET status = 'expired', released_at = ?, release_reason = 'expired', version = version + 1
+           WHERE id = ?`).run(now, existing.id);
+                const expired = mapWorkClaim(db.prepare('SELECT * FROM work_claims_current WHERE id = ?').get(existing.id));
+                insertMemoryEventInternal({
+                    ...normalizeScope(expired),
+                    session_id: expired.session_id,
+                    actor_id: expired.actor.actor_id,
+                    actor_kind: expired.actor.actor_kind,
+                    actor_system_id: expired.actor.system_id,
+                    actor_display_name: expired.actor.display_name,
+                    actor_metadata: expired.actor.metadata,
+                    entity_kind: 'work_claim',
+                    entity_id: String(expired.id),
+                    event_type: 'work_claim.expired',
+                    payload: { after: cloneValue(expired) },
+                    created_at: now,
+                });
+            }
+            const normalized = normalizeScope(input);
+            const actorParts = serializeActorMetadata(input.actor);
+            const claimToken = `claim-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+            const result = db.prepare(`INSERT INTO work_claims_current
+          (tenant_id, system_id, workspace_id, collaboration_id, scope_id, work_item_id, session_id,
+           actor_kind, actor_id, actor_system_id, actor_display_name, actor_metadata,
+           claim_token, status, claimed_at, expires_at, visibility_class, version)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'active', ?, ?, ?, 1)`).run(normalized.tenant_id, normalized.system_id, normalized.workspace_id, normalized.collaboration_id, normalized.scope_id, input.work_item_id, input.session_id ?? null, ...actorParts, claimToken, now, now + (input.lease_seconds ?? 300), input.visibility_class);
+            const claim = mapWorkClaim(db.prepare('SELECT * FROM work_claims_current WHERE id = ?').get(Number(result.lastInsertRowid)));
+            insertMemoryEventInternal({
+                ...normalized,
+                session_id: claim.session_id,
+                actor_id: claim.actor.actor_id,
+                actor_kind: claim.actor.actor_kind,
+                actor_system_id: claim.actor.system_id,
+                actor_display_name: claim.actor.display_name,
+                actor_metadata: claim.actor.metadata,
+                entity_kind: 'work_claim',
+                entity_id: String(claim.id),
+                event_type: 'work_claim.claimed',
+                payload: { after: cloneValue(claim) },
+                created_at: now,
+            });
+            return claim;
+        },
+        renewWorkClaim(claimId, actor, leaseSeconds = 300) {
+            assertActorRef(actor);
+            const before = db.prepare('SELECT * FROM work_claims_current WHERE id = ?').get(claimId);
+            if (!before)
+                return null;
+            const claim = mapWorkClaim(before);
+            if (claim.actor.actor_kind !== actor.actor_kind || claim.actor.actor_id !== actor.actor_id) {
+                throw new ConflictError(`Claim ${claimId} is owned by another actor`);
+            }
+            const now = nowSeconds();
+            if (claim.status !== 'active') {
+                throw new ConflictError(`Claim ${claimId} is no longer active`);
+            }
+            if (claim.expires_at <= now) {
+                db.prepare(`UPDATE work_claims_current
+           SET status = 'expired', released_at = ?, release_reason = 'expired', version = version + 1
+           WHERE id = ?`).run(now, claimId);
+                const expired = mapWorkClaim(db.prepare('SELECT * FROM work_claims_current WHERE id = ?').get(claimId));
+                insertMemoryEventInternal({
+                    ...normalizeScope(expired),
+                    session_id: expired.session_id,
+                    actor_id: expired.actor.actor_id,
+                    actor_kind: expired.actor.actor_kind,
+                    actor_system_id: expired.actor.system_id,
+                    actor_display_name: expired.actor.display_name,
+                    actor_metadata: expired.actor.metadata,
+                    entity_kind: 'work_claim',
+                    entity_id: String(expired.id),
+                    event_type: 'work_claim.expired',
+                    payload: { before: cloneValue(claim), after: cloneValue(expired) },
+                    created_at: now,
+                });
+                return null;
+            }
+            db.prepare(`UPDATE work_claims_current
+         SET expires_at = ?, version = version + 1
+         WHERE id = ?`).run(Math.max(claim.expires_at, now) + leaseSeconds, claimId);
+            const after = mapWorkClaim(db.prepare('SELECT * FROM work_claims_current WHERE id = ?').get(claimId));
+            insertMemoryEventInternal({
+                ...normalizeScope(after),
+                session_id: after.session_id,
+                actor_id: after.actor.actor_id,
+                actor_kind: after.actor.actor_kind,
+                actor_system_id: after.actor.system_id,
+                actor_display_name: after.actor.display_name,
+                actor_metadata: after.actor.metadata,
+                entity_kind: 'work_claim',
+                entity_id: String(after.id),
+                event_type: 'work_claim.renewed',
+                payload: { before: cloneValue(claim), after: cloneValue(after) },
+                created_at: now,
+            });
+            return after;
+        },
+        releaseWorkClaim(claimId, actor, reason) {
+            assertActorRef(actor);
+            const before = db.prepare('SELECT * FROM work_claims_current WHERE id = ?').get(claimId);
+            if (!before)
+                return null;
+            const claim = mapWorkClaim(before);
+            if (claim.actor.actor_kind !== actor.actor_kind || claim.actor.actor_id !== actor.actor_id) {
+                throw new ConflictError(`Claim ${claimId} is owned by another actor`);
+            }
+            if (claim.status !== 'active') {
+                throw new ConflictError(`Claim ${claimId} is no longer active`);
+            }
+            const now = nowSeconds();
+            db.prepare(`UPDATE work_claims_current
+         SET status = 'released', released_at = ?, release_reason = ?, version = version + 1
+         WHERE id = ?`).run(now, reason ?? null, claimId);
+            const after = mapWorkClaim(db.prepare('SELECT * FROM work_claims_current WHERE id = ?').get(claimId));
+            insertMemoryEventInternal({
+                ...normalizeScope(after),
+                session_id: after.session_id,
+                actor_id: after.actor.actor_id,
+                actor_kind: after.actor.actor_kind,
+                actor_system_id: after.actor.system_id,
+                actor_display_name: after.actor.display_name,
+                actor_metadata: after.actor.metadata,
+                entity_kind: 'work_claim',
+                entity_id: String(after.id),
+                event_type: 'work_claim.released',
+                payload: { before: cloneValue(claim), after: cloneValue(after) },
+                created_at: now,
+            });
+            return after;
+        },
+        getActiveWorkClaim(workItemId) {
+            const row = db
+                .prepare(`SELECT * FROM work_claims_current
+           WHERE work_item_id = ? AND status = 'active'
+           ORDER BY id DESC LIMIT 1`)
+                .get(workItemId);
+            if (!row)
+                return null;
+            const claim = mapWorkClaim(row);
+            if (claim.expires_at > nowSeconds())
+                return claim;
+            const expiredAt = nowSeconds();
+            db.prepare(`UPDATE work_claims_current
+         SET status = 'expired', released_at = ?, release_reason = 'expired', version = version + 1
+         WHERE id = ?`).run(expiredAt, claim.id);
+            const expired = mapWorkClaim(db.prepare('SELECT * FROM work_claims_current WHERE id = ?').get(claim.id));
+            insertMemoryEventInternal({
+                ...normalizeScope(expired),
+                session_id: expired.session_id,
+                actor_id: expired.actor.actor_id,
+                actor_kind: expired.actor.actor_kind,
+                actor_system_id: expired.actor.system_id,
+                actor_display_name: expired.actor.display_name,
+                actor_metadata: expired.actor.metadata,
+                entity_kind: 'work_claim',
+                entity_id: String(expired.id),
+                event_type: 'work_claim.expired',
+                payload: { before: cloneValue(claim), after: cloneValue(expired) },
+                created_at: expiredAt,
+            });
+            return null;
+        },
+        listWorkClaims(scope, options) {
+            const now = nowSeconds();
+            const expiredRows = db
+                .prepare(`SELECT * FROM work_claims_current
+           WHERE ${SCOPE_WHERE} AND status = 'active' AND expires_at <= ?`)
+                .all(...scopeValues(scope), now);
+            for (const row of expiredRows) {
+                const before = mapWorkClaim(row);
+                db.prepare(`UPDATE work_claims_current
+           SET status = 'expired', released_at = ?, release_reason = 'expired', version = version + 1
+           WHERE id = ?`).run(now, before.id);
+                const after = mapWorkClaim(db.prepare('SELECT * FROM work_claims_current WHERE id = ?').get(before.id));
+                insertMemoryEventInternal({
+                    ...normalizeScope(after),
+                    session_id: after.session_id,
+                    actor_id: after.actor.actor_id,
+                    actor_kind: after.actor.actor_kind,
+                    actor_system_id: after.actor.system_id,
+                    actor_display_name: after.actor.display_name,
+                    actor_metadata: after.actor.metadata,
+                    entity_kind: 'work_claim',
+                    entity_id: String(after.id),
+                    event_type: 'work_claim.expired',
+                    payload: { before: cloneValue(before), after: cloneValue(after) },
+                    created_at: now,
+                });
+            }
+            const rows = db
+                .prepare(`SELECT * FROM work_claims_current WHERE ${SCOPE_WHERE} ORDER BY claimed_at DESC`)
+                .all(...scopeValues(scope));
+            return rows
+                .map(mapWorkClaim)
+                .filter((claim) => {
+                if (!options?.includeExpired && claim.status === 'expired')
+                    return false;
+                if (!options?.includeReleased && claim.status === 'released')
+                    return false;
+                if (options?.sessionId && claim.session_id !== options.sessionId)
+                    return false;
+                if (options?.visibilityClass && claim.visibility_class !== options.visibilityClass)
+                    return false;
+                if (options?.actor) {
+                    return (claim.actor.actor_kind === options.actor.actor_kind &&
+                        claim.actor.actor_id === options.actor.actor_id);
+                }
+                return true;
+            });
+        },
+        listWorkClaimsCrossScope(scope, level, options) {
+            const now = nowSeconds();
+            const expiredRows = db
+                .prepare(`SELECT * FROM work_claims_current
+           WHERE ${scopeWhereForLevel(scope, level)} AND status = 'active' AND expires_at <= ?`)
+                .all(...scopeParamsForLevel(scope, level), now);
+            for (const row of expiredRows) {
+                const before = mapWorkClaim(row);
+                db.prepare(`UPDATE work_claims_current
+           SET status = 'expired', released_at = ?, release_reason = 'expired', version = version + 1
+           WHERE id = ?`).run(now, before.id);
+                const after = mapWorkClaim(db.prepare('SELECT * FROM work_claims_current WHERE id = ?').get(before.id));
+                insertMemoryEventInternal({
+                    ...normalizeScope(after),
+                    session_id: after.session_id,
+                    actor_id: after.actor.actor_id,
+                    actor_kind: after.actor.actor_kind,
+                    actor_system_id: after.actor.system_id,
+                    actor_display_name: after.actor.display_name,
+                    actor_metadata: after.actor.metadata,
+                    entity_kind: 'work_claim',
+                    entity_id: String(after.id),
+                    event_type: 'work_claim.expired',
+                    payload: { before: cloneValue(before), after: cloneValue(after) },
+                    created_at: now,
+                });
+            }
+            const rows = db
+                .prepare(`SELECT * FROM work_claims_current WHERE ${scopeWhereForLevel(scope, level)} ORDER BY claimed_at DESC`)
+                .all(...scopeParamsForLevel(scope, level));
+            return rows
+                .map(mapWorkClaim)
+                .filter((claim) => {
+                if (!options?.includeExpired && claim.status === 'expired')
+                    return false;
+                if (!options?.includeReleased && claim.status === 'released')
+                    return false;
+                if (options?.sessionId && claim.session_id !== options.sessionId)
+                    return false;
+                if (options?.visibilityClass && claim.visibility_class !== options.visibilityClass)
+                    return false;
+                if (options?.actor) {
+                    return (claim.actor.actor_kind === options.actor.actor_kind &&
+                        claim.actor.actor_id === options.actor.actor_id);
+                }
+                return true;
+            });
+        },
+        createHandoff(input) {
+            assertActorRef(input.from_actor, 'from_actor');
+            assertActorRef(input.to_actor, 'to_actor');
+            const normalized = normalizeScope(input);
+            const createdAt = input.created_at ?? nowSeconds();
+            const fromParts = serializeActorMetadata(input.from_actor);
+            const toParts = serializeActorMetadata(input.to_actor);
+            const result = db.prepare(`INSERT INTO handoff_records
+          (tenant_id, system_id, workspace_id, collaboration_id, scope_id, work_item_id, session_id,
+           from_actor_kind, from_actor_id, from_actor_system_id, from_actor_display_name, from_actor_metadata,
+           to_actor_kind, to_actor_id, to_actor_system_id, to_actor_display_name, to_actor_metadata,
+           summary, context_bundle_ref, status, created_at, expires_at, visibility_class, version)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'pending', ?, ?, ?, 1)`).run(normalized.tenant_id, normalized.system_id, normalized.workspace_id, normalized.collaboration_id, normalized.scope_id, input.work_item_id, input.session_id ?? null, ...fromParts, ...toParts, input.summary, input.context_bundle_ref ?? null, createdAt, input.expires_at ?? null, input.visibility_class);
+            const handoff = mapHandoff(db.prepare('SELECT * FROM handoff_records WHERE id = ?').get(Number(result.lastInsertRowid)));
+            insertMemoryEventInternal({
+                ...normalized,
+                session_id: handoff.session_id,
+                actor_id: handoff.from_actor.actor_id,
+                actor_kind: handoff.from_actor.actor_kind,
+                actor_system_id: handoff.from_actor.system_id,
+                actor_display_name: handoff.from_actor.display_name,
+                actor_metadata: handoff.from_actor.metadata,
+                entity_kind: 'handoff',
+                entity_id: String(handoff.id),
+                event_type: 'handoff.created',
+                payload: { after: cloneValue(handoff) },
+                created_at: createdAt,
+            });
+            return handoff;
+        },
+        acceptHandoff(handoffId, actor, reason) {
+            assertActorRef(actor);
+            const before = db.prepare('SELECT * FROM handoff_records WHERE id = ?').get(handoffId);
+            if (!before)
+                return null;
+            const handoff = mapHandoff(before);
+            if (handoff.to_actor.actor_kind !== actor.actor_kind || handoff.to_actor.actor_id !== actor.actor_id) {
+                throw new ConflictError(`Handoff ${handoffId} is assigned to another actor`);
+            }
+            const now = nowSeconds();
+            if (handoff.status !== 'pending') {
+                throw new ConflictError(`Handoff ${handoffId} is no longer pending`);
+            }
+            if (handoff.expires_at != null && handoff.expires_at <= now) {
+                db.prepare(`UPDATE handoff_records
+           SET status = 'expired', decision_reason = 'expired', version = version + 1
+           WHERE id = ?`).run(handoffId);
+                const expired = mapHandoff(db.prepare('SELECT * FROM handoff_records WHERE id = ?').get(handoffId));
+                insertMemoryEventInternal({
+                    ...normalizeScope(expired),
+                    session_id: expired.session_id,
+                    actor_id: expired.to_actor.actor_id,
+                    actor_kind: expired.to_actor.actor_kind,
+                    actor_system_id: expired.to_actor.system_id,
+                    actor_display_name: expired.to_actor.display_name,
+                    actor_metadata: expired.to_actor.metadata,
+                    entity_kind: 'handoff',
+                    entity_id: String(expired.id),
+                    event_type: 'handoff.expired',
+                    payload: { before: cloneValue(handoff), after: cloneValue(expired) },
+                    created_at: now,
+                });
+                return null;
+            }
+            const activeClaim = this.getActiveWorkClaim(handoff.work_item_id);
+            if (activeClaim &&
+                !(activeClaim.actor.actor_kind === handoff.from_actor.actor_kind && activeClaim.actor.actor_id === handoff.from_actor.actor_id)) {
+                throw new ConflictError(`Work item ${handoff.work_item_id} has another active owner`);
+            }
+            if (activeClaim) {
+                this.releaseWorkClaim(activeClaim.id, handoff.from_actor, 'handoff_accepted');
+            }
+            this.claimWorkItem({
+                ...normalizeScope(handoff),
+                work_item_id: handoff.work_item_id,
+                actor,
+                session_id: handoff.session_id,
+                visibility_class: handoff.visibility_class,
+            });
+            db.prepare(`UPDATE handoff_records
+         SET status = 'accepted', accepted_at = ?, decision_reason = ?, version = version + 1
+         WHERE id = ?`).run(now, reason ?? null, handoffId);
+            const after = mapHandoff(db.prepare('SELECT * FROM handoff_records WHERE id = ?').get(handoffId));
+            insertMemoryEventInternal({
+                ...normalizeScope(after),
+                session_id: after.session_id,
+                actor_id: actor.actor_id,
+                actor_kind: actor.actor_kind,
+                actor_system_id: actor.system_id,
+                actor_display_name: actor.display_name,
+                actor_metadata: actor.metadata,
+                entity_kind: 'handoff',
+                entity_id: String(after.id),
+                event_type: 'handoff.accepted',
+                payload: { before: cloneValue(handoff), after: cloneValue(after) },
+                created_at: now,
+            });
+            return after;
+        },
+        rejectHandoff(handoffId, actor, reason) {
+            assertActorRef(actor);
+            const before = db.prepare('SELECT * FROM handoff_records WHERE id = ?').get(handoffId);
+            if (!before)
+                return null;
+            const handoff = mapHandoff(before);
+            if (handoff.to_actor.actor_kind !== actor.actor_kind || handoff.to_actor.actor_id !== actor.actor_id) {
+                throw new ConflictError(`Handoff ${handoffId} is assigned to another actor`);
+            }
+            const now = nowSeconds();
+            if (handoff.status !== 'pending') {
+                throw new ConflictError(`Handoff ${handoffId} is no longer pending`);
+            }
+            if (handoff.expires_at != null && handoff.expires_at <= now) {
+                db.prepare(`UPDATE handoff_records
+           SET status = 'expired', decision_reason = 'expired', version = version + 1
+           WHERE id = ?`).run(handoffId);
+                const expired = mapHandoff(db.prepare('SELECT * FROM handoff_records WHERE id = ?').get(handoffId));
+                insertMemoryEventInternal({
+                    ...normalizeScope(expired),
+                    session_id: expired.session_id,
+                    actor_id: expired.to_actor.actor_id,
+                    actor_kind: expired.to_actor.actor_kind,
+                    actor_system_id: expired.to_actor.system_id,
+                    actor_display_name: expired.to_actor.display_name,
+                    actor_metadata: expired.to_actor.metadata,
+                    entity_kind: 'handoff',
+                    entity_id: String(expired.id),
+                    event_type: 'handoff.expired',
+                    payload: { before: cloneValue(handoff), after: cloneValue(expired) },
+                    created_at: now,
+                });
+                return null;
+            }
+            db.prepare(`UPDATE handoff_records
+         SET status = 'rejected', rejected_at = ?, decision_reason = ?, version = version + 1
+         WHERE id = ?`).run(now, reason ?? null, handoffId);
+            const after = mapHandoff(db.prepare('SELECT * FROM handoff_records WHERE id = ?').get(handoffId));
+            insertMemoryEventInternal({
+                ...normalizeScope(after),
+                session_id: after.session_id,
+                actor_id: actor.actor_id,
+                actor_kind: actor.actor_kind,
+                actor_system_id: actor.system_id,
+                actor_display_name: actor.display_name,
+                actor_metadata: actor.metadata,
+                entity_kind: 'handoff',
+                entity_id: String(after.id),
+                event_type: 'handoff.rejected',
+                payload: { before: cloneValue(handoff), after: cloneValue(after) },
+                created_at: now,
+            });
+            return after;
+        },
+        cancelHandoff(handoffId, actor, reason) {
+            assertActorRef(actor);
+            const before = db.prepare('SELECT * FROM handoff_records WHERE id = ?').get(handoffId);
+            if (!before)
+                return null;
+            const handoff = mapHandoff(before);
+            if (handoff.from_actor.actor_kind !== actor.actor_kind || handoff.from_actor.actor_id !== actor.actor_id) {
+                throw new ConflictError(`Handoff ${handoffId} was created by another actor`);
+            }
+            const now = nowSeconds();
+            if (handoff.status !== 'pending') {
+                throw new ConflictError(`Handoff ${handoffId} is no longer pending`);
+            }
+            if (handoff.expires_at != null && handoff.expires_at <= now) {
+                db.prepare(`UPDATE handoff_records
+           SET status = 'expired', decision_reason = 'expired', version = version + 1
+           WHERE id = ?`).run(handoffId);
+                const expired = mapHandoff(db.prepare('SELECT * FROM handoff_records WHERE id = ?').get(handoffId));
+                insertMemoryEventInternal({
+                    ...normalizeScope(expired),
+                    session_id: expired.session_id,
+                    actor_id: expired.from_actor.actor_id,
+                    actor_kind: expired.from_actor.actor_kind,
+                    actor_system_id: expired.from_actor.system_id,
+                    actor_display_name: expired.from_actor.display_name,
+                    actor_metadata: expired.from_actor.metadata,
+                    entity_kind: 'handoff',
+                    entity_id: String(expired.id),
+                    event_type: 'handoff.expired',
+                    payload: { before: cloneValue(handoff), after: cloneValue(expired) },
+                    created_at: now,
+                });
+                return null;
+            }
+            db.prepare(`UPDATE handoff_records
+         SET status = 'canceled', canceled_at = ?, decision_reason = ?, version = version + 1
+         WHERE id = ?`).run(now, reason ?? null, handoffId);
+            const after = mapHandoff(db.prepare('SELECT * FROM handoff_records WHERE id = ?').get(handoffId));
+            insertMemoryEventInternal({
+                ...normalizeScope(after),
+                session_id: after.session_id,
+                actor_id: actor.actor_id,
+                actor_kind: actor.actor_kind,
+                actor_system_id: actor.system_id,
+                actor_display_name: actor.display_name,
+                actor_metadata: actor.metadata,
+                entity_kind: 'handoff',
+                entity_id: String(after.id),
+                event_type: 'handoff.canceled',
+                payload: { before: cloneValue(handoff), after: cloneValue(after) },
+                created_at: now,
+            });
+            return after;
+        },
+        listHandoffs(scope, options) {
+            const now = nowSeconds();
+            const expiredRows = db
+                .prepare(`SELECT * FROM handoff_records
+           WHERE ${SCOPE_WHERE} AND status = 'pending' AND expires_at IS NOT NULL AND expires_at <= ?`)
+                .all(...scopeValues(scope), now);
+            for (const row of expiredRows) {
+                const before = mapHandoff(row);
+                db.prepare(`UPDATE handoff_records
+           SET status = 'expired', decision_reason = 'expired', version = version + 1
+           WHERE id = ?`).run(before.id);
+                const after = mapHandoff(db.prepare('SELECT * FROM handoff_records WHERE id = ?').get(before.id));
+                insertMemoryEventInternal({
+                    ...normalizeScope(after),
+                    session_id: after.session_id,
+                    actor_id: after.to_actor.actor_id,
+                    actor_kind: after.to_actor.actor_kind,
+                    actor_system_id: after.to_actor.system_id,
+                    actor_display_name: after.to_actor.display_name,
+                    actor_metadata: after.to_actor.metadata,
+                    entity_kind: 'handoff',
+                    entity_id: String(after.id),
+                    event_type: 'handoff.expired',
+                    payload: { before: cloneValue(before), after: cloneValue(after) },
+                    created_at: now,
+                });
+            }
+            const rows = db
+                .prepare(`SELECT * FROM handoff_records WHERE ${SCOPE_WHERE} ORDER BY created_at DESC`)
+                .all(...scopeValues(scope));
+            return rows.map(mapHandoff).filter((handoff) => {
+                if (options?.sessionId && handoff.session_id !== options.sessionId)
+                    return false;
+                if (options?.statuses && !options.statuses.includes(handoff.status))
+                    return false;
+                if (!options?.actor)
+                    return true;
+                const inbound = handoff.to_actor.actor_kind === options.actor.actor_kind &&
+                    handoff.to_actor.actor_id === options.actor.actor_id;
+                const outbound = handoff.from_actor.actor_kind === options.actor.actor_kind &&
+                    handoff.from_actor.actor_id === options.actor.actor_id;
+                if (options.direction === 'inbound')
+                    return inbound;
+                if (options.direction === 'outbound')
+                    return outbound;
+                return inbound || outbound;
+            });
+        },
+        listHandoffsCrossScope(scope, level, options) {
+            const now = nowSeconds();
+            const expiredRows = db
+                .prepare(`SELECT * FROM handoff_records
+           WHERE ${scopeWhereForLevel(scope, level)} AND status = 'pending' AND expires_at IS NOT NULL AND expires_at <= ?`)
+                .all(...scopeParamsForLevel(scope, level), now);
+            for (const row of expiredRows) {
+                const before = mapHandoff(row);
+                db.prepare(`UPDATE handoff_records
+           SET status = 'expired', decision_reason = 'expired', version = version + 1
+           WHERE id = ?`).run(before.id);
+                const after = mapHandoff(db.prepare('SELECT * FROM handoff_records WHERE id = ?').get(before.id));
+                insertMemoryEventInternal({
+                    ...normalizeScope(after),
+                    session_id: after.session_id,
+                    actor_id: after.to_actor.actor_id,
+                    actor_kind: after.to_actor.actor_kind,
+                    actor_system_id: after.to_actor.system_id,
+                    actor_display_name: after.to_actor.display_name,
+                    actor_metadata: after.to_actor.metadata,
+                    entity_kind: 'handoff',
+                    entity_id: String(after.id),
+                    event_type: 'handoff.expired',
+                    payload: { before: cloneValue(before), after: cloneValue(after) },
+                    created_at: now,
+                });
+            }
+            const rows = db
+                .prepare(`SELECT * FROM handoff_records WHERE ${scopeWhereForLevel(scope, level)} ORDER BY created_at DESC`)
+                .all(...scopeParamsForLevel(scope, level));
+            return rows.map(mapHandoff).filter((handoff) => {
+                if (options?.sessionId && handoff.session_id !== options.sessionId)
+                    return false;
+                if (options?.statuses && !options.statuses.includes(handoff.status))
+                    return false;
+                if (!options?.actor)
+                    return true;
+                const inbound = handoff.to_actor.actor_kind === options.actor.actor_kind &&
+                    handoff.to_actor.actor_id === options.actor.actor_id;
+                const outbound = handoff.from_actor.actor_kind === options.actor.actor_kind &&
+                    handoff.from_actor.actor_id === options.actor.actor_id;
+                if (options.direction === 'inbound')
+                    return inbound;
+                if (options.direction === 'outbound')
+                    return outbound;
+                return inbound || outbound;
+            });
         },
         touchKnowledgeMemory(id) {
+            const before = getKnowledgeMemoryById(id);
+            const touchedAt = nowSeconds();
+            db.prepare(`UPDATE knowledge_memory
+         SET last_accessed_at = ?, access_count = access_count + 1
+         WHERE id = ?`).run(touchedAt, id);
+            const after = getKnowledgeMemoryById(id);
+            if (before && after) {
+                insertMemoryEventInternal({
+                    ...normalizeScope(after),
+                    entity_kind: 'knowledge_memory',
+                    entity_id: String(after.id),
+                    event_type: 'knowledge.touched',
+                    payload: {
+                        before: cloneValue(before),
+                        after: cloneValue(after),
+                        patch: {
+                            last_accessed_at: touchedAt,
+                            access_count: after.access_count,
+                        },
+                    },
+                    created_at: touchedAt,
+                });
+            }
+        },
+        touchKnowledgeMemories(ids) {
+            const uniqueIds = [...new Set(ids)].filter((id) => Number.isInteger(id) && id > 0);
+            if (uniqueIds.length === 0)
+                return;
+            const placeholders = uniqueIds.map(() => '?').join(', ');
+            const beforeRows = db
+                .prepare(`SELECT * FROM knowledge_memory WHERE id IN (${placeholders})`)
+                .all(...uniqueIds);
+            if (beforeRows.length === 0)
+                return;
+            const touchedAt = nowSeconds();
             db.prepare(`UPDATE knowledge_memory
          SET last_accessed_at = ?, access_count = access_count + 1
-         WHERE id = ?`).run(nowSeconds(), id);
+         WHERE id IN (${placeholders})`).run(touchedAt, ...uniqueIds);
+            const afterRows = db
+                .prepare(`SELECT * FROM knowledge_memory WHERE id IN (${placeholders})`)
+                .all(...uniqueIds);
+            const afterById = new Map(afterRows.map((row) => [Number(row.id), rowToKnowledgeMemory(row)]));
+            insertMemoryEventsBatchInternal(beforeRows.flatMap((row) => {
+                const before = rowToKnowledgeMemory(row);
+                const after = afterById.get(before.id);
+                if (!after)
+                    return [];
+                return [{
+                        ...normalizeScope(after),
+                        entity_kind: 'knowledge_memory',
+                        entity_id: String(after.id),
+                        event_type: 'knowledge.touched',
+                        payload: {
+                            before: cloneValue(before),
+                            after: cloneValue(after),
+                            patch: {
+                                last_accessed_at: touchedAt,
+                                access_count: after.access_count,
+                            },
+                        },
+                        created_at: touchedAt,
+                    }];
+            }));
         },
         retireKnowledgeMemory(id, retiredAt = nowSeconds()) {
+            const before = getKnowledgeMemoryById(id);
             db.prepare('UPDATE knowledge_memory SET retired_at = ? WHERE id = ?').run(retiredAt, id);
+            const after = getKnowledgeMemoryById(id);
+            if (before && after) {
+                insertMemoryEventInternal({
+                    ...normalizeScope(after),
+                    entity_kind: 'knowledge_memory',
+                    entity_id: String(after.id),
+                    event_type: 'knowledge.retired',
+                    payload: {
+                        before: cloneValue(before),
+                        after: cloneValue(after),
+                        patch: {
+                            retired_at: retiredAt,
+                        },
+                    },
+                    created_at: retiredAt,
+                });
+            }
         },
         supersedeKnowledgeMemory(oldId, newId) {
+            const before = getKnowledgeMemoryById(oldId);
+            const supersededAt = nowSeconds();
             db.prepare(`UPDATE knowledge_memory
          SET superseded_by_id = ?, superseded_at = ?, knowledge_state = 'superseded'
-         WHERE id = ?`).run(newId, nowSeconds(), oldId);
+         WHERE id = ?`).run(newId, supersededAt, oldId);
+            const after = getKnowledgeMemoryById(oldId);
+            if (before && after) {
+                insertMemoryEventInternal({
+                    ...normalizeScope(after),
+                    entity_kind: 'knowledge_memory',
+                    entity_id: String(after.id),
+                    event_type: 'knowledge.superseded',
+                    payload: {
+                        before: cloneValue(before),
+                        after: cloneValue(after),
+                        refs: {
+                            new_id: newId,
+                        },
+                    },
+                    created_at: supersededAt,
+                });
+            }
         },
         upsertContextMonitor(input) {
             const scope = validateContextMonitorUpsert(input);
@@ -828,6 +2163,353 @@ function createAdapterFromDatabase(db, telemetry) {
                 .all(...scopeValues(scope), limit);
             return rows.map(rowToCompactionLog);
         },
+        insertPlaybook(input) {
+            const scope = normalizeScope(input);
+            const now = nowSeconds();
+            const result = db
+                .prepare(`INSERT INTO playbooks
+            (tenant_id, system_id, workspace_id, collaboration_id, scope_id, title, description, instructions,
+             references_json, templates, scripts, assets, tags, status, source_session_id, source_working_memory_id, created_at, updated_at)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+                .run(scope.tenant_id, scope.system_id, scope.workspace_id, scope.collaboration_id, scope.scope_id, input.title, input.description, input.instructions, serializeStringArray(input.references ?? []), serializeStringArray(input.templates ?? []), serializeStringArray(input.scripts ?? []), serializeStringArray(input.assets ?? []), serializeStringArray(input.tags ?? []), input.status ?? 'draft', input.source_session_id ?? null, input.source_working_memory_id ?? null, input.created_at ?? now, now);
+            const playbook = this.getPlaybookById(Number(result.lastInsertRowid));
+            insertMemoryEventInternal({
+                ...scope,
+                session_id: playbook.source_session_id,
+                entity_kind: 'playbook',
+                entity_id: String(playbook.id),
+                event_type: 'playbook.created',
+                payload: {
+                    after: cloneValue(playbook),
+                },
+                created_at: playbook.created_at,
+            });
+            return playbook;
+        },
+        getPlaybookById(id) {
+            const row = db.prepare('SELECT * FROM playbooks WHERE id = ?').get(id);
+            return row ? rowToPlaybook(row) : null;
+        },
+        getExistingPlaybookIds(ids) {
+            return getExistingIds('playbooks', ids);
+        },
+        getActivePlaybooks(scope) {
+            const rows = db
+                .prepare(`SELECT * FROM playbooks WHERE ${SCOPE_WHERE} AND status IN ('draft', 'active') ORDER BY id DESC`)
+                .all(...scopeValues(scope));
+            return rows.map(rowToPlaybook);
+        },
+        getActivePlaybooksCrossScope(scope, level) {
+            const rows = db
+                .prepare(`SELECT * FROM playbooks
+           WHERE ${scopeWhereForLevel(scope, level)} AND status IN ('draft', 'active')
+           ORDER BY id DESC`)
+                .all(...scopeParamsForLevel(scope, level));
+            return rows.map(rowToPlaybook);
+        },
+        searchPlaybooks(scope, query, options) {
+            const limit = options?.limit ?? 20;
+            const activeOnly = options?.activeOnly ?? true;
+            const safeQuery = toSafeFtsQuery(query);
+            if (!safeQuery)
+                return [];
+            const statusFilter = activeOnly
+                ? `AND p.status NOT IN ('archived', 'deprecated')`
+                : '';
+            try {
+                const rows = db
+                    .prepare(`SELECT p.* FROM playbooks p
+             INNER JOIN playbooks_fts f ON f.rowid = p.id
+             WHERE p.${SCOPE_WHERE} ${statusFilter}
+             AND playbooks_fts MATCH ?
+             ORDER BY rank LIMIT ?`)
+                    .all(...scopeValues(scope), safeQuery, limit);
+                return rows.map((row, index) => ({ item: rowToPlaybook(row), rank: index }));
+            }
+            catch {
+                return [];
+            }
+        },
+        searchPlaybooksCrossScope(scope, level, query, options) {
+            const limit = options?.limit ?? 20;
+            const activeOnly = options?.activeOnly ?? true;
+            const safeQuery = toSafeFtsQuery(query);
+            if (!safeQuery)
+                return [];
+            const statusFilter = activeOnly
+                ? `AND p.status NOT IN ('archived', 'deprecated')`
+                : '';
+            try {
+                const rows = db
+                    .prepare(`SELECT p.* FROM playbooks p
+             INNER JOIN playbooks_fts f ON f.rowid = p.id
+             WHERE ${scopeWhereForLevelWithPrefix(scope, level, 'p')} ${statusFilter}
+             AND playbooks_fts MATCH ?
+             ORDER BY rank LIMIT ?`)
+                    .all(...scopeParamsForLevel(scope, level), safeQuery, limit);
+                return rows.map((row, index) => ({ item: rowToPlaybook(row), rank: index }));
+            }
+            catch {
+                return [];
+            }
+        },
+        updatePlaybook(id, patch) {
+            const before = this.getPlaybookById(id);
+            const sets = [];
+            const values = [];
+            if (patch.title != null) {
+                sets.push('title = ?');
+                values.push(patch.title);
+            }
+            if (patch.description != null) {
+                sets.push('description = ?');
+                values.push(patch.description);
+            }
+            if (patch.instructions != null) {
+                sets.push('instructions = ?');
+                values.push(patch.instructions);
+            }
+            if (patch.references != null) {
+                sets.push('references_json = ?');
+                values.push(serializeStringArray(patch.references));
+            }
+            if (patch.templates != null) {
+                sets.push('templates = ?');
+                values.push(serializeStringArray(patch.templates));
+            }
+            if (patch.scripts != null) {
+                sets.push('scripts = ?');
+                values.push(serializeStringArray(patch.scripts));
+            }
+            if (patch.assets != null) {
+                sets.push('assets = ?');
+                values.push(serializeStringArray(patch.assets));
+            }
+            if (patch.tags != null) {
+                sets.push('tags = ?');
+                values.push(serializeStringArray(patch.tags));
+            }
+            if (patch.status != null) {
+                sets.push('status = ?');
+                values.push(patch.status);
+            }
+            if (sets.length === 0)
+                return this.getPlaybookById(id);
+            sets.push('updated_at = ?');
+            values.push(nowSeconds());
+            values.push(id);
+            db.prepare(`UPDATE playbooks SET ${sets.join(', ')} WHERE id = ?`).run(...values);
+            const after = this.getPlaybookById(id);
+            if (before && after) {
+                insertMemoryEventInternal({
+                    ...normalizeScope(after),
+                    session_id: after.source_session_id,
+                    entity_kind: 'playbook',
+                    entity_id: String(after.id),
+                    event_type: 'playbook.updated',
+                    payload: {
+                        before: cloneValue(before),
+                        after: cloneValue(after),
+                        patch: cloneValue(patch),
+                    },
+                    created_at: after.updated_at,
+                });
+            }
+            return after;
+        },
+        recordPlaybookUse(id) {
+            const before = this.getPlaybookById(id);
+            const usedAt = nowSeconds();
+            db.prepare('UPDATE playbooks SET use_count = use_count + 1, last_used_at = ? WHERE id = ?').run(usedAt, id);
+            const after = this.getPlaybookById(id);
+            if (before && after) {
+                insertMemoryEventInternal({
+                    ...normalizeScope(after),
+                    session_id: after.source_session_id,
+                    entity_kind: 'playbook',
+                    entity_id: String(after.id),
+                    event_type: 'playbook.used',
+                    payload: {
+                        before: cloneValue(before),
+                        after: cloneValue(after),
+                        refs: {
+                            use_count: after.use_count,
+                        },
+                    },
+                    created_at: usedAt,
+                });
+            }
+        },
+        insertPlaybookRevision(input) {
+            const playbook = this.getPlaybookById(input.playbook_id);
+            if (!playbook) {
+                throw new Error(`Playbook ${input.playbook_id} not found`);
+            }
+            const now = nowSeconds();
+            const result = db
+                .prepare(`INSERT INTO playbook_revisions
+            (tenant_id, system_id, workspace_id, collaboration_id, scope_id, playbook_id, instructions, revision_reason, source_session_id, created_at)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+                .run(playbook.tenant_id, playbook.system_id, playbook.workspace_id, playbook.collaboration_id, playbook.scope_id, input.playbook_id, input.instructions, input.revision_reason, input.source_session_id ?? null, input.created_at ?? now);
+            db.prepare('UPDATE playbooks SET revision_count = revision_count + 1 WHERE id = ?').run(input.playbook_id);
+            const row = db.prepare('SELECT * FROM playbook_revisions WHERE id = ?').get(Number(result.lastInsertRowid));
+            const revision = rowToPlaybookRevision(row);
+            insertMemoryEventInternal({
+                ...normalizeScope(revision),
+                session_id: revision.source_session_id,
+                entity_kind: 'playbook_revision',
+                entity_id: String(revision.id),
+                event_type: 'playbook.revised',
+                payload: {
+                    after: cloneValue(revision),
+                    refs: {
+                        playbook_id: revision.playbook_id,
+                    },
+                },
+                created_at: revision.created_at,
+            });
+            return revision;
+        },
+        getPlaybookRevisions(playbookId) {
+            const rows = db
+                .prepare('SELECT * FROM playbook_revisions WHERE playbook_id = ? ORDER BY created_at DESC')
+                .all(playbookId);
+            return rows.map(rowToPlaybookRevision);
+        },
+        insertAssociation(input) {
+            const scope = normalizeScope(input);
+            const now = nowSeconds();
+            let result;
+            try {
+                result = db
+                    .prepare(`INSERT INTO associations
+              (tenant_id, system_id, workspace_id, collaboration_id, scope_id,
+               source_kind, source_id, target_kind, target_id, association_type, confidence, auto_generated, created_at)
+             VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+                    .run(scope.tenant_id, scope.system_id, scope.workspace_id, scope.collaboration_id, scope.scope_id, input.source_kind, input.source_id, input.target_kind, input.target_id, input.association_type, input.confidence ?? 0.5, input.auto_generated ? 1 : 0, input.created_at ?? now);
+            }
+            catch (err) {
+                if (err &&
+                    typeof err === 'object' &&
+                    err.code === 'SQLITE_CONSTRAINT_UNIQUE') {
+                    throw new UniqueConstraintError(`Association already exists: ${input.source_kind}:${input.source_id} -> ${input.target_kind}:${input.target_id} (${input.association_type})`, err);
+                }
+                throw err;
+            }
+            const row = db.prepare('SELECT * FROM associations WHERE id = ?').get(Number(result.lastInsertRowid));
+            const association = {
+                ...row,
+                collaboration_id: row.collaboration_id ?? row.workspace_id,
+                auto_generated: row.auto_generated === 1,
+            };
+            insertMemoryEventInternal({
+                ...scope,
+                entity_kind: 'association',
+                entity_id: String(association.id),
+                event_type: 'association.created',
+                payload: {
+                    after: cloneValue(association),
+                },
+                created_at: association.created_at,
+            });
+            return association;
+        },
+        getAssociationById(id) {
+            const row = db.prepare('SELECT * FROM associations WHERE id = ?').get(id);
+            if (!row)
+                return null;
+            return {
+                ...row,
+                collaboration_id: row.collaboration_id ?? row.workspace_id,
+                auto_generated: row.auto_generated === 1,
+            };
+        },
+        getAssociationsFrom(kind, id, scope) {
+            const rows = db
+                .prepare(`SELECT * FROM associations WHERE source_kind = ? AND source_id = ? AND ${SCOPE_WHERE} ORDER BY id DESC`)
+                .all(kind, id, ...scopeValues(scope));
+            return rows.map((row) => ({
+                ...row,
+                collaboration_id: row.collaboration_id ?? row.workspace_id,
+                auto_generated: row.auto_generated === 1,
+            }));
+        },
+        getAssociationsTo(kind, id, scope) {
+            const rows = db
+                .prepare(`SELECT * FROM associations WHERE target_kind = ? AND target_id = ? AND ${SCOPE_WHERE} ORDER BY id DESC`)
+                .all(kind, id, ...scopeValues(scope));
+            return rows.map((row) => ({
+                ...row,
+                collaboration_id: row.collaboration_id ?? row.workspace_id,
+                auto_generated: row.auto_generated === 1,
+            }));
+        },
+        listAssociations(scope) {
+            const rows = db
+                .prepare(`SELECT * FROM associations WHERE ${SCOPE_WHERE} ORDER BY id DESC`)
+                .all(...scopeValues(scope));
+            return rows.map((row) => ({
+                ...row,
+                collaboration_id: row.collaboration_id ?? row.workspace_id,
+                auto_generated: row.auto_generated === 1,
+            }));
+        },
+        deleteAssociation(id) {
+            const before = this.getAssociationById(id);
+            db.prepare('DELETE FROM associations WHERE id = ?').run(id);
+            if (before) {
+                insertMemoryEventInternal({
+                    ...normalizeScope(before),
+                    entity_kind: 'association',
+                    entity_id: String(before.id),
+                    event_type: 'association.deleted',
+                    payload: {
+                        before: cloneValue(before),
+                    },
+                    created_at: nowSeconds(),
+                });
+            }
+        },
+        insertMemoryEvent(input) {
+            return insertMemoryEventInternal(input);
+        },
+        listMemoryEvents(scope, query) {
+            return listScopedMemoryEvents(scope, query);
+        },
+        listMemoryEventsCrossScope(scope, level, query) {
+            return listScopedMemoryEventsCrossScope(scope, level, query);
+        },
+        getMemoryEventsByEntity(scope, entityKind, entityId, query) {
+            return listScopedMemoryEvents(scope, {
+                ...query,
+                entityKind,
+                entityId,
+            });
+        },
+        getMemoryEventsBySession(scope, sessionId, query) {
+            return listScopedMemoryEvents(scope, {
+                ...query,
+                sessionId,
+            });
+        },
+        getSessionState: readSessionStateProjection,
+        upsertSessionState(input) {
+            const projection = writeSessionStateProjection(input);
+            insertMemoryEventInternal({
+                ...normalizeScope(projection),
+                session_id: projection.session_id,
+                entity_kind: 'session_state',
+                entity_id: projection.session_id,
+                event_type: 'session_state.updated',
+                payload: {
+                    after: cloneValue(projection),
+                },
+                created_at: projection.updatedAt,
+            });
+            return projection;
+        },
+        getTemporalWatermark: readTemporalWatermark,
+        upsertTemporalWatermark: writeTemporalWatermark,
         transaction(fn) {
             return db.transaction(fn)();
         },