@eventmodelers/cli 1.0.90 → 1.0.91

package/stacks/modeling-kit/templates/.claude/skills/analyze-existing-model/SKILL.md

@@ -45,30 +45,37 @@ Save the full slice list. Count total slices and group by status:
 
 ## Step 3 — Discover contexts
 
-Fetch all `MODEL_CONTEXT` nodes to identify bounded contexts on the board:
+Fetch the `MODEL_CONTEXT` nodes **and** the timelines — a timeline with no assigned or connected context is its own context (named after the timeline), so the MODEL_CONTEXT nodes alone miss it. Only ids and titles are needed, so use the `line` projection:
 
 **Prefer MCP:**
 ```
-mcp__eventmodelers__get_nodes { "boardId": "$BOARD_ID", "type": "MODEL_CONTEXT" }
+mcp__eventmodelers__get_nodes { "boardId": "$BOARD_ID", "type": "MODEL_CONTEXT", "projection": "line" }
+mcp__eventmodelers__get_nodes { "boardId": "$BOARD_ID", "type": "CHAPTER", "projection": "line" }
 ```
 
 **Fallback (no MCP):** see `references/api-fallback.md` — "Step 3 — Discover contexts".
 
 - If a `contextName` argument was given, filter to that single context and skip others.
-- If no `MODEL_CONTEXT` nodes exist, continue with a single unnamed context scope.
-- Record each context's `id` and `title`.
+- Record each MODEL_CONTEXT's `id` and `title`, and each timeline's `id` and `title`.
+- Step 4 fetches every MODEL_CONTEXT by title first. Each slice in a response carries its `chapter`; every timeline never named there is its own context (or holds no slices) — fetch it too, passing the timeline's title as `contextName`. With no MODEL_CONTEXT nodes at all, that is every timeline.
 
 ---
 
 ## Step 4 — Fetch slice data per context
 
-For each resolved context, fetch the full element graph:
+For each resolved context, fetch two trimmed projections instead of the full graph — this analysis never needs comments, codegen prompts, notes or screen images:
 
 **Prefer MCP:**
 ```
-mcp__eventmodelers__get_slice_data { "boardId": "$BOARD_ID", "contextName": "<CONTEXT_NAME>" }
+mcp__eventmodelers__get_slice_data { "boardId": "$BOARD_ID", "contextName": "<CONTEXT_NAME>", "projection": "fields", "format": "toon" }
+mcp__eventmodelers__get_slice_data { "boardId": "$BOARD_ID", "contextName": "<CONTEXT_NAME>", "projection": "specs", "format": "toon" }
 ```
 
+- `fields` — slice header (id, title, status, sliceType, chapter, context) plus every element with its fields and **dependencies**. Covers 5a (inventory), 5b (status), 5d (gaps) and 5f (structural shapes — the bed needs the SCREEN → COMMAND dependencies).
+- `specs` — slice header plus specifications (given/when/then) and storylines, no elements. Covers 5c (spec coverage).
+- If the user only asked for counts/status/coverage (no gap or shape check), use `"projection": "outline"` instead of `fields` — elements as `{id, title, type}` only, the cheapest read.
+- `outline` and `specs` only encode as `json`, `yaml` or `toon` (`textual`/`emlang`/`esdm` return `PROJECTION_FORMAT_UNSUPPORTED`); use `toon` (token-efficient) or `json`.
+
 **Fallback (no MCP):** see `references/api-fallback.md` — "Step 4 — Fetch slice data per context".
 
 Fetch all contexts in parallel if there are multiple. Merge results, keyed by context name.
@@ -97,7 +104,7 @@ Group slices by status. Report counts per status. Flag any status that suggests
 
 ### 5c — Spec coverage
 
-For each slice, check whether `specs` is non-empty. Calculate:
+For each slice in the `specs` projection, check whether its specifications are non-empty. Calculate:
 - Slices **with** at least one GWT scenario
 - Slices **without** any scenarios (grouped by slice type if detectable)
 
@@ -201,8 +208,10 @@ If a context was specified but not found, tell the user clearly and list the con
 **Prefer MCP:**
 ```
 mcp__eventmodelers__list_slices { "boardId": "$BOARD_ID" }
-mcp__eventmodelers__get_nodes { "boardId": "$BOARD_ID", "type": "MODEL_CONTEXT" }
-mcp__eventmodelers__get_slice_data { "boardId": "$BOARD_ID", "contextName": "Ordering" }
+mcp__eventmodelers__get_nodes { "boardId": "$BOARD_ID", "type": "MODEL_CONTEXT", "projection": "line" }
+mcp__eventmodelers__get_nodes { "boardId": "$BOARD_ID", "type": "CHAPTER", "projection": "line" }
+mcp__eventmodelers__get_slice_data { "boardId": "$BOARD_ID", "contextName": "Ordering", "projection": "fields", "format": "toon" }
+mcp__eventmodelers__get_slice_data { "boardId": "$BOARD_ID", "contextName": "Ordering", "projection": "specs", "format": "toon" }
 ```
 
 **Fallback (no MCP):** see `references/api-fallback.md` — "Example — full board analysis".

package/stacks/modeling-kit/templates/.claude/skills/analyze-existing-model/references/api-fallback.md

@@ -19,23 +19,35 @@ Response: `{ "slices": [{ "id": "<uuid>", "title": "<name>", "status": "<status>
 curl -s \
   -H "x-token: $TOKEN" \
   -H "x-user-id: analyze-existing-model" \
-  "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes?type=MODEL_CONTEXT"
+  "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes?type=MODEL_CONTEXT&projection=line"
+
+# Timelines too — one without a context is its own context, named after the timeline
+curl -s \
+  -H "x-token: $TOKEN" \
+  -H "x-user-id: analyze-existing-model" \
+  "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes?type=CHAPTER&projection=line"
 ```
 
+Returns `{id, type, title}` per node — all this step needs.
+
 ## Step 4 — Fetch slice data per context
 
 ```bash
 curl -s \
   -H "x-token: $TOKEN" \
   -H "x-user-id: analyze-existing-model" \
-  "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/slicedata?contextName=<CONTEXT_NAME>"
+  "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/slicedata?contextName=<CONTEXT_NAME>&projection=fields&format=toon"
+
+curl -s \
+  -H "x-token: $TOKEN" \
+  -H "x-user-id: analyze-existing-model" \
+  "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/slicedata?contextName=<CONTEXT_NAME>&projection=specs&format=toon"
 ```
 
-Each response contains a `slices` array. Each slice entry includes:
-- `id`, `title`, `status`
-- `elements`: array of `{ type, id, title, fields[] }`  — element types: `EVENT`, `COMMAND`, `READMODEL`, `SCREEN`, `AUTOMATION`
-- `specs`: array of GWT scenarios (may be empty)
-- `edges`: relationships between elements
+- `projection=fields` — slice header (id, title, status, sliceType, chapter, context) + elements (commands, events, readmodels, screens, processors, tables) with their fields and dependencies. No specs/comments.
+- `projection=specs` — slice header + specifications (given/when/then) and storylines. No elements.
+- `projection=outline` — slice header + elements as `{id, title, type}` only; use it instead of `fields` when no gap/shape check is needed.
+- `outline` and `specs` require `format=json|yaml|toon` (others → 400 `PROJECTION_FORMAT_UNSUPPORTED`).
 
 ## Example — full board analysis
 
@@ -46,17 +58,25 @@ curl -s \
   -H "x-user-id: analyze-existing-model" \
   "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/slicedata/slices"
 
-# 2. Fetch MODEL_CONTEXT nodes
+# 2. Fetch MODEL_CONTEXT nodes and timelines (a timeline without a context is its own context)
+curl -s \
+  -H "x-token: $TOKEN" \
+  -H "x-user-id: analyze-existing-model" \
+  "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes?type=MODEL_CONTEXT&projection=line"
 curl -s \
   -H "x-token: $TOKEN" \
   -H "x-user-id: analyze-existing-model" \
-  "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes?type=MODEL_CONTEXT"
+  "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes?type=CHAPTER&projection=line"
 
-# 3. Fetch full slice data for a context
+# 3. Fetch fields + specs projections for a context
+curl -s \
+  -H "x-token: $TOKEN" \
+  -H "x-user-id: analyze-existing-model" \
+  "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/slicedata?contextName=Ordering&projection=fields&format=toon"
 curl -s \
   -H "x-token: $TOKEN" \
   -H "x-user-id: analyze-existing-model" \
-  "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/slicedata?contextName=Ordering"
+  "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/slicedata?contextName=Ordering&projection=specs&format=toon"
 ```
 
 Replace `$TOKEN`, `$ORG_ID`, `$BOARD_ID`, and the context name with real values resolved from the `connect` skill.

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

@@ -1,6 +1,6 @@
 ---
 name: attributes
-description: Add a new attribute or rename an existing attribute across a chain of elements from a source cell to a target cell, following inbound dependencies
+description: Add a new attribute or rename an existing attribute across a chain of elements from a source element to a target element, following inbound dependencies
 ---
 
 # Attributes
@@ -9,7 +9,7 @@ description: Add a new attribute or rename an existing attribute across a chain
 
 Prefer `mcp__eventmodelers__*` tools when available (registered by the `connect` skill) — the curl blocks below are the fallback for sessions without MCP connected.
 
-You are propagating an attribute change (add or rename) across a chain of elements on an eventmodelers board. You start at the target cell, apply the change, then walk backwards through inbound dependencies until you reach the source cell, applying the change to every element along the way.
+You are propagating an attribute change (add or rename) across a chain of elements on an eventmodelers board. You start at the target element, apply the change, then walk backwards through inbound dependencies until you reach the source element, applying the change to every element along the way.
 
 ---
 
@@ -17,8 +17,8 @@ You are propagating an attribute change (add or rename) across a chain of elemen
 
 Ask the user for all required information **in a single message** (do not ask one at a time):
 
-1. **Target cell** — the end of the chain (e.g. `B2`)
-2. **Source cell** — the start of the chain (e.g. `A2`)
+1. **Target element** — the end of the chain: a node id, a title, or a cell name (e.g. `B2`)
+2. **Source element** — the start of the chain: a node id, a title, or a cell name (e.g. `A2`)
 3. **Operation** — `add` a new attribute, or `rename` an existing one
 4. If **rename**: which attribute name to rename FROM, and what to rename it TO
 5. If **add**: the name of the new attribute to add
@@ -29,24 +29,27 @@ If any of these were already provided in `$ARGUMENTS`, skip asking for them.
 
 ## Step 2 — Resolve the chain
 
-**Prefer MCP:** `get_attribute_chain` resolves every node between the source and target cells (inclusive), ordered target→source, each with its full `fields[]` — this collapses the manual cell-resolution and inbound-edge walk below into one call. You still need `TIMELINE_ID` (the chapter to search): if multiple chapters exist on the board, resolve which one first (see 2a fallback below, or `mcp__eventmodelers__get_nodes { "boardId": "$BOARD_ID", "type": "CHAPTER" }`) and ask the user if ambiguous.
+**Prefer MCP:** `get_attribute_chain` resolves every node in the columns between the source and target nodes (inclusive), ordered target→source (top-to-bottom within a column), each as `{id, type, title, cellName, fields}` — this collapses the manual inbound-edge walk below into one call. You still need `TIMELINE_ID` (the chapter to search): if multiple chapters exist on the board, resolve which one first (see 2a fallback below, or `mcp__eventmodelers__get_nodes { "boardId": "$BOARD_ID", "type": "CHAPTER", "projection": "line" }` — ids/titles are enough to pick one) and ask the user if ambiguous.
+
+First resolve target and source to node ids (`TARGET_NODE_ID`, `SOURCE_NODE_ID`):
+- **Node id** (incl. a node the task or a comment points at) — use it as-is.
+- **Title** — `mcp__eventmodelers__get_nodes { "boardId": "$BOARD_ID", "chapterId": "$CHAPTER_ID", "name": "<title>", "projection": "line" }`; ask the user if several match.
+- **Cell name** (e.g. `B2`) — `mcp__eventmodelers__get_board_outline { "boardId": "$BOARD_ID", "chapterId": "$CHAPTER_ID" }` and take the node whose `cellName` equals it. `get_board_outline` is the only read that reports `cellName`; never compute a node from a cell address yourself.
 
 ```
 mcp__eventmodelers__get_attribute_chain {
   "boardId": "$BOARD_ID",
   "timelineId": "$CHAPTER_ID",
-  "targetCellName": "<target cell, e.g. B2>",
-  "sourceCellName": "<source cell, e.g. A2>"
+  "targetNodeId": "<TARGET_NODE_ID>",
+  "sourceNodeId": "<SOURCE_NODE_ID>"
 }
 ```
 
-The result gives you the ordered chain directly — save it as the chain used in Step 4, and skip the manual walk in 2a–3c below. Continue with the fallback only if MCP isn't connected.
-
-**Both cell names must be real.** When the task named a node (an id, a title, a comment on it) instead of a cell, read that node's `cellName` off `get_board_outline` (every node in the chapter, with its address), `get_nodes`, or `get_node` — all three report it. Never compute an address from where a node appeared in a list, and never hand `get_attribute_chain` an address you have not read: a cell that exists but holds a different node resolves a wrong chain without any error.
+The result gives you the ordered chain directly — save it as the chain used in Step 4, and skip the manual walk in 2a–3c below. A `NODE_NOT_IN_TIMELINE` error means one of the two nodes isn't placed in `$CHAPTER_ID` — pick the right chapter (or tell the user) rather than retrying. Continue with the fallback only if MCP isn't connected.
 
-### Fallback (no MCP) — resolve both cells to nodes
+### Fallback (no MCP) — resolve target and source to nodes
 
-For each cell (target and source), resolve it to a node using the exact same cell-resolution steps as the `examples` skill's "2c — Cell name" section (fetch chapters, fetch the chapter fresh to decode the grid, decode the cell name into a `CELL_ID`, then always fetch the cell live — `get_nodes` has no `cellId` filter) — see there for the full mechanics, substituting `x-user-id: attributes-skill`.
+A node id needs no resolving (`GET .../nodes/:nodeId`); a title resolves via `GET .../nodes?chapterId=&name=`. For a cell name, resolve it to a node using the exact same cell-resolution steps as the `examples` skill's "2c — Cell name" section (fetch chapters, fetch the chapter fresh to decode the grid, decode the cell name into a `CELL_ID`, then always fetch the cell live via REST `?cellId=&timelineId=` — MCP `get_nodes` has no `cellId` filter) — see there for the full mechanics, substituting `x-user-id: attributes-skill`.
 
 Take the first non-CHAPTER result as the node for each cell. Save as `TARGET_NODE` and `SOURCE_NODE`.
 
@@ -165,7 +168,7 @@ Nodes that are skipped (field already exists / field not found) simply contribut
 
 Verify the response is HTTP 200. If the batch fails, report the error and stop; nothing was partially applied from your side, so re-run after fixing the cause rather than retrying node by node.
 
-If you also need to verify the result, re-read the whole chain in one call — `get_nodes { "boardId": "$BOARD_ID", "nodeIds": [<every node id you just wrote>] }` — never one `get_node` per node.
+If you also need to verify the result, re-read the whole chain in one call — `get_nodes { "boardId": "$BOARD_ID", "nodeIds": [<every node id you just wrote>], "projection": "line" }` when you only check that the attribute name is present/renamed (`line` lists each node's field names), or without `projection` when you must also check the field's type/example — never one `get_node` per node.
 
 ---
 

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

@@ -5,10 +5,12 @@ Only needed when MCP is not connected. Every call below has an MCP equivalent in
 ## 3a — Use Node Edges
 
 ```bash
-curl -s "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/$EDGE_SOURCE_ID" \
+curl -s "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/$EDGE_SOURCE_ID?projection=edges" \
   -H "x-token: $TOKEN" -H "x-user-id: attributes-skill"
 ```
 
+`projection=edges` returns `{nodeId, edges}` — the node's inbound/outbound connections only, no content (the full node record carries no edges). Fields for Step 4 come from the chapter-scoped `GET .../nodes?chapterId=` read.
+
 ## Step 4 — Apply the Change to Each Node in the Chain
 
 Build the payload with Python to avoid JSON escaping issues, then POST it:

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

@@ -256,11 +256,11 @@ mcp__eventmodelers__get_node { "boardId": "<BOARD_ID>", "nodeId": "<CHAPTER_ID>"
 
 **Fallback (no MCP):** see `references/api-fallback.md` — "Step 6 — Fetch chapter grid".
 
-From the result (`rows`/`columns`/`cells` directly via MCP, or `meta.timelineData` via the REST fallback):
+From the result (`rows`/`columns`/`cells` directly — the REST fallback's `?projection=cells` returns the same shape):
 - `rows` — find the row with `type === "actor"` → save its `id` as `actorRowId` and its 0-based position in `rows` as `actorRowIndex`
 - `columns` — ordered list; build an empty-column queue, remembering each entry's 0-based position in `columns` as its `columnIndex`
 
-**Cell ID convention**: `<rowId>-<columnId>` — always computed directly, never looked up. **Cell name convention** (spreadsheet-style, needed for the MCP tool in Step 7b): `<columnLetter><rowNumber>`, where `columnLetter` is `columnIndex` converted to spreadsheet letters (0→A, 1→B, …25→Z, 26→AA, …) and `rowNumber` is `actorRowIndex + 1`.
+**Cell ID convention**: `<rowId>-<columnId>` — always computed directly, never looked up. **Cell name** (spreadsheet-style, needed for the MCP tool in Step 7b): read, never computed from `columnIndex`/`actorRowIndex`. Call `mcp__eventmodelers__get_board_outline { "boardId": "<BOARD_ID>", "chapterId": "<CHAPTER_ID>" }` once and take the target column's `letter` plus the actor lane's 1-based position in its `lanes` list (lanes are listed top to bottom) — e.g. `letter: "D"`, actor lane first in `lanes` → `D1`.
 
 ---
 
@@ -272,7 +272,7 @@ For each screen:
 
 ### 7a — Acquire a column slot
 
-**If the empty-column queue is non-empty** — pop the first entry → `columnId` and its remembered `columnIndex`. Compute `CELL_ID = actorRowId + "-" + columnId` and `CELL_NAME` per the convention above.
+**If the empty-column queue is non-empty** — pop the first entry → `columnId` and its remembered `columnIndex`. Compute `CELL_ID = actorRowId + "-" + columnId` and take `CELL_NAME` from the outline as described above.
 
 **If the empty-column queue is empty** — create a new column.
 
@@ -280,11 +280,11 @@ For each screen:
 ```
 mcp__eventmodelers__add_column { "boardId": "<BOARD_ID>", "timelineId": "<CHAPTER_ID>" }
 ```
-The result's `index` field is the new column's `columnIndex` (use it directly for `CELL_NAME` — no need to recompute from the full column list).
+Re-read `get_board_outline` after adding the column and take the new (last) column's `letter` for `CELL_NAME` — don't convert the result's `index` into a letter yourself.
 
 **Fallback (no MCP):** see `references/api-fallback.md` — "Step 7a — Create column".
 
-Extract `columnId`. Compute `CELL_ID = actorRowId + "-" + columnId` and `CELL_NAME` per the convention above.
+Extract `columnId`. Compute `CELL_ID = actorRowId + "-" + columnId` and take `CELL_NAME` from the outline as described above.
 
 ### 7b — Create the SCREEN node, atomically
 
@@ -307,7 +307,7 @@ mcp__eventmodelers__create_screen {
     "contentType": "html",
     "nodeId": "<SCREEN_NODE_ID>",
     "chapterId": "<CHAPTER_ID>",
-    "cellId": "<CELL_ID>",
+    "cellName": "<CELL_NAME>",
     "title": "<screen.title>",
     "pages": ["<reconstructed HTML fragment for this screen>"],
     "description": "<screen.description — 'Shows X. Arrived via: Y. Actions: user can do A, user can do B.'>"

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

@@ -32,9 +32,11 @@ curl -s -X POST "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/events" \
 
 ```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"
 ```
 
+Returns `{rows, columns, cells}` directly (not wrapped in `meta.timelineData`).
+
 ## Step 7a — Create column
 
 ```bash

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

@@ -47,20 +47,20 @@ Follow **`eventmodeling-interview-protocol`** to run this interview and record i
 
 ## Board Context
 
-Before brainstorming, check for EVENT nodes already on the board to avoid duplicating events from a previous session:
+Before brainstorming, check for EVENT nodes already on the board to avoid duplicating events from a previous session — titles (plus field names) are all a dedupe needs, so use `projection: "line"`:
 
 **Prefer MCP:**
 ```
-mcp__eventmodelers__get_nodes { "boardId": "<BOARD_ID>", "type": "EVENT" }
+mcp__eventmodelers__get_nodes { "boardId": "<BOARD_ID>", "type": "EVENT", "projection": "line" }
 ```
 
 **Fallback (no MCP):** see `references/api-fallback.md` — "Board Context — Check existing EVENT nodes".
 
-If events already exist, treat them as the starting list and focus on discovering what might be missing. Also check for existing chapters (timelines) so you can reuse them:
+If events already exist, treat them as the starting list and focus on discovering what might be missing. Also check for existing chapters (timelines) so you can reuse them — ids and titles only, so `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` — "Board Context — Check existing CHAPTER nodes".

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

@@ -6,14 +6,14 @@ 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=EVENT"
+  "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes?type=EVENT&projection=line"
 ```
 
 ## Board Context — Check existing CHAPTER nodes
 
 ```bash
 curl -s -H "x-token: $TOKEN" \
-  "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes?type=CHAPTER"
+  "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes?type=CHAPTER&projection=line"
 ```
 
 ## Timeline Discovery — Step 2: Create one chapter per group — create the chapter
@@ -63,8 +63,8 @@ curl -s -X POST "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/timelines/$CHAPTER_I
 
 ```bash
 curl -s -H "x-token: $TOKEN" \
-  "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/$CHAPTER_ID"
-# → node.meta.timelineData.rows — find the row where type === "swimlane"
+  "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/$CHAPTER_ID?projection=cells"
+# → rows — find the row where type === "swimlane" ({rows, columns, cells} directly, not under meta.timelineData)
 ```
 
 ## Mode A — Step D: Create the event with cellId

package/stacks/modeling-kit/templates/.claude/skills/eventmodeling-checking-completeness/SKILL.md

@@ -18,18 +18,17 @@ Prefer `mcp__eventmodelers__*` tools when available (registered by the `connect`
 
 Before starting, read the current board state to drive the analysis from what is actually on the board rather than relying solely on conversation context:
 
-**Prefer MCP:**
+**Prefer MCP** — the field origin/destination checks need every element's fields plus its dependencies, which the `fields` projection of the slice data returns per slice in one call (no specs, comments or prompts):
 ```
-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" }
+mcp__eventmodelers__get_slice_data { "boardId": "<BOARD_ID>", "contextName": "<CONTEXT_NAME>", "projection": "fields", "format": "toon" }
 ```
+Drive it by timeline, not by MODEL_CONTEXT — a timeline with no assigned or connected context is its own context, so listing only the MODEL_CONTEXT nodes misses it. List the timelines (ids/titles only): `mcp__eventmodelers__get_nodes { "boardId": "<BOARD_ID>", "type": "CHAPTER", "projection": "line" }`, then pass each timeline's title as `contextName`. The response covers that timeline's whole effective context — every timeline in the same context — and each slice carries its `chapter`, so skip any timeline already named in a response you have (call the rest in parallel).Drop `projection` only for a node whose field types/examples you actually need to inspect — and then scope it with `nodeIds`.
 
 **Fallback (no MCP):** see `references/api-fallback.md` — "Board Context".
 
 Use these results as the source of truth for the completeness check.
 
-**Before treating any nodes as duplicates**: check each node's `data.linkedTo` field (see `learn-eventmodelers-api`). A node with `linkedTo` set is an intentional **linked copy** of another node — placed elsewhere on the timeline for readability, not a modeling defect. When two or more nodes share a title/type:
+**Before treating any nodes as duplicates**: check each node's `data.linkedTo` field (see `learn-eventmodelers-api`). Neither projection above carries it — fetch the full records of just the same-titled candidates with `mcp__eventmodelers__get_nodes { "boardId": "<BOARD_ID>", "nodeIds": [<their ids>] }`. A node with `linkedTo` set is an intentional **linked copy** of another node — placed elsewhere on the timeline for readability, not a modeling defect. When two or more nodes share a title/type:
 - If any of them carries `linkedTo`, do not report a duplicate. This is expected, not a gap.
 - Never propose deleting, suppressing, or "cleaning up" either node in a linked pair. Specifically, never target the node that has *no* `linkedTo` (the original) for removal — copies reference it via `moveToWidget=<originNodeId>`, so deleting it breaks every copy.
 - Only flag same-titled nodes as an actual duplicate gap when **none** of them has `linkedTo` — i.e., they are genuinely two independent, unlinked nodes describing the same concept.
@@ -53,18 +52,15 @@ Verify every field a read model displays is sourced from a connected event. A fu
 
 Every column that holds a COMMAND or READMODEL node must have a slice defined (a SLICE_BORDER node on that column) — otherwise it can never be built as a feature. Skip columns whose COMMAND/READMODEL node has `data.linkedTo` set: it's a linked copy (see Board Context above), and only the original's column needs a slice.
 
-**Prefer MCP** — `list_slices` is lighter than filtering all nodes, and also returns each slice's status:
+**Prefer MCP** — `get_board_outline` answers this directly per chapter: every column with its node list (id, type, title) and a `sliceStatus` when a slice spans it — no need to pull full SLICE_BORDER records and join on `columnId`:
 ```
-mcp__eventmodelers__list_slices { "boardId": "<BOARD_ID>" }
-```
-Or, to get the full SLICE_BORDER nodes (with `columnId`) the same way as the curl fallback:
-```
-mcp__eventmodelers__get_nodes { "boardId": "<BOARD_ID>", "type": "SLICE_BORDER" }
+mcp__eventmodelers__get_board_outline { "boardId": "<BOARD_ID>", "chapterId": "<CHAPTER_ID>" }
 ```
+Get the chapter ids from `mcp__eventmodelers__get_nodes { "boardId": "<BOARD_ID>", "type": "CHAPTER", "projection": "line" }` (ids/titles only). For just the slice list with statuses, `mcp__eventmodelers__list_slices { "boardId": "<BOARD_ID>" }` is the lightest read.
 
 **Fallback (no MCP):** see `references/api-fallback.md` — "4. Check Slice Coverage".
 
-Cross-reference each COMMAND/READMODEL node's column against the `columnId` of the SLICE_BORDER nodes, flagging any column with no matching slice as a gap (skipping linked copies, which are exempt). A full worked example is in `references/examples.md`.
+Flag any column that holds a COMMAND or READMODEL node but carries no `sliceStatus` as a gap (skipping linked copies, which are exempt — confirm `linkedTo` on the flagged nodes with a `nodeIds`-scoped full `get_nodes`). A full worked example is in `references/examples.md`.
 
 ### 5. Check Event Stream Completeness
 Verify no "missing" events:

package/stacks/modeling-kit/templates/.claude/skills/eventmodeling-checking-completeness/references/api-fallback.md

@@ -5,18 +5,28 @@ Only needed when MCP is not connected. Every call below has an MCP equivalent in
 ## Board Context
 
 ```bash
-# All nodes (events, commands, read models, screens)
+# Timelines (ids/titles only) — drive the slice data by timeline: a timeline without a context is its own context
 curl -s -H "x-token: $TOKEN" \
-  "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes?type=EVENT"
-curl -s -H "x-token: $TOKEN" \
-  "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes?type=COMMAND"
-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=CHAPTER&projection=line"
+
+# Elements with fields + dependencies for a timeline's effective context (no specs/comments).
+# Skip timelines already named in a previous response's slice `chapter` values.
+curl -s -G -H "x-token: $TOKEN" \
+  "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/slicedata" \
+  --data-urlencode "contextName=<TIMELINE_TITLE>" -d projection=fields -d format=toon
+
+# Full records (incl. data.linkedTo) for just the duplicate candidates
+curl -s -X POST -H "x-token: $TOKEN" -H "Content-Type: application/json" \
+  "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/query" -d '{"ids": ["<id1>", "<id2>"]}'
 ```
 
 ## 4. Check Slice Coverage
 
+There is no REST equivalent of `get_board_outline`, so this fallback keeps the full SLICE_BORDER rows — the cross-reference needs their `columnId`, which `projection=line` does not carry:
+
 ```bash
 curl -s -H "x-token: $TOKEN" \
   "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes?type=SLICE_BORDER"
 ```
+
+Cross-reference each COMMAND/READMODEL node's column against the `columnId` of the SLICE_BORDER nodes; a column with no matching slice is a gap (linked copies exempt).

package/stacks/modeling-kit/templates/.claude/skills/eventmodeling-elaborating-scenarios/SKILL.md

@@ -327,18 +327,18 @@ After designing all scenarios, post them to the board using the timeline/column
 
 ### Step 1 — Identify the target timeline and column
 
-Fetch all CHAPTER nodes to find the timeline.
+Fetch all CHAPTER nodes to find the timeline — ids and titles only, so `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` — "Post Scenarios to Board — Step 1: Identify the Target Timeline and Column".
 
 If there is more than one chapter, ask the user which timeline to target.
 
-For each command or view being specified, find its column: fetch the chapter node and read `meta.timelineData.columns`. Match the column to the COMMAND or READMODEL node that occupies the interaction row in that column. If the user named the slice, find the SLICE_BORDER node with that title to get its `colId`.
+For each command or view being specified, find its column: `mcp__eventmodelers__get_board_outline { "boardId": "<BOARD_ID>", "chapterId": "<TL>" }` lists every column (`columnId`, index) with the nodes in it — take the column whose node list holds that COMMAND or READMODEL. If the user named the slice, find the SLICE_BORDER node with that title (`get_nodes { "type": "SLICE_BORDER", "name": "<slice title>", "projection": "line" }` gives its id) or its column in the outline to get the `colId`. (REST fallback: `GET .../nodes/$TL?projection=cells` → `{rows, columns, cells}`; find the cell whose `nodeId` is the COMMAND/READMODEL and take its `colId`.)
 
 ### Step 2 — Load valid step elements
 

package/stacks/modeling-kit/templates/.claude/skills/eventmodeling-elaborating-scenarios/references/api-fallback.md

@@ -5,7 +5,7 @@ Only needed when MCP is not connected. Every call below has an MCP equivalent in
 ## Post Scenarios to Board — Step 1: Identify the Target Timeline and Column
 
 ```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-token: $TOKEN"
 ```
 

package/stacks/modeling-kit/templates/.claude/skills/eventmodeling-identifying-inputs/SKILL.md

@@ -197,7 +197,7 @@ After `place-element` returns the COMMAND node ID, create the arrows that comple
 
 1. **SCREEN → COMMAND** — find the SCREEN node in the actor row of the same column.
 
-   **Prefer MCP** — there is no `cellId` filter on `get_nodes` (see note below), so read the chapter's cell map instead — `projection: "cells"` returns just `{rows, columns, cells}`, not the whole chapter node:
+   **Prefer MCP** — `get_nodes` has no `cellId` filter (see note below), so read the chapter's cell map instead — `projection: "cells"` returns just `{rows, columns, cells}`, not the whole chapter node:
    ```
    mcp__eventmodelers__get_node { "boardId": "<BOARD_ID>", "nodeId": "<CHAPTER_ID>", "projection": "cells" }
    ```
@@ -224,7 +224,7 @@ After `place-element` returns the COMMAND node ID, create the arrows that comple
 
    **Fallback (no MCP):** see `references/api-fallback.md` — "Wire connections — Step 2: COMMAND → EVENT".
 
-   *Note:* `get_nodes` has no `cellId` filter (only `type`) — the `get_node`-on-CHAPTER (`projection: "cells"`) + `cells` lookup above is the only way to check single-cell occupancy via MCP.
+   *Note:* `get_nodes` filters by `type`, `name` (partial title), `chapterId` and `nodeIds`, but has no `cellId` filter — the `get_node`-on-CHAPTER (`projection: "cells"`) + `cells` lookup above is the only way to check single-cell occupancy via MCP. (The REST `GET .../nodes` does take `cellId`/`colId`, each requiring `timelineId` — see the fallback file.)
 
 Skip a connection silently if the target cell is empty (the element may be placed in a later step). Log each created arrow: `→ connected SCREEN→COMMAND "PlaceOrder"` or `→ connected COMMAND→EVENT "PlaceOrder"→"OrderPlaced"`.
 

package/stacks/modeling-kit/templates/.claude/skills/eventmodeling-identifying-inputs/references/api-fallback.md

@@ -14,8 +14,8 @@ curl -s -H "x-token: $TOKEN" \
 **Step B — Fetch the chapter to find the interaction row ID:**
 ```bash
 curl -s -H "x-token: $TOKEN" \
-  "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/$CHAPTER_ID"
-# → timelineData.rows — find the row where type === "interaction"
+  "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/$CHAPTER_ID?projection=cells"
+# → rows — find the row where type === "interaction" ({rows, columns, cells} directly, not under meta.timelineData)
 ```
 Save `interactionRow.id`.
 
@@ -51,7 +51,7 @@ curl -X POST "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/events" \
 ## Wire connections — Step 1: SCREEN → COMMAND
 
 ```bash
-curl -s "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes?cellId=<actorRowId>-<columnId>" \
+curl -s "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes?cellId=<actorRowId>-<columnId>&timelineId=$CHAPTER_ID" \
   -H "x-token: $TOKEN" -H "x-user-id: eventmodeling-identifying-inputs"
 ```
 If a SCREEN node exists, connect it:
@@ -65,7 +65,7 @@ curl -s -X POST "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/connections" \
 ## Wire connections — Step 2: COMMAND → EVENT
 
 ```bash
-curl -s "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes?cellId=<swimlaneRowId>-<columnId>" \
+curl -s "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes?cellId=<swimlaneRowId>-<columnId>&timelineId=$CHAPTER_ID" \
   -H "x-token: $TOKEN" -H "x-user-id: eventmodeling-identifying-inputs"
 ```
 Connect command to its resulting event:

package/stacks/modeling-kit/templates/.claude/skills/eventmodeling-identifying-outputs/SKILL.md

@@ -195,7 +195,7 @@ Before finalizing any read model, ask: "does this screen contain more than one c
 
 **Do not re-derive read model needs from a screen's title or description alone, and do not rely on the orchestrator's phase-summary handoff for this** — if you arrived here via `eventmodeling-orchestrating-event-modeling`, the handoff after Step 3 is a short hand-written prose summary (`.eventmodelers/interviews/.../EVENTMODELING.md`), not the actual field data. It will not reliably carry the per-field mappings forward. Go back to the board itself:
 
-For every SCREEN node, fetch it directly (`get_node`/`get_nodes`, never from memory) and read its `meta.fields`. Step 3 already required every field to carry a `mapping`, and for view fields that mapping is already in the exact form `"<ReadModelTitle>.<fieldName>"` — recorded specifically so this step doesn't have to re-guess it.
+For every SCREEN node, fetch it directly (`get_node`/`get_nodes`, never from memory) and read its `meta.fields` — a full read on purpose (`projection: "line"` carries field names only, not the `mapping` this step groups by); scope it to the chapter, e.g. `get_nodes { "boardId": "<BOARD_ID>", "type": "SCREEN", "chapterId": "<CHAPTER_ID>" }`, rather than board-wide. Step 3 already required every field to carry a `mapping`, and for view fields that mapping is already in the exact form `"<ReadModelTitle>.<fieldName>"` — recorded specifically so this step doesn't have to re-guess it.
 
 - **Group the screen's fields by the `<ReadModelTitle>` already named in their `mapping`.** That grouping — not a fresh read of the screen's visuals — is the read model's title and field list. Build the READMODEL node from it directly.
 - If a field's `mapping` names a read model that isn't `"<CommandTitle>.<fieldName>"` or `"session:..."` or `"derived:..."`, it is a read-model reference — treat it as a requirement, not a suggestion.
@@ -273,7 +273,7 @@ mcp__eventmodelers__submit_node_events {
   }]
 }
 ```
-To determine the consumer's column index beforehand, or to check whether a specific interaction cell is already occupied (there is no `cellId` filter on `get_nodes` — see the note under "Wire connections" below), fetch the chapter and read its cell map — `projection: "cells"` returns just `{rows, columns, cells}`, not the whole chapter node:
+To determine the consumer's column index beforehand, or to check whether a specific interaction cell is already occupied (`get_nodes` filters by `type`, `name`, `chapterId` and `nodeIds`, but has no `cellId` filter — see the note under "Wire connections" below), fetch the chapter and read its cell map — `projection: "cells"` returns just `{rows, columns, cells}`, not the whole chapter node:
 ```
 mcp__eventmodelers__get_node { "boardId": "<BOARD_ID>", "nodeId": "<CHAPTER_ID>", "projection": "cells" }
 # → rows (find "interaction"/"actor" rows) and cells (sparse; absent id = empty)
@@ -323,7 +323,7 @@ After `place-element` returns the READMODEL node ID, create the arrows that comp
 
 1. **EVENT → READMODEL** — find the primary source EVENT node in the swimlane row of the same column.
 
-   **Prefer MCP** — `get_nodes` has no `cellId` filter (only `type`); look up occupancy via the chapter's cell map instead (`projection: "cells"`), then connect with the type-checked edge tool (auto-corrects direction, skips duplicates):
+   **Prefer MCP** — `get_nodes` has no `cellId` filter (it filters by `type`, `name`, `chapterId`, `nodeIds` only); look up occupancy via the chapter's cell map instead (`projection: "cells"`), then connect with the type-checked edge tool (auto-corrects direction, skips duplicates):
    ```
    mcp__eventmodelers__get_node { "boardId": "<BOARD_ID>", "nodeId": "<CHAPTER_ID>", "projection": "cells" }
    # → read cells["<swimlaneRowId>-<columnId>"] for the occupying node id
@@ -369,7 +369,7 @@ If this step is processing more than one read model in the same pass, collect ev
 
 ### Step 5i — Mandatory per-node verification (run before declaring this step done)
 
-Do not declare Step 5 complete on the strength of the read models you happened to design. Instead, **re-fetch every SCREEN and AUTOMATION node on the board** (`get_nodes` per type — don't rely on the list built earlier in this step, the board may have moved on) and check each one individually:
+Do not declare Step 5 complete on the strength of the read models you happened to design. Instead, **re-fetch every SCREEN and AUTOMATION node on the board** (don't rely on the list built earlier in this step, the board may have moved on) and check each one individually. Questions 1–3 need only node types and edges: `get_board_outline { "boardId": "<BOARD_ID>", "chapterId": "<CHAPTER_ID>" }` per chapter returns every node per column plus the flat edge list — the full node records from `get_nodes` carry no edges. Read a node in full (`get_node`) only when you fix a gap and need its `meta.fields`/`mapping`:
 
 1. Does it now have an incoming `READMODEL → SCREEN` or `READMODEL → AUTOMATION` connection?
 2. If it's a SCREEN and not connected — is it a provably blank creation form with no prior state? State the reason in one line (e.g. `"Register Account" screen: blank form, no prior state — exempt`). This exemption applies to screens only.

package/stacks/modeling-kit/templates/.claude/skills/eventmodeling-identifying-outputs/references/api-fallback.md

@@ -7,12 +7,12 @@ Only needed when MCP is not connected. Every call below has an MCP equivalent in
 1. Find the column where the consumer SCREEN or AUTOMATION lives. For an AUTOMATION, the read model's target column is always the one immediately **before** it (skip straight to inserting that column — its interaction row is guaranteed occupied by the automation's own COMMAND). For a SCREEN, target the screen's own column. Fetch the timeline to get the interaction row ID:
    ```bash
    curl -s -H "x-token: $TOKEN" \
-     "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/$CHAPTER_ID"
-   # → timelineData.rows — find the row where type === "interaction"
+     "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/$CHAPTER_ID?projection=cells"
+   # → rows — find the row where type === "interaction" ({rows, columns, cells} directly, not under meta.timelineData)
    ```
 2. Check if the target interaction cell is already occupied (existing COMMAND):
    ```bash
-   curl -s "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes?cellId=<interactionRowId>-<columnId>" \
+   curl -s "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes?cellId=<interactionRowId>-<columnId>&timelineId=$CHAPTER_ID" \
      -H "x-token: $TOKEN"
    ```
    If a COMMAND occupies that cell, insert a new column immediately **before** it (`{"index": currentIndex}` — this shifts the consumer's column, and everything after it, one to the right) and use that new column's ID instead. The read model must end up upstream of (to the left of) its consumer, never downstream of it.
@@ -35,7 +35,7 @@ Only needed when MCP is not connected. Every call below has an MCP equivalent in
 ## Step 5h.1 — Wire EVENT → READMODEL
 
 ```bash
-curl -s "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes?cellId=<swimlaneRowId>-<columnId>" \
+curl -s "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes?cellId=<swimlaneRowId>-<columnId>&timelineId=$CHAPTER_ID" \
   -H "x-token: $TOKEN" -H "x-user-id: eventmodeling-identifying-outputs"
 ```
 Connect it: