@medicine-wheel/app 0.13.0 → 0.14.0

package/app/api/ceremonies/route.ts

@@ -1,7 +1,10 @@
 import { NextResponse } from "next/server";
 import { parseLimit } from "@/lib/api-paging";
 import { createProvider, detectProvider } from "@medicine-wheel/storage-provider";
-import { ceremonyBelongsToEpisode } from "@/lib/ceremony-response";
+import { ceremonyBelongsToEpisode, ceremonyEpisodePath } from "@/lib/ceremony-response";
+
+/** Episode directory names are `YYYY-MM-DD-episode-NNN-slug`; nothing else may bind. */
+const EPISODE_PATH = /^\d{4}-\d{2}-\d{2}-episode-\d{3,}-[a-z0-9-]+$/;
 
 export async function GET(request: Request) {
   try {
@@ -9,6 +12,8 @@ export async function GET(request: Request) {
     const direction = searchParams.get("direction");
     const type = searchParams.get("type");
     const episodePath = searchParams.get("episode_path");
+    const circleId = searchParams.get("circle_id");
+    const closes = searchParams.get("closes");
 
     const limit = parseLimit(searchParams.get("limit"));
     if (limit instanceof NextResponse) return limit;
@@ -41,6 +46,15 @@ export async function GET(request: Request) {
       );
     }
 
+    if (circleId) {
+      ceremonies = ceremonies.filter((c) => c.circle_id === circleId);
+    }
+
+    // `?closes=<opening id>` answers "is this ceremony closed, and by which record".
+    if (closes) {
+      ceremonies = ceremonies.filter((c) => c.closes === closes);
+    }
+
     const matched = ceremonies.length;
     if (limit !== null && ceremonies.length > limit) {
       ceremonies = ceremonies.slice(0, limit);
@@ -53,7 +67,7 @@ export async function GET(request: Request) {
       // `total` is the whole store, `matched` what the filters selected. When
       // count < matched the caller holds a page and can now see that it does.
       total,
-      ...(direction || type || episodePath ? { matched } : {}),
+      ...(direction || type || episodePath || circleId || closes ? { matched } : {}),
       truncated: ceremonies.length < matched,
     });
   } catch (error: unknown) {
@@ -66,7 +80,47 @@ export async function POST(request: Request) {
   try {
     const store = await createProvider();
     const body = await request.json();
-    
+
+    // Typed episode binding (0.14.0). A caller may still pass the legacy JSON
+    // string in `research_context`; it is lifted into the typed fields so every
+    // reader sees one shape. When both are given the typed fields win.
+    const legacy = ceremonyEpisodePath(body);
+    const episodePath: string | undefined =
+      typeof body.episode_path === "string" && body.episode_path ? body.episode_path : legacy;
+    if (episodePath !== undefined && !EPISODE_PATH.test(episodePath)) {
+      return NextResponse.json(
+        { error: `Invalid episode_path: ${episodePath}`, hint: "YYYY-MM-DD-episode-NNN-slug" },
+        { status: 400 },
+      );
+    }
+    const fromName = episodePath ? Number(episodePath.match(/-episode-(\d+)-/)?.[1]) : NaN;
+    const episodeNumber: number | undefined =
+      typeof body.episode_number === "number" ? body.episode_number : Number.isFinite(fromName) ? fromName : undefined;
+
+    if (body.closes !== undefined) {
+      if (typeof body.closes !== "string" || !body.closes) {
+        return NextResponse.json({ error: "closes must be a ceremony id" }, { status: 400 });
+      }
+      if (!(await store.getCeremony(body.closes))) {
+        return NextResponse.json(
+          { error: `Cannot close a ceremony that does not exist: ${body.closes}` },
+          { status: 404 },
+        );
+      }
+    }
+    if (body.circle_id !== undefined) {
+      if (typeof body.circle_id !== "string" || !body.circle_id) {
+        return NextResponse.json({ error: "circle_id must be a node id" }, { status: 400 });
+      }
+      const circle = await store.getNode(body.circle_id);
+      if (!circle) {
+        return NextResponse.json(
+          { error: `Cannot hold a ceremony in a circle that does not exist: ${body.circle_id}`, hint: "Create the circle node first on /nodes." },
+          { status: 404 },
+        );
+      }
+    }
+
     const ceremony = {
       id: body.id || crypto.randomUUID(),
       type: body.type,
@@ -74,10 +128,16 @@ export async function POST(request: Request) {
       participants: body.participants ?? [],
       medicines_used: body.medicines_used ?? [],
       intentions: body.intentions ?? [],
-      timestamp: new Date().toISOString(),
+      timestamp: typeof body.timestamp === "string" && body.timestamp ? body.timestamp : new Date().toISOString(),
       research_context: body.research_context,
+      ...(Array.isArray(body.relations_honored) ? { relations_honored: body.relations_honored } : {}),
+      ...(episodePath ? { episode_path: episodePath } : {}),
+      ...(episodeNumber !== undefined ? { episode_number: episodeNumber } : {}),
+      ...(typeof body.source === "string" && body.source ? { source: body.source } : {}),
+      ...(typeof body.closes === "string" ? { closes: body.closes } : {}),
+      ...(typeof body.circle_id === "string" ? { circle_id: body.circle_id } : {}),
     };
-    
+
     await store.logCeremony(ceremony);
     return NextResponse.json({ success: true, ceremony, provider: detectProvider() }, { status: 201 });
   } catch (error: unknown) {

package/app/api/diary/[id]/route.ts

@@ -0,0 +1,31 @@
+import { NextResponse } from "next/server";
+import { createProvider, detectProvider } from "@medicine-wheel/storage-provider";
+
+type RouteContext = { params: Promise<{ id: string }> };
+
+export async function GET(_request: Request, context: RouteContext) {
+  const { id } = await context.params;
+  try {
+    const store = await createProvider();
+    const entry = await store.getDiaryEntry(id);
+    if (!entry) return NextResponse.json({ error: `No diary entry with id ${id}` }, { status: 404 });
+    return NextResponse.json({ entry, provider: detectProvider() });
+  } catch (error: unknown) {
+    const message = error instanceof Error ? error.message : String(error);
+    return NextResponse.json({ error: message }, { status: 500 });
+  }
+}
+
+export async function DELETE(_request: Request, context: RouteContext) {
+  const { id } = await context.params;
+  try {
+    const store = await createProvider();
+    const entry = await store.getDiaryEntry(id);
+    if (!entry) return NextResponse.json({ error: `No diary entry with id ${id}` }, { status: 404 });
+    await store.deleteDiaryEntry(id);
+    return NextResponse.json({ success: true, deleted: { id }, provider: detectProvider() });
+  } catch (error: unknown) {
+    const message = error instanceof Error ? error.message : String(error);
+    return NextResponse.json({ error: message }, { status: 500 });
+  }
+}

package/app/api/diary/route.ts

@@ -0,0 +1,130 @@
+import { NextResponse } from "next/server";
+import { parseLimit } from "@/lib/api-paging";
+import { createProvider, detectProvider } from "@medicine-wheel/storage-provider";
+import type { DiaryEntryFilters, DiaryEntryRecord } from "@medicine-wheel/storage-provider";
+import { createDiaryEntry } from "@medicine-wheel/ceremonial-diary";
+
+/**
+ * The ceremonial diary door (0.14.0).
+ *
+ * The storage provider has carried diary records since 0.6 (`registerDiaryEntry`,
+ * `listDiaryEntries`); no route exposed them, so every consumer that wanted a
+ * diary kept its own jsonl beside the wheel. This door reads and writes the
+ * same collection the MCP and the provider share.
+ *
+ * A diary entry is a participant's voice inside a ceremony. It may name the
+ * ceremony it belongs to (`ceremony_id`, carried in metadata) and the chronicle
+ * episode it writes into (`chronicle`, `chronicle:<episode-folder>`); both are
+ * optional — the diary can speak whether or not it writes into an episode.
+ */
+
+const PHASES = ["miigwechiwendam", "nindokendaan", "ningwaab", "nindoodam", "migwech"] as const;
+const ENTRY_TYPES = ["intention", "observation", "hypothesis", "data", "synthesis", "action", "reflection", "learning"] as const;
+
+type Phase = DiaryEntryRecord["phase"];
+type EntryType = DiaryEntryRecord["entryType"];
+
+function ceremonyOf(entry: DiaryEntryRecord): string | undefined {
+  const value = entry.metadata?.ceremony_id;
+  return typeof value === "string" && value ? value : undefined;
+}
+
+export async function GET(request: Request) {
+  try {
+    const { searchParams } = new URL(request.url);
+    const limit = parseLimit(searchParams.get("limit"));
+    if (limit instanceof NextResponse) return limit;
+
+    const participant = searchParams.get("participant") ?? undefined;
+    const phase = searchParams.get("phase") ?? undefined;
+    const entryType = searchParams.get("entryType") ?? searchParams.get("entry_type") ?? undefined;
+    const chronicle = searchParams.get("chronicle") ?? undefined;
+    const ceremonyId = searchParams.get("ceremony_id") ?? undefined;
+    const tags = searchParams.getAll("tag");
+
+    if (phase && !PHASES.includes(phase as Phase)) {
+      return NextResponse.json({ error: `Invalid phase: ${phase}`, hint: PHASES.join(", ") }, { status: 400 });
+    }
+    if (entryType && !ENTRY_TYPES.includes(entryType as EntryType)) {
+      return NextResponse.json({ error: `Invalid entryType: ${entryType}`, hint: ENTRY_TYPES.join(", ") }, { status: 400 });
+    }
+
+    const filters: DiaryEntryFilters = {
+      ...(participant ? { participant } : {}),
+      ...(phase ? { phase: phase as Phase } : {}),
+      ...(entryType ? { entryType: entryType as EntryType } : {}),
+      ...(tags.length ? { tags } : {}),
+    };
+
+    const store = await createProvider();
+    const all = await store.listDiaryEntries(filters);
+    let entries = all;
+    if (chronicle) entries = entries.filter((e) => e.chronicle === chronicle);
+    if (ceremonyId) entries = entries.filter((e) => ceremonyOf(e) === ceremonyId);
+    const matched = entries.length;
+    if (limit !== null && entries.length > limit) entries = entries.slice(0, limit);
+
+    return NextResponse.json({
+      entries,
+      provider: detectProvider(),
+      count: entries.length,
+      total: all.length,
+      ...(chronicle || ceremonyId ? { matched } : {}),
+      truncated: entries.length < matched,
+    });
+  } catch (error: unknown) {
+    const message = error instanceof Error ? error.message : String(error);
+    return NextResponse.json({ error: message }, { status: 500 });
+  }
+}
+
+export async function POST(request: Request) {
+  try {
+    let body: Record<string, unknown>;
+    try {
+      body = (await request.json()) as Record<string, unknown>;
+    } catch {
+      return NextResponse.json({ error: "Body must be JSON" }, { status: 400 });
+    }
+    const { participant, phase, entryType, content } = body;
+    if (typeof participant !== "string" || !participant.trim()) {
+      return NextResponse.json({ error: "participant is required" }, { status: 400 });
+    }
+    if (typeof phase !== "string" || !PHASES.includes(phase as Phase)) {
+      return NextResponse.json({ error: `phase must be one of: ${PHASES.join(", ")}` }, { status: 400 });
+    }
+    if (typeof entryType !== "string" || !ENTRY_TYPES.includes(entryType as EntryType)) {
+      return NextResponse.json({ error: `entryType must be one of: ${ENTRY_TYPES.join(", ")}` }, { status: 400 });
+    }
+    if (typeof content !== "string" || !content.trim()) {
+      return NextResponse.json({ error: "content is required" }, { status: 400 });
+    }
+    const metadata: Record<string, unknown> =
+      body.metadata && typeof body.metadata === "object" ? { ...(body.metadata as Record<string, unknown>) } : {};
+    const store = await createProvider();
+    if (typeof body.ceremony_id === "string" && body.ceremony_id) {
+      if (!(await store.getCeremony(body.ceremony_id))) {
+        return NextResponse.json(
+          { error: `Cannot write into a ceremony that does not exist: ${body.ceremony_id}` },
+          { status: 404 },
+        );
+      }
+      metadata.ceremony_id = body.ceremony_id;
+    }
+    const entry = await createDiaryEntry(store, {
+      ...(typeof body.id === "string" && body.id ? { id: body.id } : {}),
+      ...(typeof body.timestamp === "string" && body.timestamp ? { timestamp: body.timestamp } : {}),
+      participant: participant.trim(),
+      phase: phase as Phase,
+      entryType: entryType as EntryType,
+      content,
+      metadata,
+      ...(typeof body.agent === "string" && body.agent ? { agent: body.agent } : {}),
+      ...(typeof body.chronicle === "string" && body.chronicle ? { chronicle: body.chronicle } : {}),
+    });
+    return NextResponse.json({ success: true, entry, provider: detectProvider() }, { status: 201 });
+  } catch (error: unknown) {
+    const message = error instanceof Error ? error.message : String(error);
+    return NextResponse.json({ error: message }, { status: 500 });
+  }
+}

package/app/api/narrative/beats/[id]/route.ts

@@ -0,0 +1,55 @@
+import { NextResponse } from "next/server";
+import { z } from "zod";
+import { getBeat, witnessBeat } from "@/lib/store";
+
+type RouteContext = { params: Promise<{ id: string }> };
+
+/**
+ * One beat, by id — and the witnessing door.
+ *
+ * In a talking circle a beat is one person's turn. Those who held the circle
+ * while it was spoken are its witnesses (`witnesses[]`, 0.14.0). PATCH adds
+ * witnesses (a set: repeating a name changes nothing) and may name the
+ * `speaker` when the beat was authored without one. Nothing else on a beat is
+ * editable here: what was said is what was said.
+ */
+const BeatPatchSchema = z
+  .object({
+    witnesses: z.array(z.string().trim().min(1)).optional(),
+    speaker: z.string().trim().min(1).optional(),
+  })
+  .strict()
+  .refine((patch) => patch.witnesses !== undefined || patch.speaker !== undefined, {
+    message: "Provide witnesses to add, a speaker, or both.",
+  });
+
+function notFound(id: string) {
+  return NextResponse.json({ error: `No beat with id ${id}` }, { status: 404 });
+}
+
+export async function GET(_request: Request, context: RouteContext) {
+  const { id } = await context.params;
+  const beat = getBeat(id);
+  if (!beat) return notFound(id);
+  return NextResponse.json(beat);
+}
+
+export async function PATCH(request: Request, context: RouteContext) {
+  const { id } = await context.params;
+  let body: unknown;
+  try {
+    body = await request.json();
+  } catch {
+    return NextResponse.json({ error: "Body must be JSON" }, { status: 400 });
+  }
+  const parsed = BeatPatchSchema.safeParse(body);
+  if (!parsed.success) {
+    return NextResponse.json(
+      { error: "Invalid patch", issues: parsed.error.issues },
+      { status: 400 },
+    );
+  }
+  const beat = witnessBeat(id, parsed.data);
+  if (!beat) return notFound(id);
+  return NextResponse.json(beat);
+}

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

@@ -30,6 +30,8 @@ export async function POST(request: Request) {
       parent_beat_id: body.parent_beat_id,
       sub_beats: body.sub_beats,
       origin: body.origin,
+      speaker: body.speaker,
+      witnesses: Array.isArray(body.witnesses) ? body.witnesses : undefined,
     });
     // 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

package/app/nodes/page.tsx

@@ -15,9 +15,9 @@ import { toast } from "sonner";
 // Storage returns description at the top level; legacy nodes carried it in metadata.
 type NodeRecord = RelationalNode & { description?: string };
 
-const NODE_TYPES: NodeType[] = ["human", "land", "spirit", "ancestor", "future", "knowledge"];
+const NODE_TYPES: NodeType[] = ["human", "land", "spirit", "ancestor", "future", "knowledge", "circle"];
 const DIRECTIONS: DirectionName[] = ["east", "south", "west", "north"];
-const NODE_TYPE_ICONS: Record<NodeType, string> = { human: "👤", land: "🌍", spirit: "✨", ancestor: "🪶", future: "🌱", knowledge: "📚" };
+const NODE_TYPE_ICONS: Record<NodeType, string> = { human: "👤", land: "🌍", spirit: "✨", ancestor: "🪶", future: "🌱", knowledge: "📚", circle: "⭕" };
 const DIRECTION_ICONS: Record<DirectionName, string> = { east: "🌅", south: "🌞", west: "🌄", north: "❄️" };
 
 function describeNode(node: NodeRecord): string {

package/lib/ceremony-response.ts

@@ -47,11 +47,22 @@ export function normalizeCeremonyLog(value: unknown): CeremonyLog | null {
     ...(typeof ceremony.research_context === "string"
       ? { research_context: ceremony.research_context }
       : {}),
+    ...(Array.isArray(ceremony.relations_honored)
+      ? { relations_honored: asStringArray(ceremony.relations_honored) }
+      : {}),
+    ...(typeof ceremony.episode_path === "string" ? { episode_path: ceremony.episode_path } : {}),
+    ...(typeof ceremony.episode_number === "number" ? { episode_number: ceremony.episode_number } : {}),
+    ...(typeof ceremony.source === "string" ? { source: ceremony.source } : {}),
+    ...(typeof ceremony.closes === "string" ? { closes: ceremony.closes } : {}),
+    ...(typeof ceremony.circle_id === "string" ? { circle_id: ceremony.circle_id } : {}),
   };
 }
 
 export function ceremonyEpisodePath(value: unknown): string | undefined {
   if (!value || typeof value !== "object") return undefined;
+  // Typed binding first (0.14.0), then the legacy JSON string in research_context.
+  const typed = (value as Record<string, unknown>).episode_path;
+  if (typeof typed === "string" && typed.length > 0) return typed;
   const researchContext = (value as Record<string, unknown>).research_context;
   if (typeof researchContext !== "string") return undefined;
 

package/lib/jsonl-store.ts

@@ -71,6 +71,9 @@ interface StoredBeat {
   parent_beat_id?: string;
   sub_beats?: string[];
   origin?: { producer: string; source_ref?: string; method?: string };
+  /** Talking circle (0.14.0): who spoke, who witnessed. */
+  speaker?: string;
+  witnesses?: string[];
 }
 
 interface StoredCycle {

package/lib/store.ts

@@ -175,6 +175,8 @@ export function createBeat(
     cycle_id: data.cycle_id,
     parent_beat_id: data.parent_beat_id,
     origin: data.origin ?? existing?.origin ?? { producer: 'rest' },
+    ...(data.speaker !== undefined ? { speaker: data.speaker } : {}),
+    ...(data.witnesses !== undefined ? { witnesses: data.witnesses } : {}),
   };
 
   // `strictAct` turns an act that contradicts the direction into an error
@@ -332,3 +334,34 @@ export function seedDemoData() {
 
 // Auto-seed on import
 seedDemoData();
+
+// ── Talking-circle doors on beats (0.14.0) ──
+
+/** One beat by id, normalized like the collection reads. */
+export function getBeat(id: string): NarrativeBeat | undefined {
+  const raw = store.getBeat(id);
+  if (!raw) return undefined;
+  return extractBeats([raw])[0];
+}
+
+/**
+ * Add witnesses to a beat (a set: a name already present is not repeated) and,
+ * when given, name its speaker. Returns the stored beat, or undefined when
+ * there is no such beat. What was said is never rewritten here.
+ */
+export function witnessBeat(
+  id: string,
+  patch: { witnesses?: string[]; speaker?: string },
+): NarrativeBeat | undefined {
+  const raw = store.getBeat(id) as (NarrativeBeat & Record<string, unknown>) | undefined;
+  if (!raw) return undefined;
+  const witnesses = new Set<string>(Array.isArray(raw.witnesses) ? raw.witnesses : []);
+  for (const w of patch.witnesses ?? []) witnesses.add(w);
+  const next = {
+    ...raw,
+    ...(patch.speaker !== undefined ? { speaker: patch.speaker } : {}),
+    ...(witnesses.size > 0 ? { witnesses: [...witnesses] } : {}),
+  };
+  store.createBeat(next as any);
+  return extractBeats([next])[0];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@medicine-wheel/app",
-  "version": "0.13.0",
+  "version": "0.14.0",
   "description": "Medicine Wheel — Interactive visual layer for Indigenous relational research with Four Directions, ceremonies, and narrative arcs",
   "bin": {
     "mw": "dist/cli/mw.js",
@@ -31,6 +31,7 @@
     "src/session-reader",
     "src/ceremony-protocol",
     "src/storage-provider",
+    "src/client",
     "src/data-store",
     "src/data-store-postgres",
     "src/graph-viz",
@@ -47,6 +48,7 @@
     "src/creative-problem-solving",
     "src/community-review",
     "src/consent-lifecycle",
+    "src/community-identity",
     "src/fire-keeper",
     "src/transformation-tracker",
     "src/ceremonial-diary",
@@ -86,29 +88,29 @@
     "release:major": "npm run version:major && npm run publish:all && npm run release:commit"
   },
   "dependencies": {
-    "@medicine-wheel/ceremonial-diary": "^0.13.0",
-    "@medicine-wheel/ceremony-protocol": "^0.13.0",
-    "@medicine-wheel/community-review": "^0.13.0",
-    "@medicine-wheel/consent-lifecycle": "^0.13.0",
-    "@medicine-wheel/creative-orientation": "^0.13.0",
-    "@medicine-wheel/data-store": "^0.13.0",
-    "@medicine-wheel/data-store-postgres": "^0.13.0",
-    "@medicine-wheel/fire-keeper": "^0.13.0",
-    "@medicine-wheel/github-ceremony": "^0.13.0",
-    "@medicine-wheel/graph-viz": "^0.13.0",
-    "@medicine-wheel/importance-unit": "^0.13.0",
-    "@medicine-wheel/mcp": "^4.13.0",
-    "@medicine-wheel/narrative-cluster": "^0.13.0",
-    "@medicine-wheel/narrative-engine": "^0.13.0",
-    "@medicine-wheel/ontology-core": "^0.13.0",
-    "@medicine-wheel/perception-layer": "^0.13.0",
-    "@medicine-wheel/prompt-decomposition": "^0.13.0",
-    "@medicine-wheel/relational-index": "^0.13.0",
-    "@medicine-wheel/relational-query": "^0.13.0",
-    "@medicine-wheel/session-reader": "^0.13.0",
-    "@medicine-wheel/storage-provider": "^0.13.0",
-    "@medicine-wheel/transformation-tracker": "^0.13.0",
-    "@medicine-wheel/ui-components": "^0.13.0",
+    "@medicine-wheel/ceremonial-diary": "^0.14.0",
+    "@medicine-wheel/ceremony-protocol": "^0.14.0",
+    "@medicine-wheel/community-review": "^0.14.0",
+    "@medicine-wheel/consent-lifecycle": "^0.14.0",
+    "@medicine-wheel/creative-orientation": "^0.14.0",
+    "@medicine-wheel/data-store": "^0.14.0",
+    "@medicine-wheel/data-store-postgres": "^0.14.0",
+    "@medicine-wheel/fire-keeper": "^0.14.0",
+    "@medicine-wheel/github-ceremony": "^0.14.0",
+    "@medicine-wheel/graph-viz": "^0.14.0",
+    "@medicine-wheel/importance-unit": "^0.14.0",
+    "@medicine-wheel/mcp": "^4.14.0",
+    "@medicine-wheel/narrative-cluster": "^0.14.0",
+    "@medicine-wheel/narrative-engine": "^0.14.0",
+    "@medicine-wheel/ontology-core": "^0.14.0",
+    "@medicine-wheel/perception-layer": "^0.14.0",
+    "@medicine-wheel/prompt-decomposition": "^0.14.0",
+    "@medicine-wheel/relational-index": "^0.14.0",
+    "@medicine-wheel/relational-query": "^0.14.0",
+    "@medicine-wheel/session-reader": "^0.14.0",
+    "@medicine-wheel/storage-provider": "^0.14.0",
+    "@medicine-wheel/transformation-tracker": "^0.14.0",
+    "@medicine-wheel/ui-components": "^0.14.0",
     "@neondatabase/serverless": "^0.10.0",
     "@xyflow/react": "^12.3.0",
     "clsx": "^2.1.1",