cogmem 3.6.2

package/dist/snapshot/errors.js

@@ -0,0 +1,34 @@
+export class SnapshotVersionError extends Error {
+    constructor(version) {
+        super(`Unsupported memory snapshot version: ${String(version)}`);
+        this.name = 'SnapshotVersionError';
+    }
+}
+export class DimensionMismatchError extends Error {
+    expected;
+    actual;
+    constructor(expected, actual) {
+        super(`Snapshot embedding dimension mismatch: expected ${expected}, actual ${actual}`);
+        this.expected = expected;
+        this.actual = actual;
+        this.name = 'DimensionMismatchError';
+    }
+}
+export class ChecksumError extends Error {
+    constructor() {
+        super('Snapshot checksum verification failed');
+        this.name = 'ChecksumError';
+    }
+}
+export class KernelRunningError extends Error {
+    constructor() {
+        super('Cannot import a snapshot into a started MemoryKernel');
+        this.name = 'KernelRunningError';
+    }
+}
+export class SnapshotTargetExistsError extends Error {
+    constructor(targetPath) {
+        super(`Snapshot import target already exists: ${targetPath}`);
+        this.name = 'SnapshotTargetExistsError';
+    }
+}

package/dist/snapshot/index.d.ts

@@ -0,0 +1,5 @@
+export type { SnapshotHeader, SnapshotMeta } from './SnapshotHeader.js';
+export { SnapshotExporter, type SnapshotExporterOptions } from './SnapshotExporter.js';
+export { SnapshotImporter, type ImportOptions, type ImportResult, type SnapshotImporterOptions } from './SnapshotImporter.js';
+export { ChecksumError, DimensionMismatchError, KernelRunningError, SnapshotTargetExistsError, SnapshotVersionError, } from './errors.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/snapshot/index.js

@@ -0,0 +1,3 @@
+export { SnapshotExporter } from './SnapshotExporter.js';
+export { SnapshotImporter } from './SnapshotImporter.js';
+export { ChecksumError, DimensionMismatchError, KernelRunningError, SnapshotTargetExistsError, SnapshotVersionError, } from './errors.js';

package/dist/storage/StorageCompactor.d.ts

@@ -0,0 +1,30 @@
+export type CompactableNeuronStatus = 'cold' | 'suspect' | 'archived';
+export interface StorageCompactionInput {
+    dbPath: string;
+    dryRun: boolean;
+    statuses?: CompactableNeuronStatus[];
+    projectId?: string;
+    dimension?: number;
+}
+export interface StorageCompactionResult {
+    dbPath: string;
+    dryRun: boolean;
+    statuses: CompactableNeuronStatus[];
+    projectId?: string;
+    dimension?: number;
+    rawEventsBefore: number;
+    rawEventsAfter: number;
+    rawEventsDeleted: number;
+    vectorCountBefore: number;
+    vectorCountAfter: number;
+    vectorBytesBefore: number;
+    vectorBytesAfter: number;
+    eligibleVectorCount: number;
+    eligibleVectorBytes: number;
+    vectorsDeleted: number;
+    vectorBytesDeleted: number;
+    vectorBytesPerRawEventBefore: number;
+    vectorBytesPerRawEventAfter: number;
+}
+export declare function compactStorage(input: StorageCompactionInput): StorageCompactionResult;
+//# sourceMappingURL=StorageCompactor.d.ts.map

package/dist/storage/StorageCompactor.js

@@ -0,0 +1,95 @@
+import Database from 'bun:sqlite';
+export function compactStorage(input) {
+    const statuses = input.statuses && input.statuses.length > 0
+        ? input.statuses
+        : ['archived', 'suspect'];
+    const db = new Database(input.dbPath);
+    db.exec('PRAGMA busy_timeout = 5000;');
+    try {
+        const rawEventsBefore = getRawEventCount(db);
+        const before = getVectorStats(db, input);
+        const eligible = listEligibleVectors(db, input, statuses);
+        if (!input.dryRun && eligible.length > 0) {
+            const deleteOne = db.prepare(`DELETE FROM vector_index WHERE neuron_id = ? AND (? IS NULL OR dimensions = ?)`);
+            const write = db.transaction((rows) => {
+                for (const row of rows)
+                    deleteOne.run(row.neuron_id, input.dimension ?? null, input.dimension ?? null);
+            });
+            write(eligible);
+        }
+        const rawEventsAfter = getRawEventCount(db);
+        const after = getVectorStats(db, input);
+        const deletedCount = before.count - after.count;
+        const deletedBytes = before.bytes - after.bytes;
+        return {
+            dbPath: input.dbPath,
+            dryRun: input.dryRun,
+            statuses,
+            projectId: input.projectId,
+            dimension: input.dimension,
+            rawEventsBefore,
+            rawEventsAfter,
+            rawEventsDeleted: rawEventsBefore - rawEventsAfter,
+            vectorCountBefore: before.count,
+            vectorCountAfter: after.count,
+            vectorBytesBefore: before.bytes,
+            vectorBytesAfter: after.bytes,
+            eligibleVectorCount: eligible.length,
+            eligibleVectorBytes: eligible.reduce((sum, row) => sum + row.bytes, 0),
+            vectorsDeleted: input.dryRun ? 0 : deletedCount,
+            vectorBytesDeleted: input.dryRun ? 0 : deletedBytes,
+            vectorBytesPerRawEventBefore: rawEventsBefore === 0 ? before.bytes : before.bytes / rawEventsBefore,
+            vectorBytesPerRawEventAfter: rawEventsAfter === 0 ? after.bytes : after.bytes / rawEventsAfter,
+        };
+    }
+    finally {
+        db.close();
+    }
+}
+function getRawEventCount(db) {
+    const row = db.prepare(`SELECT COUNT(*) AS count FROM memory_events`).get();
+    return row?.count || 0;
+}
+function getVectorStats(db, input) {
+    const conditions = [];
+    const params = [];
+    if (input.dimension !== undefined) {
+        conditions.push('v.dimensions = ?');
+        params.push(input.dimension);
+    }
+    if (input.projectId) {
+        conditions.push('n.project_id = ?');
+        params.push(input.projectId);
+    }
+    const where = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
+    const row = db.prepare(`
+    SELECT COUNT(*) AS count, COALESCE(SUM(length(v.vector_blob)), 0) AS bytes
+    FROM vector_index v
+    LEFT JOIN neurons n ON n.id = v.neuron_id
+    ${where}
+  `).get(...params);
+    return {
+        count: Number(row?.count || 0),
+        bytes: Number(row?.bytes || 0),
+    };
+}
+function listEligibleVectors(db, input, statuses) {
+    const statusPlaceholders = statuses.map(() => '?').join(', ');
+    const conditions = [`n.status IN (${statusPlaceholders})`];
+    const params = [...statuses];
+    if (input.dimension !== undefined) {
+        conditions.push('v.dimensions = ?');
+        params.push(input.dimension);
+    }
+    if (input.projectId) {
+        conditions.push('n.project_id = ?');
+        params.push(input.projectId);
+    }
+    return db.prepare(`
+    SELECT v.neuron_id, length(v.vector_blob) AS bytes
+    FROM vector_index v
+    JOIN neurons n ON n.id = v.neuron_id
+    WHERE ${conditions.join(' AND ')}
+    ORDER BY v.neuron_id ASC
+  `).all(...params);
+}

package/dist/store/ActivationStore.d.ts

@@ -0,0 +1,45 @@
+import Database from 'bun:sqlite';
+export interface ActivationTouchInput {
+    neuronId: string;
+    projectId?: string;
+    delta?: number;
+    source?: string;
+    touchedAt?: number;
+}
+export interface ActivationDecayOptions {
+    projectId?: string;
+    factor?: number;
+    floor?: number;
+    now?: number;
+}
+export interface ActivationHotspot {
+    neuronId: string;
+    projectId?: string;
+    activation: number;
+    touchCount: number;
+    lastTouchedAt: number;
+    source?: string;
+}
+export interface ActivationDecayResult {
+    decayedCount: number;
+    removedCount: number;
+    factor: number;
+    floor: number;
+}
+export declare class ActivationStore {
+    private readonly db;
+    private readonly ownsDb;
+    constructor(dbOrPath?: Database | string);
+    touch(input: ActivationTouchInput): ActivationHotspot;
+    get(neuronId: string): ActivationHotspot | null;
+    getTop(options?: {
+        projectId?: string;
+        limit?: number;
+        excludeNeuronIds?: string[];
+    }): ActivationHotspot[];
+    decay(options?: ActivationDecayOptions): ActivationDecayResult;
+    deleteByProject(projectId: string): number;
+    close(): void;
+    private initializeSchema;
+}
+//# sourceMappingURL=ActivationStore.d.ts.map

package/dist/store/ActivationStore.js

@@ -0,0 +1,135 @@
+import Database from 'bun:sqlite';
+export class ActivationStore {
+    db;
+    ownsDb;
+    constructor(dbOrPath = ':memory:') {
+        if (typeof dbOrPath === 'string') {
+            this.db = new Database(dbOrPath);
+            this.ownsDb = true;
+        }
+        else {
+            this.db = dbOrPath;
+            this.ownsDb = false;
+        }
+        this.initializeSchema();
+    }
+    touch(input) {
+        const now = input.touchedAt ?? Date.now();
+        const delta = clamp(input.delta ?? 1, 0, 10);
+        const existing = this.get(input.neuronId);
+        const activation = clamp((existing?.activation ?? 0) + delta, 0, 10);
+        const touchCount = (existing?.touchCount ?? 0) + 1;
+        this.db.prepare(`
+      INSERT INTO memory_activation (
+        neuron_id, project_id, activation, touch_count, source, last_touched_at
+      ) VALUES (?, ?, ?, ?, ?, ?)
+      ON CONFLICT(neuron_id) DO UPDATE SET
+        project_id = excluded.project_id,
+        activation = excluded.activation,
+        touch_count = excluded.touch_count,
+        source = excluded.source,
+        last_touched_at = excluded.last_touched_at
+    `).run(input.neuronId, input.projectId || existing?.projectId || null, activation, touchCount, input.source || existing?.source || null, now);
+        return {
+            neuronId: input.neuronId,
+            projectId: input.projectId || existing?.projectId,
+            activation,
+            touchCount,
+            source: input.source || existing?.source,
+            lastTouchedAt: now,
+        };
+    }
+    get(neuronId) {
+        const row = this.db.prepare(`
+      SELECT * FROM memory_activation WHERE neuron_id = ?
+    `).get(neuronId);
+        return row ? mapRow(row) : null;
+    }
+    getTop(options = {}) {
+        const limit = options.limit ?? 10;
+        const exclude = options.excludeNeuronIds || [];
+        const clauses = ['activation > 0'];
+        const params = [];
+        if (options.projectId) {
+            clauses.push('project_id = ?');
+            params.push(options.projectId);
+        }
+        if (exclude.length > 0) {
+            clauses.push(`neuron_id NOT IN (${exclude.map(() => '?').join(', ')})`);
+            params.push(...exclude);
+        }
+        params.push(limit);
+        const rows = this.db.prepare(`
+      SELECT *
+      FROM memory_activation
+      WHERE ${clauses.join(' AND ')}
+      ORDER BY activation DESC, last_touched_at DESC
+      LIMIT ?
+    `).all(...params);
+        return rows.map(mapRow);
+    }
+    decay(options = {}) {
+        const factor = clamp(options.factor ?? 0.85, 0, 1);
+        const floor = Math.max(0, options.floor ?? 0.05);
+        const now = options.now ?? Date.now();
+        const where = options.projectId ? 'WHERE project_id = ?' : '';
+        const params = options.projectId ? [options.projectId] : [];
+        const decayed = this.db.prepare(`
+      UPDATE memory_activation
+      SET activation = activation * ?, last_decayed_at = ?
+      ${where}
+    `).run(factor, now, ...params);
+        const deleteWhere = options.projectId ? 'WHERE project_id = ? AND activation < ?' : 'WHERE activation < ?';
+        const deleteParams = options.projectId ? [options.projectId, floor] : [floor];
+        const removed = this.db.prepare(`
+      DELETE FROM memory_activation
+      ${deleteWhere}
+    `).run(...deleteParams);
+        return {
+            decayedCount: Number(decayed.changes ?? 0),
+            removedCount: Number(removed.changes ?? 0),
+            factor,
+            floor,
+        };
+    }
+    deleteByProject(projectId) {
+        const result = this.db.prepare(`
+      DELETE FROM memory_activation
+      WHERE project_id = ?
+    `).run(projectId);
+        return Number(result.changes ?? 0);
+    }
+    close() {
+        if (this.ownsDb)
+            this.db.close();
+    }
+    initializeSchema() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS memory_activation (
+        neuron_id TEXT PRIMARY KEY,
+        project_id TEXT,
+        activation REAL NOT NULL DEFAULT 0,
+        touch_count INTEGER NOT NULL DEFAULT 0,
+        source TEXT,
+        last_touched_at INTEGER NOT NULL,
+        last_decayed_at INTEGER
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_memory_activation_project
+        ON memory_activation(project_id, activation DESC, last_touched_at DESC);
+    `);
+    }
+}
+function mapRow(row) {
+    return {
+        neuronId: row.neuron_id,
+        projectId: row.project_id || undefined,
+        activation: Number(row.activation),
+        touchCount: Number(row.touch_count),
+        source: row.source || undefined,
+        lastTouchedAt: Number(row.last_touched_at),
+    };
+}
+function clamp(value, min, max) {
+    return Math.max(min, Math.min(max, value));
+}

package/dist/store/BackgroundJobStore.d.ts

@@ -0,0 +1,49 @@
+export interface BackgroundJobRecord {
+    jobName: string;
+    intervalMs: number;
+    nextRunAt: number;
+    lastRunAt?: number;
+    lastStatus: 'idle' | 'running' | 'succeeded' | 'failed';
+    lastError?: string;
+    isEnabled: boolean;
+    leaseOwner?: string;
+    leaseExpiresAt?: number;
+    metadata?: Record<string, unknown>;
+    updatedAt: number;
+}
+export declare class BackgroundJobStore {
+    private db;
+    constructor(dbPath?: string);
+    private initializeSchema;
+    upsertJob(input: {
+        jobName: string;
+        intervalMs: number;
+        nextRunAt?: number;
+        lastRunAt?: number;
+        lastStatus?: 'idle' | 'running' | 'succeeded' | 'failed';
+        lastError?: string;
+        isEnabled?: boolean;
+        metadata?: Record<string, unknown>;
+        updatedAt?: number;
+    }): void;
+    getJob(jobName: string): BackgroundJobRecord | null;
+    listDueJobs(now?: number): BackgroundJobRecord[];
+    markStarted(jobName: string, startedAt?: number): void;
+    acquireLease(jobName: string, ownerId: string, now?: number, leaseMs?: number): boolean;
+    renewLease(jobName: string, ownerId: string, now?: number, leaseMs?: number): boolean;
+    releaseLease(jobName: string, ownerId: string): void;
+    markFinished(jobName: string, input: {
+        finishedAt?: number;
+        nextRunAt: number;
+        metadata?: Record<string, unknown>;
+    }): void;
+    markFailed(jobName: string, input: {
+        failedAt?: number;
+        error: string;
+        nextRunAt?: number;
+        metadata?: Record<string, unknown>;
+    }): void;
+    close(): void;
+    private mapRow;
+}
+//# sourceMappingURL=BackgroundJobStore.d.ts.map

package/dist/store/BackgroundJobStore.js

@@ -0,0 +1,156 @@
+import Database from 'bun:sqlite';
+export class BackgroundJobStore {
+    db;
+    constructor(dbPath = ':memory:') {
+        this.db = new Database(dbPath);
+        this.initializeSchema();
+    }
+    initializeSchema() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS background_jobs (
+        job_name TEXT PRIMARY KEY,
+        interval_ms INTEGER NOT NULL,
+        next_run_at INTEGER NOT NULL,
+        last_run_at INTEGER,
+        last_status TEXT NOT NULL DEFAULT 'idle',
+        last_error TEXT,
+        is_enabled INTEGER NOT NULL DEFAULT 1,
+        lease_owner TEXT,
+        lease_expires_at INTEGER,
+        metadata_json TEXT,
+        updated_at INTEGER NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_background_jobs_next_run
+        ON background_jobs(is_enabled, next_run_at ASC);
+    `);
+        const columns = this.db.prepare(`PRAGMA table_info(background_jobs)`).all();
+        const columnNames = new Set(columns.map((column) => column.name));
+        if (!columnNames.has('lease_owner')) {
+            this.db.exec(`ALTER TABLE background_jobs ADD COLUMN lease_owner TEXT;`);
+        }
+        if (!columnNames.has('lease_expires_at')) {
+            this.db.exec(`ALTER TABLE background_jobs ADD COLUMN lease_expires_at INTEGER;`);
+        }
+    }
+    upsertJob(input) {
+        const existing = this.getJob(input.jobName);
+        const updatedAt = input.updatedAt ?? Date.now();
+        this.db.prepare(`
+      INSERT OR REPLACE INTO background_jobs (
+        job_name, interval_ms, next_run_at, last_run_at, last_status,
+        last_error, is_enabled, lease_owner, lease_expires_at, metadata_json, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(input.jobName, input.intervalMs, input.nextRunAt ?? existing?.nextRunAt ?? (updatedAt + input.intervalMs), input.lastRunAt ?? existing?.lastRunAt ?? null, input.lastStatus ?? existing?.lastStatus ?? 'idle', input.lastError ?? existing?.lastError ?? null, input.isEnabled === undefined ? (existing?.isEnabled ?? true ? 1 : 0) : (input.isEnabled ? 1 : 0), existing?.leaseOwner ?? null, existing?.leaseExpiresAt ?? null, JSON.stringify({
+            ...(existing?.metadata || {}),
+            ...(input.metadata || {})
+        }), updatedAt);
+    }
+    getJob(jobName) {
+        const row = this.db.prepare(`
+      SELECT * FROM background_jobs WHERE job_name = ?
+    `).get(jobName);
+        return row ? this.mapRow(row) : null;
+    }
+    listDueJobs(now = Date.now()) {
+        const rows = this.db.prepare(`
+      SELECT * FROM background_jobs
+      WHERE is_enabled = 1
+        AND next_run_at <= ?
+      ORDER BY next_run_at ASC, job_name ASC
+    `).all(now);
+        return rows.map((row) => this.mapRow(row));
+    }
+    markStarted(jobName, startedAt = Date.now()) {
+        this.db.prepare(`
+      UPDATE background_jobs
+      SET last_status = 'running', updated_at = ?
+      WHERE job_name = ?
+    `).run(startedAt, jobName);
+    }
+    acquireLease(jobName, ownerId, now = Date.now(), leaseMs = 30_000) {
+        const result = this.db.prepare(`
+      UPDATE background_jobs
+      SET lease_owner = ?,
+          lease_expires_at = ?,
+          last_status = 'running',
+          updated_at = ?
+      WHERE job_name = ?
+        AND is_enabled = 1
+        AND next_run_at <= ?
+        AND (lease_expires_at IS NULL OR lease_expires_at <= ? OR lease_owner = ?)
+    `).run(ownerId, now + leaseMs, now, jobName, now, now, ownerId);
+        return Number(result.changes || 0) > 0;
+    }
+    renewLease(jobName, ownerId, now = Date.now(), leaseMs = 30_000) {
+        const result = this.db.prepare(`
+      UPDATE background_jobs
+      SET lease_expires_at = ?, updated_at = ?
+      WHERE job_name = ?
+        AND lease_owner = ?
+    `).run(now + leaseMs, now, jobName, ownerId);
+        return Number(result.changes || 0) > 0;
+    }
+    releaseLease(jobName, ownerId) {
+        this.db.prepare(`
+      UPDATE background_jobs
+      SET lease_owner = NULL, lease_expires_at = NULL, updated_at = ?
+      WHERE job_name = ? AND lease_owner = ?
+    `).run(Date.now(), jobName, ownerId);
+    }
+    markFinished(jobName, input) {
+        const finishedAt = input.finishedAt ?? Date.now();
+        const existing = this.getJob(jobName);
+        this.db.prepare(`
+      UPDATE background_jobs
+      SET last_run_at = ?,
+          next_run_at = ?,
+          last_status = 'succeeded',
+          last_error = NULL,
+          lease_owner = NULL,
+          lease_expires_at = NULL,
+          metadata_json = ?,
+          updated_at = ?
+      WHERE job_name = ?
+    `).run(finishedAt, input.nextRunAt, JSON.stringify({
+            ...(existing?.metadata || {}),
+            ...(input.metadata || {})
+        }), finishedAt, jobName);
+    }
+    markFailed(jobName, input) {
+        const failedAt = input.failedAt ?? Date.now();
+        const existing = this.getJob(jobName);
+        this.db.prepare(`
+      UPDATE background_jobs
+      SET next_run_at = ?,
+          last_status = 'failed',
+          last_error = ?,
+          lease_owner = NULL,
+          lease_expires_at = NULL,
+          metadata_json = ?,
+          updated_at = ?
+      WHERE job_name = ?
+    `).run(input.nextRunAt ?? existing?.nextRunAt ?? failedAt, input.error, JSON.stringify({
+            ...(existing?.metadata || {}),
+            ...(input.metadata || {})
+        }), failedAt, jobName);
+    }
+    close() {
+        this.db.close();
+    }
+    mapRow(row) {
+        return {
+            jobName: row.job_name,
+            intervalMs: row.interval_ms,
+            nextRunAt: row.next_run_at,
+            lastRunAt: row.last_run_at || undefined,
+            lastStatus: row.last_status,
+            lastError: row.last_error || undefined,
+            isEnabled: Boolean(row.is_enabled),
+            leaseOwner: row.lease_owner || undefined,
+            leaseExpiresAt: row.lease_expires_at || undefined,
+            metadata: row.metadata_json ? JSON.parse(row.metadata_json) : undefined,
+            updatedAt: row.updated_at
+        };
+    }
+}

package/dist/store/CandidateReviewStore.d.ts

@@ -0,0 +1,33 @@
+import type Database from 'bun:sqlite';
+import type { DeepWriteCandidateStatus } from './DeepWriteCandidateStore.js';
+export type CandidateReviewAction = 'approve' | 'reject' | 'defer' | 'supersede' | 'relink';
+export interface CandidateReviewRecord {
+    reviewId: string;
+    candidateId: string;
+    projectId?: string;
+    action: CandidateReviewAction;
+    actor: string;
+    reason: string;
+    fromStatus: DeepWriteCandidateStatus;
+    toStatus: DeepWriteCandidateStatus;
+    confirmationEventId?: string;
+    targetBeliefId?: string;
+    replacementCandidateId?: string;
+    reviewAfter?: number;
+    decision: Record<string, unknown>;
+    createdAt: number;
+}
+export declare class CandidateReviewStore {
+    private readonly db;
+    constructor(db: Database);
+    insert(input: Omit<CandidateReviewRecord, 'reviewId' | 'createdAt'> & {
+        reviewId?: string;
+        createdAt?: number;
+    }): CandidateReviewRecord;
+    list(options?: {
+        projectId?: string;
+        candidateId?: string;
+        limit?: number;
+    }): CandidateReviewRecord[];
+}
+//# sourceMappingURL=CandidateReviewStore.d.ts.map

package/dist/store/CandidateReviewStore.js

@@ -0,0 +1,67 @@
+import { randomUUID } from 'node:crypto';
+export class CandidateReviewStore {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    insert(input) {
+        const record = {
+            ...input,
+            reviewId: input.reviewId || randomUUID(),
+            createdAt: input.createdAt ?? Date.now(),
+        };
+        this.db.prepare(`
+      INSERT INTO deep_write_candidate_reviews(
+        review_id, candidate_id, project_id, action, actor, reason, from_status, to_status,
+        confirmation_event_id, target_belief_id, replacement_candidate_id, review_after,
+        decision_json, created_at
+      ) VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?)
+    `).run(record.reviewId, record.candidateId, record.projectId || null, record.action, record.actor, record.reason, record.fromStatus, record.toStatus, record.confirmationEventId || null, record.targetBeliefId || null, record.replacementCandidateId || null, record.reviewAfter ?? null, JSON.stringify(record.decision), record.createdAt);
+        return record;
+    }
+    list(options = {}) {
+        const clauses = [];
+        const params = [];
+        if (options.projectId) {
+            clauses.push('project_id=?');
+            params.push(options.projectId);
+        }
+        if (options.candidateId) {
+            clauses.push('candidate_id=?');
+            params.push(options.candidateId);
+        }
+        const where = clauses.length ? `WHERE ${clauses.join(' AND ')}` : '';
+        const rows = this.db.prepare(`
+      SELECT * FROM deep_write_candidate_reviews ${where}
+      ORDER BY created_at DESC, review_id DESC LIMIT ?
+    `).all(...params, Math.max(1, Math.min(options.limit ?? 100, 500)));
+        return rows.map(mapReview);
+    }
+}
+function mapReview(row) {
+    return {
+        reviewId: String(row.review_id),
+        candidateId: String(row.candidate_id),
+        projectId: row.project_id ? String(row.project_id) : undefined,
+        action: String(row.action),
+        actor: String(row.actor),
+        reason: String(row.reason),
+        fromStatus: String(row.from_status),
+        toStatus: String(row.to_status),
+        confirmationEventId: row.confirmation_event_id ? String(row.confirmation_event_id) : undefined,
+        targetBeliefId: row.target_belief_id ? String(row.target_belief_id) : undefined,
+        replacementCandidateId: row.replacement_candidate_id ? String(row.replacement_candidate_id) : undefined,
+        reviewAfter: row.review_after == null ? undefined : Number(row.review_after),
+        decision: parseObject(row.decision_json),
+        createdAt: Number(row.created_at),
+    };
+}
+function parseObject(value) {
+    try {
+        const parsed = JSON.parse(String(value || '{}'));
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}