@medicine-wheel/app 0.15.8 → 0.16.0

package/app/api/memory/about/route.ts

@@ -0,0 +1,27 @@
+import { NextResponse } from 'next/server';
+import { readLimit, readScope, wheelMemory } from '@/lib/memory';
+
+export const dynamic = 'force-dynamic';
+
+/**
+ * What the memory holds about one person, within a scope.
+ * Body: { person (a wheel node id), scope, question?, limit? }. jgwill/medicine-wheel#149
+ */
+export async function POST(request: Request) {
+  const body = await request.json().catch(() => null);
+  const person = typeof body?.person === 'string' ? body.person.trim() : '';
+  if (!person) return NextResponse.json({ error: 'person is required (a wheel node id)' }, { status: 400 });
+  const read = readScope(body?.scope);
+  if ('error' in read) return NextResponse.json({ error: read.error }, { status: 400 });
+  try {
+    const answer = await wheelMemory().about({
+      person,
+      scope: read.scope,
+      ...(typeof body.question === 'string' && body.question.trim() ? { question: body.question.trim() } : {}),
+      limit: readLimit(body.limit),
+    });
+    return NextResponse.json(answer, { headers: { 'cache-control': 'no-store' } });
+  } catch (error) {
+    return NextResponse.json({ error: error instanceof Error ? error.message : String(error) }, { status: 500 });
+  }
+}

package/app/api/memory/ask/route.ts

@@ -0,0 +1,31 @@
+import { NextResponse } from 'next/server';
+import { readLimit, readScope, wheelMemory } from '@/lib/memory';
+
+export const dynamic = 'force-dynamic';
+
+/**
+ * Ask the wheel's memory a question within a scope.
+ * Body: { question, scope, peer?, reasoning_level?, limit? }.
+ * The answer draws only on the ceremonies the scope reaches, and every source
+ * names the wheel record it rests on. jgwill/medicine-wheel#149
+ */
+export async function POST(request: Request) {
+  const body = await request.json().catch(() => null);
+  const question = typeof body?.question === 'string' ? body.question.trim() : '';
+  if (!question) return NextResponse.json({ error: 'question is required' }, { status: 400 });
+  if (question.length > 10000) return NextResponse.json({ error: 'question holds at most 10000 characters' }, { status: 400 });
+  const read = readScope(body?.scope);
+  if ('error' in read) return NextResponse.json({ error: read.error }, { status: 400 });
+  try {
+    const answer = await wheelMemory().ask({
+      question,
+      scope: read.scope,
+      ...(typeof body.peer === 'string' && body.peer ? { peer: body.peer } : {}),
+      ...(typeof body.reasoning_level === 'string' ? { reasoning_level: body.reasoning_level } : {}),
+      limit: readLimit(body.limit),
+    });
+    return NextResponse.json(answer, { headers: { 'cache-control': 'no-store' } });
+  } catch (error) {
+    return NextResponse.json({ error: error instanceof Error ? error.message : String(error) }, { status: 500 });
+  }
+}

package/app/api/memory/conclusions/[id]/route.ts

@@ -0,0 +1,34 @@
+import { NextResponse } from 'next/server';
+import { MEMORY_PROJECTION_KIND } from '@medicine-wheel/honcho';
+import { createProvider } from '@medicine-wheel/storage-provider';
+
+export const dynamic = 'force-dynamic';
+type RouteContext = { params: Promise<{ id: string }> };
+
+const STATUSES = ['inferred', 'confirmed', 'rejected'];
+
+/**
+ * Confirm or reject a conclusion, recording who did it and when beside the
+ * status: { status, by }. `by` names a person (a wheel node id or a name).
+ * jgwill/medicine-wheel#149 (W8)
+ */
+export async function PATCH(request: Request, context: RouteContext) {
+  const { id } = await context.params;
+  const body = await request.json().catch(() => null);
+  if (!STATUSES.includes(body?.status)) return NextResponse.json({ error: `status must be one of ${STATUSES.join(', ')}` }, { status: 400 });
+  const by = typeof body?.by === 'string' ? body.by.trim() : '';
+  if (!by) return NextResponse.json({ error: 'by is required: who confirms or rejects it' }, { status: 400 });
+  try {
+    const store = await createProvider();
+    const node = await store.getNode(id);
+    if (!node || node.metadata?.kind !== MEMORY_PROJECTION_KIND) {
+      return NextResponse.json({ error: `No conclusion ${id} on this wheel` }, { status: 404 });
+    }
+    const updated = await store.updateNode(id, {
+      metadata: { ...node.metadata, status: body.status, judged_by: by, judged_at: new Date().toISOString() },
+    });
+    return NextResponse.json({ node: updated }, { headers: { 'cache-control': 'no-store' } });
+  } catch (error) {
+    return NextResponse.json({ error: error instanceof Error ? error.message : String(error) }, { status: 500 });
+  }
+}

package/app/api/memory/conclusions/route.ts

@@ -0,0 +1,44 @@
+import { NextResponse } from 'next/server';
+import { honchoIdFor, memoryProjectionNode, type MemoryProjectionKind, type MemoryProjectionStatus } from '@medicine-wheel/honcho';
+import { createProvider } from '@medicine-wheel/storage-provider';
+
+export const dynamic = 'force-dynamic';
+
+const KINDS: MemoryProjectionKind[] = ['pattern', 'summary', 'open_question', 'preference'];
+const STATUSES: MemoryProjectionStatus[] = ['inferred', 'confirmed', 'rejected'];
+
+/**
+ * Return a conclusion the memory derived to the wheel, as a `knowledge` node
+ * with `metadata.kind: "memory_projection"`: the person it is about, what it
+ * rests on, its status. A derived pattern is never stored as a bare fact.
+ * Body: { about (a wheel node id), content, kind, status?, source_event_ids?, derived_by?, provider? }.
+ * jgwill/medicine-wheel#149
+ */
+export async function POST(request: Request) {
+  const body = await request.json().catch(() => null);
+  const about = typeof body?.about === 'string' ? body.about.trim() : '';
+  const content = typeof body?.content === 'string' ? body.content.trim() : '';
+  if (!about) return NextResponse.json({ error: 'about is required (the wheel node id the conclusion is about)' }, { status: 400 });
+  if (!content) return NextResponse.json({ error: 'content is required' }, { status: 400 });
+  if (!KINDS.includes(body.kind)) return NextResponse.json({ error: `kind must be one of ${KINDS.join(', ')}` }, { status: 400 });
+  const status: MemoryProjectionStatus = body.status === undefined ? 'inferred' : body.status;
+  if (!STATUSES.includes(status)) return NextResponse.json({ error: `status must be one of ${STATUSES.join(', ')}` }, { status: 400 });
+  try {
+    const node = memoryProjectionNode({
+      source: typeof body.provider === 'string' && body.provider ? body.provider : 'honcho',
+      peerId: honchoIdFor(about),
+      content,
+      kind: body.kind,
+      status,
+      sourceEventIds: Array.isArray(body.source_event_ids) ? body.source_event_ids.map(String) : [],
+      generatedAt: new Date().toISOString(),
+      ...(typeof body.derived_by === 'string' && body.derived_by ? { derivedBy: body.derived_by } : {}),
+    });
+    node.metadata.about = about;
+    const store = await createProvider();
+    await store.createNode(node as never);
+    return NextResponse.json({ node }, { status: 201, headers: { 'cache-control': 'no-store' } });
+  } catch (error) {
+    return NextResponse.json({ error: error instanceof Error ? error.message : String(error) }, { status: 500 });
+  }
+}

package/app/api/memory/resend/route.ts

@@ -0,0 +1,24 @@
+import { NextResponse } from 'next/server';
+import { holdsRecord, honchoProjectionStatus, isPendingRef, markPending, PENDING_KINDS, retryPending } from '@/lib/honcho-projection';
+
+export const dynamic = 'force-dynamic';
+
+/**
+ * Send one wheel record to the memory provider again: `{ kind, id }` with kind
+ * `beat`, `ceremony` or `diary`. It joins the pending ledger and one delivery
+ * pass runs before the answer. The same door as `/api/honcho/pending`, under a
+ * name that does not depend on the provider. jgwill/medicine-wheel#149
+ */
+export async function POST(request: Request) {
+  const body = await request.json().catch(() => null);
+  if (!isPendingRef(body)) {
+    return NextResponse.json({ error: 'Provide { kind, id }', kinds: PENDING_KINDS }, { status: 400 });
+  }
+  if (!honchoProjectionStatus().enabled) {
+    return NextResponse.json({ error: 'No memory provider is configured on this wheel; nothing to send to' }, { status: 409 });
+  }
+  if (!(await holdsRecord(body))) return NextResponse.json({ error: `The wheel holds no ${body.kind} ${body.id}` }, { status: 404 });
+  markPending({ kind: body.kind, id: body.id }, 'resent by hand');
+  const result = await retryPending();
+  return NextResponse.json({ resent: { kind: body.kind, id: body.id }, ...result }, { headers: { 'cache-control': 'no-store' } });
+}

package/app/api/memory/route.ts

@@ -0,0 +1,15 @@
+import { NextResponse } from 'next/server';
+import { wheelMemory } from '@/lib/memory';
+import { honchoProjectionStatus } from '@/lib/honcho-projection';
+
+export const dynamic = 'force-dynamic';
+
+/**
+ * The wheel's memory: which providers answer, whether each can keep its
+ * reasoning inside a reach, and what the river still owes Honcho.
+ * jgwill/medicine-wheel#149
+ */
+export async function GET() {
+  const { providers } = await wheelMemory().status();
+  return NextResponse.json({ providers, river: honchoProjectionStatus() }, { headers: { 'cache-control': 'no-store' } });
+}

package/app/api/memory/search/route.ts

@@ -0,0 +1,21 @@
+import { NextResponse } from 'next/server';
+import { readLimit, readScope, wheelMemory } from '@/lib/memory';
+
+export const dynamic = 'force-dynamic';
+
+/**
+ * The records within a scope closest to a query, with no reasoning.
+ * Body: { query, scope, limit? }. jgwill/medicine-wheel#149
+ */
+export async function POST(request: Request) {
+  const body = await request.json().catch(() => null);
+  const query = typeof body?.query === 'string' ? body.query.trim() : '';
+  if (!query) return NextResponse.json({ error: 'query is required' }, { status: 400 });
+  const read = readScope(body?.scope);
+  if ('error' in read) return NextResponse.json({ error: read.error }, { status: 400 });
+  try {
+    return NextResponse.json(await wheelMemory().search({ query, scope: read.scope, limit: readLimit(body.limit) }), { headers: { 'cache-control': 'no-store' } });
+  } catch (error) {
+    return NextResponse.json({ error: error instanceof Error ? error.message : String(error) }, { status: 500 });
+  }
+}

package/lib/memory.ts

@@ -0,0 +1,170 @@
+/**
+ * The wheel's memory, on the server: the one place a memory question is asked.
+ *
+ * A caller names a scope; `@medicine-wheel/memory` turns it into the
+ * ceremonies it reaches from this store, and every provider is confined to
+ * that reach. Only this server holds a provider's settings (`HONCHO_URL`,
+ * `HONCHO_WORKSPACE_ID`, `HONCHO_API_KEY`), so an agent needs `MW_API_URL`
+ * and nothing else. With no provider, or with one down, the wheel answers from
+ * its own records. jgwill/medicine-wheel#149
+ */
+
+import {
+  createMemory,
+  type CeremonyRef,
+  type Memory,
+  type MemoryRecord,
+  type MemoryScope,
+  type MemoryWheel,
+  type SeatRef,
+} from '@medicine-wheel/memory';
+import { WHEEL_PEER, createHonchoClient, honchoFromEnv, honchoMemoryProvider } from '@medicine-wheel/honcho';
+import { createProvider } from '@medicine-wheel/storage-provider';
+import { getAllBeats } from '@/lib/store';
+import { ceremonyEpisodePath } from '@/lib/ceremony-response';
+
+const MEMBER_OF = 'member_of';
+
+/** The store, as the memory reads it. Read on every question: a turn spoken a second ago is in reach. */
+export function wheelForMemory(): MemoryWheel {
+  return {
+    async ceremonies(): Promise<CeremonyRef[]> {
+      const store = await createProvider();
+      return (await store.getAllCeremonies(Number.MAX_SAFE_INTEGER)).map((c) => ({
+        id: c.id,
+        subject_id: c.subject_id ?? null,
+        circle_id: c.circle_id ?? null,
+        episode_path: ceremonyEpisodePath(c) ?? null,
+        closes: c.closes ?? null,
+        participants: c.participants ?? [],
+      }));
+    },
+
+    async seats(): Promise<SeatRef[]> {
+      const store = await createProvider();
+      return (await store.getAllEdges(Number.MAX_SAFE_INTEGER))
+        .filter((e) => e.relationship_type === MEMBER_OF)
+        .map((e) => ({ person_id: e.from_id, circle_id: e.to_id }));
+    },
+
+    async records(reach): Promise<MemoryRecord[]> {
+      const ceremonies = new Set(reach.ceremonies);
+      const chronicles = new Set(reach.episodes.flatMap((p) => [`chronicle:${p}`, p]));
+      const store = await createProvider();
+      const out: MemoryRecord[] = [];
+
+      for (const c of await store.getAllCeremonies(Number.MAX_SAFE_INTEGER)) {
+        if (!ceremonies.has(c.id)) continue;
+        out.push({
+          wheel_kind: 'ceremony',
+          wheel_id: c.id,
+          ceremony_id: c.id,
+          speaker: WHEEL_PEER,
+          text: [
+            `Ceremony: ${c.type} (${c.direction})`,
+            c.participants?.length ? `Participants: ${c.participants.join(', ')}` : '',
+            c.intentions?.length ? `Intentions: ${c.intentions.join('; ')}` : '',
+            c.research_context && !c.research_context.trim().startsWith('{') ? `Context: ${c.research_context}` : '',
+          ].filter(Boolean).join('\n'),
+          at: c.timestamp,
+        });
+      }
+
+      for (const b of getAllBeats()) {
+        const ceremony = (b.ceremonies ?? []).find((id) => ceremonies.has(id));
+        if (!ceremony) continue;
+        out.push({
+          wheel_kind: 'beat',
+          wheel_id: b.id,
+          ceremony_id: ceremony,
+          ...(b.speaker ? { speaker: b.speaker } : {}),
+          text: [`[${b.direction}] ${b.title}`, b.description, b.prose && b.prose !== b.description ? b.prose : '', (b.learnings ?? []).join('\n')]
+            .filter(Boolean)
+            .join('\n'),
+          at: b.timestamp,
+        });
+      }
+
+      for (const d of await store.listDiaryEntries({})) {
+        const ceremony = typeof d.metadata?.ceremony_id === 'string' ? d.metadata.ceremony_id : undefined;
+        const inReach = (ceremony && ceremonies.has(ceremony)) || (!ceremony && d.chronicle && chronicles.has(d.chronicle));
+        if (!inReach) continue;
+        out.push({
+          wheel_kind: 'diary',
+          wheel_id: d.id,
+          ...(ceremony ? { ceremony_id: ceremony } : {}),
+          speaker: d.participant,
+          text: `[${d.phase} · ${d.entryType}] ${d.content}`,
+          at: d.timestamp,
+        });
+      }
+      return out;
+    },
+
+    async names(ids) {
+      const store = await createProvider();
+      const out: Record<string, string> = {};
+      await Promise.all(
+        ids.map(async (id) => {
+          if (id === WHEEL_PEER) {
+            out[id] = 'the wheel';
+            return;
+          }
+          const node = await store.getNode(id).catch(() => null);
+          if (node?.name) out[id] = node.name;
+        }),
+      );
+      return out;
+    },
+  };
+}
+
+let current: { key: string; memory: Memory } | null = null;
+
+/** The memory for this process, rebuilt when the provider's settings change. */
+export function wheelMemory(): Memory {
+  const cfg = honchoFromEnv();
+  const key = cfg ? `${cfg.baseUrl}|${cfg.workspace}|${cfg.apiKey ?? ''}` : 'none';
+  if (!current || current.key !== key) {
+    // The dialectic reasons for seconds; a question over many ceremonies can take tens.
+    const providers = cfg ? [honchoMemoryProvider(createHonchoClient({ ...cfg, timeoutMs: 90_000 }))] : [];
+    current = { key, memory: createMemory({ wheel: wheelForMemory(), providers }) };
+  }
+  return current.memory;
+}
+
+const SCOPE_LISTS = ['ceremonies', 'subject_id', 'circle_id', 'episode_path'] as const;
+
+/** A scope from a request body, or the reason it is not one. */
+export function readScope(value: unknown): { scope: MemoryScope } | { error: string } {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    return { error: 'scope must be an object: { ceremonies?, subject_id?, circle_id?, episode_path?, participant?, exclude_ceremonies? }' };
+  }
+  const raw = value as Record<string, unknown>;
+  const scope: MemoryScope = {};
+  for (const key of SCOPE_LISTS) {
+    const v = raw[key];
+    if (v === undefined || v === null) continue;
+    if (typeof v === 'string') scope[key] = v;
+    else if (Array.isArray(v) && v.every((x) => typeof x === 'string')) scope[key] = v as string[];
+    else return { error: `scope.${key} must be a string or a list of strings` };
+  }
+  if (raw.participant !== undefined && raw.participant !== null) {
+    if (typeof raw.participant !== 'string') return { error: 'scope.participant must be a string' };
+    scope.participant = raw.participant;
+  }
+  if (raw.exclude_ceremonies !== undefined && raw.exclude_ceremonies !== null) {
+    if (!Array.isArray(raw.exclude_ceremonies) || !raw.exclude_ceremonies.every((x) => typeof x === 'string')) {
+      return { error: 'scope.exclude_ceremonies must be a list of strings' };
+    }
+    scope.exclude_ceremonies = raw.exclude_ceremonies as string[];
+  }
+  const unknown = Object.keys(raw).filter((k) => ![...SCOPE_LISTS, 'participant', 'exclude_ceremonies'].includes(k));
+  if (unknown.length) return { error: `scope does not know ${unknown.join(', ')}` };
+  return { scope };
+}
+
+/** A positive whole number up to `max`, or undefined. */
+export function readLimit(value: unknown, max = 50): number | undefined {
+  return typeof value === 'number' && Number.isInteger(value) && value > 0 ? Math.min(value, max) : undefined;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@medicine-wheel/app",
-  "version": "0.15.8",
+  "version": "0.16.0",
   "description": "Medicine Wheel — Interactive visual layer for Indigenous relational research with Four Directions, ceremonies, and narrative arcs",
   "bin": {
     "mw": "dist/cli/mw.js",
@@ -32,6 +32,7 @@
     "src/session-reader",
     "src/ceremony-protocol",
     "src/storage-provider",
+    "src/memory",
     "src/client",
     "src/honcho",
     "src/data-store",
@@ -90,30 +91,31 @@
     "release:major": "npm run version:major && npm run publish:all && npm run release:commit"
   },
   "dependencies": {
-    "@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",
+    "@medicine-wheel/ceremonial-diary": "^0.16.0",
+    "@medicine-wheel/ceremony-protocol": "^0.16.0",
+    "@medicine-wheel/community-review": "^0.16.0",
+    "@medicine-wheel/consent-lifecycle": "^0.16.0",
+    "@medicine-wheel/creative-orientation": "^0.16.0",
+    "@medicine-wheel/data-store": "^0.16.0",
+    "@medicine-wheel/data-store-postgres": "^0.16.0",
+    "@medicine-wheel/fire-keeper": "^0.16.0",
+    "@medicine-wheel/github-ceremony": "^0.16.0",
+    "@medicine-wheel/graph-viz": "^0.16.0",
+    "@medicine-wheel/honcho": "^0.16.0",
+    "@medicine-wheel/memory": "^0.16.0",
+    "@medicine-wheel/importance-unit": "^0.16.0",
+    "@medicine-wheel/mcp": "^4.16.0",
+    "@medicine-wheel/narrative-cluster": "^0.16.0",
+    "@medicine-wheel/narrative-engine": "^0.16.0",
+    "@medicine-wheel/ontology-core": "^0.16.0",
+    "@medicine-wheel/perception-layer": "^0.16.0",
+    "@medicine-wheel/prompt-decomposition": "^0.16.0",
+    "@medicine-wheel/relational-index": "^0.16.0",
+    "@medicine-wheel/relational-query": "^0.16.0",
+    "@medicine-wheel/session-reader": "^0.16.0",
+    "@medicine-wheel/storage-provider": "^0.16.0",
+    "@medicine-wheel/transformation-tracker": "^0.16.0",
+    "@medicine-wheel/ui-components": "^0.16.0",
     "@neondatabase/serverless": "^0.10.0",
     "@xyflow/react": "^12.3.0",
     "clsx": "^2.1.1",