@crossworks/content-core 0.232.55 → 0.232.56

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crossworks/content-core",
-  "version": "0.232.55",
+  "version": "0.232.56",
   "description": "Browser-safe content logic — markdown, blocks, pages, tables, formulas — shared by the server and any client. Zero server deps by design: nothing here may reach @mantle/db, node-only APIs, or the network (the jackdaw-repo-split P0 boundary).",
   "exports": {
     "./markdown": "./src/markdown-to-doc.ts",

package/src/journal-options.test.ts

@@ -1,5 +1,13 @@
 import { describe, expect, it } from 'vitest';
-import { categoryLabel, moodDisplay, normalizeEntryDate } from './journal-options';
+import {
+  AGENT_KIND_KEYS,
+  KIND_KEYS,
+  USER_KIND_KEYS,
+  kindLabel,
+  kindLane,
+  legacyCategoryToKind,
+  normalizeEntryDate,
+} from './journal-options';
 
 describe('normalizeEntryDate', () => {
   it('passes through a full ISO timestamp (canonicalised)', () => {
@@ -32,26 +40,49 @@ describe('normalizeEntryDate', () => {
   });
 });
 
-describe('moodDisplay', () => {
-  it('maps a known mood key to emoji + label', () => {
-    expect(moodDisplay('grateful')).toEqual({ emoji: '🙏', label: 'Grateful' });
+describe('kind vocabulary', () => {
+  it('splits cleanly into the two lanes', () => {
+    expect(USER_KIND_KEYS).toEqual(['identity', 'context', 'preference', 'goal']);
+    expect(AGENT_KIND_KEYS).toEqual(['lesson', 'expectation', 'gap']);
+    expect(KIND_KEYS).toEqual([...USER_KIND_KEYS, ...AGENT_KIND_KEYS]);
   });
-  it('tolerates an unknown/free-text mood (no emoji, raw label)', () => {
-    expect(moodDisplay('zonked')).toEqual({ emoji: '', label: 'zonked' });
+});
+
+describe('kindLabel', () => {
+  it('maps a known kind key to its label', () => {
+    expect(kindLabel('expectation')).toBe('Expectation');
+    expect(kindLabel('gap')).toBe('Open question');
+  });
+  it('title-cases an unknown/free-text kind', () => {
+    expect(kindLabel('hobbies')).toBe('Hobbies');
   });
-  it('returns null for no mood', () => {
-    expect(moodDisplay(null)).toBeNull();
+  it('returns null for no kind', () => {
+    expect(kindLabel(null)).toBeNull();
   });
 });
 
-describe('categoryLabel', () => {
-  it('maps a known category key to its label', () => {
-    expect(categoryLabel('faith')).toBe('Faith');
+describe('kindLane', () => {
+  it('routes agent kinds to the agent lane', () => {
+    expect(kindLane('lesson')).toBe('agent');
+    expect(kindLane('expectation')).toBe('agent');
+    expect(kindLane('gap')).toBe('agent');
   });
-  it('title-cases an unknown/free-text category', () => {
-    expect(categoryLabel('hobbies')).toBe('Hobbies');
+  it('routes user kinds — and anything unknown — to the user lane', () => {
+    expect(kindLane('identity')).toBe('user');
+    expect(kindLane('made-up')).toBe('user');
+    expect(kindLane(null)).toBe('user');
+  });
+});
+
+describe('legacyCategoryToKind', () => {
+  it('carries identity and goal over', () => {
+    expect(legacyCategoryToKind('identity')).toBe('identity');
+    expect(legacyCategoryToKind('goal')).toBe('goal');
   });
-  it('returns null for no category', () => {
-    expect(categoryLabel(null)).toBeNull();
+  it('maps every other legacy life area (and none) to context', () => {
+    expect(legacyCategoryToKind('work')).toBe('context');
+    expect(legacyCategoryToKind('faith')).toBe('context');
+    expect(legacyCategoryToKind('emotion')).toBe('context');
+    expect(legacyCategoryToKind(null)).toBe('context');
   });
 });

package/src/journal-options.ts

@@ -1,65 +1,79 @@
 /**
- * Browser-safe leaf for Journal option lists (moods + categories).
+ * Browser-safe leaf for Journal option lists (kinds + gap statuses).
  *
  * These constants are needed both server-side (CRUD, extractor framing, the
- * identity-context distiller) and client-side (the /journal editor + filters).
- * They live in their own module — with NO `@mantle/db` import — so a client
- * component can pull them in without dragging `postgres` into the browser
- * bundle. Same pattern as `contacts-format.ts`. `journal.ts` re-exports these.
+ * identity/working-notes distillers) and client-side (the /journal editor +
+ * filters). They live in their own module — with NO `@mantle/db` import — so a
+ * client component can pull them in without dragging `postgres` into the
+ * browser bundle. Same pattern as `contacts-format.ts`. `journal.ts`
+ * re-exports these.
+ *
+ * Journal v2 (2026-08): the mood palette and life-area categories are GONE.
+ * A journal entry is now one of a small set of KINDS across two lanes:
+ *   - user lane:  durable self-knowledge that grounds every agent turn
+ *   - agent lane: what an agent has learned about doing its job well
+ * Legacy rows keep their old `mood`/`category` jsonb values; nothing reads
+ * `mood` anymore, and `category` maps to a kind at read time (see
+ * `legacyCategoryToKind`). No migration, no backfill.
  */
 
-/** Curated mood palette (emoji + label). Stored as the bare key string in
- *  `data.mood`; the UI maps key → emoji + label. Free text is tolerated on
- *  read, but the picker offers these. */
-export const MOODS = [
-  { key: 'happy', label: 'Happy', emoji: '😀' },
-  { key: 'grateful', label: 'Grateful', emoji: '🙏' },
-  { key: 'calm', label: 'Calm', emoji: '😌' },
-  { key: 'excited', label: 'Excited', emoji: '🤩' },
-  { key: 'hopeful', label: 'Hopeful', emoji: '🌱' },
-  { key: 'reflective', label: 'Reflective', emoji: '🤔' },
-  { key: 'tired', label: 'Tired', emoji: '😮‍💨' },
-  { key: 'anxious', label: 'Anxious', emoji: '😟' },
-  { key: 'sad', label: 'Sad', emoji: '😔' },
-  { key: 'angry', label: 'Angry', emoji: '😠' },
-] as const;
-
-export type MoodKey = (typeof MOODS)[number]['key'];
-export const MOOD_KEYS: readonly string[] = MOODS.map((m) => m.key);
+/** The lane a kind belongs to. User-lane entries feed the "# About the user"
+ *  block; agent-lane entries feed the per-turn "# Working notes" block. */
+export type JournalLane = 'user' | 'agent';
 
-/** Life areas the entry speaks to. Drives the identity block's grouping
- *  ("## Work", "## Faith", …) and the list filter. */
-export const CATEGORIES = [
-  { key: 'identity', label: 'Identity' },
-  { key: 'work', label: 'Work' },
-  { key: 'family', label: 'Family' },
-  { key: 'relationships', label: 'Relationships' },
-  { key: 'faith', label: 'Faith' },
-  { key: 'health', label: 'Health' },
-  { key: 'emotion', label: 'Emotion' },
-  { key: 'goal', label: 'Goal' },
-  { key: 'reflection', label: 'Reflection' },
+/** The full kind vocabulary. Stored as the bare key string in `data.kind`;
+ *  free text is tolerated on read, but pickers/tools offer these. */
+export const KINDS = [
+  // ── user lane: who the user/org is and what they want ──────────────────
+  { key: 'identity', lane: 'user', label: 'Identity' },
+  { key: 'context', lane: 'user', label: 'Context' },
+  { key: 'preference', lane: 'user', label: 'Preference' },
+  { key: 'goal', lane: 'user', label: 'Goal' },
+  // ── agent lane: what an agent has learned about doing its job ──────────
+  { key: 'lesson', lane: 'agent', label: 'Lesson' },
+  { key: 'expectation', lane: 'agent', label: 'Expectation' },
+  { key: 'gap', lane: 'agent', label: 'Open question' },
 ] as const;
 
-export type CategoryKey = (typeof CATEGORIES)[number]['key'];
-export const CATEGORY_KEYS: readonly string[] = CATEGORIES.map((c) => c.key);
+export type KindKey = (typeof KINDS)[number]['key'];
+export const KIND_KEYS: readonly string[] = KINDS.map((k) => k.key);
+export const USER_KIND_KEYS: readonly string[] = KINDS.filter((k) => k.lane === 'user').map(
+  (k) => k.key,
+);
+export const AGENT_KIND_KEYS: readonly string[] = KINDS.filter((k) => k.lane === 'agent').map(
+  (k) => k.key,
+);
 
-/** Mood key → display (emoji + label), tolerant of free-text/unknown values. */
-export function moodDisplay(key: string | null): { emoji: string; label: string } | null {
-  if (!key) return null;
-  const found = MOODS.find((m) => m.key === key);
-  if (found) return { emoji: found.emoji, label: found.label };
-  return { emoji: '', label: key };
-}
+/** Gap-entry lifecycle. Only entries with kind='gap' carry a status. */
+export const GAP_STATUSES = ['open', 'resolved'] as const;
+export type GapStatus = (typeof GAP_STATUSES)[number];
 
-/** Category key → human label, tolerant of free-text/unknown values. */
-export function categoryLabel(key: string | null): string | null {
+/** Kind key → human label, tolerant of free-text/unknown values. */
+export function kindLabel(key: string | null): string | null {
   if (!key) return null;
-  const found = CATEGORIES.find((c) => c.key === key);
+  const found = KINDS.find((k) => k.key === key);
   if (found) return found.label;
   return key.charAt(0).toUpperCase() + key.slice(1);
 }
 
+/** Which lane a kind belongs to. Unknown/free-text kinds read as user lane —
+ *  the safe default (they render as user self-knowledge, never as agent
+ *  working notes). */
+export function kindLane(key: string | null): JournalLane {
+  const found = KINDS.find((k) => k.key === key);
+  return found?.lane ?? 'user';
+}
+
+/** Map a legacy pre-v2 `category` value to a kind, for rows written before
+ *  the kind vocabulary existed. `identity`/`goal` carry over; every other
+ *  life area (work, family, faith, health, emotion, …) reads as `context`.
+ *  Only consulted when a row has no `kind`. */
+export function legacyCategoryToKind(category: string | null): KindKey {
+  if (category === 'identity') return 'identity';
+  if (category === 'goal') return 'goal';
+  return 'context';
+}
+
 /**
  * Normalise a user/agent-supplied entry date to a canonical ISO-8601 string,
  * or return null if it isn't a real date. Stored `entry_date` is later cast to