@eventmodelers/cli 1.0.90 → 1.0.92

package/stacks/modeling-kit/templates/.claude/skills/eventmodeling-storyboarding-events/SKILL.md

@@ -90,12 +90,12 @@ Solution: Every event includes timestamp
 
 ## Board Integration
 
-Before starting the analysis, read existing screen nodes from the board to avoid designing screens that already exist. Screens created by this skill default to HTML_SCREEN, but older boards may still have plain SCREEN (sketch) nodes — check both types:
+Before starting the analysis, read existing screen nodes from the board to avoid designing screens that already exist. Screens created by this skill default to HTML_SCREEN, but older boards may still have plain SCREEN (sketch) nodes — check both types. Titles and field names are all this dedupe needs, so use `projection: "line"` (no HTML bodies); read a screen in full with `get_node` only if you must inspect its design:
 
 **Prefer MCP:**
 ```
-mcp__eventmodelers__get_nodes { "boardId": "$BOARD_ID", "type": "HTML_SCREEN" }
-mcp__eventmodelers__get_nodes { "boardId": "$BOARD_ID", "type": "SCREEN" }
+mcp__eventmodelers__get_nodes { "boardId": "$BOARD_ID", "type": "HTML_SCREEN", "projection": "line" }
+mcp__eventmodelers__get_nodes { "boardId": "$BOARD_ID", "type": "SCREEN", "projection": "line" }
 ```
 
 **Fallback (no MCP):** see `references/api-fallback.md` — "Board Integration — Check existing screen nodes".
@@ -219,8 +219,9 @@ Every screen node requires rendered content. **HTML_SCREEN (via the `html-screen
 1. Determine the target column (same column as the event/command for a command/input screen, OR the same column as the read model for a view/output screen — one column to the right only if that shared column isn't available).
 2. `actorRowId = roleLaneMap[<this screen's role>]` — the map was already resolved once for the whole chapter; do not re-fetch the chapter per screen. If this screen's role is genuinely new (wasn't in the original Role Catalog), resolve/create its lane now the same way (see above) and add it to the map before continuing.
 3. `cellId = actorRowId + "-" + columnId`
+4. For MCP `create_screen`, which takes only `cellName`: never derive it from array positions — read it from `get_board_outline` for that chapter (call it once if you don't already hold it): the column letter is the target column's `letter` there, the row number is the target lane's 1-based position in its `lanes` list (lanes are listed top to bottom, so the first lane is row 1) (e.g. column `letter: "E"`, this role's actor lane second in `lanes` → `E2`).
 
-**Step B (default) — Create the HTML_SCREEN node and render it in one atomic call.** Use `create_screen` with `contentType: "html"` — this creates the node, places it in `cellId`, and renders its pages together, so there is no window where the node exists without content:
+**Step B (default) — Create the HTML_SCREEN node and render it in one atomic call.** Use `create_screen` with `contentType: "html"` — this creates the node, places it in that cell, and renders its pages together, so there is no window where the node exists without content:
 
 **Prefer MCP:**
 ```
@@ -230,7 +231,7 @@ mcp__eventmodelers__create_screen {
     "contentType": "html",
     "nodeId": "<node-uuid>",
     "chapterId": "<CHAPTER_ID>",
-    "cellId": "<actorRowId>-<columnId>",
+    "cellName": "<cellName, e.g. E2>",
     "title": "<Screen Title>",
     "pages": ["<div>...</div>"],
     "description": "<concise description of what this screen shows>",
@@ -394,7 +395,7 @@ Older versions of this skill wrote the storyboard as a markdown document (swimla
 - [ ] **Every human role from the Role Catalog has at least one swimlane**
 - [ ] **Every human-role swimlane is labeled with the role name from the catalog**
 - [ ] **Swimlanes organized by actor/system in the narrative report**
-- [ ] **Every human role's swimlane is a real, distinct `actor`-type lane on the board (`meta.timelineData.rows`), not just a grouping in the markdown report** — no two different human roles share the same `actorRowId`
+- [ ] **Every human role's swimlane is a real, distinct `actor`-type lane on the board (the chapter's `rows`), not just a grouping in the markdown report** — no two different human roles share the same `actorRowId`
 - [ ] **No system actor / processor has been given its own labeled actor lane** — every AUTOMATION node sits in the chapter's default actor lane, never a lane fabricated to mimic a human role's
 - [ ] **Human role screens clearly separated from processor screens**
 - [ ] **Processor todo list pattern shown for automated systems**

package/stacks/modeling-kit/templates/.claude/skills/eventmodeling-storyboarding-events/references/api-fallback.md

@@ -6,16 +6,17 @@ Only needed when MCP is not connected. Every call below has an MCP equivalent in
 
 ```bash
 curl -s -H "x-token: $TOKEN" \
-  "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes?type=HTML_SCREEN"
+  "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes?type=HTML_SCREEN&projection=line"
 curl -s -H "x-token: $TOKEN" \
-  "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes?type=SCREEN"
+  "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes?type=SCREEN&projection=line"
 ```
 
 ## Resolve One Actor Lane Per Human Role — Step 1: Fetch the chapter's actor rows
 
 ```bash
 curl -s -H "x-token: $TOKEN" \
-  "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/$CHAPTER_ID"
+  "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/$CHAPTER_ID?projection=cells"
+# → {rows, columns, cells} directly — collect every row where type === "actor"
 ```
 
 ## Resolve One Actor Lane Per Human Role — Step 3: Create a new actor lane

package/stacks/modeling-kit/templates/.claude/skills/eventmodeling-validating-event-models/SKILL.md

@@ -27,13 +27,29 @@ The source can be also determined by looking at the defined Scenarios. Are all S
 
 Before starting, read the current board state to validate what is actually on the board.
 
-Prefer MCP — call `mcp__eventmodelers__get_nodes` once per type (no header wiring needed, auth resolves from the connected session):
+Prefer MCP (no header wiring needed, auth resolves from the connected session). Pick the read by what each check needs:
 
-```
-mcp__eventmodelers__get_nodes { "boardId": "$BOARD_ID", "type": "EVENT" }
-mcp__eventmodelers__get_nodes { "boardId": "$BOARD_ID", "type": "COMMAND" }
-mcp__eventmodelers__get_nodes { "boardId": "$BOARD_ID", "type": "READMODEL" }
-```
+- **Naming, past tense, duplicates, attribute names** — only titles, types and field names are needed, so call `get_nodes` once per type with the `line` projection (`{id, type, title, fields}`, `fields` = attribute names):
+
+  ```
+  mcp__eventmodelers__get_nodes { "boardId": "$BOARD_ID", "type": "EVENT", "projection": "line" }
+  mcp__eventmodelers__get_nodes { "boardId": "$BOARD_ID", "type": "COMMAND", "projection": "line" }
+  mcp__eventmodelers__get_nodes { "boardId": "$BOARD_ID", "type": "READMODEL", "projection": "line" }
+  ```
+
+- **Field-source traceability** (every command field comes from a connected read model or is marked generated) — needs field bodies and dependencies, so use the slice data `fields` projection per context:
+
+  ```
+  mcp__eventmodelers__get_slice_data { "boardId": "$BOARD_ID", "contextName": "<CONTEXT_NAME>", "projection": "fields", "format": "toon" }
+  ```
+
+- **Scenario coverage** — use the `specs` projection (given/when/then per slice, no elements):
+
+  ```
+  mcp__eventmodelers__get_slice_data { "boardId": "$BOARD_ID", "contextName": "<CONTEXT_NAME>", "projection": "specs", "format": "toon" }
+  ```
+
+  `specs` (like `outline`) only encodes as `json`, `yaml` or `toon`. Context names: `get_nodes { "type": "MODEL_CONTEXT", "projection": "line" }`, or a timeline name.
 
 **Fallback (no MCP):** see `references/api-fallback.md` — "Board Context".
 

package/stacks/modeling-kit/templates/.claude/skills/eventmodeling-validating-event-models/references/api-fallback.md

@@ -5,10 +5,19 @@ Only needed when MCP is not connected. Every call below has an MCP equivalent in
 ## Board Context
 
 ```bash
+# Naming / duplicates / attribute names — compact per-type lists
 curl -s -H "x-token: $TOKEN" \
-  "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes?type=EVENT"
+  "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes?type=EVENT&projection=line"
 curl -s -H "x-token: $TOKEN" \
-  "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes?type=COMMAND"
+  "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes?type=COMMAND&projection=line"
 curl -s -H "x-token: $TOKEN" \
-  "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes?type=READMODEL"
+  "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes?type=READMODEL&projection=line"
+
+# Field-source traceability — fields + dependencies per slice
+curl -s -H "x-token: $TOKEN" \
+  "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/slicedata?contextName=<CONTEXT_NAME>&projection=fields&format=toon"
+
+# Scenario coverage — specifications per slice (format must be json|yaml|toon)
+curl -s -H "x-token: $TOKEN" \
+  "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/slicedata?contextName=<CONTEXT_NAME>&projection=specs&format=toon"
 ```

package/stacks/modeling-kit/templates/.claude/skills/eventmodeling-validating-event-models-checklist/SKILL.md

@@ -38,13 +38,25 @@ Prefer `mcp__eventmodelers__*` tools when available (registered by the `connect`
 
 Read the current board state before running the checklist:
 
-**Prefer MCP:** call `get_nodes` once per type, or pull the fuller graph in one shot with `get_slice_data` if you need events/commands/readmodels/screens/specs/actors together:
+**Prefer MCP** — pick the read by what the phase checks:
 
-```
-mcp__eventmodelers__get_nodes { "boardId": "<BOARD_ID>", "type": "EVENT" }
-mcp__eventmodelers__get_nodes { "boardId": "<BOARD_ID>", "type": "COMMAND" }
-mcp__eventmodelers__get_nodes { "boardId": "<BOARD_ID>", "type": "READMODEL" }
-```
+- **Name/type checks** (Phase 1.1 timeline ownership by name, Phase 2.3 past tense, duplicate names) — `get_nodes` once per type with the `line` projection (`{id, type, title, fields}`, `fields` = attribute names only):
+
+  ```
+  mcp__eventmodelers__get_nodes { "boardId": "<BOARD_ID>", "type": "EVENT", "projection": "line" }
+  mcp__eventmodelers__get_nodes { "boardId": "<BOARD_ID>", "type": "COMMAND", "projection": "line" }
+  mcp__eventmodelers__get_nodes { "boardId": "<BOARD_ID>", "type": "READMODEL", "projection": "line" }
+  ```
+
+- **Field-level checks** (Phase 2.1/2.2 computed or mutable event data, Phase 3 read-model sources, Phase 5 traceability, Phase 7 structural shapes via dependencies) — the slice data `fields` projection per context: elements with fields and dependencies, no specs/comments:
+
+  ```
+  mcp__eventmodelers__get_slice_data { "boardId": "<BOARD_ID>", "contextName": "<CONTEXT_NAME>", "projection": "fields", "format": "toon" }
+  ```
+
+- **Business rules / scenarios** (Phase 4) — add `"projection": "specs"` (format `json`, `yaml` or `toon` only).
+
+Context names come from `get_nodes { "type": "MODEL_CONTEXT", "projection": "line" }` (or use a timeline name).
 
 **Fallback (no MCP):** see `references/api-fallback.md` — "Board Context".
 

package/stacks/modeling-kit/templates/.claude/skills/eventmodeling-validating-event-models-checklist/references/api-fallback.md

@@ -5,10 +5,19 @@ Only needed when MCP is not connected. Every call below has an MCP equivalent in
 ## Board Context
 
 ```bash
+# Name/type checks — compact per-type lists
 curl -s -H "x-token: $TOKEN" \
-  "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes?type=EVENT"
+  "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes?type=EVENT&projection=line"
 curl -s -H "x-token: $TOKEN" \
-  "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes?type=COMMAND"
+  "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes?type=COMMAND&projection=line"
 curl -s -H "x-token: $TOKEN" \
-  "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes?type=READMODEL"
+  "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes?type=READMODEL&projection=line"
+
+# Field-level checks — fields + dependencies per slice
+curl -s -H "x-token: $TOKEN" \
+  "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/slicedata?contextName=<CONTEXT_NAME>&projection=fields&format=toon"
+
+# Business rules / scenarios (format must be json|yaml|toon)
+curl -s -H "x-token: $TOKEN" \
+  "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/slicedata?contextName=<CONTEXT_NAME>&projection=specs&format=toon"
 ```

package/stacks/modeling-kit/templates/.claude/skills/examples/SKILL.md

@@ -42,8 +42,8 @@ A run that opens each element with its own `get_node` to "read existing examples
 Resolve `target` to a node, with whichever identifier it is:
 
 - `target` is a UUID → `mcp__eventmodelers__get_node { "boardId": "$BOARD_ID", "nodeId": "<target>" }`
-- `target` is a name → `mcp__eventmodelers__get_nodes { "boardId": "$BOARD_ID", "name": "<target>" }` — a partial, case-insensitive title match; prefer an exact title, and if several elements still match, list them and ask the user to pick one
-- `target` is a cell name (e.g. `B3`) → `mcp__eventmodelers__get_nodes { "boardId": "$BOARD_ID", "chapterId": "$CHAPTER_ID" }` and take the node whose `cellName` is `target` (if multiple chapters exist, find the chapter first with `get_nodes { "type": "CHAPTER" }` and ask the user if ambiguous). Never construct a cell address yourself — only use one you were given or read back as a node's `cellName`.
+- `target` is a name → `mcp__eventmodelers__get_nodes { "boardId": "$BOARD_ID", "name": "<target>", "projection": "line" }` — a partial, case-insensitive title match; `line` is enough to pick (ids/titles/types only); prefer an exact title, and if several elements still match, list them and ask the user to pick one. Then read the chosen node in full with `get_node` (Step 4 needs its fields' types and examples).
+- `target` is a cell name (e.g. `B3`) → `mcp__eventmodelers__get_board_outline { "boardId": "$BOARD_ID", "chapterId": "$CHAPTER_ID" }` (the only read that reports `cellName`) and take the node whose `cellName` is `target`, then read it in full by its id with `get_node` (if multiple chapters exist, find the chapter first with `get_nodes { "type": "CHAPTER", "projection": "line" }` and ask the user if ambiguous). If you already did the full chapter read from Step 1b, take the node by that id from there instead of `get_node`. Never construct a cell address yourself — only use one you were given or read back from `get_board_outline`; from then on address the element by its node id.
 
 Then continue with Step 3 (linked elements) — `mcp__eventmodelers__get_connected_nodes { "boardId": "$BOARD_ID", "nodeId": "<resolved id>", "includeFields": true }` returns the neighbours and their fields in one call.
 

package/stacks/modeling-kit/templates/.claude/skills/examples/references/api-fallback.md

@@ -15,15 +15,15 @@ curl -s "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/$target" \
 ```
 
 ### 2b — Name search
-If `target` is not a UUID, list the board's nodes and match on `meta.title` (the REST nodes endpoint has no name filter):
+If `target` is not a UUID, search by title with the `name` filter (partial, case-insensitive) — `projection=line` returns just `{id, type, title, fields}` per match, enough to pick one:
 
 ```bash
-curl -s "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes" \
-  -H "x-user-id: examples-skill" \
-  | jq --arg t "$target" '[.[] | select((.meta.title // "") | ascii_downcase | contains($t | ascii_downcase))]'
+curl -s -G "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes" \
+  --data-urlencode "name=$target" --data-urlencode "projection=line" \
+  -H "x-user-id: examples-skill"
 ```
 
-Pick the best match (exact title match preferred; case-insensitive). If multiple matches exist, list them and ask the user to pick one.
+Pick the best match (exact `title` match preferred; case-insensitive). If multiple matches exist, list them and ask the user to pick one. Then fetch the chosen node in full as in 2a — Step 4 needs its `meta.fields` with types and examples.
 
 ### 2c — Cell name (spreadsheet-style, e.g. "B3")
 If `target` matches the pattern `[A-Z]+[0-9]+`:
@@ -31,7 +31,7 @@ If `target` matches the pattern `[A-Z]+[0-9]+`:
 1. Fetch all chapters on the board to find the relevant timeline:
 
 ```bash
-curl -s "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes?type=CHAPTER" \
+curl -s "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes?type=CHAPTER&projection=line" \
   -H "x-user-id: examples-skill"
 ```
 
@@ -40,20 +40,20 @@ If multiple chapters exist, ask the user which one to use.
 2. Fetch the chapter **fresh** to decode the grid — never use cached chapter data, as cells are updated frequently:
 
 ```bash
-curl -s "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/$CHAPTER_ID" \
+curl -s "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/$CHAPTER_ID?projection=cells" \
   -H "x-user-id: examples-skill"
 ```
 
-From `meta.timelineData`, decode the cell name into a `cellId`:
+From the returned `{rows, columns, cells}` (not wrapped in `meta.timelineData`), decode the cell name into a `cellId`:
 - Column letter(s) → 0-based column index (A=0, B=1, … Z=25, AA=26, …)
 - Row digit → 0-based row index (1→0, 2→1, …)
 - Find the matching column in `columns` and the matching row in `rows`.
 - Compute: **`CELL_ID = row.id + "-" + column.id`** (cell IDs are always `<rowId>-<columnId>`).
 
-3. **Always fetch the cell live** to get the current node list — do not rely on the `nodeId` in the chapter's cell data, as it may be stale. No MCP equivalent: `get_nodes` only filters by `type`, not `cellId`:
+3. **Always fetch the cell live** to get the current node list — do not rely on the `nodeId` in the chapter's cell data, as it may be stale. No MCP equivalent: `get_nodes` filters by `type`, `name`, `chapterId` and `nodeIds`, but not `cellId`. The REST `cellId` filter requires `timelineId`:
 
 ```bash
-curl -s "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes?cellId=$CELL_ID" \
+curl -s "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes?cellId=$CELL_ID&timelineId=$CHAPTER_ID" \
   -H "x-user-id: examples-skill"
 ```
 
@@ -61,21 +61,27 @@ Use the first non-CHAPTER result (filter out CHAPTER type).
 
 If no element is found after all strategies, stop and tell the user what was tried.
 
-Save the resolved node as `TARGET_NODE` (full JSON including `id`, `meta`, `edges`).
+Save the resolved node as `TARGET_NODE` (full JSON including `id` and `meta`).
 
 ## Step 3 — Load linked elements for context
 
 Collect nearby elements to understand the domain context and generate consistent examples. **Never fetch all board nodes.** Only fetch specific nodes you already have IDs for.
 
 ### 3a — Nodes from edges
-If `TARGET_NODE.edges` is non-empty, fetch each connected node individually by its ID:
+Read the target's connections only (`projection=edges` → `{nodeId, edges}`, no node content; the full node record carries no edges):
 
 ```bash
-curl -s "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/<EDGE_NODE_ID>" \
+curl -s "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/$TARGET_ID?projection=edges" \
   -H "x-user-id: examples-skill"
 ```
 
-Fetch all edge-connected nodes in parallel (one request per node ID).
+If `edges` is non-empty, fetch every connected node (the `source`/`target` that isn't `TARGET_ID`) in full — Step 3c needs their field examples — in one call:
+
+```bash
+curl -s -X POST "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/query" \
+  -H "Content-Type: application/json" -H "x-user-id: examples-skill" \
+  -d '{"ids": ["<EDGE_NODE_ID>", "..."]}'
+```
 
 ### 3b — Nodes from the same column (cell-based resolution only)
 If you resolved `TARGET_NODE` via a cell name (Step 2c), you already have the full chapter `cells` array in memory. Use it — **no extra API call needed**:

package/stacks/modeling-kit/templates/.claude/skills/place-element/SKILL.md

@@ -64,10 +64,10 @@ This tool finds or creates an empty cell in the correct lane and places the node
 
 ## Step 2 — Resolve the timeline
 
-**Prefer MCP:**
+**Prefer MCP** — ids and titles are all this step needs, so use `projection: "line"` (without it every chapter's full grid comes back):
 
 ```
-mcp__eventmodelers__get_nodes { "boardId": "<BOARD_ID>", "type": "CHAPTER" }
+mcp__eventmodelers__get_nodes { "boardId": "<BOARD_ID>", "type": "CHAPTER", "projection": "line" }
 ```
 
 **Fallback (no MCP):** see `references/api-fallback.md` — "Step 2 — Discover chapters". If `timelineId` is not provided, this discovers chapters on the board.
@@ -90,7 +90,7 @@ mcp__eventmodelers__get_node { "boardId": "<BOARD_ID>", "nodeId": "<TIMELINE_ID>
 
 **Fallback (no MCP):** see `references/api-fallback.md` — "Step 3 — Fetch the chapter node".
 
-Read `columns` (ordered array of column objects with `id` and `index`) and `cells` (from the result directly via MCP, or from `meta.timelineData` via the REST fallback).
+Read `columns` (ordered array of column objects with `id` and `index`) and `cells` (directly from the result — MCP and the REST fallback's `?projection=cells` return the same `{rows, columns, cells}` shape).
 
 Then resolve `position`:
 
@@ -191,7 +191,7 @@ Save `columnId` from the response.
 
 ## Step 6 — Compute the target cell ID and check availability
 
-Using the `timelineData` already fetched in Step 3 (re-fetch if a column was just created):
+Using the `{rows, columns, cells}` grid already fetched in Step 3 (re-fetch if a column was just created):
 
 - Find the row in `rows` whose `type` matches the target lane (`swimlane`, `interaction`, or `actor`).
 - Compute the cell ID directly: **`CELL_ID = targetRow.id + "-" + columnId`**
@@ -208,7 +208,7 @@ Cell IDs are always `<rowId>-<columnId>` — no cell array search needed.
 
 **Fastest path**: use the `cells` array you already fetched in Step 3 via `get_node` (`projection: "cells"`) on the chapter/timeline node — `cells` is a sparse array, so a `nodeId` absent from the entry for `CELL_ID` means the cell is empty. Also scan it for the column-wide conflict from the rule above: any entry with `colId === columnId` and `nodeType === elementType` (for COMMAND/READMODEL/SCREEN/AUTOMATION) means the column is occupied even though `CELL_ID` itself is free. This avoids an extra round-trip, but can be stale if a column was just created in Step 5 — re-fetch first in that case.
 
-**No direct MCP equivalent** for querying by cell/column: `get_nodes` only filters by `type`. The REST API does support it directly though — `GET /nodes` takes `cellId` **or** `colId`, both requiring `timelineId`:
+**No direct MCP equivalent** for querying by cell/column: `get_nodes` filters by `type`, `name`, `chapterId` and `nodeIds`, but has no `cellId`/`colId` filter. The REST API does support it directly though — `GET /nodes` takes `cellId` **or** `colId`, both requiring `timelineId`:
 
 ```bash
 # Same-cell occupancy — returns [] if empty, or [nodeRecord] if occupied
@@ -218,7 +218,7 @@ curl -s "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes?cellId=$CELL_ID&timeli
 curl -s "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes?colId=$COLUMN_ID&timelineId=$TIMELINE_ID"
 ```
 
-Use this REST call (see the curl fallback below) when you don't already have fresh `timelineData` loaded, instead of re-fetching the whole chapter node just to check occupancy.
+Use this REST call (see the curl fallback below) when you don't already have a fresh grid loaded, instead of re-fetching the chapter just to check occupancy.
 
 **Fallback (no MCP):** see `references/api-fallback.md` — "Step 6 — Check cell occupancy".
 
@@ -281,7 +281,7 @@ mcp__eventmodelers__create_screen {
     "contentType": "html",
     "nodeId": "<node-uuid>",
     "chapterId": "<TIMELINE_ID>",
-    "cellId": "<CELL_ID>",
+    "cellName": "<CELL_NAME>",
     "title": "<title>",
     "pages": ["<div>...</div>"],
     "description": "<title — what this screen shows>"
@@ -302,7 +302,7 @@ mcp__eventmodelers__create_screen {
     "contentType": "sketch",
     "nodeId": "<node-uuid>",
     "chapterId": "<TIMELINE_ID>",
-    "cellId": "<CELL_ID>",
+    "cellName": "<CELL_NAME>",
     "title": "<title>",
     "elements": [...],
     "description": "<title — what this screen shows>"
@@ -312,7 +312,7 @@ mcp__eventmodelers__create_screen {
 
 **Fallback (no MCP):** see `references/api-fallback.md` — "Step 7a — SCREEN: create and render (sketch path, explicit request only)".
 
-Pass whichever cell reference you already resolved — `CELL_ID` from Step 6, or `CELL_NAME` from Step 1's fast path (either path accepts `cellId` or `cellName`). Expect success (MCP: `created: true`; curl: `204`). On failure, read the validation error, fix the payload, and retry once. Then skip the rest of Step 7 and go to Step 8.
+MCP `create_screen` takes only `cellName`: pass `CELL_NAME` from Step 1's fast path as-is, or, on the normal path, don't convert Step 6's `CELL_ID` from array positions — read it from `get_board_outline` for that chapter (call it once if you don't already hold it): the column letter is the target column's `letter` there, the row number is the target lane's 1-based position in its `lanes` list (lanes are listed top to bottom, so the first lane is row 1) (e.g. column `letter: "C"`, the target lane second in `lanes` → `C2`). The curl fallback still accepts `cellId`. Expect success (MCP: `created: true`; curl: `204`). On failure, read the validation error, fix the payload, and retry once. Then skip the rest of Step 7 and go to Step 8.
 
 ### Step 7b — All other element types
 
@@ -372,14 +372,14 @@ Response: `{ "hashes": { "<event-id>": "<hash>" } }` — keyed by the `id` you s
 
 **A command is never issued by more than one thing.** The server's fire-and-forget auto-connect (`learn-eventmodelers-api` §3) already enforces this — it skips wiring the previous column's SCREEN/AUTOMATION into a COMMAND that already has an inbound trigger, whether that trigger came from the COMMAND's own column or from a pre-existing edge in the DB. Still, run this check whenever `elementType` is `SCREEN`, `AUTOMATION`, or `COMMAND` as a sanity check — e.g. a manual `set_connection` call, or an edge created before this guard existed, can still leave a COMMAND with two issuers.
 
-After placing, resolve the relevant COMMAND node (the one just placed, or the one in the same/adjacent column as the SCREEN/AUTOMATION just placed) and inspect its edges:
+After placing, resolve the relevant COMMAND node (the one just placed, or the one in the same/adjacent column as the SCREEN/AUTOMATION just placed) and inspect its edges — only its connections are needed, so use `projection: "edges"` (the full node record carries no edges):
 
 **Prefer MCP:**
 ```
-mcp__eventmodelers__get_node { "boardId": "<BOARD_ID>", "nodeId": "<COMMAND_NODE_ID>" }
+mcp__eventmodelers__get_node { "boardId": "<BOARD_ID>", "nodeId": "<COMMAND_NODE_ID>", "projection": "edges" }
 ```
 
-Count inbound edges where `target === COMMAND_NODE_ID` and the source node is type `SCREEN` or `AUTOMATION`.
+Take the inbound edges (`target === COMMAND_NODE_ID`) and resolve their source types in one call — only `type` is needed, so `get_nodes { "boardId": "<BOARD_ID>", "nodeIds": [<every inbound source id>], "projection": "line" }`. Count the inbound edges whose source node is type `SCREEN`, `HTML_SCREEN` or `AUTOMATION`.
 
 - **0 or 1 such edge** → fine, nothing to do.
 - **2 or more** → keep the edge whose source sits in the COMMAND's own column (the deliberate, same-slice issuer) and remove every other one:

package/stacks/modeling-kit/templates/.claude/skills/place-element/references/api-fallback.md

@@ -5,15 +5,17 @@ Only needed when MCP is not connected. Every call below has an MCP equivalent in
 ## Step 2 — Discover chapters
 
 ```bash
-curl -s "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes?type=CHAPTER"
+curl -s "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes?type=CHAPTER&projection=line"
 ```
 
 ## Step 3 — Fetch the chapter node (columns + cells)
 
 ```bash
-curl -s "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/$TIMELINE_ID"
+curl -s "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/$TIMELINE_ID?projection=cells"
 ```
 
+Returns `{rows, columns, cells}` directly (not wrapped in `meta.timelineData`).
+
 ## Step 4a — SCENARIO: append scenarios via the spec endpoint
 
 ```bash
@@ -66,7 +68,7 @@ curl -s "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes?cellId=$CELL_ID&timeli
 curl -s "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes?colId=$COLUMN_ID&timelineId=$TIMELINE_ID"
 ```
 
-If you already have fresh `timelineData` loaded from Step 3, reading its `cells` array directly (sparse — an entry only exists once something has been placed there) avoids the extra round-trip; use the calls above otherwise, or when `timelineData` might be stale (e.g. a column was just created).
+If you already have a fresh grid loaded from Step 3, reading its `cells` array directly (sparse — an entry only exists once something has been placed there) avoids the extra round-trip; use the calls above otherwise, or when the grid might be stale (e.g. a column was just created).
 
 ## Step 6 — Insert a column at a specific index (conflict resolution)
 
@@ -176,7 +178,7 @@ curl -s -X POST "http://localhost:3000/api/org/<ORG_ID>/boards/<BOARD_ID>/timeli
 
 # 2. Fetch chapter to find the target lane cell for the new column
 curl -s -H "x-user-id: place-element-skill" \
-  "http://localhost:3000/api/org/<ORG_ID>/boards/<BOARD_ID>/nodes/<TIMELINE_ID>"
+  "http://localhost:3000/api/org/<ORG_ID>/boards/<BOARD_ID>/nodes/<TIMELINE_ID>?projection=cells"
 
 # 3. Create the EVENT node — do not skip the x-user-id header
 curl -s -X POST "http://localhost:3000/api/org/<ORG_ID>/boards/<BOARD_ID>/nodes/events" \

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

@@ -123,7 +123,7 @@ mcp__eventmodelers__get_node { "boardId": "<BOARD_ID>", "nodeId": "<CHAPTER_ID>"
 
 **Fallback (no MCP):** see `references/api-fallback.md` — "Step 4 — Fetch the chapter's grid state".
 
-Parse the result (`{rows, columns, cells}` directly via MCP, or `meta.timelineData` via the REST fallback):
+Parse the result (`{rows, columns, cells}` directly — the REST fallback's `?projection=cells` returns the same shape):
 - `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)
@@ -183,7 +183,7 @@ mcp__eventmodelers__create_screen {
     "contentType": "html",
     "nodeId": "<SCREEN_NODE_ID>",
     "chapterId": "<CHAPTER_ID>",
-    "cellId": "<actorCellId>",
+    "cellName": "<actorCellName>",
     "title": "<screenTitle>",
     "pages": ["<div>...</div>"],
     "description": "<screenTitle — what this screen shows>"
@@ -204,7 +204,7 @@ mcp__eventmodelers__create_screen {
     "contentType": "sketch",
     "nodeId": "<SCREEN_NODE_ID>",
     "chapterId": "<CHAPTER_ID>",
-    "cellId": "<actorCellId>",
+    "cellName": "<actorCellName>",
     "title": "<screenTitle>",
     "elements": [...],
     "description": "<screenTitle — what this screen shows>"
@@ -214,7 +214,7 @@ mcp__eventmodelers__create_screen {
 
 **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.
+MCP `create_screen` takes only `cellName`. Don't derive `actorCellName` from array positions in the grid — read it from `get_board_outline` for that chapter (call it once if you don't already hold it): the column letter is the target column's `letter` there, the row number is the target lane's 1-based position in its `lanes` list (lanes are listed top to bottom, so the first lane is row 1) (e.g. column `letter: "D"`, the actor lane first in `lanes` → `D1`). A column appended by `add_column` only has a letter once you re-read the outline. The curl fallback still takes the computed `actorCellId` as `cellId`. 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)
 

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

@@ -15,10 +15,10 @@ 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"
+curl -s "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/$CHAPTER_ID?projection=cells"
 ```
 
-Read `meta.timelineData` for `{rows, columns, cells}`.
+Returns `{rows, columns, cells}` directly (not wrapped in `meta.timelineData`).
 
 ## Step 5a — Add a column
 

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

@@ -31,11 +31,11 @@ From `$ARGUMENTS` and the conversation, extract:
 
 ### 1a — Discover existing timelines
 
-Before doing anything else, fetch all chapters (timelines) on the board.
+Before doing anything else, fetch all chapters (timelines) on the board — only ids and titles are needed to list/pick one, so use `projection: "line"` (without it every chapter's full grid comes back).
 
 **Prefer MCP:**
 ```
-mcp__eventmodelers__get_nodes { "boardId": "<BOARD_ID>", "type": "CHAPTER" }
+mcp__eventmodelers__get_nodes { "boardId": "<BOARD_ID>", "type": "CHAPTER", "projection": "line" }
 ```
 
 **Fallback (no MCP):** see `references/api-fallback.md` — "Fetch all chapters".
@@ -55,17 +55,17 @@ mcp__eventmodelers__get_nodes { "boardId": "<BOARD_ID>", "type": "CHAPTER" }
 
 A chapter and a timeline are the same thing — the terms are interchangeable.
 
-If `timelineId` is provided, first resolve it to a UUID if a name was given instead.
+If `timelineId` is provided, first resolve it to a UUID if a name was given instead (ids and titles only — `projection: "line"`).
 
 **Prefer MCP:**
 ```
-mcp__eventmodelers__get_nodes { "boardId": "<BOARD_ID>", "type": "CHAPTER" }
+mcp__eventmodelers__get_nodes { "boardId": "<BOARD_ID>", "type": "CHAPTER", "projection": "line" }
 ```
 
 **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 it looks like a name, find the CHAPTER node whose `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 — `projection: "cells"` returns just `{rows, columns, cells}`, not the whole chapter node.
@@ -77,21 +77,21 @@ mcp__eventmodelers__get_node { "boardId": "<BOARD_ID>", "nodeId": "<CHAPTER_ID>"
 
 **Fallback (no MCP):** see `references/api-fallback.md` — "Fetch the chapter's grid state".
 
-From the result (`{rows, columns, cells}` via MCP's `projection: "cells"`, or `meta.timelineData` via the REST fallback):
+From the result (`{rows, columns, cells}` — both MCP and the REST fallback use `projection=cells`):
 - `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`
 
-Then load the existing EVENT nodes.
+Then load the existing EVENT nodes of this chapter — only `id` and `title` are needed (the column comes from `cells`), so use `projection: "line"`.
 
 **Prefer MCP:**
 ```
-mcp__eventmodelers__get_nodes { "boardId": "<BOARD_ID>", "type": "EVENT" }
+mcp__eventmodelers__get_nodes { "boardId": "<BOARD_ID>", "type": "EVENT", "chapterId": "<CHAPTER_ID>", "projection": "line" }
 ```
 
 **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`.
+For each EVENT node, find its cell in `cells` where `nodeId === event.id`. That cell's `colId` gives the `columnId`. Order events by their column's position in `columns`.
 
 Set `CHAPTER_ID = <resolved uuid>`.
 
@@ -176,7 +176,7 @@ mcp__eventmodelers__get_node { "boardId": "<BOARD_ID>", "nodeId": "<CHAPTER_ID>"
 
 **Fallback (no MCP):** see `references/api-fallback.md` — "Fetch the chapter's grid state".
 
-From the result (`rows`/`columns`/`cells` directly via MCP, or under `meta.timelineData` via the REST fallback):
+From the result (`rows`/`columns`/`cells` directly, via MCP or the REST fallback's `?projection=cells`):
 - Read `rows` to find and save `swimlaneRowId` (the row whose `type === "swimlane"`).
 - Identify **empty columns**: columns where no cell has a `nodeId` set.
 

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

@@ -5,21 +5,21 @@ Only needed when MCP is not connected. Every call below has an MCP equivalent in
 ## Fetch all chapters (Steps 1a, 1b)
 
 ```bash
-curl -s "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes?type=CHAPTER"
+curl -s "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes?type=CHAPTER&projection=line"
 ```
 
 ## Fetch the chapter's grid state (Steps 1b, 3c)
 
 ```bash
-curl -s "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/$CHAPTER_ID"
+curl -s "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/$CHAPTER_ID?projection=cells"
 ```
 
-Read `meta.timelineData` for `{rows, columns, cells}`.
+Returns `{rows, columns, cells}` directly (not wrapped in `meta.timelineData`).
 
 ## Fetch all EVENT nodes (Step 1b)
 
 ```bash
-curl -s "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes?type=EVENT"
+curl -s "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes?type=EVENT&chapterId=$CHAPTER_ID&projection=line"
 ```
 
 ## Create a new chapter (Step 1c)