@medicine-wheel/app 0.12.0 → 0.14.0

package/README.md

@@ -30,7 +30,14 @@ storage alongside its composable libraries.
     ├── @medicine-wheel/relational-query     ← Query, traversal & audit
     ├── @medicine-wheel/prompt-decomposition ← Intent extraction & PDE
     ├── @medicine-wheel/ui-components        ← React components
-    ├── @medicine-wheel/data-store           ← Shared data access
+    ├── @medicine-wheel/data-store           ← Shared data access (Redis)
+    ├── @medicine-wheel/data-store-postgres  ← PostgreSQL / Neon provider scaffold
+    ├── @medicine-wheel/storage-provider     ← Canonical persistence contract (JSONL ⇄ Neon)
+    ├── @medicine-wheel/infra                ← Hosts, tenants, services, port bindings as facets
+    ├── @medicine-wheel/perception-layer     ← Witness recordings as typed perceptual events
+    ├── @medicine-wheel/narrative-cluster    ← Events → clusters → beats → Film Edit Brief
+    ├── @medicine-wheel/ceremonial-diary     ← A participant's voice across the Five Phases
+    ├── @medicine-wheel/github-ceremony      ← GitHub webhooks as ceremony beads
     └── @medicine-wheel/session-reader       ← Session event data reader
 
 @medicine-wheel/creative-orientation      ← The question asked before the work
@@ -134,6 +141,41 @@ Session event reader — JSONL parsing, session summaries, analytics extraction,
 
 - **Dependencies:** None (Node.js built-ins only)
 
+### [@medicine-wheel/storage-provider](src/storage-provider)
+The canonical persistence contract. One `StorageProvider` interface with two first-class equals behind it — a JSONL file store for a project's `.mw/store/` and a Neon (Postgres) store — plus typed relational refusals and the capture, inquiry-weave and plan-perspective registries. The app, the MCP server and every package that persists go through this door.
+
+- **Dependencies:** `@medicine-wheel/ontology-core`, `@neondatabase/serverless`, `@upstash/redis`
+
+### [@medicine-wheel/data-store-postgres](src/data-store-postgres)
+Minimal `pg` scaffold — shared pool management and provider-ready storage entrypoints. Explicitly not a competing provider architecture; `storage-provider` owns the contract.
+
+- **Dependencies:** `@medicine-wheel/ontology-core`, `pg`
+
+### [@medicine-wheel/infra](src/infra)
+Typed infrastructure facets — hosts, tenants, services and port bindings — keyed by relational node id, with `detectPortConflicts` over declared ∪ observed state. Types plus one pure function: zero I/O, zero persistence. A running service is registered as a `knowledge` node carrying `metadata.kind: "service"`, never as a new node type.
+
+- **Dependencies:** `@medicine-wheel/ontology-core`, `zod`
+
+### [@medicine-wheel/perception-layer](src/perception-layer)
+Eyes and ears of agent-supported film production — witness a belt-device recording as typed perceptual events and seed a production knowledge graph.
+
+- **Dependencies:** `@medicine-wheel/ontology-core`
+
+### [@medicine-wheel/narrative-cluster](src/narrative-cluster)
+Narrative Cluster Processor — turn witnessed perceptual events or rushes into thematic clusters, direction-aligned narrative beats, and a Film Edit Brief with EDL markers.
+
+- **Dependencies:** `@medicine-wheel/ontology-core`
+
+### [@medicine-wheel/ceremonial-diary](src/ceremonial-diary)
+A participant's voice across the Five-Phase ceremonial methodology — intention, observation and reflection entries with pattern detection, statistics, markdown export, and optional projection into the chronicle wheel.
+
+- **Dependencies:** `@medicine-wheel/ontology-core`, `@medicine-wheel/storage-provider`
+
+### [@medicine-wheel/github-ceremony](src/github-ceremony)
+Witness GitHub webhook events (issues, pull requests, merges, commits) through a ceremonial lens and record them as relational ceremony beads. Pure, framework-free functions over a parsed payload and a storage provider.
+
+- **Dependencies:** `@medicine-wheel/ontology-core`, `@medicine-wheel/storage-provider`
+
 ### [@medicine-wheel/creative-orientation](src/creative-orientation)
 The orientation question, asked before the work: *is there a prior state you are restoring?* Yes — this is a fire, route to gap analysis. No — you are creating, route to structural tension. Reads the claim the caller supplies; advises where phrasing and situation disagree, and never refuses.
 
@@ -173,6 +215,13 @@ RISE framework specifications are in [`rispecs/`](rispecs/). Start with [`medici
 | graph-viz | [graph-viz.spec.md](rispecs/graph-viz.spec.md) |
 | relational-query | [relational-query.spec.md](rispecs/relational-query.spec.md) |
 | prompt-decomposition | [prompt-decomposition.spec.md](rispecs/prompt-decomposition.spec.md) |
+| storage-provider | [storage-provider.spec.md](rispecs/storage-provider.spec.md) |
+| data-store | [data-store.spec.md](rispecs/data-store.spec.md) |
+| data-store-postgres | [data-store-postgres.spec.md](rispecs/data-store-postgres.spec.md) |
+| perception-layer | [perception-layer.spec.md](rispecs/perception-layer.spec.md) |
+| narrative-cluster | [narrative-cluster.spec.md](rispecs/narrative-cluster.spec.md) |
+| session-reader | [session-reader.spec.md](rispecs/session-reader.spec.md) |
+| infra | [infrastructure-topology-ui.spec.md](rispecs/infrastructure-topology-ui.spec.md) |
 | ui-components | [ui-components.spec.md](rispecs/ui-components.spec.md) |
 | data-store | [data-store.spec.md](rispecs/data-store.spec.md) |
 | session-reader | [session-reader.spec.md](rispecs/session-reader.spec.md) |
@@ -224,4 +273,4 @@ available via a local `MW_MCP_PATH`.
 
 ## License
 
-MIT  see [LICENSE](LICENSE)
+Indigenous Knowledge Stewardship License (IKSL) v1.0 MIT Derived   see [LICENSE](LICENSE)

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/ceremonies/page.tsx

@@ -8,6 +8,16 @@ import { extractCeremonyLogs } from "@/lib/ceremony-response";
 import { relativeTime, absoluteTime } from "@/lib/format-time";
 import { toast } from "sonner";
 
+// Static tables — module scope so they are one object for the life of the page,
+// not re-created on every render. `PHASE_FOR_DIRECTION` used to be declared inside
+// the component and read by a `useMemo` that did not list it: correct only by
+// accident of it never changing, and flagged by react-hooks/exhaustive-deps.
+const directions: DirectionName[] = ["east", "south", "west", "north"];
+const cTypes: CeremonyType[] = ["smudging", "talking_circle", "spirit_feeding", "opening", "closing"];
+const DIRECTION_ICONS: Record<DirectionName, string> = { east: "🌅", south: "🌞", west: "🌄", north: "❄️" };
+const PHASE_FOR_DIRECTION: Record<DirectionName, string> = { east: "opening", south: "council", west: "integration", north: "closure" };
+
+
 const dirVar = (d: string) => `var(--mw-${d})`;
 const dirInk = (d: string) => `var(--mw-${d}-ink)`;
 
@@ -64,15 +74,10 @@ function CeremoniesContent() {
     } else { toast.error("Could not save the ceremony — check the form and try again"); }
   }
 
-  const directions: DirectionName[] = ["east", "south", "west", "north"];
-  const cTypes: CeremonyType[] = ["smudging", "talking_circle", "spirit_feeding", "opening", "closing"];
-  const DIRECTION_ICONS: Record<DirectionName, string> = { east: "🌅", south: "🌞", west: "🌄", north: "❄️" };
-
-  const phaseMap: Record<DirectionName, string> = { east: "opening", south: "council", west: "integration", north: "closure" };
   const currentPhase = useMemo(() => {
     if (ceremonies.length === 0) return "opening";
     const latest = [...ceremonies].sort((a, b) => b.timestamp.localeCompare(a.timestamp))[0];
-    return phaseMap[latest.direction] ?? "opening";
+    return PHASE_FOR_DIRECTION[latest.direction] ?? "opening";
   }, [ceremonies]);
 
   const phaseFramings: Record<string, string> = {

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/dist/cli/beats-register.js

@@ -65,7 +65,7 @@ Object.defineProperty(exports, "actForDirection", { enumerable: true, get: funct
 /** Minimal YAML reader for the beats file — avoids a dependency for one shape. */
 function readBeatsFile(file) {
     // js-yaml ships with the app; require lazily so the CLI stays usable without it.
-    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
     const yaml = require('js-yaml');
     const parsed = yaml.load(fs.readFileSync(file, 'utf8'));
     if (!parsed || typeof parsed !== 'object') {

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.12.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",
@@ -62,7 +64,8 @@
     "dev": "next dev -p 8040",
     "build": "next build",
     "start": "next start -p 8040",
-    "lint": "next lint",
+    "lint": "eslint .",
+    "check:deps": "node scripts/check-declared-deps.mjs",
     "test": "vitest run",
     "test:watch": "vitest",
     "version:patch": "node scripts/bump-versions.mjs patch && node scripts/sync-versions.mjs && shx rm -rf node_modules src/*/node_modules package-lock.json && npm install --legacy-peer-deps",
@@ -85,29 +88,29 @@
     "release:major": "npm run version:major && npm run publish:all && npm run release:commit"
   },
   "dependencies": {
-    "@medicine-wheel/ceremonial-diary": "^0.12.0",
-    "@medicine-wheel/ceremony-protocol": "^0.12.0",
-    "@medicine-wheel/community-review": "^0.12.0",
-    "@medicine-wheel/consent-lifecycle": "^0.12.0",
-    "@medicine-wheel/creative-orientation": "^0.12.0",
-    "@medicine-wheel/data-store": "^0.12.0",
-    "@medicine-wheel/data-store-postgres": "^0.12.0",
-    "@medicine-wheel/fire-keeper": "^0.12.0",
-    "@medicine-wheel/github-ceremony": "^0.12.0",
-    "@medicine-wheel/graph-viz": "^0.12.0",
-    "@medicine-wheel/importance-unit": "^0.12.0",
-    "@medicine-wheel/mcp": "^4.12.0",
-    "@medicine-wheel/narrative-cluster": "^0.12.0",
-    "@medicine-wheel/narrative-engine": "^0.12.0",
-    "@medicine-wheel/ontology-core": "^0.12.0",
-    "@medicine-wheel/perception-layer": "^0.12.0",
-    "@medicine-wheel/prompt-decomposition": "^0.12.0",
-    "@medicine-wheel/relational-index": "^0.12.0",
-    "@medicine-wheel/relational-query": "^0.12.0",
-    "@medicine-wheel/session-reader": "^0.12.0",
-    "@medicine-wheel/storage-provider": "^0.12.0",
-    "@medicine-wheel/transformation-tracker": "^0.12.0",
-    "@medicine-wheel/ui-components": "^0.12.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",
@@ -128,6 +131,8 @@
     "@types/node": "^22.0.0",
     "@types/react": "^19.0.0",
     "@types/react-dom": "^19.0.0",
+    "eslint": "^9.39.5",
+    "eslint-config-next": "^15.5.25",
     "shx": "^0.4.0",
     "tailwindcss": "^4.1.0",
     "typescript": "^5.7.0",