@medicine-wheel/app 0.17.11 → 0.18.0

package/components/episode-files-panel.tsx

@@ -4,6 +4,9 @@
  * An episode's folder on the episode page — listed, and any text file read in
  * place. Read-only: the wheel reads an episode, Miadi writes it.
  *
+ * Files are listed in the folders their paths name, every one open to begin
+ * with, so a reader can tell which folder a file is in.
+ *
  * Text is shown as text. Markdown is not rendered here: rendering it means a
  * renderer and a sanitizer between an episode's files and this page, and plain
  * text is already readable. Media and documents are listed, not played.
@@ -11,7 +14,9 @@
  * @see app/api/episodes/[id]/files/route.ts — and the rules it states
  */
 
-import { useCallback, useEffect, useRef, useState } from "react";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { EpisodeFileTree } from "@/components/episode-file-tree";
+import { buildFileTree, folderPaths } from "@/lib/episode-file-tree";
 
 type EpisodeFile = {
   relativePath: string;
@@ -61,6 +66,8 @@ export function EpisodeFilesPanel({ episodeId }: { episodeId: string }) {
   // The path last asked for, so a slow answer for an earlier click cannot
   // replace the file the reader opened after it.
   const wanted = useRef<string | null>(null);
+  // Folders the reader closed. The tree opens fully; only a closed folder is remembered.
+  const [collapsed, setCollapsed] = useState<ReadonlySet<string>>(new Set());
 
   useEffect(() => {
     let live = true;
@@ -99,17 +106,37 @@ export function EpisodeFilesPanel({ episodeId }: { episodeId: string }) {
     [base],
   );
 
-  const files =
-    room?.state === "open"
-      ? // The episode's own work first; host and agent guidance after it.
-        [...room.files].sort((a, b) => Number(a.guidance) - Number(b.guidance))
-      : [];
+  const files = useMemo(() => (room?.state === "open" ? room.files : []), [room]);
+  const tree = useMemo(() => buildFileTree(files), [files]);
+  const folders = useMemo(() => folderPaths(tree), [tree]);
+  const allClosed = folders.length > 0 && folders.every((path) => collapsed.has(path));
+
+  const toggleFolder = useCallback(
+    (path: string) =>
+      setCollapsed((current) => {
+        const next = new Set(current);
+        if (!next.delete(path)) next.add(path);
+        return next;
+      }),
+    [],
+  );
 
   return (
     <section>
-      <h2 className="text-sm font-semibold mb-2">
-        Files {files.length > 0 && `(${files.length})`}
-      </h2>
+      <div className="flex items-baseline justify-between gap-3 mb-2">
+        <h2 className="text-sm font-semibold">
+          Files {files.length > 0 && `(${files.length})`}
+        </h2>
+        {folders.length > 0 && (
+          <button
+            type="button"
+            onClick={() => setCollapsed(allClosed ? new Set() : new Set(folders))}
+            className="text-xs text-muted-foreground hover:underline"
+          >
+            {allClosed ? "Expand all" : "Collapse all"}
+          </button>
+        )}
+      </div>
 
       {room === null ? (
         <p className="text-sm text-muted-foreground">Opening the folder…</p>
@@ -118,23 +145,30 @@ export function EpisodeFilesPanel({ episodeId }: { episodeId: string }) {
       ) : files.length === 0 ? (
         <p className="text-sm text-muted-foreground">The folder holds nothing the room shows.</p>
       ) : (
-        <ul className="space-y-1">
-          {files.map((file) => {
+        <EpisodeFileTree
+          tree={tree}
+          collapsed={collapsed}
+          onToggleFolder={toggleFolder}
+          renderFile={(file, name) => {
             const isOpen = opened?.path === file.relativePath;
             return (
-              <li key={file.relativePath}>
+              <>
                 <div className="p-2 border rounded-lg bg-card flex items-baseline justify-between gap-3 flex-wrap">
                   {file.previewable ? (
                     <button
                       onClick={() => toggle(file)}
+                      title={file.relativePath}
                       className="text-sm font-mono text-left break-all hover:underline"
                       aria-expanded={isOpen}
                     >
-                      {isOpen ? "▾" : "▸"} {file.relativePath}
+                      {isOpen ? "▾" : "▸"} {name}
                     </button>
                   ) : (
-                    <span className="text-sm font-mono break-all text-muted-foreground">
-                      {file.relativePath}
+                    <span
+                      title={file.relativePath}
+                      className="text-sm font-mono break-all text-muted-foreground"
+                    >
+                      {name}
                     </span>
                   )}
                   <span className="text-xs text-muted-foreground shrink-0 flex gap-2 items-baseline">
@@ -157,10 +191,10 @@ export function EpisodeFilesPanel({ episodeId }: { episodeId: string }) {
                     )}
                   </div>
                 )}
-              </li>
+              </>
             );
-          })}
-        </ul>
+          }}
+        />
       )}
     </section>
   );

package/dist/cli/mw.js

@@ -48,6 +48,7 @@ const fs = __importStar(require("fs"));
 const skills_1 = require("./skills");
 const beats_register_1 = require("./beats-register");
 const orientation_1 = require("./orientation");
+const events_1 = require("@medicine-wheel/events");
 // ── Config ────────────────────────────────────────────────────────
 const MW_API_URL = process.env.MW_API_URL ?? 'http://localhost:8040';
 const MW_FORMAT = process.env.MW_FORMAT ?? 'pretty';
@@ -301,6 +302,14 @@ ${C.bold}🌿 mw — Medicine Wheel CLI${C.reset}
   MEMORY
     mw memory store <key> <value> [dir]   Store relational memory
 
+  EVENTS (what happened on the wheel, kept in events.jsonl)
+    mw events [--type cycle.] [--subject <id>] [--correlation <id>]
+              [--since <iso>] [--limit 20]  List events, newest first
+    mw events status                       What the publisher still owes
+    mw events publish                      Send what waits now
+    mw events replay <event-id|all>        Send again from that event
+    mw events schema [--asyncapi]          Print the JSON Schema (or AsyncAPI)
+
   SYSTEM
     mw status                              Show system status
     mw tools                               List all MCP tools
@@ -758,6 +767,88 @@ function cmdMemory(positional) {
             unknownSub('memory', sub, ['store']);
     }
 }
+async function eventsApi(method, urlPath, body) {
+    const res = await fetch(`${MW_API_URL}${urlPath}`, {
+        method,
+        headers: { 'Content-Type': 'application/json' },
+        ...(body !== undefined ? { body: JSON.stringify(body) } : {}),
+    });
+    return { status: res.status, data: (await res.json().catch(() => ({}))) };
+}
+function printEvent(e) {
+    const when = e.observed_at.replace('T', ' ').slice(0, 19);
+    const payload = e.payload;
+    const changed = Array.isArray(payload.changed) ? ` ${C.dim}changed ${payload.changed.join(', ')}${C.reset}` : '';
+    const corr = e.correlation_id && e.correlation_id !== e.subject.id ? ` ${C.dim}↳ ${e.correlation_id}${C.reset}` : '';
+    console.log(`  ${C.dim}${when}${C.reset}  ${C.bold}${(0, events_1.shortName)(e.event_type)}${C.reset}  ${e.subject.kind} ${e.subject.id}${changed}${corr}`);
+}
+async function cmdEvents(positional, flags) {
+    const sub = positional[0] ?? 'list';
+    const failed = (status, data) => {
+        console.error(`${C.south}${data?.error ?? `HTTP ${status}`}${C.reset}`);
+        if (data?.hint)
+            console.error(`  ${data.hint}`);
+        process.exitCode = 1;
+    };
+    switch (sub) {
+        case 'list': {
+            const params = new URLSearchParams();
+            for (const key of ['type', 'subject', 'correlation', 'since', 'limit']) {
+                const value = flags[key];
+                if (typeof value === 'string')
+                    params.set(key, value);
+            }
+            if (!params.has('limit'))
+                params.set('limit', '20');
+            const { status, data } = await eventsApi('GET', `/api/events?${params}`);
+            if (status !== 200)
+                return failed(status, data);
+            if (MW_FORMAT !== 'pretty')
+                return ppValue(data);
+            const events = data.events ?? [];
+            console.log(`${C.bold}${events.length} of ${data.total ?? events.length} event(s)${C.reset}`);
+            for (const e of events)
+                printEvent(e);
+            break;
+        }
+        case 'status': {
+            const { status, data } = await eventsApi('GET', '/api/events/publish');
+            if (status !== 200)
+                return failed(status, data);
+            ppValue(data);
+            break;
+        }
+        case 'publish': {
+            const { status, data } = await eventsApi('POST', '/api/events/publish', {});
+            if (status !== 200)
+                return failed(status, data);
+            ppValue(data);
+            if (data.stopped)
+                process.exitCode = 1;
+            break;
+        }
+        case 'replay': {
+            const from = positional[1];
+            if (!from) {
+                console.error(`${C.south}mw events replay needs an event id, or "all"${C.reset}`);
+                process.exitCode = EXIT_USAGE;
+                return;
+            }
+            const { status, data } = await eventsApi('POST', '/api/events/publish', { replay_from: from });
+            if (status !== 200)
+                return failed(status, data);
+            ppValue(data);
+            if (data.stopped)
+                process.exitCode = 1;
+            break;
+        }
+        case 'schema':
+            console.log(JSON.stringify(flags['asyncapi'] ? (0, events_1.asyncApiDocument)() : (0, events_1.wheelEventsJsonSchema)(), null, 2));
+            break;
+        default:
+            unknownSub('events', sub, ['list', 'status', 'publish', 'replay', 'schema']);
+    }
+}
 // ── Main dispatch ─────────────────────────────────────────────────
 async function main() {
     const { flags, positional } = parseArgs(process.argv);
@@ -824,6 +915,10 @@ async function main() {
         case 'mem':
             cmdMemory(rest);
             break;
+        case 'events':
+        case 'ev':
+            await cmdEvents(rest, flags);
+            break;
         case 'skill':
         case 'sk':
             cmdSkill(rest);

package/instrumentation.ts

@@ -4,9 +4,15 @@
  * Starts the Honcho river's retry clock (#147): records Honcho could not
  * receive while it was away wait on the pending ledger, and are sent again on
  * start and every few minutes after. With `HONCHO_URL` unset this does nothing.
+ *
+ * Starts the event publisher's clock (#164): events in `events.jsonl` that the
+ * configured publisher has not taken are sent on start and every minute after.
+ * With `MW_EVENTS_PUBLISH_URL` unset this does nothing.
  */
 export async function register() {
   if (process.env.NEXT_RUNTIME !== "nodejs") return;
   const { startPendingRetries } = await import("@/lib/honcho-projection");
   startPendingRetries();
+  const { startEventPublishing } = await import("@/lib/event-log");
+  startEventPublishing();
 }

package/lib/episode-file-tree.ts

@@ -0,0 +1,135 @@
+/**
+ * An episode's files, grouped into the folders their paths name.
+ *
+ * `listEpisodeFiles` returns files with the path each sits at, and no folders,
+ * so the Files section printed whole paths one under another and a reader could
+ * not tell which folder a file was in. This builds the folders back from the
+ * paths, so the panel can draw them.
+ *
+ * This is layout, not a rule about what an episode shows — those live in
+ * `@miadi/episode-vessel` and in `lib/episode-files.ts`, and nothing here
+ * decides what may be listed or read. The same grouping is drawn in Miadi's room
+ * by `@miadi/episode-ui` (`buildFileTree`); the wheel keeps its own small copy
+ * until it takes that package, and the two are meant to agree on order:
+ *
+ *  1. a `README.md`;
+ *  2. the folders, by name;
+ *  3. the files — text, documents, guidance, then media — by name.
+ *
+ * Names compare numerically, so `chapter-2` comes before `chapter-10`.
+ */
+
+/** The part of a listed file the grouping reads. Any richer shape passes through untouched. */
+export interface TreeableFile {
+  relativePath: string;
+  name: string;
+  kind: string;
+  guidance: boolean;
+}
+
+export interface FileTreeFile<T extends TreeableFile> {
+  type: "file";
+  /** The last segment of the path. */
+  name: string;
+  path: string;
+  file: T;
+}
+
+export interface FileTreeFolder<T extends TreeableFile> {
+  type: "folder";
+  /** The last segment of the path. Empty for the root. */
+  name: string;
+  /** The path from the episode root. Empty for the root. */
+  path: string;
+  children: FileTreeNode<T>[];
+  /** Every file beneath this folder, at any depth. */
+  fileCount: number;
+}
+
+export type FileTreeNode<T extends TreeableFile> = FileTreeFile<T> | FileTreeFolder<T>;
+
+const compareNames = (left: string, right: string): number =>
+  left.localeCompare(right, undefined, { numeric: true, sensitivity: "base" }) ||
+  (left < right ? -1 : left > right ? 1 : 0);
+
+function rank(file: TreeableFile): number {
+  if (/^README\.md$/i.test(file.name)) return 0;
+  if (file.guidance) return 3;
+  if (file.kind === "text") return 1;
+  if (file.kind === "document") return 2;
+  return 4;
+}
+
+function order<T extends TreeableFile>(folder: FileTreeFolder<T>): void {
+  const folders = folder.children.filter((n): n is FileTreeFolder<T> => n.type === "folder");
+  const files = folder.children.filter((n): n is FileTreeFile<T> => n.type === "file");
+  folders.sort((a, b) => compareNames(a.name, b.name));
+  files.sort((a, b) => rank(a.file) - rank(b.file) || compareNames(a.name, b.name));
+  folder.children = [
+    ...files.filter((n) => rank(n.file) === 0),
+    ...folders,
+    ...files.filter((n) => rank(n.file) !== 0),
+  ];
+  folders.forEach(order);
+}
+
+/**
+ * Group `files` into folders by path. A path listed twice is kept once, and a
+ * folder exists only because a file is beneath it.
+ */
+export function buildFileTree<T extends TreeableFile>(files: readonly T[]): FileTreeFolder<T> {
+  const root: FileTreeFolder<T> = { type: "folder", name: "", path: "", children: [], fileCount: 0 };
+  const folders = new Map<string, FileTreeFolder<T>>([["", root]]);
+  const seen = new Set<string>();
+
+  const folderAt = (path: string): FileTreeFolder<T> => {
+    const known = folders.get(path);
+    if (known) return known;
+    const cut = path.lastIndexOf("/");
+    const parent = folderAt(cut === -1 ? "" : path.slice(0, cut));
+    const created: FileTreeFolder<T> = {
+      type: "folder",
+      name: cut === -1 ? path : path.slice(cut + 1),
+      path,
+      children: [],
+      fileCount: 0,
+    };
+    folders.set(path, created);
+    parent.children.push(created);
+    return created;
+  };
+
+  for (const file of files) {
+    if (seen.has(file.relativePath)) continue;
+    seen.add(file.relativePath);
+    const cut = file.relativePath.lastIndexOf("/");
+    const parent = folderAt(cut === -1 ? "" : file.relativePath.slice(0, cut));
+    parent.children.push({
+      type: "file",
+      name: cut === -1 ? file.relativePath : file.relativePath.slice(cut + 1),
+      path: file.relativePath,
+      file,
+    });
+    for (let path = parent.path; ; path = path.slice(0, Math.max(path.lastIndexOf("/"), 0))) {
+      folders.get(path)!.fileCount += 1;
+      if (!path) break;
+    }
+  }
+
+  order(root);
+  return root;
+}
+
+/** Every folder path in the tree, outermost first. The root is not one. */
+export function folderPaths<T extends TreeableFile>(tree: FileTreeFolder<T>): string[] {
+  const paths: string[] = [];
+  const walk = (folder: FileTreeFolder<T>) => {
+    for (const child of folder.children) {
+      if (child.type !== "folder") continue;
+      paths.push(child.path);
+      walk(child);
+    }
+  };
+  walk(tree);
+  return paths;
+}

package/lib/event-log.ts

@@ -0,0 +1,187 @@
+/**
+ * The wheel's event log — what happened, kept beside the store (#164).
+ *
+ * The store keeps each record's latest state: a cycle amended twice is one
+ * line in `cycles.jsonl`, and the moment it was opened exists nowhere once it
+ * has passed. This log keeps those moments. Each write a route commits leaves
+ * one line in `events.jsonl` beside the store (`MW_EVENTS_FILE` overrides).
+ * What an event is, and which event a write is, lives in
+ * `@medicine-wheel/events` — the routes hand it before and after and record
+ * what it decides, and the MCP server's local store does the same.
+ *
+ * `source.instance` names this wheel as configured (`MW_INSTANCE`, e.g.
+ * `ilex:8040`). The address a request reached is not a name: behind
+ * `0.0.0.0` every wheel looks alike, and two browsers name the same wheel two
+ * ways.
+ *
+ * Publishing (episode 548's Send): with `MW_EVENTS_PUBLISH_URL` set, the log is
+ * sent there after every recorded event and every
+ * `MW_EVENTS_PUBLISH_INTERVAL_MS` (default one minute), from this wheel's
+ * cursor, with receipts beside the log. Unset, nothing leaves the machine.
+ *
+ * Never the caller's error: a line that cannot be written is reported once on
+ * stderr with the record's id, and a publisher that cannot be reached is a
+ * receipt, not a failed write.
+ */
+
+import { buildEvent, filterEvents, type EventFilter, type WheelEvent, type WheelEventInput } from '@medicine-wheel/events';
+import { appendEvent, eventLogPath, readEventLog } from '@medicine-wheel/events/log';
+import {
+  drainLog,
+  httpPublisher,
+  publisherStatus,
+  readReceipts,
+  rewind,
+  type DrainResult,
+  type Publisher,
+  type PublisherStatus,
+  type Receipt,
+} from '@medicine-wheel/events/publish';
+import { resolveProjectDataDir } from '@/lib/jsonl-store';
+
+/** Where the log lives: `MW_EVENTS_FILE`, else beside the wheel's JSONL store. */
+export function eventLogFile(): string {
+  return eventLogPath(resolveProjectDataDir());
+}
+
+/** This wheel's name in `source.instance`, when one is configured. */
+export function eventInstance(): string | undefined {
+  return process.env.MW_INSTANCE?.trim() || undefined;
+}
+
+/**
+ * Record what a decider returned (`null`: the write changed nothing, so
+ * nothing to record). Returns the event, or `undefined` when there was none or
+ * its line could not be written.
+ */
+export function recordEvent(input: WheelEventInput | null): WheelEvent | undefined {
+  if (!input) return undefined;
+  const file = eventLogFile();
+  let event: WheelEvent;
+  try {
+    event = buildEvent(input, { instance: eventInstance() });
+    appendEvent(file, event);
+  } catch (error) {
+    console.error(
+      `[events] medicine-wheel.${input.name} for ${input.subject.kind} ${input.subject.id} was not written to ${file}: ${(error as Error)?.message ?? String(error)}`,
+    );
+    return undefined;
+  }
+  kickPublisher();
+  return event;
+}
+
+/** Every event, oldest first. */
+export function readEvents(): WheelEvent[] {
+  return readEventLog(eventLogFile());
+}
+
+export { filterEvents, type EventFilter };
+
+// ── publishing ──────────────────────────────────────────────────────────────
+
+/** The publisher `MW_EVENTS_PUBLISH_URL` names, or `null`: nothing leaves the machine. */
+export function publisherFromEnv(): Publisher | null {
+  const url = process.env.MW_EVENTS_PUBLISH_URL?.trim();
+  if (!url) return null;
+  return httpPublisher({
+    url,
+    token: process.env.MW_EVENTS_PUBLISH_TOKEN?.trim() || undefined,
+    name: process.env.MW_EVENTS_PUBLISH_NAME?.trim() || 'http',
+  });
+}
+
+// One pass at a time across every copy of this module: Next compiles
+// `instrumentation.ts` and the routes into separate bundles, and two passes
+// over the same cursor would send the same event twice.
+const STATE = Symbol.for('@medicine-wheel/app.event-publisher');
+type PublishState = { running?: Promise<DrainResult | null>; again?: boolean; timer?: ReturnType<typeof setInterval>; down?: boolean };
+const state: PublishState = ((globalThis as Record<symbol, PublishState>)[STATE] ??= {});
+
+async function pass(): Promise<DrainResult | null> {
+  const publisher = publisherFromEnv();
+  if (!publisher) return null;
+  try {
+    const result = await drainLog(eventLogFile(), publisher);
+    // A destination that stays down is one line when it goes, one when it returns.
+    if (result.stopped && !state.down) {
+      console.error(`[events] publishing to ${publisher.name} stopped: ${result.error} — ${result.pending} event(s) waiting`);
+    } else if (!result.stopped && state.down) {
+      console.log(`[events] publishing to ${publisher.name} resumed; ${result.arrived} event(s) arrived`);
+    }
+    state.down = result.stopped;
+    return result;
+  } catch (error) {
+    console.error(`[events] publishing pass failed: ${(error as Error)?.message ?? String(error)}`);
+    return null;
+  }
+}
+
+/** Send what waits. A pass already running is joined, and runs once more after it for what arrived meanwhile. */
+export function publishPending(): Promise<DrainResult | null> {
+  if (state.running) {
+    state.again = true;
+    return state.running;
+  }
+  const run = pass().then(async (result) => {
+    while (state.again) {
+      state.again = false;
+      result = (await pass()) ?? result;
+    }
+    return result;
+  }).finally(() => {
+    if (state.running === run) state.running = undefined;
+  });
+  state.running = run;
+  return run;
+}
+
+/** After a recorded event: send it soon, in the background. Nothing when no publisher is set. */
+export function kickPublisher(): void {
+  if (!process.env.MW_EVENTS_PUBLISH_URL?.trim()) return;
+  void publishPending();
+}
+
+/**
+ * Start the publishing clock: one pass now, then one every
+ * `MW_EVENTS_PUBLISH_INTERVAL_MS` (default one minute). Called once from
+ * `instrumentation.ts`; a second call is a no-op, and without a publisher
+ * there is nothing to send.
+ */
+export function startEventPublishing(intervalMs = Number(process.env.MW_EVENTS_PUBLISH_INTERVAL_MS) || 60_000): void {
+  if (state.timer || !publisherFromEnv()) return;
+  state.timer = setInterval(() => { void publishPending(); }, intervalMs);
+  state.timer.unref?.();
+  void publishPending();
+}
+
+/** Replay: the next pass sends `fromEventId` and everything after it again (the whole log without one). */
+export function replayEvents(fromEventId?: string): { pending: number } | null {
+  const publisher = publisherFromEnv();
+  if (!publisher) return null;
+  return rewind(eventLogFile(), publisher.name, fromEventId);
+}
+
+/** Where the configured publisher stands, and its latest receipts. */
+export function eventPublisherReport(limit = 20): { publisher: PublisherStatus; receipts: Receipt[] } | null {
+  const publisher = publisherFromEnv();
+  if (!publisher) return null;
+  const file = eventLogFile();
+  return { publisher: publisherStatus(file, publisher.name), receipts: readReceipts(file, publisher.name).slice(-limit).reverse() };
+}
+
+/** What `/api/health` reports: how many events, the last one, and what the publisher still owes. */
+export function eventLogStatus(): { count: number; last_at?: string; publisher?: PublisherStatus } | { error: string } {
+  try {
+    const events = readEvents();
+    const last = events[events.length - 1];
+    const publisher = publisherFromEnv();
+    return {
+      count: events.length,
+      ...(last ? { last_at: last.observed_at } : {}),
+      ...(publisher ? { publisher: publisherStatus(eventLogFile(), publisher.name) } : {}),
+    };
+  } catch (error) {
+    return { error: (error as Error)?.message ?? String(error) };
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@medicine-wheel/app",
-  "version": "0.17.11",
+  "version": "0.18.0",
   "description": "Medicine Wheel — Interactive visual layer for Indigenous relational research with Four Directions, ceremonies, and narrative arcs",
   "bin": {
     "mw": "dist/cli/mw.js",
@@ -28,6 +28,7 @@
   "workspaces": [
     "src/ontology-core",
     "src/infra",
+    "src/events",
     "src/creative-orientation",
     "src/session-reader",
     "src/ceremony-protocol",
@@ -91,32 +92,33 @@
     "release:major": "npm run version:major && npm run publish:all && npm run release:commit"
   },
   "dependencies": {
-    "@medicine-wheel/ceremonial-diary": "^0.17.11",
-    "@medicine-wheel/ceremony-protocol": "^0.17.11",
-    "@medicine-wheel/community-identity": "^0.17.11",
-    "@medicine-wheel/community-review": "^0.17.11",
-    "@medicine-wheel/consent-lifecycle": "^0.17.11",
-    "@medicine-wheel/creative-orientation": "^0.17.11",
-    "@medicine-wheel/data-store": "^0.17.11",
-    "@medicine-wheel/data-store-postgres": "^0.17.11",
-    "@medicine-wheel/fire-keeper": "^0.17.11",
-    "@medicine-wheel/github-ceremony": "^0.17.11",
-    "@medicine-wheel/graph-viz": "^0.17.11",
-    "@medicine-wheel/honcho": "^0.17.11",
-    "@medicine-wheel/importance-unit": "^0.17.11",
-    "@medicine-wheel/mcp": "^4.17.11",
-    "@medicine-wheel/memory": "^0.17.11",
-    "@medicine-wheel/narrative-cluster": "^0.17.11",
-    "@medicine-wheel/narrative-engine": "^0.17.11",
-    "@medicine-wheel/ontology-core": "^0.17.11",
-    "@medicine-wheel/perception-layer": "^0.17.11",
-    "@medicine-wheel/prompt-decomposition": "^0.17.11",
-    "@medicine-wheel/relational-index": "^0.17.11",
-    "@medicine-wheel/relational-query": "^0.17.11",
-    "@medicine-wheel/session-reader": "^0.17.11",
-    "@medicine-wheel/storage-provider": "^0.17.11",
-    "@medicine-wheel/transformation-tracker": "^0.17.11",
-    "@medicine-wheel/ui-components": "^0.17.11",
+    "@medicine-wheel/ceremonial-diary": "^0.18.0",
+    "@medicine-wheel/ceremony-protocol": "^0.18.0",
+    "@medicine-wheel/community-identity": "^0.18.0",
+    "@medicine-wheel/community-review": "^0.18.0",
+    "@medicine-wheel/consent-lifecycle": "^0.18.0",
+    "@medicine-wheel/creative-orientation": "^0.18.0",
+    "@medicine-wheel/data-store": "^0.18.0",
+    "@medicine-wheel/data-store-postgres": "^0.18.0",
+    "@medicine-wheel/events": "^0.18.0",
+    "@medicine-wheel/fire-keeper": "^0.18.0",
+    "@medicine-wheel/github-ceremony": "^0.18.0",
+    "@medicine-wheel/graph-viz": "^0.18.0",
+    "@medicine-wheel/honcho": "^0.18.0",
+    "@medicine-wheel/importance-unit": "^0.18.0",
+    "@medicine-wheel/mcp": "^4.18.0",
+    "@medicine-wheel/memory": "^0.18.0",
+    "@medicine-wheel/narrative-cluster": "^0.18.0",
+    "@medicine-wheel/narrative-engine": "^0.18.0",
+    "@medicine-wheel/ontology-core": "^0.18.0",
+    "@medicine-wheel/perception-layer": "^0.18.0",
+    "@medicine-wheel/prompt-decomposition": "^0.18.0",
+    "@medicine-wheel/relational-index": "^0.18.0",
+    "@medicine-wheel/relational-query": "^0.18.0",
+    "@medicine-wheel/session-reader": "^0.18.0",
+    "@medicine-wheel/storage-provider": "^0.18.0",
+    "@medicine-wheel/transformation-tracker": "^0.18.0",
+    "@medicine-wheel/ui-components": "^0.18.0",
     "@miadi/episode-vessel": "^0.2.1",
     "@neondatabase/serverless": "^0.10.0",
     "@xyflow/react": "^12.3.0",
@@ -138,6 +140,7 @@
     "@types/node": "^22.0.0",
     "@types/react": "^19.0.0",
     "@types/react-dom": "^19.0.0",
+    "ajv": "^6.12.6",
     "eslint": "^9.39.5",
     "eslint-config-next": "^15.5.25",
     "shx": "^0.4.0",