@medicine-wheel/storage-provider 0.5.0 → 0.5.1

package/dist/ceremony-events.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Ceremony Event filter semantics shared by every provider.
+ *
+ * A ceremony event is a GitHub happening (issue, pull request, merge, commit)
+ * witnessed through a ceremonial lens and recorded as a relational bead. The
+ * detection and processing logic lives in @medicine-wheel/github-ceremony;
+ * here we keep only the record shape's filter matching so jsonl and neon agree.
+ */
+import type { CeremonyEventFilters, CeremonyEventRecord } from './interface.js';
+/** True when a ceremony-event record satisfies every provided filter. */
+export declare function matchesCeremonyEventFilters(record: CeremonyEventRecord, filters: CeremonyEventFilters): boolean;

package/dist/ceremony-events.js

@@ -0,0 +1,27 @@
+/**
+ * Ceremony Event filter semantics shared by every provider.
+ *
+ * A ceremony event is a GitHub happening (issue, pull request, merge, commit)
+ * witnessed through a ceremonial lens and recorded as a relational bead. The
+ * detection and processing logic lives in @medicine-wheel/github-ceremony;
+ * here we keep only the record shape's filter matching so jsonl and neon agree.
+ */
+/** True when a ceremony-event record satisfies every provided filter. */
+export function matchesCeremonyEventFilters(record, filters) {
+    if (filters.source !== undefined && record.source !== filters.source) {
+        return false;
+    }
+    if (filters.kind !== undefined && record.kind !== filters.kind) {
+        return false;
+    }
+    if (filters.phase !== undefined && record.phase !== filters.phase) {
+        return false;
+    }
+    if (filters.direction !== undefined && record.direction !== filters.direction) {
+        return false;
+    }
+    if (filters.repository !== undefined && record.repository !== filters.repository) {
+        return false;
+    }
+    return true;
+}

package/dist/diary-records.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Diary Entry filter + ordering semantics shared by every provider.
+ *
+ * The ceremonial diary is a participant's voice — intention, observation,
+ * reflection — written across the Five-Phase ceremonial methodology. The
+ * record schema lives with the providers so both the jsonl and neon backends
+ * read and write the same shape; the diary domain package
+ * (@medicine-wheel/ceremonial-diary) owns creation helpers, pattern detection,
+ * and markdown export.
+ */
+import type { DiaryEntryFilters, DiaryEntryRecord } from './interface.js';
+/** True when a record satisfies every provided filter (limit is applied separately). */
+export declare function matchesDiaryEntryFilters(record: DiaryEntryRecord, filters: DiaryEntryFilters): boolean;
+/**
+ * Filter, order (oldest → newest, mirroring the ceremonial journey), and apply
+ * the optional limit. Providers call this after loading their raw records so
+ * jsonl and neon return identical result sets.
+ */
+export declare function filterAndOrderDiaryEntries(records: readonly DiaryEntryRecord[], filters?: DiaryEntryFilters): DiaryEntryRecord[];

package/dist/diary-records.js

@@ -0,0 +1,52 @@
+/**
+ * Diary Entry filter + ordering semantics shared by every provider.
+ *
+ * The ceremonial diary is a participant's voice — intention, observation,
+ * reflection — written across the Five-Phase ceremonial methodology. The
+ * record schema lives with the providers so both the jsonl and neon backends
+ * read and write the same shape; the diary domain package
+ * (@medicine-wheel/ceremonial-diary) owns creation helpers, pattern detection,
+ * and markdown export.
+ */
+/** True when a record satisfies every provided filter (limit is applied separately). */
+export function matchesDiaryEntryFilters(record, filters) {
+    if (filters.participant !== undefined && record.participant !== filters.participant) {
+        return false;
+    }
+    if (filters.phase !== undefined && record.phase !== filters.phase) {
+        return false;
+    }
+    if (filters.entryType !== undefined && record.entryType !== filters.entryType) {
+        return false;
+    }
+    if (filters.dateRange !== undefined) {
+        const entryTime = Date.parse(record.timestamp);
+        const startTime = Date.parse(filters.dateRange.start);
+        const endTime = Date.parse(filters.dateRange.end);
+        if (entryTime < startTime || entryTime > endTime) {
+            return false;
+        }
+    }
+    if (filters.tags !== undefined && filters.tags.length > 0) {
+        const entryTags = record.metadata?.tags ?? [];
+        const hasTag = filters.tags.some((tag) => entryTags.includes(tag));
+        if (!hasTag) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Filter, order (oldest → newest, mirroring the ceremonial journey), and apply
+ * the optional limit. Providers call this after loading their raw records so
+ * jsonl and neon return identical result sets.
+ */
+export function filterAndOrderDiaryEntries(records, filters = {}) {
+    const filtered = records
+        .filter((record) => matchesDiaryEntryFilters(record, filters))
+        .sort((left, right) => Date.parse(left.timestamp) - Date.parse(right.timestamp));
+    if (typeof filters.limit === 'number' && filters.limit >= 0) {
+        return filtered.slice(0, filters.limit);
+    }
+    return filtered;
+}

package/dist/index.d.ts

@@ -15,9 +15,11 @@
  * const node = await store.getNode('elder-1');
  * ```
  */
-export type { StorageProvider, RelationalNode, RelationalEdge, CeremonyLog, WeaveRecord, WeaveSyncState, InquiryWeaveFilters, PlanPerspectiveRecord, PlanPerspectiveEpisode, PlanPerspectiveFilters, ProviderType, NodePatch, EdgePatch, } from './interface.js';
+export type { StorageProvider, RelationalNode, RelationalEdge, CeremonyLog, WeaveRecord, WeaveSyncState, InquiryWeaveFilters, PlanPerspectiveRecord, PlanPerspectiveEpisode, PlanPerspectiveFilters, CeremonialPhase, DiaryEntryType, DiaryEntryLocation, DiaryEntryMetadata, DiaryEntryRecord, DiaryEntryFilters, CeremonyEventKind, CeremonyEventParticipant, CeremonyEventRecord, CeremonyEventFilters, ProviderType, NodePatch, EdgePatch, } from './interface.js';
 export { NodeNotFoundError, EdgeNotFoundError, NodeHasRelationsError, } from './interface.js';
 export { mergePlanPerspectiveRecords, unionPlanPerspectiveEpisodes, matchesPlanPerspectiveFilters, } from './plan-perspectives.js';
+export { matchesDiaryEntryFilters, filterAndOrderDiaryEntries, } from './diary-records.js';
+export { matchesCeremonyEventFilters } from './ceremony-events.js';
 export { createProvider, detectProvider } from './factory.js';
 export { JsonlProvider } from './jsonl.js';
 export { NeonProvider } from './neon.js';

package/dist/index.js

@@ -19,6 +19,10 @@
 export { NodeNotFoundError, EdgeNotFoundError, NodeHasRelationsError, } from './interface.js';
 // Plan Perspective merge/filter semantics (shared across providers)
 export { mergePlanPerspectiveRecords, unionPlanPerspectiveEpisodes, matchesPlanPerspectiveFilters, } from './plan-perspectives.js';
+// Ceremonial Diary filter/ordering semantics (shared across providers)
+export { matchesDiaryEntryFilters, filterAndOrderDiaryEntries, } from './diary-records.js';
+// Ceremony Event filter semantics (shared across providers)
+export { matchesCeremonyEventFilters } from './ceremony-events.js';
 // Factory
 export { createProvider, detectProvider } from './factory.js';
 // Providers (for direct instantiation)

package/dist/interface.d.ts

@@ -137,6 +137,87 @@ export interface PlanPerspectiveFilters {
     session_id?: string;
     id?: string;
 }
+export type CeremonialPhase = 'miigwechiwendam' | 'nindokendaan' | 'ningwaab' | 'nindoodam' | 'migwech';
+export type DiaryEntryType = 'intention' | 'observation' | 'hypothesis' | 'data' | 'synthesis' | 'action' | 'reflection' | 'learning';
+export interface DiaryEntryLocation {
+    lat: number;
+    lon: number;
+    name?: string;
+}
+export interface DiaryEntryMetadata {
+    location?: DiaryEntryLocation;
+    activity?: 'walking' | 'sitting' | 'coding' | 'reflecting' | string;
+    weather?: string;
+    emotionalTone?: string;
+    /** Related stories, sessions, or other entry keys. */
+    relatedKeys?: string[];
+    tags?: string[];
+    [key: string]: unknown;
+}
+export interface DiaryEntryRecord extends Record<string, unknown> {
+    id: string;
+    /** ISO 8601 timestamp. */
+    timestamp: string;
+    /** Author identity — the participant whose voice this entry carries. */
+    participant: string;
+    /** Which agent facilitated this entry, when applicable. */
+    agent?: string;
+    phase: CeremonialPhase;
+    entryType: DiaryEntryType;
+    /** Main diary text; supports Markdown. */
+    content: string;
+    metadata: DiaryEntryMetadata;
+    /**
+     * Optional relation into the chronicle. Medicine-wheel node-id convention is
+     * `chronicle:<episode-folder-name>` (a chronicle_episode node under parent
+     * `chronicle:miadi-chronicle`). Entries without a chronicle reference remain
+     * fully valid — the diary can speak whether or not it writes into an episode.
+     */
+    chronicle?: string;
+}
+export interface DiaryEntryFilters {
+    participant?: string;
+    phase?: CeremonialPhase;
+    entryType?: DiaryEntryType;
+    dateRange?: {
+        start: string;
+        end: string;
+    };
+    tags?: string[];
+    limit?: number;
+}
+export type CeremonyEventKind = 'issue' | 'pr' | 'merge' | 'commit';
+export interface CeremonyEventParticipant {
+    name: string;
+    role: string;
+    perspective: 'indigenous' | 'western' | 'both';
+}
+export interface CeremonyEventRecord extends Record<string, unknown> {
+    id: string;
+    /** Origin of the event — currently 'github'. */
+    source: string;
+    kind: CeremonyEventKind;
+    phase: CeremonialPhase;
+    /** Four-Directions bridge derived from the ceremonial phase. */
+    direction?: DirectionName;
+    participants: CeremonyEventParticipant[];
+    relationshipImpacts: string[];
+    /** Spiral key preserved from Miadi semantics (non-Redis, deterministic). */
+    spiralKey: string;
+    /** ISO 8601 timestamp. */
+    timestamp: string;
+    repository?: string;
+    /** Issue/PR number or short commit sha. */
+    reference?: string | number;
+    metadata?: Record<string, unknown>;
+}
+export interface CeremonyEventFilters {
+    source?: string;
+    kind?: CeremonyEventKind;
+    phase?: CeremonialPhase;
+    direction?: DirectionName;
+    repository?: string;
+}
 export interface StorageProvider {
     readonly name: string;
     connect(): Promise<void>;
@@ -171,5 +252,12 @@ export interface StorageProvider {
     registerPlanPerspective(record: PlanPerspectiveRecord): Promise<PlanPerspectiveRecord>;
     getPlanPerspective(id: string): Promise<PlanPerspectiveRecord | null>;
     listPlanPerspectives(filters?: PlanPerspectiveFilters): Promise<PlanPerspectiveRecord[]>;
+    registerDiaryEntry(record: DiaryEntryRecord): Promise<DiaryEntryRecord>;
+    getDiaryEntry(id: string): Promise<DiaryEntryRecord | null>;
+    listDiaryEntries(filters?: DiaryEntryFilters): Promise<DiaryEntryRecord[]>;
+    deleteDiaryEntry(id: string): Promise<void>;
+    registerCeremonyEvent(record: CeremonyEventRecord): Promise<CeremonyEventRecord>;
+    getCeremonyEvent(id: string): Promise<CeremonyEventRecord | null>;
+    listCeremonyEvents(filters?: CeremonyEventFilters): Promise<CeremonyEventRecord[]>;
 }
 export type ProviderType = 'jsonl' | 'neon' | 'redis' | 'auto';

package/dist/jsonl.d.ts

@@ -1,5 +1,5 @@
 import type { DirectionName, NodeType, CeremonyType } from '@medicine-wheel/ontology-core';
-import type { StorageProvider, RelationalNode, RelationalEdge, CeremonyLog, WeaveRecord, InquiryWeaveFilters, PlanPerspectiveRecord, PlanPerspectiveFilters, NodePatch, EdgePatch } from './interface.js';
+import type { StorageProvider, RelationalNode, RelationalEdge, CeremonyLog, WeaveRecord, InquiryWeaveFilters, PlanPerspectiveRecord, PlanPerspectiveFilters, DiaryEntryRecord, DiaryEntryFilters, CeremonyEventRecord, CeremonyEventFilters, NodePatch, EdgePatch } from './interface.js';
 export declare class JsonlProvider implements StorageProvider {
     readonly name = "jsonl";
     readonly dataDir: string;
@@ -8,6 +8,8 @@ export declare class JsonlProvider implements StorageProvider {
     private readonly ceremoniesFile;
     private readonly inquiryWeavesFile;
     private readonly planPerspectivesFile;
+    private readonly diaryEntriesFile;
+    private readonly ceremonyEventsFile;
     constructor(dataDir?: string);
     connect(): Promise<void>;
     disconnect(): Promise<void>;
@@ -37,11 +39,20 @@ export declare class JsonlProvider implements StorageProvider {
     registerPlanPerspective(record: PlanPerspectiveRecord): Promise<PlanPerspectiveRecord>;
     getPlanPerspective(id: string): Promise<PlanPerspectiveRecord | null>;
     listPlanPerspectives(filters?: PlanPerspectiveFilters): Promise<PlanPerspectiveRecord[]>;
+    registerDiaryEntry(record: DiaryEntryRecord): Promise<DiaryEntryRecord>;
+    getDiaryEntry(id: string): Promise<DiaryEntryRecord | null>;
+    listDiaryEntries(filters?: DiaryEntryFilters): Promise<DiaryEntryRecord[]>;
+    deleteDiaryEntry(id: string): Promise<void>;
+    registerCeremonyEvent(record: CeremonyEventRecord): Promise<CeremonyEventRecord>;
+    getCeremonyEvent(id: string): Promise<CeremonyEventRecord | null>;
+    listCeremonyEvents(filters?: CeremonyEventFilters): Promise<CeremonyEventRecord[]>;
     private readNodes;
     private readEdges;
     private readCeremonies;
     private readInquiryWeaves;
     private readPlanPerspectives;
+    private readDiaryEntries;
+    private readCeremonyEvents;
     private upsertById;
     private upsertEdge;
     private parseNode;

package/dist/jsonl.js

@@ -3,6 +3,8 @@ import * as path from 'path';
 import { randomUUID } from 'crypto';
 import { NodeNotFoundError, EdgeNotFoundError, NodeHasRelationsError, } from './interface.js';
 import { mergePlanPerspectiveRecords, matchesPlanPerspectiveFilters, } from './plan-perspectives.js';
+import { filterAndOrderDiaryEntries } from './diary-records.js';
+import { matchesCeremonyEventFilters } from './ceremony-events.js';
 export class JsonlProvider {
     name = 'jsonl';
     dataDir;
@@ -11,6 +13,8 @@ export class JsonlProvider {
     ceremoniesFile;
     inquiryWeavesFile;
     planPerspectivesFile;
+    diaryEntriesFile;
+    ceremonyEventsFile;
     constructor(dataDir) {
         this.dataDir = path.resolve(dataDir ?? resolveProjectDataDir());
         this.nodesFile = path.join(this.dataDir, 'nodes.jsonl');
@@ -18,6 +22,8 @@ export class JsonlProvider {
         this.ceremoniesFile = path.join(this.dataDir, 'ceremonies.jsonl');
         this.inquiryWeavesFile = path.join(this.dataDir, 'inquiry-weaves.jsonl');
         this.planPerspectivesFile = path.join(this.dataDir, 'plan-perspectives.jsonl');
+        this.diaryEntriesFile = path.join(this.dataDir, 'diary-entries.jsonl');
+        this.ceremonyEventsFile = path.join(this.dataDir, 'ceremony-events.jsonl');
     }
     async connect() {
         ensureDirectory(this.dataDir);
@@ -219,6 +225,34 @@ export class JsonlProvider {
     async listPlanPerspectives(filters = {}) {
         return this.readPlanPerspectives().filter((record) => matchesPlanPerspectiveFilters(record, filters));
     }
+    async registerDiaryEntry(record) {
+        await this.upsertById(this.diaryEntriesFile, record);
+        return record;
+    }
+    async getDiaryEntry(id) {
+        return this.readDiaryEntries().find((record) => record.id === id) ?? null;
+    }
+    async listDiaryEntries(filters = {}) {
+        return filterAndOrderDiaryEntries(this.readDiaryEntries(), filters);
+    }
+    async deleteDiaryEntry(id) {
+        await withWriteLock(this.diaryEntriesFile, () => {
+            const remaining = this.readDiaryEntries().filter((record) => record.id !== id);
+            writeJsonl(this.diaryEntriesFile, remaining);
+        });
+    }
+    async registerCeremonyEvent(record) {
+        await this.upsertById(this.ceremonyEventsFile, record);
+        return record;
+    }
+    async getCeremonyEvent(id) {
+        return this.readCeremonyEvents().find((record) => record.id === id) ?? null;
+    }
+    async listCeremonyEvents(filters = {}) {
+        return this.readCeremonyEvents()
+            .filter((record) => matchesCeremonyEventFilters(record, filters))
+            .sort(sortByNewest('timestamp'));
+    }
     readNodes() {
         return readJsonl(this.nodesFile);
     }
@@ -234,6 +268,12 @@ export class JsonlProvider {
     readPlanPerspectives() {
         return readJsonl(this.planPerspectivesFile);
     }
+    readDiaryEntries() {
+        return readJsonl(this.diaryEntriesFile);
+    }
+    readCeremonyEvents() {
+        return readJsonl(this.ceremonyEventsFile);
+    }
     async upsertById(filePath, item) {
         await withWriteLock(filePath, () => {
             const nextRecords = readJsonl(filePath).filter((candidate) => candidate.id !== item.id);

package/dist/neon.d.ts

@@ -2,7 +2,7 @@
  * Neon (Postgres) Storage Provider
  */
 import type { DirectionName, NodeType, CeremonyType } from '@medicine-wheel/ontology-core';
-import type { StorageProvider, RelationalNode, RelationalEdge, CeremonyLog, WeaveRecord, InquiryWeaveFilters, PlanPerspectiveRecord, PlanPerspectiveFilters, NodePatch, EdgePatch } from './interface.js';
+import type { StorageProvider, RelationalNode, RelationalEdge, CeremonyLog, WeaveRecord, InquiryWeaveFilters, PlanPerspectiveRecord, PlanPerspectiveFilters, DiaryEntryRecord, DiaryEntryFilters, CeremonyEventRecord, CeremonyEventFilters, NodePatch, EdgePatch } from './interface.js';
 export declare class NeonProvider implements StorageProvider {
     readonly name = "neon";
     private sql;
@@ -41,4 +41,13 @@ export declare class NeonProvider implements StorageProvider {
     getPlanPerspective(id: string): Promise<PlanPerspectiveRecord | null>;
     listPlanPerspectives(filters?: PlanPerspectiveFilters): Promise<PlanPerspectiveRecord[]>;
     private ensurePlanPerspectivesTable;
+    registerDiaryEntry(record: DiaryEntryRecord): Promise<DiaryEntryRecord>;
+    getDiaryEntry(id: string): Promise<DiaryEntryRecord | null>;
+    listDiaryEntries(filters?: DiaryEntryFilters): Promise<DiaryEntryRecord[]>;
+    deleteDiaryEntry(id: string): Promise<void>;
+    private ensureDiaryEntriesTable;
+    registerCeremonyEvent(record: CeremonyEventRecord): Promise<CeremonyEventRecord>;
+    getCeremonyEvent(id: string): Promise<CeremonyEventRecord | null>;
+    listCeremonyEvents(filters?: CeremonyEventFilters): Promise<CeremonyEventRecord[]>;
+    private ensureCeremonyEventsTable;
 }

package/dist/neon.js

@@ -3,6 +3,8 @@
  */
 import { NodeNotFoundError, EdgeNotFoundError, NodeHasRelationsError, } from './interface.js';
 import { mergePlanPerspectiveRecords, matchesPlanPerspectiveFilters, } from './plan-perspectives.js';
+import { filterAndOrderDiaryEntries } from './diary-records.js';
+import { matchesCeremonyEventFilters } from './ceremony-events.js';
 export class NeonProvider {
     name = 'neon';
     sql = null;
@@ -14,6 +16,8 @@ export class NeonProvider {
         this.sql = neon(url);
         await this.ensureInquiryWeavesTable();
         await this.ensurePlanPerspectivesTable();
+        await this.ensureDiaryEntriesTable();
+        await this.ensureCeremonyEventsTable();
     }
     async disconnect() {
         this.sql = null;
@@ -370,6 +374,121 @@ export class NeonProvider {
         await this.db `CREATE INDEX IF NOT EXISTS idx_plan_perspectives_session_id ON plan_perspectives(session_id)`;
         await this.db `CREATE INDEX IF NOT EXISTS idx_plan_perspectives_episode_paths ON plan_perspectives USING GIN(episode_paths)`;
     }
+    // ── Ceremonial Diary Operations ──
+    async registerDiaryEntry(record) {
+        await this.db `
+      INSERT INTO diary_entries (id, payload, participant, phase, entry_type, chronicle, timestamp, updated_at)
+      VALUES (
+        ${record.id},
+        ${JSON.stringify(record)},
+        ${record.participant},
+        ${record.phase},
+        ${record.entryType},
+        ${record.chronicle ?? null},
+        ${record.timestamp},
+        NOW()
+      )
+      ON CONFLICT (id) DO UPDATE SET
+        payload = EXCLUDED.payload,
+        participant = EXCLUDED.participant,
+        phase = EXCLUDED.phase,
+        entry_type = EXCLUDED.entry_type,
+        chronicle = EXCLUDED.chronicle,
+        timestamp = EXCLUDED.timestamp,
+        updated_at = NOW()
+    `;
+        return record;
+    }
+    async getDiaryEntry(id) {
+        const rows = await this.db `SELECT payload FROM diary_entries WHERE id = ${id}`;
+        if (rows.length === 0)
+            return null;
+        return parseJsonValue(rows[0].payload, null);
+    }
+    async listDiaryEntries(filters = {}) {
+        const rows = await this.db `SELECT payload FROM diary_entries`;
+        const records = rows
+            .map((row) => parseJsonValue(row.payload, null))
+            .filter((record) => record !== null);
+        return filterAndOrderDiaryEntries(records, filters);
+    }
+    async deleteDiaryEntry(id) {
+        await this.db `DELETE FROM diary_entries WHERE id = ${id}`;
+    }
+    async ensureDiaryEntriesTable() {
+        await this.db `
+      CREATE TABLE IF NOT EXISTS diary_entries (
+        id TEXT PRIMARY KEY,
+        payload JSONB NOT NULL,
+        participant TEXT NOT NULL,
+        phase TEXT NOT NULL,
+        entry_type TEXT NOT NULL,
+        chronicle TEXT,
+        timestamp TIMESTAMPTZ NOT NULL,
+        updated_at TIMESTAMPTZ DEFAULT NOW()
+      )
+    `;
+        await this.db `CREATE INDEX IF NOT EXISTS idx_diary_entries_participant ON diary_entries(participant)`;
+        await this.db `CREATE INDEX IF NOT EXISTS idx_diary_entries_phase ON diary_entries(phase)`;
+        await this.db `CREATE INDEX IF NOT EXISTS idx_diary_entries_chronicle ON diary_entries(chronicle)`;
+    }
+    // ── Ceremony Event Operations ──
+    async registerCeremonyEvent(record) {
+        await this.db `
+      INSERT INTO ceremony_events (id, payload, source, kind, phase, direction, repository, timestamp, updated_at)
+      VALUES (
+        ${record.id},
+        ${JSON.stringify(record)},
+        ${record.source},
+        ${record.kind},
+        ${record.phase},
+        ${record.direction ?? null},
+        ${record.repository ?? null},
+        ${record.timestamp},
+        NOW()
+      )
+      ON CONFLICT (id) DO UPDATE SET
+        payload = EXCLUDED.payload,
+        source = EXCLUDED.source,
+        kind = EXCLUDED.kind,
+        phase = EXCLUDED.phase,
+        direction = EXCLUDED.direction,
+        repository = EXCLUDED.repository,
+        timestamp = EXCLUDED.timestamp,
+        updated_at = NOW()
+    `;
+        return record;
+    }
+    async getCeremonyEvent(id) {
+        const rows = await this.db `SELECT payload FROM ceremony_events WHERE id = ${id}`;
+        if (rows.length === 0)
+            return null;
+        return parseJsonValue(rows[0].payload, null);
+    }
+    async listCeremonyEvents(filters = {}) {
+        const rows = await this.db `SELECT payload FROM ceremony_events ORDER BY timestamp DESC`;
+        return rows
+            .map((row) => parseJsonValue(row.payload, null))
+            .filter((record) => record !== null && matchesCeremonyEventFilters(record, filters));
+    }
+    async ensureCeremonyEventsTable() {
+        await this.db `
+      CREATE TABLE IF NOT EXISTS ceremony_events (
+        id TEXT PRIMARY KEY,
+        payload JSONB NOT NULL,
+        source TEXT NOT NULL,
+        kind TEXT NOT NULL,
+        phase TEXT NOT NULL,
+        direction TEXT,
+        repository TEXT,
+        timestamp TIMESTAMPTZ NOT NULL,
+        updated_at TIMESTAMPTZ DEFAULT NOW()
+      )
+    `;
+        await this.db `CREATE INDEX IF NOT EXISTS idx_ceremony_events_kind ON ceremony_events(kind)`;
+        await this.db `CREATE INDEX IF NOT EXISTS idx_ceremony_events_phase ON ceremony_events(phase)`;
+        await this.db `CREATE INDEX IF NOT EXISTS idx_ceremony_events_repository ON ceremony_events(repository)`;
+    }
 }
 function getConnectionString() {
     return process.env.DATABASE_URL ?? process.env.POSTGRES_URL ?? process.env.NEON_DATABASE_URL;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@medicine-wheel/storage-provider",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -16,7 +16,7 @@
   "dependencies": {
     "@neondatabase/serverless": "^0.10.0",
     "@upstash/redis": "^1.34.3",
-    "@medicine-wheel/ontology-core": "^0.5.0"
+    "@medicine-wheel/ontology-core": "^0.5.1"
   },
   "devDependencies": {
     "typescript": "^5.7.0"