@medicine-wheel/app 0.15.6 → 0.15.8

package/README.md

@@ -348,7 +348,10 @@ HONCHO_WORKSPACE_ID=medicine-wheel      # default
 With `HONCHO_URL` set, every stored beat, ceremony and diary entry projects into
 Honcho on write, in the background. `GET /api/health` reports `honcho.enabled`.
 A projection never delays the wheel's answer, and a Honcho that is down is a
-line on stderr, not an error to the writer. A running server holds its old
+line on stderr, not an error to the writer. The record is not lost: its
+reference waits in `honcho-pending.jsonl` beside the store and is sent again on
+start, every five minutes, and after any projection that gets through —
+`honcho.pending` counts what waits. A running server holds its old
 build and its old environment — restart it for either to take effect.
 
 ## License

package/app/api/ceremonies/route.ts

@@ -162,7 +162,7 @@ export async function POST(request: Request) {
     await store.logCeremony(ceremony);
     // The river: the stored ceremony leaves for Honcho in the background when
     // HONCHO_URL is set. Never awaited.
-    projectAfterWrite(() => projectCeremony(ceremony), `ceremony ${ceremony.id}`);
+    projectAfterWrite({ kind: "ceremony", id: ceremony.id }, () => projectCeremony(ceremony));
     return NextResponse.json({ success: true, ceremony, provider: detectProvider() }, { status: 201 });
   } catch (error: unknown) {
     const message = error instanceof Error ? error.message : String(error);

package/app/api/diary/route.ts

@@ -126,7 +126,7 @@ export async function POST(request: Request) {
     });
     // The river: the participant's voice leaves for Honcho in the background
     // when HONCHO_URL is set. Never awaited.
-    projectAfterWrite(() => projectDiaryEntry(entry), `diary entry ${entry.id}`);
+    projectAfterWrite({ kind: "diary", id: entry.id }, () => projectDiaryEntry(entry));
     return NextResponse.json({ success: true, entry, provider: detectProvider() }, { status: 201 });
   } catch (error: unknown) {
     const message = error instanceof Error ? error.message : String(error);

package/app/api/health/route.ts

@@ -28,7 +28,8 @@ export async function GET() {
         ceremonies,
       },
       // The river to Honcho: enabled when HONCHO_URL is set. A wheel that
-      // reports enabled projects every stored beat, ceremony and diary entry.
+      // reports enabled projects every stored beat, ceremony and diary entry;
+      // `pending` counts those still waiting for Honcho to take them (#147).
       honcho: honchoProjectionStatus(),
       env: {
         MW_STORAGE_PROVIDER: process.env.MW_STORAGE_PROVIDER || 'not set',

package/app/api/honcho/pending/route.ts

@@ -0,0 +1,67 @@
+import { NextResponse } from "next/server";
+import {
+  holdsRecord,
+  honchoProjectionStatus,
+  isPendingRef,
+  listPending,
+  markPending,
+  PENDING_KINDS,
+  retryPending,
+  type PendingRef,
+} from "@/lib/honcho-projection";
+
+/**
+ * The river's pending ledger (#147): records the wheel holds and Honcho has
+ * not received yet.
+ *
+ * GET  — what waits, oldest first, with the river's status.
+ * POST — put records on the ledger by reference: `{ kind, id }`, or
+ *        `{ refs: [{ kind, id }, …] }`. For records lost before the ledger
+ *        existed, whose ids the server log still names. Each must be a record
+ *        the wheel holds. A retry pass starts at once and the answer does not
+ *        wait for it; `{ refs: [] }` only starts the pass.
+ */
+
+export async function GET() {
+  try {
+    return NextResponse.json({ honcho: honchoProjectionStatus(), pending: listPending() });
+  } catch (error: unknown) {
+    return NextResponse.json({ error: error instanceof Error ? error.message : String(error) }, { status: 500 });
+  }
+}
+
+export async function POST(request: Request) {
+  try {
+    const status = honchoProjectionStatus();
+    if (!status.enabled) {
+      return NextResponse.json(
+        { error: "The river is off (HONCHO_URL is unset); nothing would carry these records." },
+        { status: 409 },
+      );
+    }
+    const body = await request.json().catch(() => null);
+    const raw: unknown[] | null = Array.isArray(body?.refs) ? body.refs : isPendingRef(body) ? [body] : null;
+    if (!raw) {
+      return NextResponse.json(
+        { error: "Provide { kind, id } or { refs: [{ kind, id }, …] }", kinds: PENDING_KINDS },
+        { status: 400 },
+      );
+    }
+    const refs: PendingRef[] = [];
+    for (const r of raw) {
+      if (!isPendingRef(r)) {
+        return NextResponse.json({ error: `Not a record reference: ${JSON.stringify(r)}`, kinds: PENDING_KINDS }, { status: 400 });
+      }
+      if (!(await holdsRecord(r))) {
+        return NextResponse.json({ error: `The wheel holds no ${r.kind} ${r.id}` }, { status: 404 });
+      }
+      refs.push({ kind: r.kind, id: r.id });
+    }
+    let pending = listPending().length;
+    for (const ref of refs) pending = markPending(ref, "queued by hand");
+    void retryPending();
+    return NextResponse.json({ queued: refs.length, pending }, { status: 202 });
+  } catch (error: unknown) {
+    return NextResponse.json({ error: error instanceof Error ? error.message : String(error) }, { status: 500 });
+  }
+}

package/app/api/narrative/beats/route.ts

@@ -37,7 +37,7 @@ export async function POST(request: Request) {
     });
     // The river: a stored beat leaves for Honcho in the background when
     // HONCHO_URL is set. Never awaited — the wheel answers on its own clock.
-    projectAfterWrite(() => projectBeat(beat), `beat ${beat.id}`);
+    projectAfterWrite({ kind: "beat", id: beat.id }, () => projectBeat(beat));
     // Warnings ride on the created beat rather than replacing it, so clients
     // that read the beat back by id keep working while advisory findings stop
     // being computed-and-discarded.

package/instrumentation.ts

@@ -0,0 +1,12 @@
+/**
+ * Runs once when the server starts (Next.js instrumentation hook).
+ *
+ * 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.
+ */
+export async function register() {
+  if (process.env.NEXT_RUNTIME !== "nodejs") return;
+  const { startPendingRetries } = await import("@/lib/honcho-projection");
+  startPendingRetries();
+}

package/lib/honcho-projection.ts

@@ -11,16 +11,32 @@
  * A failure is reported once on stderr with the record's id, because a silent
  * memory is worse than a noisy one. `awaitProjections()` exists for tests and
  * for anything that must know the river has run dry before it exits.
+ *
+ * A record Honcho could not receive is not lost (#147). Until then a Honcho
+ * that was offline left a hole in its memory of every talking circle held
+ * while it was away — the wheel kept the turns, and nothing ever sent them.
+ * Now the record's reference, `{ kind, id }`, waits in a pending ledger beside
+ * the wheel's store (`honcho-pending.jsonl`, or `HONCHO_PENDING_FILE`), and
+ * {@link retryPending} sends it again: when the server starts, every few
+ * minutes, and right after any projection that gets through. Only the
+ * reference waits. The words stay in the wheel, which remains canonical and is
+ * read again when the record finally leaves.
  */
 
+import * as fs from 'node:fs';
+import * as path from 'node:path';
 import {
   createHonchoClient,
   honchoFromEnv,
   project,
+  projectBeat,
+  projectCeremony,
+  projectDiaryEntry,
   type HonchoClient,
   type HonchoConfig,
   type Projection,
 } from '@medicine-wheel/honcho';
+import { resolveProjectDataDir } from '@/lib/jsonl-store';
 
 const inFlight = new Set<Promise<unknown>>();
 
@@ -32,41 +48,323 @@ function clientFor(cfg: HonchoConfig): HonchoClient {
   return cached.client;
 }
 
-/** What `/api/health` reports: whether the river runs, and where to. */
-export function honchoProjectionStatus(): { enabled: boolean; url?: string; workspace?: string } {
+function track(run: Promise<unknown>): void {
+  inFlight.add(run);
+  run.finally(() => { inFlight.delete(run); }).catch(() => {});
+}
+
+// ── what can wait ───────────────────────────────────────────────────────────
+
+export const PENDING_KINDS = ['beat', 'ceremony', 'diary'] as const;
+export type PendingKind = (typeof PENDING_KINDS)[number];
+
+/** A record the river owes Honcho, by reference. */
+export interface PendingRef {
+  kind: PendingKind;
+  id: string;
+}
+
+export interface PendingEntry extends PendingRef {
+  /** When the record first failed to arrive. */
+  since: string;
+  /** The failure that put it here. */
+  error?: string;
+}
+
+const KIND_LABEL: Record<PendingKind, string> = { beat: 'beat', ceremony: 'ceremony', diary: 'diary entry' };
+
+const labelOf = (ref: PendingRef) => `${KIND_LABEL[ref.kind]} ${ref.id}`;
+const same = (a: PendingRef, b: PendingRef) => a.kind === b.kind && a.id === b.id;
+
+export function isPendingRef(value: unknown): value is PendingRef {
+  const v = value as Partial<PendingRef> | null;
+  return !!v && typeof v === 'object'
+    && typeof v.kind === 'string' && (PENDING_KINDS as readonly string[]).includes(v.kind)
+    && typeof v.id === 'string' && v.id.length > 0;
+}
+
+// ── the pending ledger ──────────────────────────────────────────────────────
+//
+// Every read and write below is synchronous on purpose. Next compiles
+// `instrumentation.ts` and the routes into separate bundles, each with its own
+// copy of this module; the file is what they share. A synchronous
+// read-modify-write cannot interleave with another inside one Node process, so
+// a record queued by a route while the timer's pass is sending another is
+// never overwritten away.
+
+/** Where the ledger lives: `HONCHO_PENDING_FILE`, else beside the wheel's JSONL store. */
+export function pendingFile(): string {
+  return process.env.HONCHO_PENDING_FILE || path.join(resolveProjectDataDir(), 'honcho-pending.jsonl');
+}
+
+function readLedger(): PendingEntry[] {
+  let text: string;
+  try {
+    text = fs.readFileSync(pendingFile(), 'utf-8');
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return [];
+    throw error;
+  }
+  const entries: PendingEntry[] = [];
+  for (const line of text.split('\n')) {
+    if (!line.trim()) continue;
+    try {
+      const entry = JSON.parse(line);
+      if (isPendingRef(entry) && !entries.some((e) => same(e, entry))) entries.push(entry as PendingEntry);
+    } catch {
+      // A torn line is skipped, not fatal: the rest of the ledger still sends.
+    }
+  }
+  return entries;
+}
+
+/** An empty ledger is no file, so a data repository shows it only while something waits. */
+function writeLedger(entries: PendingEntry[]): void {
+  const file = pendingFile();
+  if (!entries.length) {
+    fs.rmSync(file, { force: true });
+    return;
+  }
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const tmp = `${file}.${process.pid}.tmp`;
+  fs.writeFileSync(tmp, entries.map((e) => JSON.stringify(e)).join('\n') + '\n');
+  fs.renameSync(tmp, file);
+}
+
+/** What waits, oldest first. */
+export function listPending(): PendingEntry[] {
+  return readLedger();
+}
+
+/** Put a record on the ledger (once — a reference already waiting keeps its place). Returns how many wait. */
+export function markPending(ref: PendingRef, error?: string): number {
+  const entries = readLedger();
+  if (!entries.some((e) => same(e, ref))) {
+    entries.push({ kind: ref.kind, id: ref.id, since: new Date().toISOString(), ...(error ? { error } : {}) });
+    writeLedger(entries);
+  }
+  return entries.length;
+}
+
+function clearPending(ref: PendingRef): void {
+  const entries = readLedger();
+  const rest = entries.filter((e) => !same(e, ref));
+  if (rest.length !== entries.length) writeLedger(rest);
+}
+
+// ── reading a record back ───────────────────────────────────────────────────
+
+/**
+ * The record a reference names, shaped for Honcho — read from the wheel now,
+ * so what leaves is what the wheel holds, including any witness added since.
+ * `null` when the wheel no longer holds it. Throws when the store cannot be
+ * read, which is a reason to wait, not to forget.
+ */
+async function shaperFor(ref: PendingRef): Promise<(() => Projection) | null> {
+  if (ref.kind === 'beat') {
+    const { getBeat } = await import('@/lib/store');
+    const beat = getBeat(ref.id);
+    return beat ? () => projectBeat(beat) : null;
+  }
+  const { createProvider } = await import('@medicine-wheel/storage-provider');
+  const store = await createProvider();
+  if (ref.kind === 'ceremony') {
+    const ceremony = await store.getCeremony(ref.id);
+    return ceremony ? () => projectCeremony(ceremony) : null;
+  }
+  const entry = await store.getDiaryEntry(ref.id);
+  return entry ? () => projectDiaryEntry(entry) : null;
+}
+
+/** Whether the wheel holds the record a reference names. */
+export async function holdsRecord(ref: PendingRef): Promise<boolean> {
+  return (await shaperFor(ref)) !== null;
+}
+
+// ── failures ────────────────────────────────────────────────────────────────
+
+/**
+ * Whether sending again can change the outcome: Honcho unreachable or timed
+ * out (the client reports 502), failing on its own side (5xx), or asking us
+ * to slow down. A 4xx refusal is Honcho's answer to this record as shaped;
+ * it would give the same answer every five minutes, forever.
+ */
+function mayArriveLater(error: unknown): boolean {
+  const status = (error as { status?: unknown })?.status;
+  return typeof status !== 'number' || status >= 500 || status === 408 || status === 429;
+}
+
+function report(cfg: HonchoConfig, label: string, error: unknown, tail = ''): void {
+  const err = error as { message?: string; body?: string };
+  console.error(
+    `[honcho] projection of ${label} into ${cfg.workspace}@${cfg.baseUrl} failed: ${err?.message ?? String(error)}` +
+      (err?.body ? ` — ${err.body}` : '') +
+      tail,
+  );
+}
+
+/** What `/api/health` reports: whether the river runs, where to, and how much waits for it. */
+export function honchoProjectionStatus(): { enabled: boolean; url?: string; workspace?: string; pending?: number } {
   const cfg = honchoFromEnv();
-  return cfg ? { enabled: true, url: cfg.baseUrl, workspace: cfg.workspace } : { enabled: false };
+  if (!cfg) return { enabled: false };
+  let pending: number | undefined;
+  try {
+    pending = readLedger().length;
+  } catch {
+    pending = undefined;
+  }
+  return { enabled: true, url: cfg.baseUrl, workspace: cfg.workspace, ...(pending !== undefined ? { pending } : {}) };
 }
 
+// ── the river ───────────────────────────────────────────────────────────────
+
 /**
  * Fire-and-forget. Returns immediately; the projection runs in the background.
- * `label` names the record in the one line written when Honcho refuses or is
- * unreachable.
+ * `ref` names the record — in the one line written when Honcho refuses or is
+ * unreachable, and on the ledger when it may arrive later.
  *
  * The projection is built by `shape`, called *inside* the error boundary. It
  * used to be built by the caller, in the route's own expression — so a record
  * the projection could not shape (a `learnings` that arrived as a string, say)
  * threw synchronously and turned an already-stored write into a 500 for the
  * writer. The wheel's answer to its caller must not depend on the river, and
- * that includes the part that reads the record.
+ * that includes the part that reads the record. A record that cannot be
+ * shaped is reported and not queued: shaping it again fails the same way.
  */
-export function projectAfterWrite(shape: () => Projection, label: string): void {
+export function projectAfterWrite(ref: PendingRef, shape: () => Projection): void {
   const cfg = honchoFromEnv();
   if (!cfg) return;
-  const run = Promise.resolve()
-    .then(() => project(clientFor(cfg), shape()))
-    .catch((error: unknown) => {
-      const err = error as { message?: string; status?: number; body?: string };
-      console.error(
-        `[honcho] projection of ${label} into ${cfg.workspace}@${cfg.baseUrl} failed: ${err?.message ?? String(error)}` +
-          (err?.body ? ` — ${err.body}` : ''),
-      );
-    })
-    .finally(() => { inFlight.delete(run); });
-  inFlight.add(run);
+  const label = labelOf(ref);
+  track(
+    Promise.resolve().then(async () => {
+      let projection: Projection;
+      try {
+        projection = shape();
+      } catch (error) {
+        report(cfg, label, error);
+        return;
+      }
+      try {
+        await project(clientFor(cfg), projection);
+      } catch (error) {
+        if (!mayArriveLater(error)) {
+          report(cfg, label, error);
+          return;
+        }
+        let tail: string;
+        try {
+          tail = ` — waiting to be sent again (${markPending(ref, (error as Error)?.message)} pending)`;
+        } catch (ledgerError) {
+          tail = ` — and could not be kept for later: ${(ledgerError as Error)?.message ?? String(ledgerError)}`;
+        }
+        report(cfg, label, error, tail);
+        return;
+      }
+      // Honcho answered, so whatever waited behind it can go now.
+      try {
+        if (readLedger().length) void retryPending();
+      } catch {
+        // The ledger is the timer's to reach; this was only a head start.
+      }
+    }),
+  );
+}
+
+export interface RetryResult {
+  /** Delivered on this pass and cleared from the ledger. */
+  sent: number;
+  /** Cleared without delivery: the wheel no longer holds it, or Honcho refused it. */
+  dropped: number;
+  /** Still waiting after this pass. */
+  pending: number;
+}
+
+// One pass at a time across every copy of this module (see the ledger note):
+// two passes over the same ledger would send the same record twice.
+const RETRY_STATE = Symbol.for('@medicine-wheel/app.honcho-retry');
+type RetryState = { running?: Promise<RetryResult>; timer?: ReturnType<typeof setInterval> };
+const retryState: RetryState = ((globalThis as Record<symbol, RetryState>)[RETRY_STATE] ??= {});
+
+async function drain(): Promise<RetryResult> {
+  const result: RetryResult = { sent: 0, dropped: 0, pending: 0 };
+  const cfg = honchoFromEnv();
+  try {
+    if (cfg) {
+      for (const entry of readLedger()) {
+        const label = labelOf(entry);
+        // A store that cannot be read ends the pass with everything still waiting.
+        const shape = await shaperFor(entry);
+        if (!shape) {
+          console.error(`[honcho] ${label} was waiting for Honcho and the wheel no longer holds it; dropped from the ledger`);
+          clearPending(entry);
+          result.dropped++;
+          continue;
+        }
+        let projection: Projection;
+        try {
+          projection = shape();
+        } catch (error) {
+          report(cfg, label, error, ' — dropped from the ledger');
+          clearPending(entry);
+          result.dropped++;
+          continue;
+        }
+        try {
+          await project(clientFor(cfg), projection);
+        } catch (error) {
+          // Still away: this record and every one behind it keep waiting,
+          // and a Honcho that is down is not asked once per record.
+          if (mayArriveLater(error)) break;
+          report(cfg, label, error, ' — dropped from the ledger');
+          clearPending(entry);
+          result.dropped++;
+          continue;
+        }
+        clearPending(entry);
+        result.sent++;
+      }
+    }
+    result.pending = readLedger().length;
+  } catch (error) {
+    console.error(`[honcho] retrying the pending ledger (${pendingFile()}) failed: ${(error as Error)?.message ?? String(error)}`);
+  }
+  if (result.sent) {
+    console.log(`[honcho] ${result.sent} waiting projection(s) delivered; ${result.pending} still pending`);
+  }
+  return result;
+}
+
+/**
+ * Send what waits, oldest first, and clear each record Honcho takes. Stops at
+ * the first sign Honcho is still away. Never rejects. A pass already running
+ * is joined, not repeated.
+ */
+export function retryPending(): Promise<RetryResult> {
+  if (retryState.running) return retryState.running;
+  const run = drain().finally(() => {
+    if (retryState.running === run) retryState.running = undefined;
+  });
+  retryState.running = run;
+  track(run);
+  return run;
+}
+
+/**
+ * Start the retry clock: one pass now, then one every `intervalMs`
+ * (`HONCHO_RETRY_INTERVAL_MS`, default five minutes). Called once from
+ * `instrumentation.ts` when the server starts; a second call is a no-op, and
+ * with `HONCHO_URL` unset there is no river to wait for.
+ */
+export function startPendingRetries(
+  intervalMs = Number(process.env.HONCHO_RETRY_INTERVAL_MS) || 5 * 60_000,
+): void {
+  if (retryState.timer || !honchoFromEnv()) return;
+  retryState.timer = setInterval(() => { void retryPending(); }, intervalMs);
+  retryState.timer.unref?.();
+  void retryPending();
 }
 
-/** Resolves once every projection started so far has settled. */
+/** Resolves once every projection and retry pass started so far has settled. */
 export async function awaitProjections(): Promise<void> {
   while (inFlight.size) await Promise.allSettled([...inFlight]);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@medicine-wheel/app",
-  "version": "0.15.6",
+  "version": "0.15.8",
   "description": "Medicine Wheel — Interactive visual layer for Indigenous relational research with Four Directions, ceremonies, and narrative arcs",
   "bin": {
     "mw": "dist/cli/mw.js",
@@ -14,6 +14,7 @@
     "public/**/*",
     "dist/cli/**/*",
     "next.config.mjs",
+    "instrumentation.ts",
     "next-env.d.ts",
     "postcss.config.mjs",
     "tsconfig.json",
@@ -89,30 +90,30 @@
     "release:major": "npm run version:major && npm run publish:all && npm run release:commit"
   },
   "dependencies": {
-    "@medicine-wheel/ceremonial-diary": "^0.15.6",
-    "@medicine-wheel/ceremony-protocol": "^0.15.6",
-    "@medicine-wheel/community-review": "^0.15.6",
-    "@medicine-wheel/consent-lifecycle": "^0.15.6",
-    "@medicine-wheel/creative-orientation": "^0.15.6",
-    "@medicine-wheel/data-store": "^0.15.6",
-    "@medicine-wheel/data-store-postgres": "^0.15.6",
-    "@medicine-wheel/fire-keeper": "^0.15.6",
-    "@medicine-wheel/github-ceremony": "^0.15.6",
-    "@medicine-wheel/graph-viz": "^0.15.6",
-    "@medicine-wheel/honcho": "^0.15.6",
-    "@medicine-wheel/importance-unit": "^0.15.6",
-    "@medicine-wheel/mcp": "^4.15.6",
-    "@medicine-wheel/narrative-cluster": "^0.15.6",
-    "@medicine-wheel/narrative-engine": "^0.15.6",
-    "@medicine-wheel/ontology-core": "^0.15.6",
-    "@medicine-wheel/perception-layer": "^0.15.6",
-    "@medicine-wheel/prompt-decomposition": "^0.15.6",
-    "@medicine-wheel/relational-index": "^0.15.6",
-    "@medicine-wheel/relational-query": "^0.15.6",
-    "@medicine-wheel/session-reader": "^0.15.6",
-    "@medicine-wheel/storage-provider": "^0.15.6",
-    "@medicine-wheel/transformation-tracker": "^0.15.6",
-    "@medicine-wheel/ui-components": "^0.15.6",
+    "@medicine-wheel/ceremonial-diary": "^0.15.8",
+    "@medicine-wheel/ceremony-protocol": "^0.15.8",
+    "@medicine-wheel/community-review": "^0.15.8",
+    "@medicine-wheel/consent-lifecycle": "^0.15.8",
+    "@medicine-wheel/creative-orientation": "^0.15.8",
+    "@medicine-wheel/data-store": "^0.15.8",
+    "@medicine-wheel/data-store-postgres": "^0.15.8",
+    "@medicine-wheel/fire-keeper": "^0.15.8",
+    "@medicine-wheel/github-ceremony": "^0.15.8",
+    "@medicine-wheel/graph-viz": "^0.15.8",
+    "@medicine-wheel/honcho": "^0.15.8",
+    "@medicine-wheel/importance-unit": "^0.15.8",
+    "@medicine-wheel/mcp": "^4.15.8",
+    "@medicine-wheel/narrative-cluster": "^0.15.8",
+    "@medicine-wheel/narrative-engine": "^0.15.8",
+    "@medicine-wheel/ontology-core": "^0.15.8",
+    "@medicine-wheel/perception-layer": "^0.15.8",
+    "@medicine-wheel/prompt-decomposition": "^0.15.8",
+    "@medicine-wheel/relational-index": "^0.15.8",
+    "@medicine-wheel/relational-query": "^0.15.8",
+    "@medicine-wheel/session-reader": "^0.15.8",
+    "@medicine-wheel/storage-provider": "^0.15.8",
+    "@medicine-wheel/transformation-tracker": "^0.15.8",
+    "@medicine-wheel/ui-components": "^0.15.8",
     "@neondatabase/serverless": "^0.10.0",
     "@xyflow/react": "^12.3.0",
     "clsx": "^2.1.1",