coaia-visualizer 1.6.1 → 1.6.2

package/README.md

@@ -17,6 +17,7 @@ This tool allows users to upload their `coaia-narrative` memory files and gain c
 *   **Dynamic Structural Tension Display:** Clearly distinguishes and presents the core Desired Outcome and Current Reality observations, making the generative force of structural tension visible.
 *   **Action Step Tracking:** View all Action Steps for a selected chart, complete with their descriptions, completion status, and due dates, facilitating a clear understanding of strategic advancement.
 *   **Narrative Beat Integration:** Displays associated Narrative Beats, offering multi-universe perspectives (Engineer-World, Ceremony-World, Story-Engine-World) to enrich the context of your creative efforts.
+*   **Rich JSONL Metadata Projection:** Separates chart, action-step, and narrative-beat records; exposes nested `metadata.github`, RISE/spec fields, unknown extension metadata, and preservation warnings aligned with [`avadisabelle/coaia-narrative#35`](https://github.com/avadisabelle/coaia-narrative/issues/35).
 *   **Inter-Chart Relation Graph:** Visualizes the relationships between charts and entities, illustrating how different creative projects and their components are interconnected.
 *   **Data Statistics Overview:** Provides summary statistics of the loaded data, including total charts, entities, and relations, for quick comprehension of your creative landscape.
 
@@ -113,4 +114,3 @@ Continue building your app on:
 ## Alternative
 * You can run it locally
 
-

package/STC.md

@@ -16,3 +16,9 @@
 - **Event**: issues.opened
 - **Issue**: #19
 
+
+## Activity Log Entry (2026-05-19T06:53:31Z)
+- **Bot**: @stcissue
+- **Event**: issues.opened
+- **Issue**: #20
+

package/STCISSUE.md

@@ -34,3 +34,15 @@ Issue being tracked via @stcissue bot.
 ### Current Reality
 Issue being tracked via @stcissue bot.
 
+
+## Issue #20 - Render rich COAIA JSONL metadata with chart/action/beat projections
+
+- **Repository**: jgwill/coaia-visualizer
+- **State**: open
+- **Category**: technical
+- **Logged**: 2026-05-19T06:53:31Z
+- **GitHub Link**: https://github.com/jgwill/coaia-visualizer/issues/20
+
+### Current Reality
+Issue being tracked via @stcissue bot.
+

package/app/page.tsx

@@ -8,6 +8,7 @@ import { DataStats } from "@/components/data-stats"
 import { CreateChartForm } from "@/components/create-chart-form"
 import type { ParsedData, Chart } from "@/lib/types"
 import { parseJSONL, organizeData } from "@/lib/jsonl-parser"
+import { serializeParsedData } from "@/lib/jsonl-preservation"
 import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs"
 import { Download, Upload, RefreshCw, Save, Edit3, Plus } from "lucide-react"
 import { Button } from "@/components/ui/button"
@@ -120,20 +121,10 @@ export default function Page() {
 
     setIsLoading(true)
     try {
-      const jsonlLines: string[] = []
-
-      for (const entity of data.entities.values()) {
-        jsonlLines.push(JSON.stringify(entity))
-      }
-
-      for (const relation of data.relations) {
-        jsonlLines.push(JSON.stringify(relation))
-      }
-
       const response = await fetch("/api/jsonl", {
         method: "POST",
         headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ content: jsonlLines.join("\n") + "\n" }),
+        body: JSON.stringify({ content: serializeParsedData(data) }),
       })
 
       if (response.ok) {
@@ -160,17 +151,7 @@ export default function Page() {
   const handleExportData = () => {
     if (!data) return
 
-    const jsonlLines: string[] = []
-
-    for (const entity of data.entities.values()) {
-      jsonlLines.push(JSON.stringify(entity))
-    }
-
-    for (const relation of data.relations) {
-      jsonlLines.push(JSON.stringify(relation))
-    }
-
-    const blob = new Blob([jsonlLines.join("\n") + "\n"], { type: "application/jsonl" })
+    const blob = new Blob([serializeParsedData(data)], { type: "application/jsonl" })
     const url = URL.createObjectURL(blob)
     const a = document.createElement("a")
     a.href = url
@@ -206,7 +187,7 @@ export default function Page() {
       const previousChartId = newStack.pop()!.id
       setChartNavigationStack(newStack)
       // Find the refreshed parent chart from current data (with populated subCharts)
-      const refreshedParent = data.charts.find((c) => c.id === previousChartId)
+      const refreshedParent = data?.charts.find((c) => c.id === previousChartId)
       if (refreshedParent) {
         setSelectedChart(refreshedParent)
       }

package/components/chart-detail-editable.tsx

@@ -9,6 +9,7 @@ import { Separator } from "@/components/ui/separator"
 import type { ParsedData, Chart } from "@/lib/types"
 import { Target, MapPin, ListChecks, Network, BookOpen, TrendingUp, ArrowLeft } from "lucide-react"
 import { NarrativeBeats } from "@/components/narrative-beats"
+import { MetadataProjections } from "@/components/metadata-projections"
 import { RelationGraph } from "@/components/relation-graph"
 import { EditDesiredOutcome } from "./edit-desired-outcome"
 import { EditCurrentReality } from "./edit-current-reality"
@@ -218,6 +219,8 @@ export function ChartDetailEditable({
         </div>
       )}
 
+      <MetadataProjections chart={chart} data={data} />
+
       {/* Sub-charts */}
       {chart.subCharts.length > 0 && (
         <Card>

package/components/metadata-projections.tsx

@@ -0,0 +1,208 @@
+"use client"
+
+import { AlertTriangle, Blocks, FileJson, Github, ListChecks, Sparkles, Target } from "lucide-react"
+import { Badge } from "@/components/ui/badge"
+import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card"
+import type { Chart, EntityRecord, ParsedData } from "@/lib/types"
+
+interface MetadataProjectionsProps {
+  chart: Chart
+  data: ParsedData
+}
+
+const KNOWN_METADATA_KEYS = new Set([
+  "dueDate",
+  "chartId",
+  "phase",
+  "completionStatus",
+  "completedAt",
+  "parentChart",
+  "parentActionStep",
+  "level",
+  "createdAt",
+  "updatedAt",
+  "act",
+  "type_dramatic",
+  "universes",
+  "timestamp",
+  "elementsOfPerformance",
+  "mmotEvaluations",
+  "relationalAlignment",
+  "fourDirections",
+  "narrative",
+  "isTelescopedChart",
+  "telescopedChartId",
+  "github",
+])
+
+function JsonBlock({ value }: { value: unknown }) {
+  return (
+    <pre className="max-h-64 overflow-auto rounded-md border bg-muted/40 p-3 text-xs leading-relaxed">
+      {JSON.stringify(value, null, 2)}
+    </pre>
+  )
+}
+
+function ProjectionRecord({ entity, label }: { entity?: EntityRecord; label: string }) {
+  if (!entity) return null
+
+  const metadata = entity.metadata || {}
+  const unknownKeys = Object.keys(metadata).filter((key) => !KNOWN_METADATA_KEYS.has(key))
+
+  return (
+    <div className="rounded-md border p-3">
+      <div className="flex flex-wrap items-center gap-2">
+        <Badge variant="outline">{label}</Badge>
+        <span className="font-mono text-xs text-muted-foreground">{entity.name}</span>
+        {metadata.github && (
+          <Badge variant="secondary" className="gap-1">
+            <Github className="h-3 w-3" />
+            GitHub
+          </Badge>
+        )}
+        {unknownKeys.length > 0 && <Badge variant="secondary">{unknownKeys.length} extensions</Badge>}
+      </div>
+
+      {metadata.github && (
+        <div className="mt-3">
+          <div className="mb-1 flex items-center gap-2 text-sm font-medium">
+            <Github className="h-4 w-4" />
+            GitHub Provenance
+          </div>
+          <JsonBlock value={metadata.github} />
+        </div>
+      )}
+
+      <details className="mt-3">
+        <summary className="cursor-pointer text-sm font-medium">Full Metadata</summary>
+        <div className="mt-2">
+          <JsonBlock value={metadata} />
+        </div>
+      </details>
+    </div>
+  )
+}
+
+export function MetadataProjections({ chart, data }: MetadataProjectionsProps) {
+  const riseSpec = (data.riseSpecs || []).find((spec) => spec.chartId === chart.id)
+  const chartRecordNames = new Set(
+    [
+      chart.chartEntity.name,
+      chart.desiredOutcome?.name,
+      chart.currentReality?.name,
+      ...chart.actions.map((action) => action.name),
+      ...chart.narrativeBeats.map((beat) => beat.name),
+    ].filter(Boolean),
+  )
+  const warnings = (data.preservationWarnings || []).filter(
+    (warning) => !warning.recordName || chartRecordNames.has(warning.recordName),
+  )
+
+  return (
+    <div className="space-y-6">
+      {warnings.length > 0 && (
+        <Card className="border-amber-500/40">
+          <CardHeader>
+            <CardTitle className="flex items-center gap-2 text-base">
+              <AlertTriangle className="h-5 w-5 text-amber-600" />
+              Preservation Warnings
+            </CardTitle>
+          </CardHeader>
+          <CardContent className="space-y-2">
+            {warnings.map((warning, index) => (
+              <div key={`${warning.recordName}-${index}`} className="rounded-md border border-amber-500/30 bg-amber-500/5 p-3 text-sm">
+                <div className="font-medium">{warning.recordName || warning.recordType || "JSONL record"}</div>
+                <div className="text-muted-foreground">{warning.message}</div>
+                {warning.upstreamIssue && (
+                  <a className="text-xs underline" href={warning.upstreamIssue} target="_blank" rel="noreferrer">
+                    avadisabelle/coaia-narrative#35
+                  </a>
+                )}
+              </div>
+            ))}
+          </CardContent>
+        </Card>
+      )}
+
+      <Card>
+        <CardHeader>
+          <CardTitle className="flex items-center gap-2 text-base">
+            <Blocks className="h-5 w-5" />
+            RISE Projection
+          </CardTitle>
+        </CardHeader>
+        <CardContent className="grid gap-4 md:grid-cols-2">
+          <div>
+            <div className="mb-1 flex items-center gap-2 text-sm font-medium">
+              <Target className="h-4 w-4" />
+              Desired Outcome
+            </div>
+            <p className="text-sm text-muted-foreground">{riseSpec?.desiredOutcome || "No desired outcome"}</p>
+          </div>
+          <div>
+            <div className="mb-1 text-sm font-medium">Current Reality</div>
+            <ul className="space-y-1 text-sm text-muted-foreground">
+              {(riseSpec?.currentReality.length ? riseSpec.currentReality : ["No current reality"]).map((item, index) => (
+                <li key={index}>{item}</li>
+              ))}
+            </ul>
+          </div>
+          <div>
+            <div className="mb-1 text-sm font-medium">Natural Progression</div>
+            <ul className="space-y-1 text-sm text-muted-foreground">
+              {(riseSpec?.naturalProgression.length ? riseSpec.naturalProgression : ["No projected progression"]).map((item, index) => (
+                <li key={index}>{item}</li>
+              ))}
+            </ul>
+          </div>
+          <div>
+            <div className="mb-1 text-sm font-medium">Remaining Blockers</div>
+            <ul className="space-y-1 text-sm text-muted-foreground">
+              {(riseSpec?.remainingBlockers.length ? riseSpec.remainingBlockers : ["No blockers recorded"]).map((item, index) => (
+                <li key={index}>{item}</li>
+              ))}
+            </ul>
+          </div>
+          <div className="md:col-span-2">
+            <div className="mb-1 text-sm font-medium">Next Chart Operations</div>
+            <ul className="space-y-1 text-sm text-muted-foreground">
+              {(riseSpec?.nextOperations.length ? riseSpec.nextOperations : ["No next operations recorded"]).map((item, index) => (
+                <li key={index}>{item}</li>
+              ))}
+            </ul>
+          </div>
+        </CardContent>
+      </Card>
+
+      <Card>
+        <CardHeader>
+          <CardTitle className="flex items-center gap-2 text-base">
+            <FileJson className="h-5 w-5" />
+            Rich Metadata Projection
+          </CardTitle>
+        </CardHeader>
+        <CardContent className="space-y-3">
+          <ProjectionRecord label="Chart" entity={chart.chartEntity} />
+          <ProjectionRecord label="Desired Outcome" entity={chart.desiredOutcome} />
+          <ProjectionRecord label="Current Reality" entity={chart.currentReality} />
+          {chart.actions.map((action) => (
+            <ProjectionRecord key={action.name} label="Action Step" entity={action} />
+          ))}
+          {chart.narrativeBeats.map((beat) => (
+            <ProjectionRecord key={beat.name} label="Narrative Beat" entity={beat} />
+          ))}
+          <div className="flex flex-wrap gap-2 pt-1 text-sm text-muted-foreground">
+            <Badge variant="outline" className="gap-1">
+              <ListChecks className="h-3 w-3" />
+              {data.projections?.actionStepRecords.length || 0} actions
+            </Badge>
+            <Badge variant="outline" className="gap-1">
+              <Sparkles className="h-3 w-3" />
+              {data.projections?.narrativeBeatRecords.length || 0} beats
+            </Badge>
+          </div>
+        </CardContent>
+      </Card>
+    </div>
+  )
+}

package/lib/chart-editor.ts

@@ -1,6 +1,8 @@
 // lib/chart-editor.ts - Chart editing logic
 
 import type { EntityRecord, RelationRecord, ParsedData } from "./types"
+import { buildMetadataWarnings, buildRecordProjections, serializeParsedData } from "./jsonl-preservation"
+import { buildRiseSpecs } from "./jsonl-parser"
 
 export interface ChartUpdate {
   type:
@@ -20,11 +22,13 @@ export interface ChartUpdate {
 export class ChartEditor {
   private entities: Map<string, EntityRecord>
   private relations: RelationRecord[]
+  private rawRecords: NonNullable<ParsedData["rawRecords"]>
 
   constructor(parsedData: ParsedData) {
     // Clone data to avoid mutations
     this.entities = new Map(parsedData.entities)
     this.relations = [...parsedData.relations]
+    this.rawRecords = [...(parsedData.rawRecords || [])]
   }
 
   private resolveStructuralChart(chartRef: string): { entityName: string; chartId: string; entity: EntityRecord } | null {
@@ -520,19 +524,11 @@ export class ChartEditor {
   }
 
   exportToJSONL(): string {
-    const lines: string[] = []
-
-    // Export entities
-    for (const entity of this.entities.values()) {
-      lines.push(JSON.stringify(entity))
-    }
-
-    // Export relations
-    for (const relation of this.relations) {
-      lines.push(JSON.stringify(relation))
-    }
-
-    return lines.join("\n") + "\n"
+    return serializeParsedData({
+      entities: this.entities,
+      relations: this.relations,
+      rawRecords: this.rawRecords,
+    })
   }
 
   getUpdatedData(): ParsedData {
@@ -615,6 +611,10 @@ export class ChartEditor {
       relations: this.relations,
       charts: chartsArray,
       rootCharts: rootCharts,
+      rawRecords: this.rawRecords,
+      projections: buildRecordProjections(this.entities),
+      preservationWarnings: buildMetadataWarnings(this.rawRecords),
+      riseSpecs: buildRiseSpecs(chartsArray),
     }
   }
 }

package/lib/jsonl-parser.ts

@@ -1,8 +1,9 @@
-import type { EntityRecord, RelationRecord, JSONLRecord, Chart, ParsedData } from "./types"
+import type { Chart, EntityRecord, JSONLRecord, ParsedData, RawJSONLRecord, RelationRecord, RiseSpecProjection } from "./types"
+import { buildMetadataWarnings, buildRecordProjections, normalizeJsonlRecord } from "./jsonl-preservation"
 
-export function parseJSONL(content: string): JSONLRecord[] {
+export function parseJSONL(content: string): RawJSONLRecord[] {
   const lines = content.trim().split("\n")
-  const records: JSONLRecord[] = []
+  const records: RawJSONLRecord[] = []
 
   for (const line of lines) {
     if (!line.trim()) continue
@@ -17,7 +18,44 @@ export function parseJSONL(content: string): JSONLRecord[] {
   return records
 }
 
-export function organizeData(records: JSONLRecord[]): ParsedData {
+function firstObservation(entity?: EntityRecord): string {
+  return entity?.observations?.[0] || ""
+}
+
+function asStringList(value: unknown): string[] {
+  if (Array.isArray(value)) {
+    return value.map((item) => typeof item === "string" ? item : JSON.stringify(item))
+  }
+  if (typeof value === "string" && value.trim()) {
+    return [value]
+  }
+  return []
+}
+
+export function buildRiseSpecs(charts: Chart[]): RiseSpecProjection[] {
+  return charts.map((chart) => {
+    const metadata = chart.chartEntity.metadata || {}
+    const rise = metadata.rise || metadata.riseSpec || metadata.spec || {}
+    const incompleteActions = chart.actions.filter((action) => action.metadata?.completionStatus !== true)
+
+    return {
+      chartId: chart.id,
+      desiredOutcome: firstObservation(chart.desiredOutcome),
+      currentReality: chart.currentReality?.observations || [],
+      naturalProgression: [
+        ...asStringList(rise.naturalProgression || metadata.naturalProgression),
+        ...incompleteActions.slice(0, 3).map((action) => action.observations?.[0]).filter(Boolean),
+      ],
+      remainingBlockers: asStringList(rise.remainingBlockers || rise.blockers || metadata.remainingBlockers || metadata.blockers),
+      nextOperations: [
+        ...asStringList(rise.nextOperations || metadata.nextOperations),
+        ...incompleteActions.slice(0, 5).map((action) => action.observations?.[0]).filter(Boolean),
+      ],
+    }
+  })
+}
+
+export function organizeData(records: RawJSONLRecord[]): ParsedData {
   const entities = new Map<string, EntityRecord>()
   const relations: RelationRecord[] = []
   const charts = new Map<string, Chart>()
@@ -26,10 +64,15 @@ export function organizeData(records: JSONLRecord[]): ParsedData {
 
   // First pass: separate entities and relations
   for (const record of records) {
-    if (record.type === "entity") {
-      entities.set(record.name, record)
-    } else if (record.type === "relation") {
-      relations.push(record)
+    const normalized = normalizeJsonlRecord(record)
+    if (!normalized) {
+      continue
+    }
+
+    if (normalized.type === "entity") {
+      entities.set(normalized.name, normalized)
+    } else if (normalized.type === "relation") {
+      relations.push(normalized)
     }
   }
 
@@ -163,6 +206,10 @@ export function organizeData(records: JSONLRecord[]): ParsedData {
     entities,
     relations,
     rootCharts,
+    rawRecords: records,
+    projections: buildRecordProjections(entities),
+    preservationWarnings: buildMetadataWarnings(records),
+    riseSpecs: buildRiseSpecs(Array.from(charts.values())),
   }
 }
 

package/lib/jsonl-preservation.ts

@@ -0,0 +1,405 @@
+import type {
+  EntityRecord,
+  MetadataWarning,
+  ParsedData,
+  RawJSONLRecord,
+  RecordProjections,
+  RelationRecord,
+} from "./types"
+
+const UPSTREAM_ISSUE = "https://github.com/avadisabelle/coaia-narrative/issues/35"
+
+const ENTITY_TOP_LEVEL_KEYS = new Set(["type", "name", "entityType", "observations", "metadata"])
+const RELATION_TOP_LEVEL_KEYS = new Set(["type", "from", "to", "relationType", "metadata"])
+const NARRATIVE_BEAT_TOP_LEVEL_KEYS = new Set([
+  ...ENTITY_TOP_LEVEL_KEYS,
+  "narrative",
+  "relational_alignment",
+  "four_directions",
+])
+const MUTABLE_METADATA_KEYS = new Set([
+  "dueDate",
+  "chartId",
+  "phase",
+  "completionStatus",
+  "completedAt",
+  "parentChart",
+  "parentActionStep",
+  "level",
+  "createdAt",
+  "updatedAt",
+  "act",
+  "type_dramatic",
+  "universes",
+  "timestamp",
+  "elementsOfPerformance",
+  "mmotEvaluations",
+  "relationalAlignment",
+  "fourDirections",
+  "narrative",
+  "isTelescopedChart",
+  "telescopedChartId",
+])
+
+function isObject(value: unknown): value is Record<string, any> {
+  return typeof value === "object" && value !== null && !Array.isArray(value)
+}
+
+function cloneJson<T>(value: T): T {
+  return value === undefined ? value : JSON.parse(JSON.stringify(value))
+}
+
+function deepEqual(left: unknown, right: unknown): boolean {
+  return JSON.stringify(left) === JSON.stringify(right)
+}
+
+function removeUndefined<T extends Record<string, any>>(record: T): T {
+  for (const key of Object.keys(record)) {
+    if (record[key] === undefined) {
+      delete record[key]
+    }
+  }
+  return record
+}
+
+function relationKey(relation: Pick<RelationRecord, "from" | "to" | "relationType">): string {
+  return `${relation.from}\u0000${relation.to}\u0000${relation.relationType}`
+}
+
+export function isEntityLikeRecord(record: RawJSONLRecord): boolean {
+  return (record.type === "entity" || record.type === "narrative_beat") && typeof record.name === "string"
+}
+
+export function isRelationLikeRecord(record: RawJSONLRecord): boolean {
+  return (
+    record.type === "relation" &&
+    typeof record.from === "string" &&
+    typeof record.to === "string" &&
+    typeof record.relationType === "string"
+  )
+}
+
+export function normalizeJsonlRecord(record: RawJSONLRecord): EntityRecord | RelationRecord | null {
+  if (record.type === "entity" && typeof record.name === "string") {
+    return {
+      ...record,
+      type: "entity",
+      observations: Array.isArray(record.observations) ? record.observations : [],
+      metadata: isObject(record.metadata) ? record.metadata : {},
+    } as EntityRecord
+  }
+
+  if (record.type === "narrative_beat" && typeof record.name === "string") {
+    const metadata = {
+      ...(isObject(record.metadata) ? record.metadata : {}),
+      narrative: isObject(record.metadata) && record.metadata.narrative !== undefined
+        ? record.metadata.narrative
+        : record.narrative,
+      relationalAlignment: isObject(record.metadata) && record.metadata.relationalAlignment !== undefined
+        ? record.metadata.relationalAlignment
+        : record.relational_alignment,
+      fourDirections: isObject(record.metadata) && record.metadata.fourDirections !== undefined
+        ? record.metadata.fourDirections
+        : record.four_directions,
+    }
+
+    return removeUndefined({
+      ...record,
+      type: "entity",
+      name: record.name as string,
+      entityType: "narrative_beat",
+      observations: Array.isArray(record.observations) ? record.observations : [],
+      metadata: removeUndefined(metadata),
+    }) as EntityRecord
+  }
+
+  if (isRelationLikeRecord(record)) {
+    return {
+      ...record,
+      type: "relation",
+      metadata: isObject(record.metadata) ? record.metadata : {},
+    } as RelationRecord
+  }
+
+  return null
+}
+
+function mergePreservedMetadata(originalMetadata: unknown, currentMetadata: unknown): Record<string, any> {
+  const merged = {
+    ...(isObject(currentMetadata) ? currentMetadata : {}),
+  }
+
+  if (isObject(originalMetadata)) {
+    for (const [key, value] of Object.entries(originalMetadata)) {
+      if (!(key in merged) && (!MUTABLE_METADATA_KEYS.has(key) || key === "github")) {
+        merged[key] = cloneJson(value)
+      }
+    }
+  }
+
+  return merged
+}
+
+function serializeEntity(entity: EntityRecord, original?: RawJSONLRecord): RawJSONLRecord {
+  const metadata = mergePreservedMetadata(original?.metadata, entity.metadata)
+
+  if (original?.type === "narrative_beat") {
+    const record: RawJSONLRecord = {
+      ...original,
+      type: "narrative_beat",
+      name: entity.name,
+      observations: entity.observations,
+      metadata,
+    }
+
+    if ("entityType" in original) {
+      record.entityType = entity.entityType
+    }
+    if ("narrative" in original && entity.metadata?.narrative !== undefined) {
+      record.narrative = cloneJson(entity.metadata.narrative)
+    }
+    if ("relational_alignment" in original && entity.metadata?.relationalAlignment !== undefined) {
+      record.relational_alignment = cloneJson(entity.metadata.relationalAlignment)
+    }
+    if ("four_directions" in original && entity.metadata?.fourDirections !== undefined) {
+      record.four_directions = cloneJson(entity.metadata.fourDirections)
+    }
+
+    return removeUndefined(record)
+  }
+
+  return removeUndefined({
+    ...original,
+    ...entity,
+    type: "entity",
+    metadata,
+  })
+}
+
+function serializeRelation(relation: RelationRecord, original?: RawJSONLRecord): RawJSONLRecord {
+  return removeUndefined({
+    ...original,
+    ...relation,
+    type: "relation",
+    metadata: mergePreservedMetadata(original?.metadata, relation.metadata),
+  })
+}
+
+function findRecord(records: RawJSONLRecord[], key: string): RawJSONLRecord | undefined {
+  return records.find((record) => {
+    if (isEntityLikeRecord(record) && record.name === key) return true
+    if (isRelationLikeRecord(record)) return relationKey(record as RelationRecord) === key
+    return false
+  })
+}
+
+function validateMetadata(label: string, beforeMetadata: unknown, afterMetadata: unknown, failures: string[]): void {
+  if (!isObject(beforeMetadata)) return
+  if (!isObject(afterMetadata)) {
+    failures.push(`${label}: metadata object missing after write`)
+    return
+  }
+
+  for (const [key, value] of Object.entries(beforeMetadata)) {
+    if (!(key in afterMetadata)) {
+      failures.push(`${label}: metadata.${key} missing after write`)
+      continue
+    }
+
+    if ((key === "github" || !MUTABLE_METADATA_KEYS.has(key)) && !deepEqual(value, afterMetadata[key])) {
+      failures.push(`${label}: metadata.${key} changed unexpectedly`)
+    }
+  }
+}
+
+function validateRecordPreservation(
+  beforeRecords: RawJSONLRecord[],
+  afterRecords: RawJSONLRecord[],
+  entities: Map<string, EntityRecord>,
+  relations: RelationRecord[],
+): void {
+  const relationKeys = new Set(relations.map((relation) => relationKey(relation)))
+  const failures: string[] = []
+
+  for (const before of beforeRecords) {
+    if (isEntityLikeRecord(before)) {
+      const name = before.name as string
+      if (!entities.has(name)) continue
+
+      const after = findRecord(afterRecords, name)
+      if (!after) {
+        failures.push(`${name}: record missing after write`)
+        continue
+      }
+
+      if (before.type === "narrative_beat" && after.type !== "narrative_beat") {
+        failures.push(`${name}: legacy narrative_beat record type was flattened`)
+      }
+
+      const knownKeys = before.type === "narrative_beat" ? NARRATIVE_BEAT_TOP_LEVEL_KEYS : ENTITY_TOP_LEVEL_KEYS
+      for (const key of Object.keys(before)) {
+        if (!knownKeys.has(key) && !deepEqual(before[key], after[key])) {
+          failures.push(`${name}: top-level extension field "${key}" was not preserved`)
+        }
+      }
+      validateMetadata(name, before.metadata, after.metadata, failures)
+    }
+
+    if (isRelationLikeRecord(before)) {
+      const key = relationKey(before as RelationRecord)
+      if (!relationKeys.has(key)) continue
+
+      const after = findRecord(afterRecords, key)
+      if (!after) {
+        failures.push(`${key}: relation missing after write`)
+        continue
+      }
+
+      for (const topLevelKey of Object.keys(before)) {
+        if (!RELATION_TOP_LEVEL_KEYS.has(topLevelKey) && !deepEqual(before[topLevelKey], after[topLevelKey])) {
+          failures.push(`${key}: relation extension field "${topLevelKey}" was not preserved`)
+        }
+      }
+      validateMetadata(key, before.metadata, after.metadata, failures)
+    }
+  }
+
+  if (failures.length > 0) {
+    throw new Error(`COAIA JSONL metadata preservation failed:\n- ${failures.join("\n- ")}`)
+  }
+}
+
+export function buildRecordProjections(entities: Map<string, EntityRecord>): RecordProjections {
+  const allEntities = Array.from(entities.values())
+  return {
+    chartRecords: allEntities.filter((entity) => entity.entityType === "structural_tension_chart"),
+    actionStepRecords: allEntities.filter((entity) => entity.entityType === "action_step" || entity.metadata?.isTelescopedChart),
+    narrativeBeatRecords: allEntities.filter((entity) => entity.entityType === "narrative_beat"),
+  }
+}
+
+export function buildMetadataWarnings(records: RawJSONLRecord[]): MetadataWarning[] {
+  const warnings: MetadataWarning[] = []
+
+  for (const record of records) {
+    if (!isEntityLikeRecord(record) && !isRelationLikeRecord(record)) continue
+
+    const recordName = record.name || [record.from, record.to, record.relationType].filter(Boolean).join(" -> ")
+    const metadata = record.metadata
+
+    if (!isObject(metadata)) {
+      warnings.push({
+        severity: "warning",
+        recordName,
+        recordType: record.type,
+        message: "Record has no metadata object; provenance and extension fields may already be flattened.",
+        upstreamIssue: UPSTREAM_ISSUE,
+      })
+      continue
+    }
+
+    if (record.github && !metadata.github) {
+      warnings.push({
+        severity: "warning",
+        recordName,
+        recordType: record.type,
+        message: "GitHub provenance exists outside metadata.github; this shape is suspicious for preservation-aware tools.",
+        upstreamIssue: UPSTREAM_ISSUE,
+      })
+    }
+
+    const normalized = normalizeJsonlRecord(record)
+    if (normalized && "entityType" in normalized) {
+      if (
+        ["structural_tension_chart", "action_step", "desired_outcome", "current_reality", "narrative_beat"].includes(
+          normalized.entityType,
+        ) &&
+        !normalized.metadata?.chartId
+      ) {
+        warnings.push({
+          severity: "warning",
+          recordName: normalized.name,
+          recordType: normalized.entityType,
+          message: "COAIA entity is missing metadata.chartId, so chart/action projection may be incomplete.",
+          upstreamIssue: UPSTREAM_ISSUE,
+        })
+      }
+
+      if (
+        normalized.entityType === "narrative_beat" &&
+        !normalized.metadata?.narrative &&
+        !record.narrative &&
+        normalized.observations.length <= 1
+      ) {
+        warnings.push({
+          severity: "warning",
+          recordName: normalized.name,
+          recordType: normalized.entityType,
+          message: "Narrative beat appears flattened: no narrative metadata or rich beat payload is visible.",
+          upstreamIssue: UPSTREAM_ISSUE,
+        })
+      }
+    }
+
+    if (record.type === "narrative_beat") {
+      warnings.push({
+        severity: "warning",
+        recordName,
+        recordType: "narrative_beat",
+        message: "Legacy narrative_beat shape detected. It is rendered separately and preserved on save.",
+        upstreamIssue: UPSTREAM_ISSUE,
+      })
+    }
+  }
+
+  return warnings
+}
+
+export function serializeParsedData(data: Pick<ParsedData, "entities" | "relations" | "rawRecords">): string {
+  const rawRecords = data.rawRecords || []
+  const emittedEntities = new Set<string>()
+  const emittedRelations = new Set<string>()
+  const records: RawJSONLRecord[] = []
+
+  for (const original of rawRecords) {
+    if (isEntityLikeRecord(original)) {
+      const entity = data.entities.get(original.name)
+      if (entity) {
+        records.push(serializeEntity(entity, original))
+        emittedEntities.add(entity.name)
+      }
+      continue
+    }
+
+    if (isRelationLikeRecord(original)) {
+      const key = relationKey(original as RelationRecord)
+      const relation = data.relations.find((candidate) => relationKey(candidate) === key)
+      if (relation) {
+        records.push(serializeRelation(relation, original))
+        emittedRelations.add(key)
+      }
+      continue
+    }
+
+    records.push(original)
+  }
+
+  for (const entity of data.entities.values()) {
+    if (!emittedEntities.has(entity.name)) {
+      records.push(serializeEntity(entity))
+    }
+  }
+
+  for (const relation of data.relations) {
+    const key = relationKey(relation)
+    if (!emittedRelations.has(key)) {
+      records.push(serializeRelation(relation))
+    }
+  }
+
+  validateRecordPreservation(rawRecords, records, data.entities, data.relations)
+
+  return `${records.map((record) => JSON.stringify(record)).join("\n")}\n`
+}
+
+export { UPSTREAM_ISSUE }

package/lib/types.ts

@@ -6,6 +6,7 @@ export interface EntityRecord {
   entityType: "structural_tension_chart" | "desired_outcome" | "current_reality" | "action_step" | "narrative_beat"
   observations: string[]
   metadata: Record<string, any>
+  [key: string]: any
 }
 
 export interface RelationRecord {
@@ -14,9 +15,34 @@ export interface RelationRecord {
   to: string
   relationType: "contains" | "creates_tension_with" | "advances_toward" | "documents"
   metadata: Record<string, any>
+  [key: string]: any
 }
 
 export type JSONLRecord = EntityRecord | RelationRecord
+export type RawJSONLRecord = Record<string, any>
+
+export interface MetadataWarning {
+  severity: "warning" | "error"
+  recordName?: string
+  recordType?: string
+  message: string
+  upstreamIssue?: string
+}
+
+export interface RecordProjections {
+  chartRecords: EntityRecord[]
+  actionStepRecords: EntityRecord[]
+  narrativeBeatRecords: EntityRecord[]
+}
+
+export interface RiseSpecProjection {
+  chartId: string
+  desiredOutcome: string
+  currentReality: string[]
+  naturalProgression: string[]
+  remainingBlockers: string[]
+  nextOperations: string[]
+}
 
 export interface Chart {
   id: string
@@ -36,4 +62,8 @@ export interface ParsedData {
   entities: Map<string, EntityRecord>
   relations: RelationRecord[]
   rootCharts: Chart[]
+  rawRecords?: RawJSONLRecord[]
+  projections?: RecordProjections
+  preservationWarnings?: MetadataWarning[]
+  riseSpecs?: RiseSpecProjection[]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "coaia-visualizer",
-  "version": "1.6.1",
+  "version": "1.6.2",
   "private": false,
   "type": "module",
   "main": "./index.tsx",
@@ -26,6 +26,7 @@
     "prepare": "npm run build:cli",
     "start": "next start",
     "test": "playwright test",
+    "test:rich-jsonl": "playwright test test-scripts/rich-jsonl-preservation.spec.ts",
     "test:global-cli": "playwright test test-scripts/test-global-cli.spec.ts",
     "docker:build": "docker build -t jgwill/coaia:visualizer .",
     "docker:push": "docker push jgwill/coaia:visualizer",

package/test-results/.last-run.json

@@ -0,0 +1,4 @@
+{
+  "status": "passed",
+  "failedTests": []
+}

package/test-scripts/rich-jsonl-preservation.spec.ts

@@ -0,0 +1,118 @@
+import { test, expect } from "@playwright/test"
+import { organizeData, parseJSONL } from "../lib/jsonl-parser"
+import { serializeParsedData } from "../lib/jsonl-preservation"
+import { ChartEditor } from "../lib/chart-editor"
+
+const fixture = [
+  {
+    type: "entity",
+    name: "chart_preserve_chart",
+    entityType: "structural_tension_chart",
+    observations: ["Chart fixture"],
+    metadata: {
+      chartId: "chart_preserve",
+      dueDate: "2026-12-31T00:00:00.000Z",
+      github: { owner: "jgwill", repo: "coaia-visualizer", issue: 20 },
+      rise: {
+        naturalProgression: ["Render projections"],
+        remainingBlockers: ["No metadata panel"],
+        nextOperations: ["Inspect beat metadata"],
+      },
+      runtime: { agent: "coaia-agent" },
+    },
+    topLevelExtension: { source: "fixture-chart" },
+  },
+  {
+    type: "entity",
+    name: "chart_preserve_desired_outcome",
+    entityType: "desired_outcome",
+    observations: ["Render rich metadata"],
+    metadata: {
+      chartId: "chart_preserve",
+      github: { owner: "jgwill", repo: "coaia-visualizer", issue: 20 },
+    },
+  },
+  {
+    type: "entity",
+    name: "chart_preserve_current_reality",
+    entityType: "current_reality",
+    observations: ["Visualizer can flatten records"],
+    metadata: {
+      chartId: "chart_preserve",
+      github: { owner: "jgwill", repo: "coaia-visualizer", issue: 20 },
+      provenance: { source: "coaia-agent" },
+    },
+  },
+  {
+    type: "entity",
+    name: "chart_preserve_action_1",
+    entityType: "action_step",
+    observations: ["Expose metadata"],
+    metadata: {
+      chartId: "chart_preserve",
+      completionStatus: false,
+      github: { owner: "jgwill", repo: "coaia-visualizer", issue: 20 },
+      unknownActionMetadata: { survives: true },
+    },
+  },
+  {
+    type: "narrative_beat",
+    name: "chart_preserve_beat_1",
+    observations: ["Act 1 setup"],
+    metadata: {
+      chartId: "chart_preserve",
+      act: 1,
+      type_dramatic: "setup",
+      github: { owner: "jgwill", repo: "coaia-visualizer", issue: 20 },
+      beatSpecific: { nested: { survives: true } },
+    },
+    narrative: {
+      description: "Legacy beat payload",
+      prose: "The beat remains inspectable.",
+      lessons: ["Show the nested fields"],
+    },
+    topLevelExtension: { source: "legacy-beat" },
+  },
+  {
+    type: "relation",
+    from: "chart_preserve_beat_1",
+    to: "chart_preserve_chart",
+    relationType: "documents",
+    metadata: {
+      github: { owner: "jgwill", repo: "coaia-visualizer", issue: 20 },
+      relationExtension: { survives: true },
+    },
+  },
+]
+
+test("projects and preserves mixed COAIA JSONL metadata", () => {
+  const content = `${fixture.map((record) => JSON.stringify(record)).join("\n")}\n`
+  const parsed = organizeData(parseJSONL(content))
+
+  expect(parsed.projections!.chartRecords).toHaveLength(1)
+  expect(parsed.projections!.actionStepRecords).toHaveLength(1)
+  expect(parsed.projections!.narrativeBeatRecords).toHaveLength(1)
+  expect(parsed.preservationWarnings!.some((warning) => warning.upstreamIssue?.includes("coaia-narrative/issues/35"))).toBe(true)
+  expect(parsed.riseSpecs![0]).toMatchObject({
+    desiredOutcome: "Render rich metadata",
+    remainingBlockers: ["No metadata panel"],
+  })
+
+  const editor = new ChartEditor(parsed)
+  editor.updateActionProgress("chart_preserve_action_1", "Progress remains rich", false)
+  const exported = serializeParsedData(editor.getUpdatedData())
+  const records = exported.trim().split("\n").map((line) => JSON.parse(line))
+  const chart = records.find((record) => record.name === "chart_preserve_chart")
+  const action = records.find((record) => record.name === "chart_preserve_action_1")
+  const beat = records.find((record) => record.name === "chart_preserve_beat_1")
+  const relation = records.find((record) => record.type === "relation")
+
+  expect(chart.metadata.github.issue).toBe(20)
+  expect(chart.metadata.runtime.agent).toBe("coaia-agent")
+  expect(chart.topLevelExtension.source).toBe("fixture-chart")
+  expect(action.metadata.unknownActionMetadata.survives).toBe(true)
+  expect(beat.type).toBe("narrative_beat")
+  expect(beat.metadata.beatSpecific.nested.survives).toBe(true)
+  expect(beat.narrative.lessons[0]).toBe("Show the nested fields")
+  expect(relation.metadata.relationExtension.survives).toBe(true)
+})