@oh-my-pi/pi-mnemosyne 15.6.0

package/dist/types/core/shmr.d.ts

@@ -0,0 +1,56 @@
+import type { Database } from "bun:sqlite";
+export declare const SHMR_BATCH_SIZE: number;
+export declare const SHMR_MAX_ITERATIONS: number;
+export declare const SHMR_SIMILARITY_THRESHOLD: number;
+export declare const SHMR_HARMONY_THRESHOLD: number;
+export declare const SHMR_MIN_CLUSTER_SIZE: number;
+export declare const EMBEDDING_DIM = 384;
+export type Vector = Float32Array;
+export interface ShmrItem {
+    readonly fact_id?: string;
+    readonly subject?: string;
+    readonly predicate?: string;
+    readonly object?: string;
+    readonly content?: string;
+    readonly confidence?: number;
+    readonly timestamp?: string;
+    readonly source?: string;
+    readonly embedding?: Vector;
+}
+export interface Belief {
+    readonly subject: string;
+    readonly predicate: string;
+    readonly object: string;
+    readonly confidence: number;
+    readonly action?: "create" | "update" | "dampen";
+    readonly target_fact_id?: string | null;
+    readonly rationale?: string;
+}
+export interface HarmonizeStats {
+    readonly clusters_found: number;
+    readonly beliefs_generated: number;
+    readonly contradictions_resolved: number;
+    readonly harmony_score_avg: number;
+    readonly duration_ms: number;
+    readonly status: "insufficient_candidates" | "harmonized" | "no_convergence";
+}
+type BeamLike = {
+    readonly conn?: Database;
+    readonly db?: Database;
+    readonly session_id?: string;
+    readonly sessionId?: string;
+};
+export declare const FACTS_SCHEMA_SQL = "\nCREATE TABLE IF NOT EXISTS harmonic_beliefs (\n\tbelief_id TEXT PRIMARY KEY,\n\tsubject TEXT,\n\tpredicate TEXT,\n\tobject TEXT NOT NULL,\n\tconfidence REAL DEFAULT 0.5,\n\tprovenance TEXT,\n\tcluster_id TEXT,\n\titeration INTEGER DEFAULT 0,\n\tcreated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,\n\tupdated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP\n);\nCREATE TABLE IF NOT EXISTS memory_resonance_log (\n\tid INTEGER PRIMARY KEY AUTOINCREMENT,\n\tsession_id TEXT,\n\tcluster_count INTEGER,\n\tbeliefs_generated INTEGER,\n\tcontradictions_resolved INTEGER,\n\tharmony_score_avg REAL,\n\tduration_ms INTEGER,\n\tcreated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP\n);\nCREATE INDEX IF NOT EXISTS idx_beliefs_subject ON harmonic_beliefs(subject);\nCREATE INDEX IF NOT EXISTS idx_beliefs_predicate ON harmonic_beliefs(predicate);\nCREATE INDEX IF NOT EXISTS idx_beliefs_confidence ON harmonic_beliefs(confidence);\n";
+export declare function initSchema(db: Database): void;
+export declare function embed(text: string): Vector;
+export declare function cosineSimilarity(a: ArrayLike<number>, b: ArrayLike<number>): number;
+export declare function clusterBySimilarity(items: readonly ShmrItem[], threshold: number): ShmrItem[][];
+export declare function formatClusterForLlm(cluster: readonly ShmrItem[]): string;
+export declare function extractJsonFromLlmOutput(text: string): Belief[];
+export declare function computeHarmonyScore(beliefs: readonly Belief[], cluster: readonly ShmrItem[]): number;
+export declare function applyBeliefs(db: Database, beliefs: readonly Belief[], cluster: readonly ShmrItem[], clusterId: string): void;
+export declare function harmonize(beam: BeamLike, batchSize?: number, maxIterations?: number, similarityThreshold?: number): HarmonizeStats;
+export declare function recallBeliefs(beam: BeamLike, query: string, topK?: number): Array<Record<string, unknown>>;
+export declare function reflect(_beam: BeamLike | null, _question: string, facts?: Array<Record<string, unknown>> | null, topK?: number): string | null;
+export declare function getResonanceLog(beam: BeamLike, limit?: number): Array<Record<string, unknown>>;
+export {};

package/dist/types/core/streaming.d.ts

@@ -0,0 +1,136 @@
+import type { Database } from "bun:sqlite";
+export declare const ALLOWED_DELTA_TABLES: Set<"episodic_memory" | "working_memory">;
+export type DeltaTable = "working_memory" | "episodic_memory";
+export declare enum EventType {
+    MEMORY_ADDED = "MEMORY_ADDED",
+    MEMORY_RECALLED = "MEMORY_RECALLED",
+    MEMORY_INVALIDATED = "MEMORY_INVALIDATED",
+    MEMORY_CONSOLIDATED = "MEMORY_CONSOLIDATED",
+    MEMORY_UPDATED = "MEMORY_UPDATED"
+}
+export interface MemoryEventInit {
+    readonly eventType?: string;
+    readonly event_type?: string;
+    readonly memoryId?: string;
+    readonly memory_id?: string;
+    readonly timestamp?: string;
+    readonly sessionId?: string | null;
+    readonly session_id?: string | null;
+    readonly content?: string | null;
+    readonly source?: string | null;
+    readonly importance?: number | null;
+    readonly metadata?: Record<string, unknown> | null;
+    readonly delta?: Record<string, unknown> | null;
+}
+export type MemoryEventDict = {
+    event_type: string;
+    memory_id: string;
+    timestamp: string;
+    session_id?: string | null;
+    content?: string | null;
+    source?: string | null;
+    importance?: number | null;
+    metadata?: Record<string, unknown> | null;
+    delta?: Record<string, unknown> | null;
+};
+export declare class MemoryEvent {
+    readonly eventType: EventType;
+    readonly memoryId: string;
+    readonly timestamp: string;
+    readonly sessionId: string | null;
+    readonly content: string | null;
+    readonly source: string | null;
+    readonly importance: number | null;
+    readonly metadata: Record<string, unknown> | null;
+    readonly delta: Record<string, unknown> | null;
+    constructor(init: MemoryEventInit);
+    toDict(): MemoryEventDict;
+    toJSON(): string;
+    static fromDict(data: MemoryEventDict | MemoryEventInit): MemoryEvent;
+}
+export type MemoryEventHandler = (event: MemoryEvent) => void;
+export declare class StreamIterator implements AsyncIterable<MemoryEvent>, AsyncIterator<MemoryEvent> {
+    private readonly stream;
+    private readonly eventTypes;
+    private readonly queue;
+    private readonly waiters;
+    private closed;
+    constructor(stream: MemoryStream, eventTypes?: readonly EventType[] | null);
+    push(event: MemoryEvent): void;
+    next(): Promise<IteratorResult<MemoryEvent>>;
+    return(): Promise<IteratorResult<MemoryEvent>>;
+    [Symbol.asyncIterator](): AsyncIterator<MemoryEvent>;
+}
+export declare class MemoryStream {
+    private readonly maxBuffer;
+    private readonly callbacks;
+    private readonly anyCallbacks;
+    private readonly buffer;
+    private readonly iterators;
+    constructor(maxBuffer?: number);
+    on(eventType: EventType, callback: MemoryEventHandler): void;
+    onAny(callback: MemoryEventHandler): void;
+    off(eventType: EventType, callback: MemoryEventHandler): void;
+    offAny(callback: MemoryEventHandler): void;
+    emit(event: MemoryEvent): void;
+    listen(eventTypes?: readonly EventType[] | null): StreamIterator;
+    removeIterator(iterator: StreamIterator): void;
+    getBuffer(eventTypes?: readonly EventType[] | null, since?: string | null): MemoryEvent[];
+    clearBuffer(): void;
+}
+export interface SyncCheckpointInit {
+    readonly peerId?: string;
+    readonly peer_id?: string;
+    readonly lastSyncAt?: string;
+    readonly last_sync_at?: string;
+    readonly lastRowid?: number;
+    readonly last_rowid?: number;
+    readonly checksum?: string;
+}
+export declare class SyncCheckpoint {
+    readonly peerId: string;
+    readonly lastSyncAt: string;
+    readonly lastRowid: number;
+    readonly checksum: string | null;
+    constructor(init: SyncCheckpointInit);
+    toDict(): Record<string, unknown>;
+    toJson(): string;
+    static fromJSON(text: string): SyncCheckpoint;
+}
+type MemoryHost = {
+    readonly conn?: Database;
+    readonly db?: Database;
+    readonly dbPath?: string;
+    readonly db_path?: string;
+};
+export declare class DeltaSync {
+    readonly mnemosyne: MemoryHost;
+    readonly checkpointDir: string;
+    private readonly db;
+    constructor(mnemosyne: MemoryHost, checkpointDir?: string);
+    private checkpointPath;
+    private legacyCheckpointPath;
+    getCheckpoint(peerId: string, table?: DeltaTable): SyncCheckpoint | null;
+    saveCheckpoint(checkpoint: SyncCheckpoint, table?: DeltaTable): void;
+    setCheckpoint(peerId: string, checkpoint: SyncCheckpoint, table?: DeltaTable): void;
+    computeDelta(peerId: string, table?: DeltaTable): Record<string, unknown>[];
+    applyDelta(peerId: string, delta: readonly Record<string, unknown>[], table?: DeltaTable): {
+        inserted: number;
+        updated: number;
+        skipped: number;
+        filtered_keys: number;
+    };
+    syncTo(peerId: string, table?: DeltaTable): {
+        delta: Record<string, unknown>[];
+        count: number;
+    };
+    syncFrom(peerId: string, delta: readonly Record<string, unknown>[], table?: DeltaTable): {
+        stats: {
+            inserted: number;
+            updated: number;
+            skipped: number;
+            filtered_keys: number;
+        };
+    };
+}
+export {};

package/dist/types/core/synonyms.d.ts

@@ -0,0 +1,46 @@
+export declare const SYNONYM_GROUPS: {
+    readonly database: readonly ["db", "datastore", "data_store"];
+    readonly password: readonly ["pass", "pwd", "passwd", "credential", "secret", "token"];
+    readonly config: readonly ["configuration", "settings", "cfg", "setup"];
+    readonly error: readonly ["bug", "issue", "fault", "failure", "crash", "exception", "traceback"];
+    readonly fix: readonly ["repair", "resolve", "solve", "patch", "correct", "address"];
+    readonly deploy: readonly ["deployment", "release", "ship", "push", "rollout"];
+    readonly server: readonly ["host", "machine", "vm", "instance", "node", "vps"];
+    readonly api: readonly ["endpoint", "interface", "service"];
+    readonly key: readonly ["token", "credential", "secret", "api_key"];
+    readonly user: readonly ["account", "profile", "identity", "person"];
+    readonly model: readonly ["llm", "ai", "provider", "gpt", "claude", "gemini"];
+    readonly speed: readonly ["fast", "quick", "performance", "latency", "throughput"];
+    readonly memory: readonly ["recall", "remember", "storage", "retention"];
+    readonly search: readonly ["find", "lookup", "query", "retrieve", "locate"];
+    readonly file: readonly ["document", "doc", "text", "note"];
+    readonly code: readonly ["script", "program", "source", "implementation"];
+    readonly test: readonly ["verify", "check", "validate", "probe", "examine"];
+    readonly backup: readonly ["snapshot", "copy", "save", "archive"];
+    readonly install: readonly ["setup", "configure", "bootstrap", "init"];
+    readonly update: readonly ["upgrade", "refresh", "renew", "sync"];
+    readonly delete: readonly ["remove", "destroy", "purge", "clean", "wipe", "erase"];
+    readonly list: readonly ["show", "display", "enumerate", "catalog"];
+    readonly time: readonly ["date", "when", "timestamp", "schedule"];
+    readonly url: readonly ["link", "address", "uri", "path"];
+    readonly health: readonly ["status", "check", "pulse", "alive", "up"];
+    readonly service: readonly ["daemon", "process", "systemd", "worker"];
+    readonly port: readonly ["socket", "bind", "listen"];
+    readonly network: readonly ["internet", "connection", "connectivity", "dns"];
+    readonly ssh: readonly ["terminal", "shell", "remote", "connect"];
+    readonly git: readonly ["commit", "push", "pull", "repo", "repository", "branch"];
+    readonly log: readonly ["output", "stdout", "stderr", "trace", "debug"];
+    readonly cron: readonly ["schedule", "job", "task", "timer", "periodic"];
+    readonly email: readonly ["mail", "message", "inbox", "smtp"];
+    readonly image: readonly ["picture", "photo", "screenshot", "graphic"];
+    readonly browser: readonly ["web", "page", "site", "navigate", "chrome"];
+    readonly monitor: readonly ["watch", "observe", "track", "survey"];
+    readonly alert: readonly ["notify", "notification", "warning", "ping"];
+    readonly migrate: readonly ["transfer", "move", "relocate", "port"];
+    readonly compare: readonly ["diff", "versus", "vs", "contrast"];
+    readonly save: readonly ["store", "persist", "preserve", "keep"];
+};
+export declare const STOP_WORDS: Set<string>;
+export declare function normalizeQuery(query: string): string;
+export declare function expandQuery(query: string): string;
+export declare function getSynonyms(word: string): string[];

package/dist/types/core/temporal-parser.d.ts

@@ -0,0 +1,16 @@
+import { type QueryTime } from "../util/datetime";
+export type DatePrecision = "day" | "week" | "month" | "year" | "relative" | "unknown";
+export type ParsedNaturalDate = [eventDate: Date, precision: Exclude<DatePrecision, "unknown">, temporalTags: string[]];
+export interface TemporalInfo {
+    event_date: string | null;
+    event_date_precision: DatePrecision;
+    temporal_tags: string[];
+    primary_signal: string | null;
+}
+export declare const DAY_MAP: Readonly<Record<string, number>>;
+export declare const MONTH_MAP: Readonly<Record<string, number>>;
+export declare const NAMED_TIMES: Readonly<Record<string, readonly [startHour: number, endHour: number]>>;
+export declare function resolveRelativeDay(reference: Date, dayNameText: string, qualifier?: string): Date;
+export declare function parseNlDate(text: string, reference?: QueryTime): ParsedNaturalDate | null;
+export declare function extractTemporal(text: string, reference?: QueryTime): TemporalInfo;
+export declare function extractDateFromText(text: string, reference?: QueryTime): string | null;

package/dist/types/core/token-counter.d.ts

@@ -0,0 +1,8 @@
+export interface CostEstimate {
+    tokens: number;
+    model: string;
+    cost_usd: number;
+    rate_per_1m: number;
+}
+export declare function estimateTokens(text: string, _model?: string): number;
+export declare function estimateCost(tokens: number, model?: string): CostEstimate;

package/dist/types/core/triples.d.ts

@@ -0,0 +1,63 @@
+import { Database } from "bun:sqlite";
+import { type DatabasePath } from "../db";
+export interface TripleRow {
+    id: number;
+    subject: string;
+    predicate: string;
+    object: string;
+    valid_from: string;
+    valid_until: string | null;
+    source: string | null;
+    confidence: number | null;
+    created_at: string | null;
+}
+export interface TripleWriteOptions {
+    readonly validFrom?: string | null;
+    readonly valid_from?: string | null;
+    readonly source?: string | null;
+    readonly confidence?: number | null;
+}
+export interface TripleQueryOptions {
+    readonly subject?: string | null;
+    readonly predicate?: string | null;
+    readonly object?: string | null;
+    readonly asOf?: string | null;
+    readonly as_of?: string | null;
+}
+export interface TripleImportStats {
+    inserted: number;
+    skipped: number;
+    overwritten: number;
+    imported_renumbered: number;
+}
+export type TripleImportRow = Partial<Omit<TripleRow, "id">> & {
+    readonly id?: number | null;
+};
+type ProcessEnv = Record<string, string | undefined>;
+export declare function legacyDataDir(env?: ProcessEnv): string;
+export declare function defaultDataDir(env?: ProcessEnv): string;
+export declare function defaultTripleDbPath(env?: ProcessEnv): string;
+export declare function legacyTripleDbPath(env?: ProcessEnv): string;
+export declare function resolveDefaultTripleDb(env?: ProcessEnv): string;
+export declare function initTriples(dbOrPath?: Database | DatabasePath | null): void;
+export declare class TripleStore {
+    #private;
+    readonly dbPath: DatabasePath;
+    readonly conn: Database;
+    constructor(dbPath?: DatabasePath | Database | null);
+    close(): void;
+    add(subject: string, predicate: string, object: string, options?: TripleWriteOptions | string | null): number;
+    query(options?: TripleQueryOptions): TripleRow[];
+    query(subject?: string | null, predicate?: string | null, object?: string | null, asOf?: string | null): TripleRow[];
+    queryByPredicate(predicate: string, object?: string | null, subject?: string | null): TripleRow[];
+    getDistinctObjects(predicate: string): string[];
+    exportAll(): TripleRow[];
+    importAll(triples: readonly TripleImportRow[], force?: boolean): TripleImportStats;
+}
+export declare function addTriple(subject: string, predicate: string, object: string, options?: TripleWriteOptions & {
+    readonly dbPath?: DatabasePath | null;
+}): number;
+export declare function queryTriples(options?: TripleQueryOptions & {
+    readonly dbPath?: DatabasePath | null;
+}): TripleRow[];
+export {};

package/dist/types/core/typed-memory.d.ts

@@ -0,0 +1,39 @@
+export declare const MemoryType: {
+    readonly FACT: "fact";
+    readonly PREFERENCE: "preference";
+    readonly DECISION: "decision";
+    readonly COMMITMENT: "commitment";
+    readonly GOAL: "goal";
+    readonly EVENT: "event";
+    readonly INSTRUCTION: "instruction";
+    readonly RELATIONSHIP: "relationship";
+    readonly CONTEXT: "context";
+    readonly LEARNING: "learning";
+    readonly OBSERVATION: "observation";
+    readonly ERROR: "error";
+    readonly ARTIFACT: "artifact";
+    readonly UNKNOWN: "unknown";
+};
+export type MemoryType = (typeof MemoryType)[keyof typeof MemoryType];
+export type TypePriority = "stable" | "moderate" | "high" | "time_critical" | "decaying" | "accumulating" | "evolving" | "persistent" | "reference";
+export interface TypeMatch {
+    memory_type: MemoryType;
+    memoryType: MemoryType;
+    confidence: number;
+    matched_pattern: string;
+    matchedPattern: string;
+    priority: TypePriority;
+}
+export type TypePattern = readonly [
+    pattern: string,
+    memoryType: MemoryType,
+    baseConfidence: number,
+    priority: TypePriority
+];
+export declare const TYPE_PATTERNS: readonly TypePattern[];
+export declare const CONFIDENCE_BOOSTERS: Readonly<Record<MemoryType, readonly string[]>>;
+export declare function classifyMemory(content: string): TypeMatch;
+export declare function classifyBatch(contents: readonly string[]): TypeMatch[];
+export declare function getTypePriority(memoryType: MemoryType | string): number;
+export declare function shouldConsolidate(memoryType: MemoryType | string): boolean;
+export declare function getDecayRate(memoryType: MemoryType | string): number;

package/dist/types/core/veracity-consolidation.d.ts

@@ -0,0 +1,60 @@
+import type { Database } from "bun:sqlite";
+import { type DatabasePath } from "../db";
+export declare const VERACITY_WEIGHTS: Readonly<{
+    stated: 1;
+    inferred: 0.7;
+    tool: 0.5;
+    imported: 0.6;
+    unknown: 0.8;
+}>;
+export type Veracity = keyof typeof VERACITY_WEIGHTS;
+export declare const VERACITY_ALLOWED: Record<Veracity, true>;
+export interface ConsolidatedFact {
+    readonly subject: string;
+    readonly predicate: string;
+    readonly object: string;
+    readonly confidence: number;
+    readonly mention_count: number;
+    readonly first_seen: string | null;
+    readonly last_seen: string | null;
+    readonly sources: string[];
+    readonly veracity: string;
+    readonly superseded: boolean;
+    readonly id: string | null;
+}
+export interface Conflict {
+    readonly id: number;
+    readonly fact_a_id: string;
+    readonly fact_b_id: string;
+    readonly type: string | null;
+    readonly created_at: string | null;
+}
+export interface ConsolidationStats {
+    readonly active_facts: number;
+    readonly superseded_facts: number;
+    readonly unresolved_conflicts: number;
+    readonly avg_confidence: number;
+    readonly avg_mentions: number;
+}
+export declare function computeFactId(subject: string, predicate: string, object: string): string;
+export declare function clampVeracity(raw: unknown, context?: string): Veracity;
+export declare function aggregateVeracity(sourceVeracities: readonly string[] | null | undefined): Veracity;
+export declare class VeracityConsolidator {
+    readonly conn: Database;
+    readonly dbPath: DatabasePath;
+    readonly ownsConnection: boolean;
+    constructor(dbPath?: DatabasePath, conn?: Database);
+    initTables(): void;
+    serializedWrite<T>(body: () => T): T;
+    bayesianUpdate(currentConfidence: number, veracity: string): number;
+    consolidateFact(subject: string, predicate: string, object: string, veracity?: string, source?: string | null): ConsolidatedFact;
+    recordConflict(factAId: string, factBId: string, conflictType: string, commit?: boolean): void;
+    resolveConflict(conflictId: number, winningFactId: string): void;
+    getConflicts(): Conflict[];
+    getConsolidatedFacts(subject?: string | null, minConfidence?: number): ConsolidatedFact[];
+    getHighConfidenceSummary(subject: string, threshold?: number): string;
+    runConsolidationPass(): void;
+    resolveConflictByFacts(winningId: string, losingId: string): void;
+    getStats(): ConsolidationStats;
+    close(): void;
+}

package/dist/types/core/weibull.d.ts

@@ -0,0 +1,96 @@
+export type MemoryType = keyof typeof WEIBULL_PARAMS;
+export interface WeibullParams {
+    readonly k: number;
+    readonly eta: number;
+}
+export declare const WEIBULL_PARAMS: {
+    readonly profile: {
+        readonly k: 0.3;
+        readonly eta: 8760;
+    };
+    readonly preference: {
+        readonly k: 0.4;
+        readonly eta: 4380;
+    };
+    readonly relationship: {
+        readonly k: 0.35;
+        readonly eta: 8760;
+    };
+    readonly learning: {
+        readonly k: 0.7;
+        readonly eta: 1440;
+    };
+    readonly fact: {
+        readonly k: 0.8;
+        readonly eta: 720;
+    };
+    readonly entity: {
+        readonly k: 0.5;
+        readonly eta: 4380;
+    };
+    readonly setup: {
+        readonly k: 0.6;
+        readonly eta: 2160;
+    };
+    readonly pattern: {
+        readonly k: 0.6;
+        readonly eta: 1680;
+    };
+    readonly context: {
+        readonly k: 0.85;
+        readonly eta: 360;
+    };
+    readonly observation: {
+        readonly k: 0.9;
+        readonly eta: 480;
+    };
+    readonly artifact: {
+        readonly k: 0.75;
+        readonly eta: 2160;
+    };
+    readonly project: {
+        readonly k: 0.85;
+        readonly eta: 1080;
+    };
+    readonly goal: {
+        readonly k: 0.9;
+        readonly eta: 720;
+    };
+    readonly decision: {
+        readonly k: 1;
+        readonly eta: 336;
+    };
+    readonly commitment: {
+        readonly k: 1;
+        readonly eta: 240;
+    };
+    readonly event: {
+        readonly k: 1.2;
+        readonly eta: 168;
+    };
+    readonly instruction: {
+        readonly k: 0.9;
+        readonly eta: 480;
+    };
+    readonly error: {
+        readonly k: 1.1;
+        readonly eta: 336;
+    };
+    readonly issue: {
+        readonly k: 1.1;
+        readonly eta: 336;
+    };
+    readonly request: {
+        readonly k: 1.5;
+        readonly eta: 72;
+    };
+    readonly general: {
+        readonly k: 1;
+        readonly eta: 168;
+    };
+};
+export declare const DEFAULT_HALFLIFE_HOURS = 168;
+type TimestampInput = string | Date | null | undefined;
+export declare function weibullBoost(timestamp: TimestampInput, queryTime?: Date | null, memoryType?: string, halflifeHours?: number | null): number;
+export declare function weibullDecayFactor(ageHours: number, memoryType?: string): number;
+export {};

package/dist/types/db.d.ts

@@ -0,0 +1,16 @@
+import { Database } from "bun:sqlite";
+export type DatabasePath = string | ":memory:";
+export interface OpenDatabaseOptions {
+    readonly create?: boolean;
+    readonly readwrite?: boolean;
+    readonly strict?: boolean;
+    readonly loadExtension?: string | readonly string[];
+    readonly pragmas?: boolean;
+}
+export declare function openDatabase(path?: DatabasePath, options?: OpenDatabaseOptions): Database;
+export declare function enablePragmas(db: Database, path?: DatabasePath): void;
+export declare function loadExtensions(db: Database, extensions: string | readonly string[]): void;
+export declare function transaction<T>(db: Database, fn: () => T): T;
+export declare const deferredTransaction: typeof transaction;
+export declare function transactionAsync<T>(db: Database, fn: () => Promise<T>): Promise<T>;
+export declare function closeQuietly(db: Database | undefined | null): void;

package/dist/types/diagnose.d.ts

@@ -0,0 +1,24 @@
+import type { Database } from "bun:sqlite";
+export interface DiagnosticEntry {
+    readonly ts: string;
+    readonly category: string;
+    readonly check: string;
+    readonly status: string;
+    readonly detail?: string;
+}
+export interface DiagnosticSummary {
+    readonly checks_total: number;
+    readonly checks_passed: number;
+    readonly checks_failed: number;
+    readonly key_findings: string[];
+    readonly entries: DiagnosticEntry[];
+    readonly database: string;
+}
+export interface DiagnosticOptions {
+    readonly db?: Database;
+    readonly dbPath?: string;
+    readonly dataDir?: string;
+    readonly initialize?: boolean;
+}
+export declare function inspectDatabase(options?: DiagnosticOptions): DiagnosticSummary;
+export declare function runDiagnostics(options?: DiagnosticOptions): DiagnosticSummary;

package/dist/types/dr/index.d.ts

@@ -0,0 +1 @@
+export * from "./recovery";

package/dist/types/dr/recovery.d.ts

@@ -0,0 +1,68 @@
+import { type Env } from "../config";
+export interface RecoveryPaths {
+    readonly dataDir: string;
+    readonly backupDir: string;
+    readonly dbPath: string;
+}
+export interface BackupMetadata {
+    readonly timestamp: string;
+    readonly original_size: number;
+    readonly backup_size: number;
+    readonly db_checksum: string;
+    readonly backup_checksum: string;
+    readonly compressed: true;
+}
+export interface BackupResult extends BackupMetadata {
+    readonly backup_path: string;
+    readonly metadata_path: string;
+}
+export interface RestoreResult {
+    readonly restored: true;
+    readonly backup_used: string;
+    readonly database_path: string;
+    readonly integrity_check: boolean;
+}
+export interface EmergencyRestoreResult {
+    readonly restored: true;
+    readonly backup_used: string;
+    readonly attempts: number;
+}
+export interface BackupInfo {
+    readonly file: string;
+    readonly name: string;
+    readonly size: number;
+    readonly modified: string;
+    readonly metadata?: BackupMetadata;
+}
+export interface RotateBackupsResult {
+    readonly total_backups: number;
+    readonly kept: number;
+    readonly deleted: number;
+    readonly deleted_files: string[];
+}
+export interface HealthCheckResult {
+    readonly database: {
+        readonly exists: boolean;
+        readonly valid: boolean;
+        readonly path: string;
+        readonly message: string;
+    };
+    readonly backups: {
+        readonly total: number;
+        readonly latest: string | null;
+        readonly directory: string;
+    };
+    readonly status: "healthy" | "unhealthy";
+}
+export declare function getDefaultPaths(env?: Env): RecoveryPaths;
+export declare function createBackup(dbPath?: string | null, backupDir?: string | null): BackupResult;
+export declare function restoreBackup(backupPath: string, dbPath?: string | null): RestoreResult;
+export declare function emergencyRestore(backupDir?: string | null, dbPath?: string | null): EmergencyRestoreResult;
+export declare function verifyIntegrity(dbPath?: string | null): boolean;
+export declare function listBackups(backupDir?: string | null): BackupInfo[];
+export declare function rotateBackups(backupDir?: string | null, keep?: number): RotateBackupsResult;
+export declare function healthCheck(): HealthCheckResult;
+export declare class FileNotFoundError extends Error {
+    constructor(message: string);
+}
+export declare function resetRecoveryForTests(): void;

package/dist/types/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./core/beam/index";
+export * from "./core/embeddings";
+export * from "./core/llm-backends";
+export * from "./core/memory";
+export { addMemory, flushExtractions, forget, get, getBank, getContext, getDefaultInstance, getStats, Mnemosyne, query, recall, recallEnhanced, remember, resetDefaultInstanceForTests, resetMemoryForTests, resetModuleStateForTests, saveMemory, scratchpadClear, scratchpadRead, scratchpadWrite, search, setBank, sleep, sleepAllSessions, storeMemory, update, } from "./core/memory";