forma-arch 0.10.1 → 0.11.1

package/README.md

@@ -77,6 +77,53 @@ Column roles are detected by header name (`capability`/`feature`/`description`
 
 The overlay is the authority: every field it sets wins over anything derived, and `check` stops re-deriving that field. You do not have to hand-edit that JSON — `forma gen --status-apply <file>` merges `{"nodes":{"<id>":{…}}}` into it, validating every patch **before** it touches disk, so a rejected fill leaves the committed overlay untouched. It is the state counterpart of `--enrich-apply`, for the fields no document can supply. To describe one box by hand without a table, put the sentence in `descriptions`, keyed `"<containerId>/<node-name-without-extension>"` — `"core/alpha"` for the leaf `alpha.js` in container `core`, `"core/core"` for the container itself, since a container is its own container. It outranks every other source.
 
+**Future architecture can be a governed timeline.** Add an optional `timeline` to the curated
+`c4-topology.json` when one binary target is not enough. The generated `nodes` and `edges` remain
+the code-verified `AS-IS`; each checkpoint applies a compact typed patch over every checkpoint
+before it. Forma never stores a second complete graph, never reads a board count as architecture,
+and validates every cumulative state before replacing the last model.
+
+```json
+{
+  "timeline": {
+    "source": "docs/architecture/FUTURE.md",
+    "checkpoints": [{
+      "id": "g1", "label": "G1 · UAT", "badge": "9 board · 1 P0",
+      "patch": {
+        "nodes": {
+          "add": [{ "node": {
+            "id": "mcp", "level": "container", "parent": "system",
+            "kind": "container", "name": "MCP channel", "status": "planned"
+          }, "change": "Add the MCP surface." }],
+          "update": [{ "id": "engine", "set": {
+            "current": "Serves HTTP and MCP through one core."
+          }, "change": "Extend the existing engine." }]
+        },
+        "edges": {
+          "add": [{ "edge": {
+            "from": "mcp", "to": "engine", "label": "delegates",
+            "estatus": "to-build"
+          }, "change": "Connect the new surface to the engine." }]
+        }
+      }
+    }]
+  }
+}
+```
+
+Node patches support `add`, non-structural `update`, and child-first `remove`; edge patches support
+`add`, exact-match `rewire`, and `remove`. Every operation carries governed change prose; a live
+node changed locally exposes it as “Change from previous”, while the graph accents changed nodes
+and relations without keeping a second change log or drawing ghosts for removals. IDs, parents,
+levels and kinds cannot be edited in place, ambiguous edge selectors fail, and a node cannot
+disappear while children or incident relations survive. The source path must exist. `AS-IS` is
+implicit and reserved; the last checkpoint is the target, so `target` is forbidden inside timeline
+patches. With a timeline the viewer replaces CURRENT/TARGET with the checkpoints, supports
+`?checkpoint=g1`, accents only the local patch, and keeps drill, layout, re-verification and export
+working on the cumulative graph. A future checkpoint with no local patch says “no architecture
+changes”; its display-only badge is not interpreted. Without a timeline, the legacy controls and
+model are unchanged.
+
 **Curated state, verified against reality.** `forma verify` asks your `gh` CLI for the state of every issue the model references (`--gh-repo owner/repo`, or `meta.ghRepo` in the topology), marks the nodes whose issues are closed as done, and prefixes their `current` with dated evidence. It touches state, never structure, and re-running it never stacks the evidence. It is opt-in and separate on purpose: `gen` and `check` never open a socket. In the served viewer, **RE-VERIFY** re-reads the model without losing your level, layout or mode.
 
 **One source of truth.** `forma doc --attach docs/architecture/arc42.md` injects the generated diagrams/tables between `<!-- forma:begin -->` / `<!-- forma:end -->` markers in your existing doc; your prose lives outside them, and `forma check` fails if that block drifts. Attached files are recorded in `source.attachedDocs`, so the gate governs **every** doc you attach — not just the model's `docPath`; deleting the markers (or the file) from a registered doc fails the check rather than quietly un-governing it. That registry lives in `c4-model.json`, so **commit the model** — a lost model takes the registry with it. Where a repo lacks docs, `forma gen --enrich` can fill the remaining box holes with an LLM — opt-in, cached, never on the deterministic gate:
@@ -121,7 +168,9 @@ contract. The Claude skill in `adapters/` is a thin wrapper, not the product.
 
 The viewer is a live C4 map, not a static picture:
 
-- **Click any box** to read its explanation — what it does, current state, target, verification source — at *every* level, from context down to a leaf.
+- **Click any box** to read its explanation — what it does, current state/target on legacy models,
+  or the state and local change at the selected checkpoint — at *every* level, from context down to
+  a leaf.
 - **Double-click a box** (or its `[+] DRILL`) to descend into it; **BACK**, the breadcrumb, or `ESC` climb back out.
 - **Drag boxes** to lay out the view your way; **RESET LAYOUT** restores the arrangement (your curated hints if the topology has them, the automatic one otherwise). To keep a layout, drag it, pick **Export layout JSON**, and paste the result under `"layout"` in the topology — `gen` carries it into `meta.layout` and the viewer pins those boxes, auto-arranging everything else clear of them.
 - **Arrow labels** are painted on the diagram while the level stays readable (≤14 arrows) and turn off above that; **LABELS** forces them on or off, and hovering an arrow always reveals its label.

package/lib/check.mjs

@@ -10,7 +10,7 @@ import { containerOf } from './cluster.mjs'
 import { renderBlock, extractBetween, norm } from './render.mjs'
 import { descInputHash } from './enrich.mjs'
 import { loadDocRows, indexByNode, describingRows, statusFor } from './docmap.mjs'
-import { validateModel } from './validate.mjs'
+import { materializeTimeline, validateModel } from './validate.mjs'
 
 const HERE = dirname(fileURLToPath(import.meta.url))
 const arg = (f, d) => { const i = process.argv.indexOf(f); return i > -1 ? process.argv[i + 1] : d }
@@ -26,6 +26,13 @@ if (!existsSync(TOPO)) { console.error('[check-c4] FAIL: topology missing: ' + T
 const model = JSON.parse(readFileSync(MODEL, 'utf-8'))
 const topo = JSON.parse(readFileSync(TOPO, 'utf-8'))
 for (const err of validateModel(model)) errs.push('SCHEMA: ' + err)
+// The topology is the curated architecture authority. The generated model carries the same compact
+// patch programme for the browser; editing either side alone is drift even when both JSON values
+// remain individually valid.
+if (JSON.stringify(model.timeline || null) !== JSON.stringify(topo.timeline || null)) {
+  fail('TIMELINE DRIFT: model.timeline does not match c4-topology.json — regenerate c4-model.json.')
+}
+for (const err of materializeTimeline(model, { sourceExists: (rel) => existsSync(rp(rel)) }).errors) fail('TIMELINE: ' + err)
 const byId = new Map((model.nodes || []).map((n) => [n.id, n]))
 
 // 1) schemaVersion present + basic shape

package/lib/docmap.mjs

@@ -101,6 +101,7 @@ export function loadDocRows(repo, docSources, inventoryOnly = false) {
     if (!existsSync(abs)) continue
     let text
     try { text = readFileSync(abs, 'utf-8') } catch { continue }
+    const before = out.length
     for (const t of tables(text)) {
       const iD = roleIndex(t.header, 'describe', src.describe)
       const iM = roleIndex(t.header, 'ref', src.ref)
@@ -115,6 +116,15 @@ export function loadDocRows(repo, docSources, inventoryOnly = false) {
                    done: iS < 0 ? null : DONE.test(String(r[iS]).replace(/[*_`]+/g, '').trim()), from: rel })
       }
     }
+    // A status column that never once says "not done" is an INVENTORY, not a measure. `done /
+    // rows.length` is then pinned to 1 by arithmetic, for every node and every subset of rows:
+    // haben's feature matrix is 39 rows, 39 DONE, and all 27 nodes it reached came out at exactly
+    // 100 — a constant a stakeholder reads as a measurement. The document is still saying
+    // something (it declares those capabilities finished), so the VERDICT survives; the percentage
+    // does not. Per source, because that is the unit that either discriminates or does not.
+    const mine = out.slice(before)
+    const measures = mine.some((r) => r.done === false)
+    for (const r of mine) r.measures = measures
   }
   return out
 }
@@ -147,7 +157,11 @@ export function indexByNode(rows, nodes) {
     const paths = subtree(n.id)
     if (!paths.length) continue
     const hit = rows.filter((r) => r.refs.some((ref) => paths.some((p) => touches(ref, p))))
-    if (hit.length) idx.set(n.id, { rows: hit, cover: coverOf(n, byId, kids, hit, paths) })
+    // `located`: does this node have evidence of its OWN? A curated grouping box has none — every
+    // path in its subtree belongs to a child — so no row ever names IT, only things inside it.
+    // Reporting what is underneath is the viewer's job (rollStatus); claiming it as the box's own
+    // verdict is not. See statusFor.
+    if (hit.length) idx.set(n.id, { rows: hit, cover: coverOf(n, byId, kids, hit, paths), located: (n.evidence || []).length > 0 })
   }
   return idx
 }
@@ -176,19 +190,44 @@ export const describingRows = (idx, id) => {
   const e = idx.get(id)
   return e && e.rows.length <= MAX_ROWS ? e.rows : null
 }
+
+// The rows that RULE on a node: every row that names it, cap or no cap. MAX_ROWS is a limit on how
+// much prose a box can carry honestly; counting how many named capabilities are finished is not
+// prose, and inheriting the cap made the verdict scale backwards — the more rows named a module,
+// the less it was judged. `internal_budget`, named by four DONE rows, came out unassessed next to
+// modules nobody documented at all (#43).
+export const rulingRows = (idx, id) => {
+  const e = idx.get(id)
+  return e && e.rows.length ? e.rows : null
+}
 export const coverageFor = (idx, id) => (idx.get(id) || {}).cover || null
 
 // Programme state a document states outright: how many of the capabilities living in this node are
 // finished. Derived, never curated — the c4-status.json overlay still overrides it (gen.mjs §WP-A1),
 // and `check` re-derives it from the same document rather than trusting the committed model.
+//
+// A DECLARATION, and only sometimes a measurement. The verdict is what the document says; the
+// percentage is only emitted when the document's status column can say no (see `measures` in
+// loadDocRows). A number nobody could have varied is not a measurement, and on a board it is read
+// as one — which is worse than no number at all.
 export function statusFor(idx, id) {
-  const rows = describingRows(idx, id)
+  const rows = rulingRows(idx, id)
   if (!rows || rows.some((r) => r.done == null)) return null // no status column: describe only
-  const done = rows.filter((r) => r.done).length
+  // A box the document cannot name did not get ruled on: the rows reached it only through its
+  // children. The demo's `fisco` and `accesso` are curated groupings with no evidence of their own,
+  // and both came out done/100 with coverage {named:0} — a verdict borrowed from below and printed
+  // as the box's own. Reporting what is underneath is the viewer's job (rollStatus), not gen's.
+  if (!(idx.get(id) || {}).located) return null
   const c = coverageFor(idx, id)
+  const done = rows.filter((r) => r.done).length
+  // Past the cap the document TOUCHES the node rather than describing it (see MAX_ROWS), and the
+  // two halves of the answer part company: "of the rows that name this, N are done" is still
+  // something the document says, so the verdict stands — but a percentage over a reach nobody can
+  // state is the invented number this file exists to refuse. Verdict yes, percentage no.
+  const described = rows.length <= MAX_ROWS
   return {
     status2: done === rows.length ? 'done' : done === 0 ? 'planned' : 'in-progress',
-    completion: Math.round((done / rows.length) * 100),
+    ...(described && rows.every((r) => r.measures) ? { completion: Math.round((done / rows.length) * 100) } : {}),
     // The citation says what it is: a repo document declaring itself finished, not a verification.
     source: `${rows[0].from} (${done}/${rows.length} declared done)`,
     ...(c ? { coverage: c } : {}),

package/lib/gen.mjs

@@ -11,14 +11,14 @@ import { isGo, goEdges } from './lang.mjs'
 import { makeDescribeCtx, resolveDescription } from './describe.mjs'
 import { loadDocRows, indexByNode, describingRows, statusFor } from './docmap.mjs'
 import { loadCache, mergeCache, enrich, agentPlan, applyFills } from './enrich.mjs'
-import { validateModel } from './validate.mjs'
+import { materializeTimeline, validateModel } from './validate.mjs'
 
 const HERE = dirname(fileURLToPath(import.meta.url))
 const arg = (f, d) => { const i = process.argv.indexOf(f); return i > -1 ? process.argv[i + 1] : d }
 const REPO = arg('--repo', process.cwd())
 const TOPO = arg('--topology', join(REPO, 'docs/architecture/c4-topology.json'))
 const OUT = arg('--out', join(REPO, 'docs/architecture/c4-model.json'))
-const SCHEMA_VERSION = '1.5.0' // +descSource:"docmap" (additive enum value → MINOR)
+const SCHEMA_VERSION = '1.6.0' // +optional cumulative architecture timeline (additive)
 const CLUSTER = !process.argv.includes('--no-cluster') // §2: auto-cluster flat containers; --no-cluster to disable
 const ENRICH = process.argv.includes('--enrich')       // §7: opt-in LLM prose for description holes
 const ENRICHER = arg('--enricher', null)
@@ -168,7 +168,10 @@ for (const n of nodes) {
   // `coverage` rides in `verify` (additionalProperties: true there, so no schema churn) and says how
   // much of the node the citation actually reaches — the difference between "3 of 3 rows are done"
   // and "this module is done".
-  if (ds) { n.status2 = ds.status2; if (n.completion == null) n.completion = ds.completion; if (!n.verify) n.verify = { source: ds.source, derived: true, ...(ds.coverage ? { coverage: ds.coverage } : {}) } }
+  // `ds.completion` is ABSENT when the document declares rather than measures (docmap §statusFor).
+  // Assigning it anyway would put an own `completion: undefined` on the node — invisible in the
+  // written JSON, but validateModel walks own properties and would reject it against `integer`.
+  if (ds) { n.status2 = ds.status2; if (n.completion == null && ds.completion != null) n.completion = ds.completion; if (!n.verify) n.verify = { source: ds.source, derived: true, ...(ds.coverage ? { coverage: ds.coverage } : {}) } }
   // Code can prove a file EXISTS; it cannot prove the work behind it is finished. Marking every
   // undecorated node done/100 turned a virgin repo into a board reading "10/10 complete" — the
   // exact false green this tool exists to kill. No overlay (§WP-A1), no verdict: `unknown`, and
@@ -380,6 +383,7 @@ const model = {
   schemaVersion: SCHEMA_VERSION,
   generatedAt: new Date().toISOString(),
   source: { repo: topo.meta.repo, commit, branch, docPath: topo.docPath, generator: 'gen-c4-model@' + SCHEMA_VERSION, ...(attachedDocs.length ? { attachedDocs } : {}), ...(statusPath ? { statusPath } : {}) },
+  ...(topo.timeline ? { timeline: topo.timeline } : {}),
   // topo.layout (optional curated coordinates, keyed by parent id) rides along verbatim: the
   // viewer pins those nodes and auto-arranges the rest. `meta` is the model's free-form area.
   meta: { ...topo.meta, ...(topo.layout ? { layout: topo.layout } : {}), verifyMethod: 'code+topology (gh re-verify optional)' },
@@ -402,11 +406,14 @@ if (process.argv.includes('--from-docs')) {
     console.log(`[gen-c4] --from-docs: ${planned.length} planned milestone(s), ${accepted}/${adrs} ADR accepted`)
   } catch (e) { model.meta.verifyError = 'from-docs: ' + String((e && e.message) || e) }
 }
-writeFileSync(OUT, JSON.stringify(model, null, 2) + '\n')
-// topo.nodes are copied verbatim into the model (pass 1), so a bad curated kind used to leak in
-// and only fail later — this catches it immediately and keeps invalid artifacts from being written.
+// topo.nodes and timeline patches are copied into the model, so validate both the static schema and
+// EVERY cumulative checkpoint before touching OUT. A rejected projection must not corrupt the last
+// committed model any more than a rejected status overlay does.
 const schemaErrors = validateModel(model)
 if (schemaErrors.length) fail('model does not validate against lib/schema/c4-model.schema.json:\n - ' + schemaErrors.join('\n - '))
+const timelineErrors = materializeTimeline(model, { sourceExists: (rel) => existsSync(rp(rel)) }).errors
+if (timelineErrors.length) fail('timeline is not a valid cumulative architecture projection:\n - ' + timelineErrors.join('\n - '))
+writeFileSync(OUT, JSON.stringify(model, null, 2) + '\n')
 const counts = { total: nodes.length, leaves: nodes.filter((n) => n.kind === 'leaf').length, planned: nodes.filter((n) => n.status === 'planned').length }
 console.log(`[gen-c4] wrote ${OUT}`)
 console.log(`[gen-c4] nodes=${counts.total} leaves=${counts.leaves} planned=${counts.planned} edges=${model.edges.length} commit=${commit.slice(0,8)}`)

package/lib/schema/c4-model.schema.json

@@ -2,7 +2,7 @@
   "$schema": "http://json-schema.org/draft-07/schema#",
   "$id": "https://github.com/LucaDominici/forma/blob/main/lib/schema/c4-model.schema.json",
   "title": "C4 model \u2014 stack-agnostic architecture graph",
-  "description": "Reusable contract for the C4 live dashboard. A generator conforms iff its output validates; the viewer renders anything that validates. Stack-specific facts live only in tech/meta.",
+  "description": "Reusable structural contract for the C4 live dashboard. A generator conforms iff its output validates and every optional timeline checkpoint materializes semantically; the viewer renders generator-conformant models. Stack-specific facts live only in tech/meta.",
   "type": "object",
   "required": [
     "schemaVersion",
@@ -61,6 +61,319 @@
         }
       }
     },
+    "timeline": {
+      "type": "object",
+      "description": "Optional governed future architecture. The generated nodes/edges remain the AS-IS baseline; ordered checkpoint patches are applied cumulatively.",
+      "required": [
+        "source",
+        "checkpoints"
+      ],
+      "additionalProperties": false,
+      "properties": {
+        "source": {
+          "type": "string",
+          "description": "Repo-relative architecture document governing the future projection."
+        },
+        "checkpoints": {
+          "type": "array",
+          "minItems": 1,
+          "items": {
+            "type": "object",
+            "required": [
+              "id",
+              "label"
+            ],
+            "additionalProperties": false,
+            "properties": {
+              "id": {
+                "type": "string",
+                "pattern": "^[a-z0-9][a-z0-9._-]*$"
+              },
+              "label": {
+                "type": "string"
+              },
+              "badge": {
+                "type": "string",
+                "description": "Display-only checkpoint annotation. Never interpreted as architecture operations."
+              },
+              "patch": {
+                "type": "object",
+                "additionalProperties": false,
+                "properties": {
+                  "nodes": {
+                    "type": "object",
+                    "additionalProperties": false,
+                    "properties": {
+                      "add": {
+                        "type": "array",
+                        "items": {
+                          "type": "object",
+                          "required": [
+                            "node",
+                            "change"
+                          ],
+                          "additionalProperties": false,
+                          "properties": {
+                            "node": {
+                              "$ref": "#/properties/nodes/items"
+                            },
+                            "change": {
+                              "type": "string"
+                            }
+                          }
+                        }
+                      },
+                      "update": {
+                        "type": "array",
+                        "items": {
+                          "type": "object",
+                          "required": [
+                            "id",
+                            "set",
+                            "change"
+                          ],
+                          "additionalProperties": false,
+                          "properties": {
+                            "id": {
+                              "type": "string"
+                            },
+                            "set": {
+                              "type": "object",
+                              "minProperties": 1,
+                              "additionalProperties": false,
+                              "properties": {
+                                "name": {
+                                  "$ref": "#/properties/nodes/items/properties/name"
+                                },
+                                "drill": {
+                                  "$ref": "#/properties/nodes/items/properties/drill"
+                                },
+                                "tech": {
+                                  "$ref": "#/properties/nodes/items/properties/tech"
+                                },
+                                "description": {
+                                  "$ref": "#/properties/nodes/items/properties/description"
+                                },
+                                "status": {
+                                  "$ref": "#/properties/nodes/items/properties/status"
+                                },
+                                "link": {
+                                  "$ref": "#/properties/nodes/items/properties/link"
+                                },
+                                "evidence": {
+                                  "$ref": "#/properties/nodes/items/properties/evidence"
+                                },
+                                "meta": {
+                                  "$ref": "#/properties/nodes/items/properties/meta"
+                                },
+                                "category": {
+                                  "$ref": "#/properties/nodes/items/properties/category"
+                                },
+                                "status2": {
+                                  "$ref": "#/properties/nodes/items/properties/status2"
+                                },
+                                "completion": {
+                                  "$ref": "#/properties/nodes/items/properties/completion"
+                                },
+                                "statusWord": {
+                                  "$ref": "#/properties/nodes/items/properties/statusWord"
+                                },
+                                "current": {
+                                  "$ref": "#/properties/nodes/items/properties/current"
+                                },
+                                "issues": {
+                                  "$ref": "#/properties/nodes/items/properties/issues"
+                                },
+                                "verify": {
+                                  "$ref": "#/properties/nodes/items/properties/verify"
+                                },
+                                "func": {
+                                  "$ref": "#/properties/nodes/items/properties/func"
+                                },
+                                "descSource": {
+                                  "$ref": "#/properties/nodes/items/properties/descSource"
+                                },
+                                "descInputHash": {
+                                  "$ref": "#/properties/nodes/items/properties/descInputHash"
+                                }
+                              }
+                            },
+                            "change": {
+                              "type": "string"
+                            }
+                          }
+                        }
+                      },
+                      "remove": {
+                        "type": "array",
+                        "items": {
+                          "type": "object",
+                          "required": [
+                            "id",
+                            "change"
+                          ],
+                          "additionalProperties": false,
+                          "properties": {
+                            "id": {
+                              "type": "string"
+                            },
+                            "change": {
+                              "type": "string"
+                            }
+                          }
+                        }
+                      }
+                    }
+                  },
+                  "edges": {
+                    "type": "object",
+                    "additionalProperties": false,
+                    "properties": {
+                      "add": {
+                        "type": "array",
+                        "items": {
+                          "type": "object",
+                          "required": [
+                            "edge",
+                            "change"
+                          ],
+                          "additionalProperties": false,
+                          "properties": {
+                            "edge": {
+                              "$ref": "#/properties/edges/items"
+                            },
+                            "change": {
+                              "type": "string"
+                            }
+                          }
+                        }
+                      },
+                      "rewire": {
+                        "type": "array",
+                        "items": {
+                          "type": "object",
+                          "required": [
+                            "match",
+                            "set",
+                            "change"
+                          ],
+                          "additionalProperties": false,
+                          "properties": {
+                            "match": {
+                              "type": "object",
+                              "required": [
+                                "from",
+                                "to"
+                              ],
+                              "additionalProperties": false,
+                              "properties": {
+                                "from": {
+                                  "type": "string"
+                                },
+                                "to": {
+                                  "type": "string"
+                                },
+                                "label": {
+                                  "type": "string"
+                                },
+                                "kind": {
+                                  "type": "string"
+                                }
+                              }
+                            },
+                            "set": {
+                              "type": "object",
+                              "minProperties": 1,
+                              "additionalProperties": false,
+                              "anyOf": [
+                                {
+                                  "required": [
+                                    "from"
+                                  ]
+                                },
+                                {
+                                  "required": [
+                                    "to"
+                                  ]
+                                }
+                              ],
+                              "properties": {
+                                "from": {
+                                  "$ref": "#/properties/edges/items/properties/from"
+                                },
+                                "to": {
+                                  "$ref": "#/properties/edges/items/properties/to"
+                                },
+                                "label": {
+                                  "$ref": "#/properties/edges/items/properties/label"
+                                },
+                                "kind": {
+                                  "$ref": "#/properties/edges/items/properties/kind"
+                                },
+                                "status": {
+                                  "$ref": "#/properties/edges/items/properties/status"
+                                },
+                                "evidence": {
+                                  "$ref": "#/properties/edges/items/properties/evidence"
+                                },
+                                "estatus": {
+                                  "$ref": "#/properties/edges/items/properties/estatus"
+                                }
+                              }
+                            },
+                            "change": {
+                              "type": "string"
+                            }
+                          }
+                        }
+                      },
+                      "remove": {
+                        "type": "array",
+                        "items": {
+                          "type": "object",
+                          "required": [
+                            "match",
+                            "change"
+                          ],
+                          "additionalProperties": false,
+                          "properties": {
+                            "match": {
+                              "type": "object",
+                              "required": [
+                                "from",
+                                "to"
+                              ],
+                              "additionalProperties": false,
+                              "properties": {
+                                "from": {
+                                  "type": "string"
+                                },
+                                "to": {
+                                  "type": "string"
+                                },
+                                "label": {
+                                  "type": "string"
+                                },
+                                "kind": {
+                                  "type": "string"
+                                }
+                              }
+                            },
+                            "change": {
+                              "type": "string"
+                            }
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    },
     "meta": {
       "type": "object",
       "description": "Repo-level escape hatch (archetype, stack, overlays, version). Never required by the viewer.",