@medicine-wheel/app 0.19.1 → 0.20.0

package/README.md

@@ -391,20 +391,23 @@ Two chronicle episodes related through the Miadi lineage door (`POST /api/edges`
 between two `chronicle_episode` nodes) produce `chronicle.lineage.made`, which
 carries the manifest's sentence that says why.
 
-**Publishing.** Nothing leaves the machine until `MW_EVENTS_PUBLISH_URL` is set.
-Once it is, the wheel POSTs each event, in log order, after every write and
-every minute (`MW_EVENTS_PUBLISH_INTERVAL_MS`).
-
-- **Headers:** `Idempotency-Key`, `X-Event-Type`, and `Authorization: Bearer
-  $MW_EVENTS_PUBLISH_TOKEN` when a token is set.
-- **Delivery records:** a cursor and receipts beside the log record
-  `arrived`, `failed` (retried) or `refused` (passed).
-- **Checking and replaying:** `mw events status`, `mw events publish` and
-  `mw events replay <event-id|all>` (also `GET`/`POST /api/events/publish`).
-- **What can receive it:** a webhook endpoint, a Hookdeck source, a Cloudflare
-  Worker in front of a queue, or the Miadi hooks-gateway. A broker client is
-  another publisher beside it. The events keep their names
-  (jgwill/medicine-wheel#164, miadi-chronicle://548).
+**Publishing.** Nothing leaves the machine until a destination is configured. Each destination is an
+adapter with its own cursor, so one that is down never holds another back:
+
+- any HTTP receiver: `MW_EVENTS_PUBLISH_URL`, with `_FORMAT` = `envelope`, `cloudevents` or
+  `cloudevents-binary`;
+- a Hookdeck source: `MW_EVENTS_HOOKDECK_SOURCE_URL`;
+- a Cloudflare queue: `MW_EVENTS_CF_ACCOUNT_ID`, `MW_EVENTS_CF_QUEUE_ID` and `MW_EVENTS_CF_API_TOKEN`.
+
+The wheel sends in log order, after every write and every minute. Each adapter declares what it guarantees,
+and receipts record `arrived`, `failed` (kept and retried) or `refused` (recorded and passed). Wrong
+credentials and wrong addresses count as `failed`, never as `refused`.
+
+`mw events status`, `mw events publish` and `mw events replay <event-id|all> --publisher <name>` show and
+drive it, as do `GET` and `POST /api/events/publish`.
+
+NATS JetStream and Kafka are specified, not built. Which broker to try first is weighed in
+miadi-chronicle://548, `foundations/broker-adapters/` (jgwill/medicine-wheel#165).
 
 ## License
 

package/app/api/events/publish/route.ts

@@ -2,41 +2,43 @@ import { NextResponse } from "next/server";
 import { eventPublisherReport, publishPending, replayEvents } from "@/lib/event-log";
 
 const NO_PUBLISHER = {
-  error: "No publisher is configured — the events wait in events.jsonl.",
-  hint: "Set MW_EVENTS_PUBLISH_URL (and MW_EVENTS_PUBLISH_TOKEN) and restart the wheel.",
+  error: "No destination is configured — the events wait in events.jsonl.",
+  hint: "Set MW_EVENTS_PUBLISH_URL, MW_EVENTS_HOOKDECK_SOURCE_URL, or MW_EVENTS_CF_ACCOUNT_ID + MW_EVENTS_CF_QUEUE_ID + MW_EVENTS_CF_API_TOKEN, and restart the wheel.",
 };
 
 /**
- * The publisher's side of the log (#164) — episode 548's Send, Receipt,
- * Failure and Replay.
+ * The destinations' side of the log (#164, #165) — episode 548's Send,
+ * Receipt, Failure and Replay.
  *
- * GET: where the configured publisher stands (`pending`, the last event it is
- * done with, the last arrival, the last failure) and its latest receipts.
- * POST: send what waits now. `{ "replay_from": "<event id>" }` first moves the
- * cursor back so that event and every later one go out again, with the same
- * idempotency keys; `{ "replay_from": "all" }` replays the whole log.
+ * GET: for each destination, where it stands (`pending`, the last event it
+ * is done with, the last arrival, the last failure), what it promises, and
+ * its latest receipts.
+ * POST: send what waits now, to every destination. `{ "replay_from": "<event
+ * id>" | "all", "publisher": "<name>" }` first moves that destination's
+ * cursor back, so the same lines go out again with the same idempotency keys;
+ * the name may be left out when only one destination is configured.
  */
 export async function GET() {
-  const report = eventPublisherReport();
-  if (!report) return NextResponse.json(NO_PUBLISHER, { status: 409 });
-  return NextResponse.json(report);
+  const publishers = eventPublisherReport();
+  if (!publishers) return NextResponse.json(NO_PUBLISHER, { status: 409 });
+  return NextResponse.json({ publishers });
 }
 
 export async function POST(request: Request) {
-  const body = (await request.json().catch(() => ({}))) as { replay_from?: unknown };
-  let replay: { pending: number } | null = null;
+  const body = (await request.json().catch(() => ({}))) as { replay_from?: unknown; publisher?: unknown };
+  let replay: { publisher: string; pending: number } | null = null;
   if (body?.replay_from !== undefined) {
     if (typeof body.replay_from !== "string" || !body.replay_from) {
       return NextResponse.json({ error: 'replay_from must be an event id, or "all"' }, { status: 400 });
     }
     try {
-      replay = replayEvents(body.replay_from === "all" ? undefined : body.replay_from);
+      replay = replayEvents(body.replay_from === "all" ? undefined : body.replay_from, typeof body.publisher === "string" ? body.publisher : undefined);
     } catch (error: unknown) {
       return NextResponse.json({ error: error instanceof Error ? error.message : String(error) }, { status: 404 });
     }
     if (!replay) return NextResponse.json(NO_PUBLISHER, { status: 409 });
   }
-  const result = await publishPending();
-  if (!result) return NextResponse.json(NO_PUBLISHER, { status: 409 });
-  return NextResponse.json({ ...(replay ? { replayed: replay.pending } : {}), ...result });
+  const results = await publishPending();
+  if (!results) return NextResponse.json(NO_PUBLISHER, { status: 409 });
+  return NextResponse.json({ ...(replay ? { replayed: replay } : {}), results });
 }

package/dist/cli/mw.js

@@ -305,9 +305,9 @@ ${C.bold}🌿 mw — Medicine Wheel CLI${C.reset}
   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 status                       What each destination owes and promises
+    mw events publish                      Send what waits now, to every destination
+    mw events replay <event-id|all> [--publisher <name>]  Send again from that event
     mw events sync                         Commit (and push) events.jsonl now
     mw events schema [--asyncapi]          Print the JSON Schema (or AsyncAPI)
 
@@ -824,7 +824,7 @@ async function cmdEvents(positional, flags) {
             if (status !== 200)
                 return failed(status, data);
             ppValue(data);
-            if (data.stopped)
+            if (data.results?.some((r) => r.stopped))
                 process.exitCode = 1;
             break;
         }
@@ -835,11 +835,12 @@ async function cmdEvents(positional, flags) {
                 process.exitCode = EXIT_USAGE;
                 return;
             }
-            const { status, data } = await eventsApi('POST', '/api/events/publish', { replay_from: from });
+            const publisher = typeof flags['publisher'] === 'string' ? flags['publisher'] : undefined;
+            const { status, data } = await eventsApi('POST', '/api/events/publish', { replay_from: from, ...(publisher ? { publisher } : {}) });
             if (status !== 200)
                 return failed(status, data);
             ppValue(data);
-            if (data.stopped)
+            if (data.results?.some((r) => r.stopped))
                 process.exitCode = 1;
             break;
         }

package/lib/event-log.ts

@@ -14,10 +14,18 @@
  * `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.
+ * Publishing (episode 548's Send, #165): each configured destination is a
+ * publisher with its own cursor and receipts beside the log, sent to after
+ * every recorded event and every `MW_EVENTS_PUBLISH_INTERVAL_MS` (default one
+ * minute). One destination down never holds another back. Unset, nothing
+ * leaves the machine. The destinations:
+ *
+ * - `MW_EVENTS_PUBLISH_URL` (`_TOKEN`, `_NAME`, `_FORMAT` = envelope |
+ *   cloudevents | cloudevents-binary): any HTTP receiver.
+ * - `MW_EVENTS_HOOKDECK_SOURCE_URL` (`_FORMAT`): a Hookdeck source.
+ * - `MW_EVENTS_CF_ACCOUNT_ID` + `MW_EVENTS_CF_QUEUE_ID` + `MW_EVENTS_CF_API_TOKEN`
+ *   (`MW_EVENTS_CF_FORMAT` = envelope | cloudevents; `MW_EVENTS_CF_API_BASE`
+ *   for a proxy): a Cloudflare queue.
  *
  * Carried by git, before any broker: with `MW_EVENTS_GIT_SYNC=push` (or
  * `commit`), the wheel commits `events.jsonl` — that file only — in the data
@@ -34,13 +42,17 @@
 import { buildEvent, filterEvents, type EventFilter, type WheelEvent, type WheelEventInput } from '@medicine-wheel/events';
 import { appendEvent, eventLogPath, readEventLog } from '@medicine-wheel/events/log';
 import {
+  cloudflareQueuesPublisher,
   drainLog,
+  hookdeckPublisher,
   httpPublisher,
   publisherStatus,
   readReceipts,
   rewind,
+  type AdapterGuarantees,
   type DrainResult,
   type Publisher,
+  type WireFormat,
   type PublisherStatus,
   type Receipt,
 } from '@medicine-wheel/events/publish';
@@ -89,55 +101,99 @@ 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',
+const env = (key: string) => process.env[key]?.trim() || undefined;
+
+function formatOf(key: string, allowed: readonly WireFormat[]): WireFormat {
+  const value = env(key);
+  if (!value) return 'envelope';
+  if ((allowed as readonly string[]).includes(value)) return value as WireFormat;
+  console.error(`[events] ${key}=${value} is not one of ${allowed.join(', ')}; sending the envelope`);
+  return 'envelope';
+}
+
+/** Every destination the environment names, each a publisher with its own cursor. None: nothing leaves the machine. */
+export function publishersFromEnv(): Publisher[] {
+  const publishers: Publisher[] = [];
+  const url = env('MW_EVENTS_PUBLISH_URL');
+  if (url) {
+    publishers.push(httpPublisher({
+      url,
+      token: env('MW_EVENTS_PUBLISH_TOKEN'),
+      name: env('MW_EVENTS_PUBLISH_NAME') || 'http',
+      format: formatOf('MW_EVENTS_PUBLISH_FORMAT', ['envelope', 'cloudevents', 'cloudevents-binary']),
+    }));
+  }
+  const hookdeck = env('MW_EVENTS_HOOKDECK_SOURCE_URL');
+  if (hookdeck) {
+    publishers.push(hookdeckPublisher({ sourceUrl: hookdeck, format: formatOf('MW_EVENTS_HOOKDECK_FORMAT', ['envelope', 'cloudevents', 'cloudevents-binary']) }));
+  }
+  const [accountId, queueId, token] = [env('MW_EVENTS_CF_ACCOUNT_ID'), env('MW_EVENTS_CF_QUEUE_ID'), env('MW_EVENTS_CF_API_TOKEN')];
+  if (accountId && queueId && token) {
+    publishers.push(cloudflareQueuesPublisher({
+      accountId,
+      queueId,
+      token,
+      format: formatOf('MW_EVENTS_CF_FORMAT', ['envelope', 'cloudevents']) as 'envelope' | 'cloudevents',
+      apiBase: env('MW_EVENTS_CF_API_BASE'),
+    }));
+  } else if (accountId || queueId || token) {
+    console.error('[events] Cloudflare Queues needs MW_EVENTS_CF_ACCOUNT_ID, MW_EVENTS_CF_QUEUE_ID and MW_EVENTS_CF_API_TOKEN together; it is off');
+  }
+  // Two publishers under one name would share a cursor and each skip what the other sent.
+  const seen = new Set<string>();
+  return publishers.filter((p) => {
+    if (!seen.has(p.name)) return seen.add(p.name), true;
+    console.error(`[events] two publishers are named ${p.name}; the second is off`);
+    return false;
   });
 }
 
+const publishingConfigured = () =>
+  Boolean(env('MW_EVENTS_PUBLISH_URL') || env('MW_EVENTS_HOOKDECK_SOURCE_URL') || env('MW_EVENTS_CF_ACCOUNT_ID'));
+
 // 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 };
+type PublishState = { running?: Promise<DrainResult[] | null>; again?: boolean; timer?: ReturnType<typeof setInterval>; down?: Set<string> };
 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`);
+async function pass(): Promise<DrainResult[] | null> {
+  const publishers = publishersFromEnv();
+  if (!publishers.length) return null;
+  const down = (state.down ??= new Set());
+  const results: DrainResult[] = [];
+  for (const publisher of publishers) {
+    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 && !down.has(publisher.name)) {
+        console.error(`[events] publishing to ${publisher.name} stopped: ${result.error} — ${result.pending} event(s) waiting`);
+        down.add(publisher.name);
+      } else if (!result.stopped && down.has(publisher.name)) {
+        console.log(`[events] publishing to ${publisher.name} resumed; ${result.arrived} event(s) arrived`);
+        down.delete(publisher.name);
+      }
+      results.push(result);
+    } catch (error) {
+      console.error(`[events] publishing to ${publisher.name} failed: ${(error as Error)?.message ?? String(error)}`);
     }
-    state.down = result.stopped;
-    return result;
-  } catch (error) {
-    console.error(`[events] publishing pass failed: ${(error as Error)?.message ?? String(error)}`);
-    return null;
   }
+  return results;
 }
 
-/** 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> {
+/** Send what waits, to every destination. 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) => {
+  const run = pass().then(async (results) => {
     while (state.again) {
       state.again = false;
-      result = (await pass()) ?? result;
+      results = (await pass()) ?? results;
     }
-    return result;
+    return results;
   }).finally(() => {
     if (state.running === run) state.running = undefined;
   });
@@ -145,38 +201,58 @@ export function publishPending(): Promise<DrainResult | null> {
   return run;
 }
 
-/** After a recorded event: send it soon, in the background. Nothing when no publisher is set. */
+/** After a recorded event: send it soon, in the background. Nothing when no destination is set. */
 export function kickPublisher(): void {
-  if (!process.env.MW_EVENTS_PUBLISH_URL?.trim()) return;
+  if (!publishingConfigured()) 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
+ * `instrumentation.ts`; a second call is a no-op, and without a destination
  * 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;
+  if (state.timer || !publishersFromEnv().length) 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);
+/**
+ * Replay: the named publisher's next pass sends `fromEventId` and everything
+ * after it again (the whole log without one). With one destination the name
+ * may be left out. `null`: no destination is configured.
+ */
+export function replayEvents(fromEventId?: string, publisherName?: string): { publisher: string; pending: number } | null {
+  const publishers = publishersFromEnv();
+  if (!publishers.length) return null;
+  const publisher = publisherName ? publishers.find((p) => p.name === publisherName) : publishers.length === 1 ? publishers[0] : undefined;
+  if (!publisher) {
+    throw new Error(publisherName
+      ? `No publisher named ${publisherName}; configured: ${publishers.map((p) => p.name).join(', ')}`
+      : `Name the publisher to replay: ${publishers.map((p) => p.name).join(', ')}`);
+  }
+  return { publisher: publisher.name, ...rewind(eventLogFile(), publisher.name, fromEventId) };
+}
+
+export interface PublisherReport {
+  status: PublisherStatus;
+  guarantees?: AdapterGuarantees;
+  receipts: Receipt[];
 }
 
-/** 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;
+/** Where each destination stands, what it promises, and its latest receipts. `null`: none is configured. */
+export function eventPublisherReport(limit = 20): PublisherReport[] | null {
+  const publishers = publishersFromEnv();
+  if (!publishers.length) return null;
   const file = eventLogFile();
-  return { publisher: publisherStatus(file, publisher.name), receipts: readReceipts(file, publisher.name).slice(-limit).reverse() };
+  return publishers.map((p) => ({
+    status: publisherStatus(file, p.name),
+    ...(p.guarantees ? { guarantees: p.guarantees } : {}),
+    receipts: readReceipts(file, p.name).slice(-limit).reverse(),
+  }));
 }
 
 // ── carried by git ──────────────────────────────────────────────────────────
@@ -261,16 +337,16 @@ export function eventGitStatus(): { mode: GitSyncMode; last?: GitState['last'] }
   return { mode: gitSyncMode(), ...(gitState.last ? { last: gitState.last } : {}) };
 }
 
-/** What `/api/health` reports: how many events, the last one, what the publisher owes, how the git carriage stands. */
-export function eventLogStatus(): { count: number; last_at?: string; publisher?: PublisherStatus; git?: ReturnType<typeof eventGitStatus> } | { error: string } {
+/** What `/api/health` reports: how many events, the last one, what each destination owes, how the git carriage stands. */
+export function eventLogStatus(): { count: number; last_at?: string; publishers?: PublisherStatus[]; git?: ReturnType<typeof eventGitStatus> } | { error: string } {
   try {
     const events = readEvents();
     const last = events[events.length - 1];
-    const publisher = publisherFromEnv();
+    const publishers = publishersFromEnv();
     return {
       count: events.length,
       ...(last ? { last_at: last.observed_at } : {}),
-      ...(publisher ? { publisher: publisherStatus(eventLogFile(), publisher.name) } : {}),
+      ...(publishers.length ? { publishers: publishers.map((p) => publisherStatus(eventLogFile(), p.name)) } : {}),
       ...(gitSyncMode() !== 'off' ? { git: eventGitStatus() } : {}),
     };
   } catch (error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@medicine-wheel/app",
-  "version": "0.19.1",
+  "version": "0.20.0",
   "description": "Medicine Wheel — Interactive visual layer for Indigenous relational research with Four Directions, ceremonies, and narrative arcs",
   "bin": {
     "mw": "dist/cli/mw.js",
@@ -92,33 +92,33 @@
     "release:major": "npm run version:major && npm run publish:all && npm run release:commit"
   },
   "dependencies": {
-    "@medicine-wheel/ceremonial-diary": "^0.19.1",
-    "@medicine-wheel/ceremony-protocol": "^0.19.1",
-    "@medicine-wheel/community-identity": "^0.19.1",
-    "@medicine-wheel/community-review": "^0.19.1",
-    "@medicine-wheel/consent-lifecycle": "^0.19.1",
-    "@medicine-wheel/creative-orientation": "^0.19.1",
-    "@medicine-wheel/data-store": "^0.19.1",
-    "@medicine-wheel/data-store-postgres": "^0.19.1",
-    "@medicine-wheel/events": "^0.19.1",
-    "@medicine-wheel/fire-keeper": "^0.19.1",
-    "@medicine-wheel/github-ceremony": "^0.19.1",
-    "@medicine-wheel/graph-viz": "^0.19.1",
-    "@medicine-wheel/honcho": "^0.19.1",
-    "@medicine-wheel/importance-unit": "^0.19.1",
-    "@medicine-wheel/mcp": "^4.19.1",
-    "@medicine-wheel/memory": "^0.19.1",
-    "@medicine-wheel/narrative-cluster": "^0.19.1",
-    "@medicine-wheel/narrative-engine": "^0.19.1",
-    "@medicine-wheel/ontology-core": "^0.19.1",
-    "@medicine-wheel/perception-layer": "^0.19.1",
-    "@medicine-wheel/prompt-decomposition": "^0.19.1",
-    "@medicine-wheel/relational-index": "^0.19.1",
-    "@medicine-wheel/relational-query": "^0.19.1",
-    "@medicine-wheel/session-reader": "^0.19.1",
-    "@medicine-wheel/storage-provider": "^0.19.1",
-    "@medicine-wheel/transformation-tracker": "^0.19.1",
-    "@medicine-wheel/ui-components": "^0.19.1",
+    "@medicine-wheel/ceremonial-diary": "^0.20.0",
+    "@medicine-wheel/ceremony-protocol": "^0.20.0",
+    "@medicine-wheel/community-identity": "^0.20.0",
+    "@medicine-wheel/community-review": "^0.20.0",
+    "@medicine-wheel/consent-lifecycle": "^0.20.0",
+    "@medicine-wheel/creative-orientation": "^0.20.0",
+    "@medicine-wheel/data-store": "^0.20.0",
+    "@medicine-wheel/data-store-postgres": "^0.20.0",
+    "@medicine-wheel/events": "^0.20.0",
+    "@medicine-wheel/fire-keeper": "^0.20.0",
+    "@medicine-wheel/github-ceremony": "^0.20.0",
+    "@medicine-wheel/graph-viz": "^0.20.0",
+    "@medicine-wheel/honcho": "^0.20.0",
+    "@medicine-wheel/importance-unit": "^0.20.0",
+    "@medicine-wheel/mcp": "^4.20.0",
+    "@medicine-wheel/memory": "^0.20.0",
+    "@medicine-wheel/narrative-cluster": "^0.20.0",
+    "@medicine-wheel/narrative-engine": "^0.20.0",
+    "@medicine-wheel/ontology-core": "^0.20.0",
+    "@medicine-wheel/perception-layer": "^0.20.0",
+    "@medicine-wheel/prompt-decomposition": "^0.20.0",
+    "@medicine-wheel/relational-index": "^0.20.0",
+    "@medicine-wheel/relational-query": "^0.20.0",
+    "@medicine-wheel/session-reader": "^0.20.0",
+    "@medicine-wheel/storage-provider": "^0.20.0",
+    "@medicine-wheel/transformation-tracker": "^0.20.0",
+    "@medicine-wheel/ui-components": "^0.20.0",
     "@miadi/episode-vessel": "^0.2.1",
     "@neondatabase/serverless": "^0.10.0",
     "@xyflow/react": "^12.3.0",