npm - @eventmodelers/cli - Versions diffs - 1.0.36 → 1.0.37 - Mend

@eventmodelers/cli 1.0.36 → 1.0.37

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (69) hide show

package/stacks/modeling-kit/templates/.claude/skills/storyboard/SKILL.md CHANGED Viewed

@@ -7,7 +7,7 @@ description: Build a complete visual storyboard with AI-generated screens from a
 > **Before doing anything else**, invoke the `connect` skill — if not already connected — to resolve `TOKEN`, `BOARD_ID`, and `BASE_URL`. Do not proceed until the connect skill has completed.
-Prefer `mcp__eventmodelers__*` tools when available (registered by the `connect` skill) — the curl blocks below are the fallback for sessions without MCP connected.
+Prefer `mcp__eventmodelers__*` tools when available (registered by the `connect` skill) — `references/api-fallback.md` has the curl fallback for every MCP call below, for sessions without MCP connected.
 > **HTML is the default content type**: every screen this skill creates is a real HTML/CSS mockup (`contentType: "html"`, HTML_SCREEN node) unless the user's request explicitly asks for a "sketch", "wireframe", or "low-fidelity mockup" — only then does a screen use the sketch path (`contentType: "sketch"`, plain SCREEN node) described under "Sketch path (explicit request only)" below. Decide this once per storyboard, before Step 2 — do not mix content types across screens in the same storyboard unless the user asked for that mix.
@@ -43,14 +43,7 @@ Then **create one task per screen** using TaskCreate, naming each task after the
 ## HTML page design (default)
-Write normal, full-size HTML/CSS for each screen — as if designing a real webpage, not a tiny thumbnail. The canvas node renders this at a real page width and visually scales it down to fit, so there is no need to shrink font sizes or padding.
-- Each page is one complete, standalone HTML fragment — not a `data-step` div nested inside a shared blob. A multi-step flow is multiple pages, each fully self-contained.
-- Inline styles (`style="..."`) are the simplest way to keep each page self-contained.
-- No `<script>` tags, no inline event handlers (`onclick`, `onload`, ...), no `javascript:` URIs — these are stripped server-side before persisting. This is a static visual mockup, not an interactive prototype.
-- A real page background (e.g. a light gray full-bleed background behind a centered white card) reads more realistically than a bare form floating on white.
-- Don't add `<html>`/`<head>`/`<body>` tags — every page is a body-only fragment; the canvas wraps it at render time.
-- Bulma CSS (0.9.4) is loaded by default — classes like `title`, `button`, `is-primary`, `field`/`control`/`input` etc. all work out of the box. Headings need a size modifier too, e.g. `class="title is-1"`.
+Design each page as real, full-size HTML/CSS following the `html-screen` skill's conventions: full-size markup (16px body text, generous padding — the canvas scales it down, don't shrink it yourself), one complete self-contained fragment per page (no `<html>`/`<head>`/`<body>` wrapper), no `<script>`/inline handlers (stripped server-side), and Bulma CSS classes (`title`, `button`, `is-primary`, `field`/`control`/`input`, etc. — remember heading size modifiers like `class="title is-1"`) since Bulma 0.9.4 is loaded by default.
 ## Sketch path (explicit request only)
@@ -116,33 +109,21 @@ Keep all coordinates within bounds: gridX 0–50, gridY 0–40.
 mcp__eventmodelers__create_chapter { "boardId": "<BOARD_ID>", "x": 0, "y": 0 }
 ```
-**Fallback (no MCP):**
-```bash
-curl -s -X POST "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/chapters" \
-  -H "Content-Type: application/json" \
-  -d '{"position":{"x":0,"y":0}}'
-```
-Extract `id` from the response → `CHAPTER_ID`.
+**Fallback (no MCP):** see `references/api-fallback.md` — "Step 3 — Create a chapter".
 **You now have exactly one `CHAPTER_ID`. Do not create another chapter.**
 ### Step 4 — Fetch chapter state and build empty-column queue
-**Prefer MCP:**
+**Prefer MCP** — `projection: "cells"` returns just `{rows, columns, cells}`, not the whole chapter node:
 ```
-mcp__eventmodelers__get_node { "boardId": "<BOARD_ID>", "nodeId": "<CHAPTER_ID>" }
+mcp__eventmodelers__get_node { "boardId": "<BOARD_ID>", "nodeId": "<CHAPTER_ID>", "projection": "cells" }
 ```
-**Fallback (no MCP):**
+**Fallback (no MCP):** see `references/api-fallback.md` — "Step 4 — Fetch the chapter's grid state".
-```bash
-curl -s "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/$CHAPTER_ID"
-```
-Parse `meta.timelineData` from the response:
+Parse the result (`{rows, columns, cells}` directly via MCP, or `meta.timelineData` via the REST fallback):
 - `rows` — list of row objects, each with `id` and `type`
 - `columns` — list of column objects, each with `id`
 - `cells` — list of cell objects, each with `rowId`, `colId`, and optionally `nodeId` (used only to check occupancy)
@@ -159,6 +140,8 @@ Build an **empty-column queue**: for each column (in order), compute `actorCellI
 Process screens **one at a time**. Do not start the next screen until the current one is fully complete (node created + sketch rendered).
+**Before starting the loop**, if the empty-column queue (Step 4) has fewer entries than N screens, create the shortfall in one call — `mcp__eventmodelers__add_column { "boardId": "<BOARD_ID>", "timelineId": "<CHAPTER_ID>", "count": <N - queue.length> }` returns `columnIds: [...]` — and push each new column onto the queue, rather than calling `add_column` once per screen inside Step 5a whenever the queue runs dry.
 **You have ONE chapter (`CHAPTER_ID`). All screens go into this same chapter. Do NOT call the chapter creation endpoint again inside this loop.**
 Only SCREEN nodes are created. COMMAND and EVENT nodes are not created.
@@ -175,13 +158,7 @@ Only SCREEN nodes are created. COMMAND and EVENT nodes are not created.
 mcp__eventmodelers__add_column { "boardId": "<BOARD_ID>", "timelineId": "<CHAPTER_ID>" }
 ```
-**Fallback (no MCP):**
-```bash
-curl -s -X POST "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/timelines/$CHAPTER_ID/columns" \
-  -H "Content-Type: application/json" \
-  -d '{}'
-```
+**Fallback (no MCP):** see `references/api-fallback.md` — "Step 5a — Add a column".
 Extract `columnId` from the response. Compute the actor cell ID directly:
@@ -211,20 +188,7 @@ mcp__eventmodelers__create_screen {
 }
 ```
-**Fallback (no MCP):**
-```bash
-curl -s -X POST "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/html-screen-nodes/$SCREEN_NODE_ID" \
-  -H "x-token: $TOKEN" \
-  -H "x-board-id: $BOARD_ID" \
-  -H "x-user-id: agent" \
-  -H "Content-Type: application/json" \
-  -d '{
-    "chapterId": "<CHAPTER_ID>",
-    "cellId": "<actorCellId>",
-    "pages": ["<div>...</div>"]
-  }'
-```
+**Fallback (no MCP):** see `references/api-fallback.md` — "Step 5b — Create the screen node and render it (HTML path)".
 **Sketch path (explicit request only) — `contentType: "sketch"`, plain SCREEN node:**
@@ -242,33 +206,13 @@ mcp__eventmodelers__create_screen {
 }
 ```
-**Fallback (no MCP):**
-```bash
-curl -s -X POST "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/image-nodes/$SCREEN_NODE_ID/sketch" \
-  -H "x-token: $TOKEN" \
-  -H "x-board-id: $BOARD_ID" \
-  -H "x-user-id: agent" \
-  -H "Content-Type: application/json" \
-  -d '{
-    "chapterId": "<CHAPTER_ID>",
-    "cellId": "<actorCellId>",
-    "description": {"elements": [...]},
-    "semanticDescription": "<screenTitle — what this screen shows>"
-  }'
-```
+**Fallback (no MCP):** see `references/api-fallback.md` — "Step 5b — Create the screen node and render it (sketch path, explicit request only)".
 Pass the already-computed `actorCellId` directly as `cellId` in either path. Expect success (MCP: `created: true`; curl: `204`). On failure, read the validation error, fix the payload, and retry once before reporting failure.
 ### Step 5b(ii) — Set field data lineage (mandatory)
-Push the `fields` planned in Step 2 onto the node with a `node:changed` call. Every field needs a `mapping`:
-| Field type | `mapping` | Example |
-|---|---|---|
-| User types a value, sent as a command | `"<CommandTitle>.<fieldName>"` | `"ReserveBike.bikeId"` |
-| Displayed data, sourced from a read model | `"<ReadModelTitle>.<fieldName>"` | `"ActiveReservationView.status"` |
-| Calculated/formatted only for display | `"derived:<expression>"` | `"derived:formatDuration(durationMinutes)"` |
+Push the `fields` planned in Step 2 onto the node with a `node:changed` call. Every field needs a `mapping` — see the `html-screen` skill's "Step 5 — Define field data lineage" for the full `mapping`-format table (command/session/read-model/derived forms).
 Name the read model even if it doesn't exist as a board node yet — this skill only creates SCREEN/HTML_SCREEN nodes, never READMODEL nodes or connections. But naming the source is **not optional**: a screen displaying data should almost never have a field with no mapping. Set `cardinality` too (`"Single"` unless it's a repeated/list value).
@@ -285,18 +229,7 @@ mcp__eventmodelers__submit_node_events {
 }
 ```
-**Fallback (no MCP):**
-```bash
-curl -s -X POST "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/events" \
-  -H "x-token: $TOKEN" -H "x-board-id: $BOARD_ID" -H "x-user-id: agent" \
-  -H "Content-Type: application/json" \
-  -d '[{
-    "id": "<event-uuid>", "eventType": "node:changed", "nodeId": "<SCREEN_NODE_ID>",
-    "boardId": "<BOARD_ID>", "timestamp": <NOW_MS>,
-    "changedAttributes": ["meta.fields"],
-    "meta": { "type": "HTML_SCREEN", "fields": [ /* planned fields */ ] }
-  }]'
-```
+**Fallback (no MCP):** see `references/api-fallback.md` — "Step 5b(ii) — Set field data lineage".
 ### Step 5c — Mark the task complete

package/stacks/modeling-kit/templates/.claude/skills/storyboard/references/api-fallback.md ADDED Viewed

@@ -0,0 +1,74 @@
+# Storyboard — curl Fallback Calls
+Only needed when MCP is not connected. Every call below has an MCP equivalent in the main SKILL.md — always prefer that.
+## Step 3 — Create a chapter
+```bash
+curl -s -X POST "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/chapters" \
+  -H "Content-Type: application/json" \
+  -d '{"position":{"x":0,"y":0}}'
+```
+Extract `id` from the response → `CHAPTER_ID`.
+## Step 4 — Fetch the chapter's grid state
+```bash
+curl -s "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/$CHAPTER_ID"
+```
+Read `meta.timelineData` for `{rows, columns, cells}`.
+## Step 5a — Add a column
+```bash
+curl -s -X POST "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/timelines/$CHAPTER_ID/columns" \
+  -H "Content-Type: application/json" \
+  -d '{}'
+```
+## Step 5b — Create the screen node and render it (HTML path)
+```bash
+curl -s -X POST "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/html-screen-nodes/$SCREEN_NODE_ID" \
+  -H "x-token: $TOKEN" \
+  -H "x-board-id: $BOARD_ID" \
+  -H "x-user-id: agent" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "chapterId": "<CHAPTER_ID>",
+    "cellId": "<actorCellId>",
+    "pages": ["<div>...</div>"]
+  }'
+```
+## Step 5b — Create the screen node and render it (sketch path, explicit request only)
+```bash
+curl -s -X POST "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/image-nodes/$SCREEN_NODE_ID/sketch" \
+  -H "x-token: $TOKEN" \
+  -H "x-board-id: $BOARD_ID" \
+  -H "x-user-id: agent" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "chapterId": "<CHAPTER_ID>",
+    "cellId": "<actorCellId>",
+    "description": {"elements": [...]},
+    "semanticDescription": "<screenTitle — what this screen shows>"
+  }'
+```
+## Step 5b(ii) — Set field data lineage
+```bash
+curl -s -X POST "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/events" \
+  -H "x-token: $TOKEN" -H "x-board-id: $BOARD_ID" -H "x-user-id: agent" \
+  -H "Content-Type: application/json" \
+  -d '[{
+    "id": "<event-uuid>", "eventType": "node:changed", "nodeId": "<SCREEN_NODE_ID>",
+    "boardId": "<BOARD_ID>", "timestamp": <NOW_MS>,
+    "changedAttributes": ["meta.fields"],
+    "meta": { "type": "HTML_SCREEN", "fields": [ /* planned fields */ ] }
+  }]'
+```

package/stacks/modeling-kit/templates/.claude/skills/storyboard-screen/SKILL.md CHANGED Viewed

@@ -38,17 +38,7 @@ If `nodeId` refers to a screen that has already been rendered (i.e. this is an a
 mcp__eventmodelers__get_image_snapshot_description { "boardId": "<BOARD_ID>", "nodeId": "<NODE_ID>" }
 ```
-**Fallback (no MCP):**
-```bash
-curl -s "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/images/$NODE_ID/description" \
-  -H "x-token: $TOKEN" \
-  -H "x-board-id: $BOARD_ID" \
-  -H "x-user-id: agent"
-```
-- `200` — returns the previously stored `{ elements: [...] }`. Use this as the base and apply only the requested change (e.g. edit one element's `text`/`fill`, add/remove a specific element) — leave everything else untouched.
-- `404` — no description stored yet (e.g. an older screen rendered before this endpoint existed, or a placeholder node). Fall back to designing from scratch in Step 3.
+**Fallback (no MCP):** see `references/api-fallback.md` — "Step 2 — Load existing description".
 Skip this step entirely when the node is brand-new (no prior render) — go straight to Step 3.
@@ -116,29 +106,11 @@ mcp__eventmodelers__render_screen {
 }
 ```
-**Fallback (no MCP):**
-```bash
-curl -s -X POST "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/images/$NODE_ID/sketch" \
-  -H "x-token: $TOKEN" \
-  -H "x-board-id: $BOARD_ID" \
-  -H "x-user-id: agent" \
-  -H "Content-Type: application/json" \
-  -d '{"description": "<what this screen shows>", "elements": [...]}'
-```
-Expect `204 No Content` on success.
+**Fallback (no MCP):** see `references/api-fallback.md` — "Step 4 — Render the sketch".
 ## Step 5 — Define field data lineage (mandatory)
-Every screen — new or updated — needs `meta.fields`: one entry per piece of data the screen displays or captures, each with a `mapping` naming where that data comes from. A screen with only a title and no fields is an empty placeholder from a data-lineage standpoint, even once the wireframe is rendered.
-| Field type | `mapping` | Example |
-|---|---|---|
-| User types a value, sent as a command | `"<CommandTitle>.<fieldName>"` | `"ReserveBike.bikeId"` |
-| Read from session | `"session:<fieldName>"` | `"session:customerId"` |
-| Displayed data, sourced from a read model | `"<ReadModelTitle>.<fieldName>"` | `"ActiveReservationView.status"` |
-| Calculated/formatted only for display | `"derived:<expression>"` | `"derived:formatDuration(durationMinutes)"` |
+Every screen — new or updated — needs `meta.fields`: one entry per piece of data the screen displays or captures, each with a `mapping` naming where that data comes from. A screen with only a title and no fields is an empty placeholder from a data-lineage standpoint, even once the wireframe is rendered. See the `html-screen` skill's "Step 5 — Define field data lineage" for the full `mapping`-format table (command/session/read-model/derived forms).
 Name the read model even if it doesn't exist as a board node yet — this skill only renders the screen, it does not create READMODEL nodes or connections. But naming the source is **not optional**: a screen displaying data should almost never have a field with no mapping. If you can't say which read model a displayed field comes from, that's a sign the model is missing something — not a reason to skip the field.
@@ -159,20 +131,7 @@ mcp__eventmodelers__submit_node_events {
 }
 ```
-**Fallback (no MCP):**
-```bash
-curl -s -X POST "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/events" \
-  -H "x-token: $TOKEN" -H "x-board-id: $BOARD_ID" -H "x-user-id: agent" \
-  -H "Content-Type: application/json" \
-  -d '[{
-    "id": "<event-uuid>", "eventType": "node:changed", "nodeId": "<NODE_ID>",
-    "boardId": "<BOARD_ID>", "timestamp": <NOW_MS>,
-    "changedAttributes": ["meta.fields"],
-    "meta": { "type": "SCREEN", "fields": [
-      {"name": "status", "type": "String", "example": "confirmed", "mapping": "ActiveReservationView.status", "cardinality": "Single"}
-    ] }
-  }]'
-```
+**Fallback (no MCP):** see `references/api-fallback.md` — "Step 5 — Define field data lineage".
 ## Step 6 — Report back

package/stacks/modeling-kit/templates/.claude/skills/storyboard-screen/references/api-fallback.md ADDED Viewed

@@ -0,0 +1,44 @@
+# Storyboard Screen Designer — curl Fallback Calls
+Only needed when MCP is not connected. Every call below has an MCP equivalent in the main SKILL.md — always prefer that.
+## Step 2 — Load existing description
+```bash
+curl -s "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/images/$NODE_ID/description" \
+  -H "x-token: $TOKEN" \
+  -H "x-board-id: $BOARD_ID" \
+  -H "x-user-id: agent"
+```
+- `200` — returns the previously stored `{ elements: [...] }`. Use this as the base and apply only the requested change (e.g. edit one element's `text`/`fill`, add/remove a specific element) — leave everything else untouched.
+- `404` — no description stored yet (e.g. an older screen rendered before this endpoint existed, or a placeholder node). Fall back to designing from scratch in Step 3.
+## Step 4 — Render the sketch
+```bash
+curl -s -X POST "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/images/$NODE_ID/sketch" \
+  -H "x-token: $TOKEN" \
+  -H "x-board-id: $BOARD_ID" \
+  -H "x-user-id: agent" \
+  -H "Content-Type: application/json" \
+  -d '{"description": "<what this screen shows>", "elements": [...]}'
+```
+Expect `204 No Content` on success.
+## Step 5 — Define field data lineage
+```bash
+curl -s -X POST "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/events" \
+  -H "x-token: $TOKEN" -H "x-board-id: $BOARD_ID" -H "x-user-id: agent" \
+  -H "Content-Type: application/json" \
+  -d '[{
+    "id": "<event-uuid>", "eventType": "node:changed", "nodeId": "<NODE_ID>",
+    "boardId": "<BOARD_ID>", "timestamp": <NOW_MS>,
+    "changedAttributes": ["meta.fields"],
+    "meta": { "type": "SCREEN", "fields": [
+      {"name": "status", "type": "String", "example": "confirmed", "mapping": "ActiveReservationView.status", "cardinality": "Single"}
+    ] }
+  }]'
+```

package/stacks/modeling-kit/templates/.claude/skills/timeline/SKILL.md CHANGED Viewed

@@ -7,7 +7,7 @@ description: Live event storming facilitator — asks questions about any busine
 > **Before doing anything else**, invoke the `connect` skill — if not already connected — to resolve `TOKEN`, `BOARD_ID`, and `BASE_URL`. Do not proceed until it has completed. Consult `learn-eventmodelers-api` only if you need to look up a specific endpoint or field this file doesn't cover — don't load it eagerly.
-> Prefer `mcp__eventmodelers__*` tools when available (registered by the `connect` skill) — the curl blocks below are the fallback for sessions without MCP connected.
+> Prefer `mcp__eventmodelers__*` tools when available (registered by the `connect` skill) — `references/api-fallback.md` has the curl fallback for every MCP call below, for sessions without MCP connected.
 You are a live event storming facilitator. You discover domain events through conversation — or from any input (pasted text, documents, notes) — and **immediately place them on the board as they emerge**. The timeline grows and evolves in real time. You don't wait until the end.
@@ -38,10 +38,7 @@ Before doing anything else, fetch all chapters (timelines) on the board.
 mcp__eventmodelers__get_nodes { "boardId": "<BOARD_ID>", "type": "CHAPTER" }
 ```
-**Fallback (no MCP):**
-```bash
-curl -s "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes?type=CHAPTER"
-```
+**Fallback (no MCP):** see `references/api-fallback.md` — "Fetch all chapters".
 **If `timelineId` was provided** (UUID or name), skip directly to [1b — Continuing an existing timeline](#1b--continuing-an-existing-timeline).
@@ -65,28 +62,22 @@ If `timelineId` is provided, first resolve it to a UUID if a name was given inst
 mcp__eventmodelers__get_nodes { "boardId": "<BOARD_ID>", "type": "CHAPTER" }
 ```
-**Fallback (no MCP):**
-```bash
-curl -s "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes?type=CHAPTER"
-```
+**Fallback (no MCP):** see `references/api-fallback.md` — "Fetch all chapters".
 - If the value looks like a UUID, use it directly as `CHAPTER_ID`.
 - If it looks like a name, find the CHAPTER node whose `meta.title` matches (case-insensitive) and use its `id` as `CHAPTER_ID`.
 - If no match is found, tell the user and stop.
-Fetch the chapter node to read its grid structure.
+Fetch the chapter node to read its grid structure — `projection: "cells"` returns just `{rows, columns, cells}`, not the whole chapter node.
 **Prefer MCP:**
 ```
-mcp__eventmodelers__get_node { "boardId": "<BOARD_ID>", "nodeId": "<CHAPTER_ID>" }
+mcp__eventmodelers__get_node { "boardId": "<BOARD_ID>", "nodeId": "<CHAPTER_ID>", "projection": "cells" }
 ```
-**Fallback (no MCP):**
-```bash
-curl -s "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/$CHAPTER_ID"
-```
+**Fallback (no MCP):** see `references/api-fallback.md` — "Fetch the chapter's grid state".
-From `meta.timelineData`:
+From the result (`{rows, columns, cells}` via MCP's `projection: "cells"`, or `meta.timelineData` via the REST fallback):
 - `rows` — find the row with `type === "swimlane"` and save its `id` as `swimlaneRowId`
 - `columns` — ordered list of columns, each with an `id`
 - `cells` — each cell has `colId`, `rowId`, and optionally `nodeId`
@@ -98,10 +89,7 @@ Then load the existing EVENT nodes.
 mcp__eventmodelers__get_nodes { "boardId": "<BOARD_ID>", "type": "EVENT" }
 ```
-**Fallback (no MCP):**
-```bash
-curl -s "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes?type=EVENT"
-```
+**Fallback (no MCP):** see `references/api-fallback.md` — "Fetch all EVENT nodes".
 For each EVENT node, find its cell in `timelineData.cells` where `nodeId === event.id`. That cell's `colId` gives the `columnId`. Order events by their column's position in `timelineData.columns`.
@@ -126,12 +114,7 @@ If no `timelineId` is provided, **create the chapter immediately** — before an
 mcp__eventmodelers__create_chapter { "boardId": "<BOARD_ID>", "x": 0, "y": 0 }
 ```
-**Fallback (no MCP):**
-```bash
-curl -s -X POST "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/chapters" \
-  -H "Content-Type: application/json" \
-  -d '{"position":{"x":0,"y":0}}'
-```
+**Fallback (no MCP):** see `references/api-fallback.md` — "Create a new chapter".
 Extract `id` from the response → `CHAPTER_ID`. If this fails, stop and report the error.
@@ -184,19 +167,16 @@ Compare against the current `events` state:
 ### 3c — Inspect the timeline and maintain continuity
-Before placing any new events, fetch the chapter node to get the current grid state.
+Before placing any new events, fetch the chapter node to get the current grid state — `projection: "cells"` returns just `{rows, columns, cells}`, not the whole chapter node.
 **Prefer MCP:**
 ```
-mcp__eventmodelers__get_node { "boardId": "<BOARD_ID>", "nodeId": "<CHAPTER_ID>" }
+mcp__eventmodelers__get_node { "boardId": "<BOARD_ID>", "nodeId": "<CHAPTER_ID>", "projection": "cells" }
 ```
-**Fallback (no MCP):**
-```bash
-curl -s "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/$CHAPTER_ID"
-```
+**Fallback (no MCP):** see `references/api-fallback.md` — "Fetch the chapter's grid state".
-From `meta.timelineData`:
+From the result (`rows`/`columns`/`cells` directly via MCP, or under `meta.timelineData` via the REST fallback):
 - Read `rows` to find and save `swimlaneRowId` (the row whose `type === "swimlane"`).
 - Identify **empty columns**: columns where no cell has a `nodeId` set.
@@ -214,10 +194,7 @@ emptyColumns = [columnId, ...]   // in column order, ready to reuse
 mcp__eventmodelers__delete_column { "boardId": "<BOARD_ID>", "timelineId": "<CHAPTER_ID>", "columnId": "<columnId>" }
 ```
-**Fallback (no MCP):**
-```bash
-curl -s -X DELETE "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/timelines/$CHAPTER_ID/columns/<columnId>"
-```
+**Fallback (no MCP):** see `references/api-fallback.md` — "Delete a column".
 Make all necessary API calls for this turn before responding to the user. The board is updated **before** you summarise what changed.
@@ -279,23 +256,7 @@ mcp__eventmodelers__submit_node_events {
 }
 ```
-**Fallback (no MCP):**
-```bash
-curl -s -X POST "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/events" \
-  -H "Content-Type: application/json" \
-  -H "x-user-id: timeline-skill" \
-  -d '[{
-    "id": "<event-uuid>",
-    "eventType": "node:created",
-    "nodeId": "<node-uuid>",
-    "boardId": "<BOARD_ID>",
-    "timestamp": <Date.now()>,
-    "chapterId": "<CHAPTER_ID>",
-    "cellId": "<CELL_ID>",
-    "meta": { "type": "EVENT", "title": "<EventName>" },
-    "node": { "id": "<node-uuid>", "data": { "title": "<EventName>" } }
-  }]'
-```
+**Fallback (no MCP):** see `references/api-fallback.md` — "Create an EVENT node in a reused empty column".
 #### If no empty column is available — create one
@@ -350,22 +311,7 @@ mcp__eventmodelers__submit_node_events {
 }
 ```
-**Fallback (no MCP):**
-```bash
-curl -s -X POST "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/events" \
-  -H "Content-Type: application/json" \
-  -H "x-user-id: timeline-skill" \
-  -d '[{
-    "id": "<new-uuid>",
-    "eventType": "node:changed",
-    "nodeId": "<eventNodeId>",
-    "boardId": "<BOARD_ID>",
-    "timestamp": <Date.now()>,
-    "changedAttributes": ["meta.title"],
-    "meta": { "type": "EVENT", "title": "<NewTitle>" },
-    "node": { "id": "<eventNodeId>", "data": {} }
-  }]'
-```
+**Fallback (no MCP):** see `references/api-fallback.md` — "Rename an event".
 Update your local state: `events[i].title = "<NewTitle>"`.
@@ -380,19 +326,7 @@ Two steps — delete the node, then delete the column:
 mcp__eventmodelers__delete_node { "boardId": "<BOARD_ID>", "nodeId": "<eventNodeId>" }
 ```
-**Fallback (no MCP):**
-```bash
-curl -s -X POST "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/events" \
-  -H "Content-Type: application/json" \
-  -H "x-user-id: timeline-skill" \
-  -d '[{
-    "id": "<new-uuid>",
-    "eventType": "node:deleted",
-    "nodeId": "<eventNodeId>",
-    "boardId": "<BOARD_ID>",
-    "timestamp": <Date.now()>
-  }]'
-```
+**Fallback (no MCP):** see `references/api-fallback.md` — "Delete an event node".
 **2. Delete the column** using `columnId` from local state.
@@ -401,12 +335,9 @@ curl -s -X POST "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/events" \
 mcp__eventmodelers__delete_column { "boardId": "<BOARD_ID>", "timelineId": "<CHAPTER_ID>", "columnId": "<columnId>" }
 ```
-**Fallback (no MCP):**
-```bash
-curl -s -X DELETE "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/timelines/$CHAPTER_ID/columns/<columnId>"
-```
+**Fallback (no MCP):** see `references/api-fallback.md` — "Delete a column".
-If `columnId` is not in local state, fetch the chapter node (`mcp__eventmodelers__get_node { "boardId": "<BOARD_ID>", "nodeId": "<CHAPTER_ID>" }`, or the curl fallback above), scan `meta.timelineData.cells` for the cell where `nodeId === eventNodeId`, and use that cell's `colId`.
+If `columnId` is not in local state, fetch the chapter node (`mcp__eventmodelers__get_node { "boardId": "<BOARD_ID>", "nodeId": "<CHAPTER_ID>", "projection": "cells" }`, or the curl fallback above), scan `cells` for the cell where `nodeId === eventNodeId`, and use that cell's `colId`.
 Remove from local state and re-number remaining indexes.

package/stacks/modeling-kit/templates/.claude/skills/timeline/references/api-fallback.md ADDED Viewed

@@ -0,0 +1,91 @@
+# Timeline — curl Fallback Calls
+Only needed when MCP is not connected. Every call below has an MCP equivalent in the main SKILL.md — always prefer that.
+## Fetch all chapters (Steps 1a, 1b)
+```bash
+curl -s "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes?type=CHAPTER"
+```
+## Fetch the chapter's grid state (Steps 1b, 3c)
+```bash
+curl -s "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/$CHAPTER_ID"
+```
+Read `meta.timelineData` for `{rows, columns, cells}`.
+## Fetch all EVENT nodes (Step 1b)
+```bash
+curl -s "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes?type=EVENT"
+```
+## Create a new chapter (Step 1c)
+```bash
+curl -s -X POST "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/chapters" \
+  -H "Content-Type: application/json" \
+  -d '{"position":{"x":0,"y":0}}'
+```
+Extract `id` from the response → `CHAPTER_ID`.
+## Delete a column (Steps 3c, 4c)
+```bash
+curl -s -X DELETE "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/timelines/$CHAPTER_ID/columns/<columnId>"
+```
+## Create an EVENT node in a reused empty column (Step 4a)
+```bash
+curl -s -X POST "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/events" \
+  -H "Content-Type: application/json" \
+  -H "x-user-id: timeline-skill" \
+  -d '[{
+    "id": "<event-uuid>",
+    "eventType": "node:created",
+    "nodeId": "<node-uuid>",
+    "boardId": "<BOARD_ID>",
+    "timestamp": <Date.now()>,
+    "chapterId": "<CHAPTER_ID>",
+    "cellId": "<CELL_ID>",
+    "meta": { "type": "EVENT", "title": "<EventName>" },
+    "node": { "id": "<node-uuid>", "data": { "title": "<EventName>" } }
+  }]'
+```
+## Rename an event (Step 4b)
+```bash
+curl -s -X POST "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/events" \
+  -H "Content-Type: application/json" \
+  -H "x-user-id: timeline-skill" \
+  -d '[{
+    "id": "<new-uuid>",
+    "eventType": "node:changed",
+    "nodeId": "<eventNodeId>",
+    "boardId": "<BOARD_ID>",
+    "timestamp": <Date.now()>,
+    "changedAttributes": ["meta.title"],
+    "meta": { "type": "EVENT", "title": "<NewTitle>" },
+    "node": { "id": "<eventNodeId>", "data": {} }
+  }]'
+```
+## Delete an event node (Step 4c, part 1)
+```bash
+curl -s -X POST "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/events" \
+  -H "Content-Type: application/json" \
+  -H "x-user-id: timeline-skill" \
+  -d '[{
+    "id": "<new-uuid>",
+    "eventType": "node:deleted",
+    "nodeId": "<eventNodeId>",
+    "boardId": "<BOARD_ID>",
+    "timestamp": <Date.now()>
+  }]'
+```