@eventmodelers/cli 1.0.36 → 1.0.37

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eventmodelers/cli",
-  "version": "1.0.36",
+  "version": "1.0.37",
   "description": "Eventmodelers CLI — real-time Claude agent + skills for Claude Code, for any stack (Node, Supabase, Axon, Cratis, or modeling-only)",
   "type": "module",
   "bin": {

package/shared/skills/learn-eventmodelers-api/SKILL.md

@@ -20,18 +20,18 @@ Server name: `eventmodelers`. Every tool takes `boardId` explicitly; none need `
 | Tool | Args | Purpose | REST equivalent |
 |---|---|---|---|
 | `list_boards` | — | List boards for the org | §1 `GET /api/boards` (org-scoped) |
-| `get_nodes` | `boardId`, `type?`, `name?` | List nodes, optionally by type and/or a partial case-insensitive title match | §3 `GET .../nodes` |
-| `get_node` | `boardId`, `nodeId` | Get one node | §3 `GET .../nodes/:nodeId` |
+| `get_nodes` | `boardId`, `type?`, `name?`, `chapterId?`, `nodeIds?`, `projection?` (`"line"`) | List nodes, optionally by type and/or a partial case-insensitive title match. `chapterId` scopes to one timeline — prefer this over an unscoped board-wide call whenever the step is working within one chapter (the common case); `nodeIds` fetches a known, scattered subset in one call (e.g. re-verifying exactly the nodes just touched by a batch write) instead of a full `type` refetch; `projection: "line"` maps each match to `{id, type, title}` only | §3 `GET .../nodes` |
+| `get_node` | `boardId`, `nodeId`, `projection?` (`"cells"` \| `"edges"`) | Get one node. `projection: "cells"` (CHAPTER nodes only) returns just `{rows, columns, cells}` instead of the full `timelineData` — use whenever only the grid/occupancy is needed, not the whole chapter; `projection: "edges"` returns just that node's inbound/outbound connections instead of `findNodeById`'s full record. Both are opt-in — omitting `projection` is the unchanged full response | §3 `GET .../nodes/:nodeId` |
 | `get_node_comments` | `boardId`, `nodeId` | List comments on a node | §1 `GET .../nodes/:nodeId/comments` |
 | `get_board_events` | `boardId` | All board events, in sequence | §1 `GET .../events` |
 | `search_board_events` | `boardId`, `name` | Search events by node name | §1 `GET .../events/search` |
-| `submit_node_events` | `boardId`, `events[]` | Create/update nodes (raw `NodeChangeEvent`/edge events) | §3 `POST .../nodes/events` |
+| `submit_node_events` | `boardId`, `events[]`, `autoConnect?`, `compact?` | Create/update nodes (raw `NodeChangeEvent`/edge events). `autoConnect: false` places freshly-created nodes without wiring them to their own/previous-column neighbors (avoids a stray nearest-left edge); `compact: true` returns `{persisted: <count>}` instead of the per-node hash map | §3 `POST .../nodes/events` |
 | `delete_node` | `boardId`, `nodeId` | Delete a node. Deleting a chapter (timeline) cascades — every node placed in one of its cells, plus any node parented to it (e.g. SLICE_BORDER), is deleted too, along with all their edges | (via `node:deleted` event, §3) |
 | `create_drawing` | `boardId`, `kind`, `x`, `y`, `width`, `height`, ... | Freehand canvas annotation (path/rect/text) — never placed in a cell | — (no REST equivalent; MCP-only) |
 | `find_nodes_in_drawing` | `boardId`, `drawingId` | Nodes fully contained inside a drawing's bounding box | — (no REST equivalent; MCP-only) |
 | `create_chapter` | `boardId`, `x?`, `y?` | Create a timeline. Omitting `x`/`y` auto-stacks it below the lowest existing chapter (by its *actual current* row-height total, not the height it was created with — safe even after `add_lane` growth), plus a fixed margin | §2 `POST .../chapters` |
 | `get_chapter_bounds` | `boardId` | Absolute canvas bounding box `{id, title, x, y, width, height}` of every chapter on the board — width/height derived from each chapter's current row/column layout, not a guessed default. Use before picking explicit `x`/`y` for `create_chapter` (e.g. placing below the chapter with the largest `y + height`) to avoid overlapping one that grew since it was created | §2 `GET .../chapters/bounds` |
-| `add_column` | `boardId`, `timelineId`, `index?` | Add a column | §2 `POST .../timelines/:id/columns` |
+| `add_column` | `boardId`, `timelineId`, `index?`, `beforeNodeId?`, `afterNodeId?`, `count?` | Add one or more columns in one call. `count` inserts that many contiguously starting at the insertion point (default 1). Position with at most one of `index` (0-based), `beforeNodeId`, or `afterNodeId` (resolves the index from where that already-placed node currently sits) — omit all three to append | §2 `POST .../timelines/:id/columns` |
 | `delete_column` | `boardId`, `timelineId`, `columnId` | Delete a column | §2 `DELETE .../columns/:columnId` |
 | `add_lane` | `boardId`, `timelineId`, `type`, `label?`, `index?` | Add a lane/row | §2 `POST .../timelines/:id/lanes` |
 | `remove_lane` | `boardId`, `timelineId`, `rowId` | Remove a lane | — (extends §2; no direct REST route) |
@@ -42,19 +42,21 @@ Server name: `eventmodelers`. Every tool takes `boardId` explicitly; none need `
 | `clear_cell` | `boardId`, `timelineId`, `cellId` | Unassign the node from a cell without deleting it — the cell becomes empty and the node survives (unplaced); no-op if already empty. Use `delete_node` to remove the node entirely | — (MCP-only convenience) |
 | `create_slice` | `boardId`, `timelineId`, `type`, `index?`, `nodes?: {actor?, interaction?, swimlane?}` (each `{rowId?, title?}`) | Create a full slice (column + nodes + SLICE_BORDER). `rowId` targets a specific lane when the chapter has more than one lane of that type (e.g. several actor lanes); omit to use the first matching lane | §5 `POST .../slices` |
 | `create_slice_definition` | `boardId`, `timelineId`, `columnId`, `title`, `data?`, `meta?` | Create a SLICE_BORDER over an existing column | §5 `POST .../slice-definitions` |
-| `place_element` | `boardId`, `timelineId`, `elementType`, `title`, `columnIndex?` | Find/create an empty cell in the right lane and place a COMMAND/READMODEL/EVENT | — (MCP-only convenience; composes §2+§3) |
+| `place_element` | `boardId`, `timelineId`, `elementType`, `title`, `columnIndex?`, `compact?`, `autoConnect?` | Find/create an empty cell in the right lane and place a COMMAND/READMODEL/EVENT. `autoConnect: false` places without wiring to timeline neighbors — wire the edges yourself | — (MCP-only convenience; composes §2+§3) |
 | `list_slices` | `boardId` | List slices (id, title, status) | §8 `GET .../slicedata/slices` |
 | `update_slice_status` | `boardId`, `sliceId`, `newStatus` | Change a SLICE_BORDER's `sliceStatus` | — (via `node:changed` event, §3) |
 | `get_slice_data` | `boardId`, `contextName?`, `contextId?`, `sliceId?` | Full element graph for slices in a context | §8 `GET /slicedata` |
-| `get_spec_info` | `boardId`, `timelineId` | EVENT/COMMAND/READMODEL nodes valid in GWT steps | §6 `GET .../spec-info` |
-| `add_scenario` | `boardId`, `timelineId`, `columnId`, `scenarios[]` | Append GWT scenario(s) to a column's spec node | §6 `POST .../scenarios` |
-| `add_storyline` | `boardId`, `timelineId`, `columnId`, `storylines[]` | **Experimental — only use when explicitly asked for a storyline/walkthrough.** Append storyline(s) (ordered, branchable beats over existing elements) to a column's spec node | §6 `POST .../storylines` |
-| `set_connection` | `boardId`, `source`, `target`, `action` (`'connect'\|'remove'`) | Add or remove a type-checked directed edge | — (via `edges` on §3 events) |
+| `get_spec_info` | `boardId`, `timelineId`, `elementTypes?` | EVENT/COMMAND/READMODEL nodes valid in GWT steps. Pass `elementTypes` (subset of `EVENT`/`COMMAND`/`READMODEL`) to avoid pulling the full element list when only one or two types are needed — filtered server-side, not just after a full fetch | §6 `GET .../spec-info` |
+| `get_board_outline` | `boardId`, `chapterId` | One chapter's structure, compact: per-column node lists (`{id, type, title, lane}`) + a flat edge list, no HTML pages / field bodies / meta. The cheap "what is where and how is it wired" read — prefer over `get_nodes` (no projection) for orientation checks | — (MCP-only convenience) |
+| `validate_model` | `boardId`, `chapterId`, `checks?[]` | Server-side Event Modeling structural checklist over one chapter — compact `findings` only. Checks: unplaced nodes, backward arrows (with the todo-list `EVENT→READMODEL` exception), zero/multi-issuer commands, sourceless read models, two-screens-in-a-column, missing scenarios. Replaces the manual per-type `get_nodes` + `get_node projection=edges` validation pass | — (MCP-only convenience) |
+| `add_scenario` | `boardId`, `timelineId`, `columnId`, `scenarios[]`, `compact?` | Append GWT scenario(s) to a column's spec node. `compact: true` returns `{specNodeId, added, scenarioCount, isNewNode}` instead of echoing every scenario back | §6 `POST .../scenarios` |
+| `add_storyline` | `boardId`, `timelineId`, `columnId`, `storylines[]`, `compact?` | **Experimental — only use when explicitly asked for a storyline/walkthrough.** Append storyline(s) (ordered, branchable beats over existing elements) to a column's spec node. `compact: true` suppresses the full storyline echo | §6 `POST .../storylines` |
+| `set_connection` | `boardId`, `source`, `target`, `action` (`'connect'\|'remove'`) | Add or remove a type-checked directed edge. Batch form `set_connections` takes `connections[]` (applied in order) plus `compact?` — `compact: true` returns a `{connected, existed, removed, notFound, failed, errors}` tally instead of one row per edge | — (via `edges` on §3 events) |
 | `auto_connect_node` | `boardId`, `nodeId` | Re-run auto-connect for a node | §3 `POST .../nodes/:nodeId/auto-connect` |
 | `link_element` | `boardId`, `nodeId`, `targetNodeId` | Link two existing same-type nodes: `targetNodeId` is replaced with a full copy of `nodeId`'s meta plus `meta.linkedTo`. Linking means first create, then link | §3 `POST .../nodes/:nodeId/link` |
 | `add_comment` | `boardId`, `nodeId`, `text`, `type?` (`'COMMENT'\|'TASK'\|'QUESTION'`), `author?` | Add a comment — `QUESTION` flags gaps/edge cases during review | — (via comment events) |
 | `update_comment` | `boardId`, `nodeId`, `commentId`, `action` (`'resolve'\|'delete'`) | Resolve or delete a comment | — (via comment events) |
-| `create_screen` | `boardId`, `contentType` (`'image'\|'sketch'\|'html'`), `nodeId?`, `chapterId`, `cellId?`/`cellName?`, plus content fields (`imageBase64`/`mimeType`, `elements[]`, or `pages[]`/`backgroundColor`), `description?` | Create + place a new screen node (SCREEN or HTML_SCREEN) atomically, in one call | §4 `POST .../images/:id/sketch` + `image-nodes` |
+| `create_screen` | `boardId`, `contentType` (`'image'\|'sketch'\|'html'`), `nodeId?`, `chapterId`, `cellId?`/`cellName?`, plus content fields (`imageBase64`/`mimeType`, `elements[]`, or `pages[]`/`backgroundColor`), `description?`, `fields?`, `autoConnect?` | Create + place a new screen node (SCREEN or HTML_SCREEN) atomically, in one call. Batch form `create_screens` takes `screens[]` (HTML only) + `autoConnect?`. `autoConnect: false` places without wiring to timeline neighbors | §4 `POST .../images/:id/sketch` + `image-nodes` |
 | `render_screen` | `boardId`, `nodeId`, `elements[]?` (SCREEN) or `pages[]?`+`backgroundColor?` (HTML_SCREEN), `description?` | Update an existing screen's content — exactly one of `elements`/`pages` | §4 `POST .../images/:id/sketch` + `image-nodes` |
 | `add_field_examples` | `boardId`, `nodeId?`, `name?`, `cellName?`, `timelineId?` | Fill empty field examples using linked-node context | — (MCP-only convenience) |
 | `get_attribute_chain` | `boardId`, `timelineId`, `targetCellName`, `sourceCellName` | Resolve every node between two cells, ordered target→source | — (MCP-only convenience) |

package/stacks/modeling-kit/templates/.claude/skills/add-next-slice/SKILL.md

@@ -15,23 +15,7 @@ This is the counterpart to `eventmodeling-slicing-event-models`, which only ever
 
 ## Core Concept: A Slice Is One Command, One Read Model, or One Automation — Never Combined
 
-Same rules as `eventmodeling-slicing-event-models` — the slice you create here must obey them too, not just slices made from pre-existing elements.
-
-A **Feature Slice** is the thinnest possible vertical cut through the model — exactly one decision or one query:
-
-```
-state-change slice = SCREEN/Processor → COMMAND → EVENT(s)
-state-view slice   = EVENT(s) → READMODEL → SCREEN/Processor
-automation slice   = EVENT(s) → AUTOMATION → COMMAND → EVENT(s)
-```
-
-A slice never mixes a COMMAND and a READMODEL — the platform models these as two distinct slice types (`state-change` and `state-view`). If the capability you decide on in Step 1 needs both a command and a read model (e.g. "place an order" needs the `PlaceOrder` command *and* an `OrderDetailView` read model), that's **two slices** — create them one at a time, each its own `create_slice` call.
-
-**Key characteristics**:
-- Exactly one COMMAND (state-change), exactly one READMODEL (state-view), or one AUTOMATION's command — never combined
-- Named after that command, read model, or automation
-- Independently deployable
-- Communicates with other slices via events only
+Same rules as `eventmodeling-slicing-event-models`'s own "Core Concept" section — see there for the full definition (the state-change/state-view/automation shapes, key characteristics) — the slice you create here must obey them too, not just slices made from pre-existing elements. If the capability you decide on in Step 1 needs both a command and a read model (e.g. "place an order" needs the `PlaceOrder` command *and* an `OrderDetailView` read model), that's **two slices** — create them one at a time, each its own `create_slice` call.
 
 ---
 
@@ -65,12 +49,7 @@ Pick `type` based on what you decided in Step 1 — `state-change` for a new com
 
 If the chapter has more than one lane of the same type (e.g. several actor lanes for different user roles), `create_slice` places each node in the **first** matching lane by default — pass `nodes.<actor|interaction|swimlane>.rowId` (the target row's id, from the chapter's `timelineData.rows`) to target a specific lane instead of the first one.
 
-**Fallback (no MCP):**
-```bash
-curl -X POST $BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/timelines/$TL/slices \
-  -H "x-token: $TOKEN" -H "Content-Type: application/json" \
-  -d '{"type":"state-change","nodes":{"interaction":{"title":"CancelReservation"}}}'
-```
+**Fallback (no MCP):** see `references/api-fallback.md` — "Step 2: Create the Slice".
 
 ## Step 3: Replace the placeholder screen — matching the board's existing style
 

package/stacks/modeling-kit/templates/.claude/skills/add-next-slice/references/api-fallback.md

@@ -0,0 +1,11 @@
+# Add Next Slice — 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: Create the Slice
+
+```bash
+curl -X POST $BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/timelines/$TL/slices \
+  -H "x-token: $TOKEN" -H "Content-Type: application/json" \
+  -d '{"type":"state-change","nodes":{"interaction":{"title":"CancelReservation"}}}'
+```

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

@@ -33,16 +33,7 @@ If `boardId` is explicitly passed it overrides `BOARD_ID` from `connect`.
 mcp__eventmodelers__list_slices { "boardId": "$BOARD_ID" }
 ```
 
-**Fallback (no MCP):**
-```bash
-curl -s \
-  -H "x-token: $TOKEN" \
-  -H "x-board-id: $BOARD_ID" \
-  -H "x-user-id: analyze-existing-model" \
-  "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/slicedata/slices"
-```
-
-Response: `{ "slices": [{ "id": "<uuid>", "title": "<name>", "status": "<status>" }] }`
+**Fallback (no MCP):** see `references/api-fallback.md` — "Step 2 — List all slices".
 
 Save the full slice list. Count total slices and group by status:
 
@@ -61,14 +52,7 @@ Fetch all `MODEL_CONTEXT` nodes to identify bounded contexts on the board:
 mcp__eventmodelers__get_nodes { "boardId": "$BOARD_ID", "type": "MODEL_CONTEXT" }
 ```
 
-**Fallback (no MCP):**
-```bash
-curl -s \
-  -H "x-token: $TOKEN" \
-  -H "x-board-id: $BOARD_ID" \
-  -H "x-user-id: analyze-existing-model" \
-  "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes?type=MODEL_CONTEXT"
-```
+**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.
@@ -85,20 +69,7 @@ For each resolved context, fetch the full element graph:
 mcp__eventmodelers__get_slice_data { "boardId": "$BOARD_ID", "contextName": "<CONTEXT_NAME>" }
 ```
 
-**Fallback (no MCP):**
-```bash
-curl -s \
-  -H "x-token: $TOKEN" \
-  -H "x-board-id: $BOARD_ID" \
-  -H "x-user-id: analyze-existing-model" \
-  "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/slicedata?contextName=<CONTEXT_NAME>"
-```
-
-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
+**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.
 
@@ -132,6 +103,8 @@ For each slice, check whether `specs` is non-empty. Calculate:
 
 ### 5d — Structural gaps per slice
 
+For a fast structural read per chapter, call `validate_model` (`{boardId, chapterId}`) — it returns unplaced nodes, backward arrows, zero/multi-issuer commands, sourceless read models, screen-per-column collisions and missing scenarios in one compact response, which covers most of the gaps this section looks for without walking every slice by hand. For a plain "what is where and how is it wired" dump (no field bodies or screen HTML), `get_board_outline` (`{boardId, chapterId}`) is the cheap fetch. Use the per-slice table below for anything those two don't answer.
+
 For every slice, determine its type from the elements present and check for common structural issues:
 
 | Slice type | Expect | Flag if missing |
@@ -216,28 +189,4 @@ mcp__eventmodelers__get_nodes { "boardId": "$BOARD_ID", "type": "MODEL_CONTEXT"
 mcp__eventmodelers__get_slice_data { "boardId": "$BOARD_ID", "contextName": "Ordering" }
 ```
 
-**Fallback (no MCP):**
-```bash
-# 1. List slices
-curl -s \
-  -H "x-token: $TOKEN" \
-  -H "x-board-id: $BOARD_ID" \
-  -H "x-user-id: analyze-existing-model" \
-  "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/slicedata/slices"
-
-# 2. Fetch MODEL_CONTEXT nodes
-curl -s \
-  -H "x-token: $TOKEN" \
-  -H "x-board-id: $BOARD_ID" \
-  -H "x-user-id: analyze-existing-model" \
-  "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes?type=MODEL_CONTEXT"
-
-# 3. Fetch full slice data for a context
-curl -s \
-  -H "x-token: $TOKEN" \
-  -H "x-board-id: $BOARD_ID" \
-  -H "x-user-id: analyze-existing-model" \
-  "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/slicedata?contextName=Ordering"
-```
-
-Replace `$TOKEN`, `$ORG_ID`, `$BOARD_ID`, and the context name with real values resolved from the `connect` skill.
+**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

@@ -0,0 +1,68 @@
+# Analyze Existing Model — 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 — List all slices
+
+```bash
+curl -s \
+  -H "x-token: $TOKEN" \
+  -H "x-board-id: $BOARD_ID" \
+  -H "x-user-id: analyze-existing-model" \
+  "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/slicedata/slices"
+```
+
+Response: `{ "slices": [{ "id": "<uuid>", "title": "<name>", "status": "<status>" }] }`
+
+## Step 3 — Discover contexts
+
+```bash
+curl -s \
+  -H "x-token: $TOKEN" \
+  -H "x-board-id: $BOARD_ID" \
+  -H "x-user-id: analyze-existing-model" \
+  "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes?type=MODEL_CONTEXT"
+```
+
+## Step 4 — Fetch slice data per context
+
+```bash
+curl -s \
+  -H "x-token: $TOKEN" \
+  -H "x-board-id: $BOARD_ID" \
+  -H "x-user-id: analyze-existing-model" \
+  "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/slicedata?contextName=<CONTEXT_NAME>"
+```
+
+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
+
+## Example — full board analysis
+
+```bash
+# 1. List slices
+curl -s \
+  -H "x-token: $TOKEN" \
+  -H "x-board-id: $BOARD_ID" \
+  -H "x-user-id: analyze-existing-model" \
+  "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/slicedata/slices"
+
+# 2. Fetch MODEL_CONTEXT nodes
+curl -s \
+  -H "x-token: $TOKEN" \
+  -H "x-board-id: $BOARD_ID" \
+  -H "x-user-id: analyze-existing-model" \
+  "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes?type=MODEL_CONTEXT"
+
+# 3. Fetch full slice data for a context
+curl -s \
+  -H "x-token: $TOKEN" \
+  -H "x-board-id: $BOARD_ID" \
+  -H "x-user-id: analyze-existing-model" \
+  "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/slicedata?contextName=Ordering"
+```
+
+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

@@ -44,37 +44,9 @@ The result gives you the ordered chain directly — save it as the chain used in
 
 ### Fallback (no MCP) — resolve both cells to nodes
 
-For each cell (target and source), resolve it to a node using the same cell-resolution strategy as the `examples` skill. Always fetch fresh:
+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`.
 
-1. Fetch chapters:
-```bash
-curl -s "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes?type=CHAPTER" \
-  -H "x-token: $TOKEN" -H "x-board-id: $BOARD_ID" -H "x-user-id: attributes-skill"
-```
-
-If multiple chapters exist, ask the user which one to use.
-
-2. Fetch the chapter fresh to decode the grid:
-```bash
-curl -s "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/$CHAPTER_ID" \
-  -H "x-token: $TOKEN" -H "x-board-id: $BOARD_ID" -H "x-user-id: attributes-skill"
-```
-
-Decode the cell name:
-- Column letter(s) → 0-based index (A=0, B=1, … Z=25, AA=26, …)
-- Row number → 0-based index (1→0, 2→1, …)
-s- Find the matching column in `columns` and row in `rows`.
-- Compute: **`CELL_ID = row.id + "-" + column.id`** (cell IDs are always `<rowId>-<columnId>`).
-
-3. Always fetch the cell live. No MCP equivalent: `get_nodes` only filters by `type`, not `cellId` — the alternative is `get_node` on the CHAPTER node, reading `meta.timelineData.cells` (a sparse array; an absent cell id means the cell is empty), but that reuses the same chapter fetch from step 2 rather than guaranteeing the freshest live state, so this curl call has no direct MCP replacement:
-```bash
-curl -s "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes?cellId=$CELL_ID" \
-  -H "x-token: $TOKEN" -H "x-board-id: $BOARD_ID" -H "x-user-id: attributes-skill"
-```
-
-Take the first non-CHAPTER result as the node for that cell.
-
-Save as `TARGET_NODE` and `SOURCE_NODE`.
+Take the first non-CHAPTER result as the node for each cell. Save as `TARGET_NODE` and `SOURCE_NODE`.
 
 ---
 
@@ -94,11 +66,7 @@ An **inbound** edge is one where `edge.target === currentNode.id`. For each inbo
 mcp__eventmodelers__get_node { "boardId": "$BOARD_ID", "nodeId": "$EDGE_SOURCE_ID" }
 ```
 
-**Fallback (no MCP):**
-```bash
-curl -s "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/$EDGE_SOURCE_ID" \
-  -H "x-token: $TOKEN" -H "x-board-id: $BOARD_ID" -H "x-user-id: attributes-skill"
-```
+**Fallback (no MCP):** see `references/api-fallback.md` — "3a — Use Node Edges".
 
 ### 3b — Column-based fallback (if no edges)
 If a node has no edges, use the chapter cell layout (already in memory) to find plausible inbound neighbours:
@@ -165,32 +133,7 @@ mcp__eventmodelers__submit_node_events {
 }
 ```
 
-**Fallback (no MCP)** — build the payload with Python to avoid JSON escaping issues, then POST it:
-
-```bash
-python3 - <<EOF > /tmp/attributes_payload.json
-import json, time, uuid
-payload = [{
-  "id": str(uuid.uuid4()),
-  "eventType": "node:changed",
-  "nodeId": "<NODE_ID>",
-  "boardId": "<BOARD_ID>",
-  "timestamp": int(time.time() * 1000),
-  "changedAttributes": ["meta.fields"],
-  "meta": {
-    "fields": <updated_fields_as_python_list>
-  }
-}]
-print(json.dumps(payload))
-EOF
-
-curl -s -w "\n%{http_code}" -X POST "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/events" \
-  -H "Content-Type: application/json" \
-  -H "x-token: $TOKEN" \
-  -H "x-board-id: $BOARD_ID" \
-  -H "x-user-id: attributes-skill" \
-  --data-binary @/tmp/attributes_payload.json
-```
+**Fallback (no MCP):** see `references/api-fallback.md` — "Step 4 — Apply the Change to Each Node in the Chain".
 
 Verify HTTP 200 before proceeding to the next node. If a node fails, report the error and stop.
 

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

@@ -0,0 +1,39 @@
+# Attributes — 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.
+
+## 3a — Use Node Edges
+
+```bash
+curl -s "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/$EDGE_SOURCE_ID" \
+  -H "x-token: $TOKEN" -H "x-board-id: $BOARD_ID" -H "x-user-id: attributes-skill"
+```
+
+## Step 4 — Apply the Change to Each Node in the Chain
+
+Build the payload with Python to avoid JSON escaping issues, then POST it:
+
+```bash
+python3 - <<EOF > /tmp/attributes_payload.json
+import json, time, uuid
+payload = [{
+  "id": str(uuid.uuid4()),
+  "eventType": "node:changed",
+  "nodeId": "<NODE_ID>",
+  "boardId": "<BOARD_ID>",
+  "timestamp": int(time.time() * 1000),
+  "changedAttributes": ["meta.fields"],
+  "meta": {
+    "fields": <updated_fields_as_python_list>
+  }
+}]
+print(json.dumps(payload))
+EOF
+
+curl -s -w "\n%{http_code}" -X POST "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/events" \
+  -H "Content-Type: application/json" \
+  -H "x-token: $TOKEN" \
+  -H "x-board-id: $BOARD_ID" \
+  -H "x-user-id: attributes-skill" \
+  --data-binary @/tmp/attributes_payload.json
+```

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

@@ -218,13 +218,7 @@ Discovered N screens across M flows:
 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 "x-token: $TOKEN" \
-  -H "Content-Type: application/json" \
-  -d '{"position":{"x":0,"y":0}}'
-```
+**Fallback (no MCP):** see `references/api-fallback.md` — "Step 5 — Create chapter".
 
 Extract `id` → `CHAPTER_ID` for this flow.
 
@@ -247,24 +241,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: discover-storyboard" \
-  -H "Content-Type: application/json" \
-  -d '[{
-    "id": "<uuid>",
-    "eventType": "node:changed",
-    "nodeId": "<CHAPTER_ID>",
-    "boardId": "<BOARD_ID>",
-    "timestamp": <NOW_MS>,
-    "changedAttributes": ["meta.title"],
-    "meta": { "type": "CHAPTER", "title": "<flow name>" },
-    "node": { "id": "<CHAPTER_ID>", "data": {} }
-  }]'
-```
+**Fallback (no MCP):** see `references/api-fallback.md` — "Step 5 — Update chapter title".
 
 Save `CHAPTER_ID` against each flow.
 
@@ -272,20 +249,16 @@ Save `CHAPTER_ID` against each flow.
 
 ## Step 6 — Fetch chapter grid and build column queue
 
-For each chapter, fetch its current grid state.
+For each chapter, fetch its 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 -H "x-token: $TOKEN" \
-  "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/$CHAPTER_ID"
-```
+**Fallback (no MCP):** see `references/api-fallback.md` — "Step 6 — Fetch chapter grid".
 
-From `meta.timelineData`:
+From the result (`rows`/`columns`/`cells` directly via MCP, or `meta.timelineData` via the REST fallback):
 - `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`
 
@@ -311,16 +284,7 @@ mcp__eventmodelers__add_column { "boardId": "<BOARD_ID>", "timelineId": "<CHAPTE
 ```
 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).
 
-**Fallback (no MCP):**
-```bash
-curl -s -X POST "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/timelines/$CHAPTER_ID/columns" \
-  -H "x-token: $TOKEN" \
-  -H "x-board-id: $BOARD_ID" \
-  -H "x-user-id: discover-storyboard" \
-  -H "Content-Type: application/json" \
-  -d '{}'
-```
-Response includes `{ columnId, index, totalColumns }` — `index` is the new `columnIndex`.
+**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.
 
@@ -336,7 +300,7 @@ This step must create the node and attach its content (HTML pages, or the screen
 
 **Default path — `renderMode == "html"` (use unless the user explicitly asked for screenshots/images in Step 2):**
 
-Reconstruct the captured screen as a real HTML/CSS fragment from `screen.capturedMarkup`, following the `html-screen` skill's conventions: full-size markup (16px body text, generous padding), one self-contained fragment per page (no `<html>`/`<head>`/`<body>` wrapper), no `<script>`/inline handlers, Bulma CSS classes (`title`, `button`, `is-primary`, `field`/`control`/`input`, tables, tags for status badges, etc.). Reproduce the real layout, labels, form fields, buttons, and any live data/status values seen on the actual page — this is a faithful reconstruction of the discovered screen, not a generic mockup.
+Reconstruct the captured screen as a real HTML/CSS fragment from `screen.capturedMarkup`, following the `html-screen` skill's page-design conventions (Step 3) — full-size markup, one self-contained fragment per page, no script/inline handlers, Bulma classes. Reproduce the real layout, labels, form fields, buttons, and any live data/status values seen on the actual page — this is a faithful reconstruction of the discovered screen, not a generic mockup.
 
 ```
 mcp__eventmodelers__create_screen {
@@ -367,15 +331,7 @@ mcp__eventmodelers__create_screen {
 }
 ```
 
-**Fallback (no MCP)** — the same atomic operation via the `image-nodes` endpoint (not the plain `images/:id` endpoint, which only updates an existing node's image and does not place it) — image path only:
-```bash
-curl -s -X POST "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/image-nodes/$SCREEN_NODE_ID" \
-  -H "x-token: $TOKEN" \
-  -F "file=@<screen.filepath>" \
-  -F "chapterId=$CHAPTER_ID" \
-  -F "cellName=$CELL_NAME"
-```
-For the HTML path with no MCP, use the `html-screen-nodes` endpoint per the `html-screen` skill's fallback mechanics instead.
+**Fallback (no MCP):** see `references/api-fallback.md` — "Step 7b — Upload image (fallback)".
 
 Response: `204`/success on success. Log failures in the final report but continue to the next screen — do not stop the entire run.
 

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

@@ -0,0 +1,63 @@
+# Discover 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 5 — Create chapter
+
+```bash
+curl -s -X POST "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/chapters" \
+  -H "x-token: $TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '{"position":{"x":0,"y":0}}'
+```
+
+## Step 5 — Update chapter title
+
+```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: discover-storyboard" \
+  -H "Content-Type: application/json" \
+  -d '[{
+    "id": "<uuid>",
+    "eventType": "node:changed",
+    "nodeId": "<CHAPTER_ID>",
+    "boardId": "<BOARD_ID>",
+    "timestamp": <NOW_MS>,
+    "changedAttributes": ["meta.title"],
+    "meta": { "type": "CHAPTER", "title": "<flow name>" },
+    "node": { "id": "<CHAPTER_ID>", "data": {} }
+  }]'
+```
+
+## Step 6 — Fetch chapter grid
+
+```bash
+curl -s -H "x-token: $TOKEN" \
+  "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/$CHAPTER_ID"
+```
+
+## Step 7a — Create column
+
+```bash
+curl -s -X POST "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/timelines/$CHAPTER_ID/columns" \
+  -H "x-token: $TOKEN" \
+  -H "x-board-id: $BOARD_ID" \
+  -H "x-user-id: discover-storyboard" \
+  -H "Content-Type: application/json" \
+  -d '{}'
+```
+Response includes `{ columnId, index, totalColumns }` — `index` is the new `columnIndex`.
+
+## Step 7b — Upload image (fallback)
+
+The same atomic operation via the `image-nodes` endpoint (not the plain `images/:id` endpoint, which only updates an existing node's image and does not place it) — image path only:
+```bash
+curl -s -X POST "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/image-nodes/$SCREEN_NODE_ID" \
+  -H "x-token: $TOKEN" \
+  -F "file=@<screen.filepath>" \
+  -F "chapterId=$CHAPTER_ID" \
+  -F "cellName=$CELL_NAME"
+```
+For the HTML path with no MCP, use the `html-screen-nodes` endpoint per the `html-screen` skill's fallback mechanics instead.