@medicine-wheel/storage-provider 0.4.13 → 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,8 +15,11 @@
  * const node = await store.getNode('elder-1');
  * ```
  */
-export type { StorageProvider, RelationalNode, RelationalEdge, CeremonyLog, WeaveRecord, WeaveSyncState, InquiryWeaveFilters, PlanPerspectiveRecord, PlanPerspectiveEpisode, PlanPerspectiveFilters, ProviderType, } 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

@@ -15,8 +15,14 @@
  * const node = await store.getNode('elder-1');
  * ```
  */
+// Typed errors (thrown by update/delete operations)
+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

@@ -13,6 +13,42 @@ export interface RelationalEdge extends Omit<OntologyRelationalEdge, 'id'> {
     last_ceremony?: string;
 }
 export type CeremonyLog = OntologyCeremonyLog;
+/** Partial update for a node. `direction: null` releases the node from its direction. */
+export interface NodePatch {
+    name?: string;
+    type?: NodeType;
+    description?: string;
+    direction?: DirectionName | null;
+    metadata?: Record<string, unknown>;
+}
+/** Partial update for an edge (identified by from_id + to_id). */
+export interface EdgePatch {
+    relationship_type?: string;
+    strength?: number;
+    ceremony_honored?: boolean;
+    obligations?: string[];
+}
+export declare class NodeNotFoundError extends Error {
+    readonly nodeId: string;
+    readonly code = "NODE_NOT_FOUND";
+    constructor(nodeId: string);
+}
+export declare class EdgeNotFoundError extends Error {
+    readonly fromId: string;
+    readonly toId: string;
+    readonly code = "EDGE_NOT_FOUND";
+    constructor(fromId: string, toId: string);
+}
+/**
+ * Deleting a node with living relations is refused: relational accountability
+ * means severing each relation consciously before releasing the node.
+ */
+export declare class NodeHasRelationsError extends Error {
+    readonly nodeId: string;
+    readonly relationCount: number;
+    readonly code = "NODE_HAS_RELATIONS";
+    constructor(nodeId: string, relationCount: number);
+}
 export type WeaveSyncState = 'never-synced' | 'in-sync' | 'stale' | 'episode-copy-diverged';
 export interface WeaveRecord extends Record<string, unknown> {
     id: string;
@@ -101,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>;
@@ -110,11 +227,19 @@ export interface StorageProvider {
     getNodesByType(type: NodeType): Promise<RelationalNode[]>;
     getNodesByDirection(direction: DirectionName): Promise<RelationalNode[]>;
     getAllNodes(limit?: number): Promise<RelationalNode[]>;
+    /** Throws NodeNotFoundError when the node does not exist. */
+    updateNode(id: string, patch: NodePatch): Promise<RelationalNode>;
+    /** Throws NodeNotFoundError or NodeHasRelationsError (refusal, never cascade). */
+    deleteNode(id: string): Promise<void>;
     createEdge(edge: RelationalEdge): Promise<void>;
     getEdge(fromId: string, toId: string): Promise<RelationalEdge | null>;
     getAllEdges(limit?: number): Promise<RelationalEdge[]>;
     getRelatedNodes(nodeId: string, direction?: 'from' | 'to' | 'both'): Promise<string[]>;
     updateEdgeCeremony(fromId: string, toId: string, ceremonyId: string): Promise<void>;
+    /** Throws EdgeNotFoundError when no relation exists between the pair. */
+    updateEdge(fromId: string, toId: string, patch: EdgePatch): Promise<RelationalEdge>;
+    /** Throws EdgeNotFoundError when no relation exists between the pair. */
+    deleteEdge(fromId: string, toId: string): Promise<void>;
     logCeremony(ceremony: CeremonyLog): Promise<void>;
     getCeremony(id: string): Promise<CeremonyLog | null>;
     getCeremoniesTimeline(limit?: number): Promise<CeremonyLog[]>;
@@ -127,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/interface.js

@@ -4,4 +4,40 @@
  * Abstract interface for Medicine Wheel data persistence.
  * Implementations: JsonlProvider (local/default), NeonProvider (Postgres), RedisProvider (future)
  */
-export {};
+// ── Typed Errors ──
+// Providers throw these so API layers can answer with honest status codes.
+export class NodeNotFoundError extends Error {
+    nodeId;
+    code = 'NODE_NOT_FOUND';
+    constructor(nodeId) {
+        super(`Node not found: ${nodeId}`);
+        this.nodeId = nodeId;
+        this.name = 'NodeNotFoundError';
+    }
+}
+export class EdgeNotFoundError extends Error {
+    fromId;
+    toId;
+    code = 'EDGE_NOT_FOUND';
+    constructor(fromId, toId) {
+        super(`Relation not found between ${fromId} and ${toId}`);
+        this.fromId = fromId;
+        this.toId = toId;
+        this.name = 'EdgeNotFoundError';
+    }
+}
+/**
+ * Deleting a node with living relations is refused: relational accountability
+ * means severing each relation consciously before releasing the node.
+ */
+export class NodeHasRelationsError extends Error {
+    nodeId;
+    relationCount;
+    code = 'NODE_HAS_RELATIONS';
+    constructor(nodeId, relationCount) {
+        super(`This node holds ${relationCount} relation${relationCount === 1 ? '' : 's'} — release them first`);
+        this.nodeId = nodeId;
+        this.relationCount = relationCount;
+        this.name = 'NodeHasRelationsError';
+    }
+}

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 } 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>;
@@ -16,11 +18,15 @@ export declare class JsonlProvider implements StorageProvider {
     getNodesByType(type: NodeType): Promise<RelationalNode[]>;
     getNodesByDirection(direction: DirectionName): Promise<RelationalNode[]>;
     getAllNodes(limit?: number): Promise<RelationalNode[]>;
+    updateNode(id: string, patch: NodePatch): Promise<RelationalNode>;
+    deleteNode(id: string): Promise<void>;
     createEdge(edge: RelationalEdge): Promise<void>;
     getEdge(fromId: string, toId: string): Promise<RelationalEdge | null>;
     getRelatedNodes(nodeId: string, direction?: 'from' | 'to' | 'both'): Promise<string[]>;
     getAllEdges(limit?: number): Promise<RelationalEdge[]>;
     updateEdgeCeremony(fromId: string, toId: string, ceremonyId: string): Promise<void>;
+    updateEdge(fromId: string, toId: string, patch: EdgePatch): Promise<RelationalEdge>;
+    deleteEdge(fromId: string, toId: string): Promise<void>;
     logCeremony(ceremony: CeremonyLog): Promise<void>;
     getCeremony(id: string): Promise<CeremonyLog | null>;
     getCeremoniesTimeline(limit?: number): Promise<CeremonyLog[]>;
@@ -33,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

@@ -1,7 +1,10 @@
 import * as fs from 'fs';
 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;
@@ -10,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');
@@ -17,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);
@@ -49,6 +56,42 @@ export class JsonlProvider {
             .slice(0, limit)
             .map((node) => this.parseNode(node));
     }
+    async updateNode(id, patch) {
+        return withWriteLock(this.nodesFile, () => {
+            const nodes = this.readNodes();
+            const index = nodes.findIndex((candidate) => candidate.id === id);
+            if (index === -1)
+                throw new NodeNotFoundError(id);
+            const current = nodes[index];
+            const next = {
+                ...current,
+                ...(patch.name !== undefined ? { name: patch.name } : {}),
+                ...(patch.type !== undefined ? { type: patch.type } : {}),
+                ...(patch.description !== undefined ? { description: patch.description } : {}),
+                ...(patch.metadata !== undefined ? { metadata: patch.metadata } : {}),
+                updated_at: new Date().toISOString(),
+            };
+            if (patch.direction !== undefined) {
+                next.direction = patch.direction === null ? undefined : patch.direction;
+            }
+            nodes[index] = next;
+            writeJsonl(this.nodesFile, nodes);
+            return this.parseNode(next);
+        });
+    }
+    async deleteNode(id) {
+        await withWriteLock(this.nodesFile, () => {
+            const nodes = this.readNodes();
+            if (!nodes.some((candidate) => candidate.id === id)) {
+                throw new NodeNotFoundError(id);
+            }
+            const relationCount = this.readEdges().filter((edge) => edge.from_id === id || edge.to_id === id).length;
+            if (relationCount > 0) {
+                throw new NodeHasRelationsError(id, relationCount);
+            }
+            writeJsonl(this.nodesFile, nodes.filter((candidate) => candidate.id !== id));
+        });
+    }
     async createEdge(edge) {
         await this.upsertEdge({
             ...edge,
@@ -92,6 +135,38 @@ export class JsonlProvider {
             writeJsonl(this.edgesFile, nextEdges);
         });
     }
+    async updateEdge(fromId, toId, patch) {
+        return withWriteLock(this.edgesFile, () => {
+            const edges = this.readEdges();
+            const index = edges.findIndex((candidate) => candidate.from_id === fromId && candidate.to_id === toId);
+            if (index === -1)
+                throw new EdgeNotFoundError(fromId, toId);
+            const next = {
+                ...edges[index],
+                ...(patch.relationship_type !== undefined
+                    ? { relationship_type: patch.relationship_type }
+                    : {}),
+                ...(patch.strength !== undefined ? { strength: patch.strength } : {}),
+                ...(patch.ceremony_honored !== undefined
+                    ? { ceremony_honored: patch.ceremony_honored }
+                    : {}),
+                ...(patch.obligations !== undefined ? { obligations: patch.obligations } : {}),
+            };
+            edges[index] = next;
+            writeJsonl(this.edgesFile, edges);
+            return this.parseEdge(next);
+        });
+    }
+    async deleteEdge(fromId, toId) {
+        await withWriteLock(this.edgesFile, () => {
+            const edges = this.readEdges();
+            const remaining = edges.filter((candidate) => !(candidate.from_id === fromId && candidate.to_id === toId));
+            if (remaining.length === edges.length) {
+                throw new EdgeNotFoundError(fromId, toId);
+            }
+            writeJsonl(this.edgesFile, remaining);
+        });
+    }
     async logCeremony(ceremony) {
         await this.upsertById(this.ceremoniesFile, ceremony);
     }
@@ -150,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);
     }
@@ -165,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);
@@ -193,6 +302,7 @@ export class JsonlProvider {
     }
     parseEdge(edge) {
         return {
+            id: edge.id ?? `${edge.from_id}:${edge.to_id}`,
             from_id: edge.from_id,
             to_id: edge.to_id,
             relationship_type: edge.relationship_type,

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 } 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;
@@ -14,12 +14,16 @@ export declare class NeonProvider implements StorageProvider {
     getNodesByType(type: NodeType): Promise<RelationalNode[]>;
     getNodesByDirection(direction: DirectionName): Promise<RelationalNode[]>;
     getAllNodes(limit?: number): Promise<RelationalNode[]>;
+    updateNode(id: string, patch: NodePatch): Promise<RelationalNode>;
+    deleteNode(id: string): Promise<void>;
     private parseNode;
     createEdge(edge: RelationalEdge): Promise<void>;
     getEdge(fromId: string, toId: string): Promise<RelationalEdge | null>;
     getRelatedNodes(nodeId: string, direction?: 'from' | 'to' | 'both'): Promise<string[]>;
     getAllEdges(limit?: number): Promise<RelationalEdge[]>;
     updateEdgeCeremony(fromId: string, toId: string, ceremonyId: string): Promise<void>;
+    updateEdge(fromId: string, toId: string, patch: EdgePatch): Promise<RelationalEdge>;
+    deleteEdge(fromId: string, toId: string): Promise<void>;
     private parseEdge;
     logCeremony(ceremony: CeremonyLog): Promise<void>;
     getCeremony(id: string): Promise<CeremonyLog | null>;
@@ -37,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

@@ -1,7 +1,10 @@
 /**
  * Neon (Postgres) Storage Provider
  */
+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;
@@ -13,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;
@@ -56,6 +61,45 @@ export class NeonProvider {
         const rows = await this.db `SELECT * FROM nodes ORDER BY created_at DESC LIMIT ${limit}`;
         return rows.map((row) => this.parseNode(row));
     }
+    async updateNode(id, patch) {
+        const existing = await this.getNode(id);
+        if (!existing)
+            throw new NodeNotFoundError(id);
+        const next = {
+            ...existing,
+            ...(patch.name !== undefined ? { name: patch.name } : {}),
+            ...(patch.type !== undefined ? { type: patch.type } : {}),
+            ...(patch.description !== undefined ? { description: patch.description } : {}),
+            ...(patch.metadata !== undefined ? { metadata: patch.metadata } : {}),
+            updated_at: new Date().toISOString(),
+        };
+        if (patch.direction !== undefined) {
+            next.direction = patch.direction === null ? undefined : patch.direction;
+        }
+        await this.db `
+      UPDATE nodes SET
+        name = ${next.name},
+        type = ${next.type},
+        description = ${next.description ?? ''},
+        direction = ${next.direction || null},
+        metadata = ${JSON.stringify(next.metadata)},
+        updated_at = ${next.updated_at}
+      WHERE id = ${id}
+    `;
+        return next;
+    }
+    async deleteNode(id) {
+        const existing = await this.db `SELECT id FROM nodes WHERE id = ${id}`;
+        if (existing.length === 0)
+            throw new NodeNotFoundError(id);
+        const counts = await this.db `
+      SELECT COUNT(*)::int AS count FROM edges WHERE from_id = ${id} OR to_id = ${id}
+    `;
+        const relationCount = Number(counts[0]?.count ?? 0);
+        if (relationCount > 0)
+            throw new NodeHasRelationsError(id, relationCount);
+        await this.db `DELETE FROM nodes WHERE id = ${id}`;
+    }
     parseNode(row) {
         return {
             id: row.id,
@@ -115,8 +159,41 @@ export class NeonProvider {
       WHERE from_id = ${fromId} AND to_id = ${toId}
     `;
     }
+    async updateEdge(fromId, toId, patch) {
+        const existing = await this.getEdge(fromId, toId);
+        if (!existing)
+            throw new EdgeNotFoundError(fromId, toId);
+        const next = {
+            ...existing,
+            ...(patch.relationship_type !== undefined
+                ? { relationship_type: patch.relationship_type }
+                : {}),
+            ...(patch.strength !== undefined ? { strength: patch.strength } : {}),
+            ...(patch.ceremony_honored !== undefined
+                ? { ceremony_honored: patch.ceremony_honored }
+                : {}),
+            ...(patch.obligations !== undefined ? { obligations: patch.obligations } : {}),
+        };
+        await this.db `
+      UPDATE edges SET
+        relationship_type = ${next.relationship_type},
+        strength = ${next.strength},
+        ceremony_honored = ${next.ceremony_honored},
+        obligations = ${JSON.stringify(next.obligations)}
+      WHERE from_id = ${fromId} AND to_id = ${toId}
+    `;
+        return next;
+    }
+    async deleteEdge(fromId, toId) {
+        const deleted = await this.db `
+      DELETE FROM edges WHERE from_id = ${fromId} AND to_id = ${toId} RETURNING from_id
+    `;
+        if (deleted.length === 0)
+            throw new EdgeNotFoundError(fromId, toId);
+    }
     parseEdge(row) {
         return {
+            id: `${row.from_id}:${row.to_id}`,
             from_id: row.from_id,
             to_id: row.to_id,
             relationship_type: row.relationship_type,
@@ -297,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.4.13",
+  "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.4.13"
+    "@medicine-wheel/ontology-core": "^0.5.1"
   },
   "devDependencies": {
     "typescript": "^5.7.0"