@eventmodelers/cli 0.0.39 → 1.0.1

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

@@ -5,7 +5,9 @@ description: Add a new attribute or rename an existing attribute across a chain
 
 # Attributes
 
-> **Before doing anything else**, invoke the `connect` skill to resolve `TOKEN`, `BOARD_ID`, and `BASE_URL`. Do not proceed until the connect skill has completed.
+> **Before doing anything else**, invoke the `connect` skill — if not already connected — to resolve `TOKEN`, `BOARD_ID`, and `BASE_URL`. Do not proceed until the connect skill has completed.
+
+Prefer `mcp__eventmodelers__*` tools when available (registered by the `connect` skill) — the curl blocks below are the fallback for sessions without MCP connected.
 
 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.
 
@@ -25,7 +27,22 @@ If any of these were already provided in `$ARGUMENTS`, skip asking for them.
 
 ---
 
-## Step 2 — Resolve both cells to nodes
+## 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.
+
+```
+mcp__eventmodelers__get_attribute_chain {
+  "boardId": "$BOARD_ID",
+  "timelineId": "$CHAPTER_ID",
+  "targetCellName": "<target cell, e.g. B2>",
+  "sourceCellName": "<source cell, e.g. A2>"
+}
+```
+
+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.
+
+### 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:
 
@@ -49,7 +66,7 @@ Decode the cell name:
 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:
+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"
@@ -61,7 +78,7 @@ Save as `TARGET_NODE` and `SOURCE_NODE`.
 
 ---
 
-## Step 3 — Build the dependency chain
+### Fallback (no MCP) — build the dependency chain
 
 Walk backwards from `TARGET_NODE` to `SOURCE_NODE` by following inbound edges. Build an ordered list: `[TARGET_NODE, …intermediate nodes…, SOURCE_NODE]`.
 
@@ -71,6 +88,13 @@ Each node may have an `edges` array:
 edges: [{ id, source, target, sourceHandle, targetHandle }]
 ```
 An **inbound** edge is one where `edge.target === currentNode.id`. For each inbound edge, fetch the source node:
+
+**Prefer MCP:**
+```
+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"
@@ -123,7 +147,25 @@ For each node:
 - Find the field where `name === oldName` (case-insensitive). If not found in this node, skip it (log it).
 - Update only the `name` property to `newName`. Leave all other field properties unchanged.
 
-Build the updated `fields` array and send a `node:changed` event using Python to avoid JSON escaping issues:
+Build the updated `fields` array and send a `node:changed` event.
+
+**Prefer MCP** — same event body, passed as a tool arg instead of `-d`:
+```
+mcp__eventmodelers__submit_node_events {
+  "boardId": "$BOARD_ID",
+  "events": [{
+    "id": "<uuid>",
+    "eventType": "node:changed",
+    "nodeId": "<NODE_ID>",
+    "boardId": "$BOARD_ID",
+    "timestamp": <epoch-ms>,
+    "changedAttributes": ["meta.fields"],
+    "meta": { "fields": "<updated_fields_array>" }
+  }]
+}
+```
+
+**Fallback (no MCP)** — build the payload with Python to avoid JSON escaping issues, then POST it:
 
 ```bash
 python3 - <<EOF > /tmp/attributes_payload.json

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

@@ -49,7 +49,9 @@ Do NOT invoke `connect`. Do NOT proceed to Step 1.
 
 ## Step 1 — Connect
 
-Invoke the `connect` skill to resolve `TOKEN`, `BOARD_ID`, `ORG_ID`, and `BASE_URL`. Do not proceed until all four are available.
+Invoke the `connect` skill — if not already connected — to resolve `TOKEN`, `BOARD_ID`, `ORG_ID`, and `BASE_URL`. Do not proceed until all four are available.
+
+> Prefer `mcp__eventmodelers__*` tools when available (registered by the `connect` skill) — the curl blocks below (Steps 5–7, the eventmodelers board-API calls) are the fallback for sessions without MCP connected. This is unrelated to the browser automation MCP checked in Step 0, which stays as-is.
 
 ---
 
@@ -201,8 +203,14 @@ Discovered N screens across M flows:
 
 **If `chapterId` was provided** — use it as the single `CHAPTER_ID` for all screens. Skip this step.
 
-**Otherwise** — for each flow, create one chapter:
+**Otherwise** — for each flow, create one chapter.
+
+**Prefer MCP:**
+```
+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" \
@@ -212,8 +220,26 @@ curl -s -X POST "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/chapters" \
 
 Extract `id` → `CHAPTER_ID` for this flow.
 
-Update the chapter title to the flow name using `node:changed`:
+Update the chapter title to the flow name using `node:changed`.
 
+**Prefer MCP:**
+```
+mcp__eventmodelers__submit_node_events {
+  "boardId": "<BOARD_ID>",
+  "events": [{
+    "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):**
 ```bash
 curl -s -X POST "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/events" \
   -H "x-token: $TOKEN" \
@@ -238,18 +264,24 @@ 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.
+
+**Prefer MCP:**
+```
+mcp__eventmodelers__get_node { "boardId": "<BOARD_ID>", "nodeId": "<CHAPTER_ID>" }
+```
 
+**Fallback (no MCP):**
 ```bash
 curl -s -H "x-token: $TOKEN" \
   "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/$CHAPTER_ID"
 ```
 
 From `meta.timelineData`:
-- `rows` — find the row with `type === "actor"` → save its `id` as `actorRowId`
-- `columns` — ordered list; build an empty-column queue
+- `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 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`.
 
 ---
 
@@ -261,10 +293,17 @@ For each screen:
 
 ### 7a — Acquire a column slot
 
-**If the empty-column queue is non-empty** — pop the first entry → `columnId`. Compute `CELL_ID = actorRowId + "-" + columnId`.
+**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 empty** — create a new column.
 
-**If the empty-column queue is empty** — create a new column:
+**Prefer MCP:**
+```
+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).
 
+**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" \
@@ -273,70 +312,46 @@ curl -s -X POST "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/timelines/$CHAPTER_I
   -H "Content-Type: application/json" \
   -d '{}'
 ```
+Response includes `{ columnId, index, totalColumns }` — `index` is the new `columnIndex`.
 
-Extract `columnId`. Compute `CELL_ID = actorRowId + "-" + columnId`.
+Extract `columnId`. Compute `CELL_ID = actorRowId + "-" + columnId` and `CELL_NAME` per the convention above.
 
-### 7b — Generate UUID and upload the screenshot
+### 7b — Create the SCREEN node with its screenshot, atomically
 
-Generate UUIDs for `SCREEN_NODE_ID` and `EVT_ID`:
+Generate a UUID for `SCREEN_NODE_ID`:
 
 ```bash
 python3 -c "import uuid; print(uuid.uuid4())"
 ```
 
-Upload the saved screenshot file using `SCREEN_NODE_ID` **before** creating the node:
+This step must create the node and attach the real screenshot in a single call — never split into "upload image" then "create node" (or vice versa), which leaves a window where the node exists with no image or an image with no node.
 
-```bash
-curl -s -X POST "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/images/$SCREEN_NODE_ID" \
-  -H "x-token: $TOKEN" \
-  -F "file=@<screen.filepath>"
+**Prefer MCP:**
 ```
-
-> **Note**: This uploads the real screenshot to the SCREEN node — it is a different endpoint from the sketch API. The sketch API (`/images/$NODE/sketch`) renders AI-generated wireframe elements. This endpoint (`/images/$NODE`) uploads an actual image file.
-
-Log success or failure. On failure, note it in the final report but continue.
-
-### 7c — Create the SCREEN node
-
-Now create the SCREEN node using the same `SCREEN_NODE_ID` (the image is already uploaded for it):
-
-```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":        "<EVT_ID>",
-    "eventType": "node:created",
-    "nodeId":    "<SCREEN_NODE_ID>",
-    "boardId":   "<BOARD_ID>",
-    "timestamp": <NOW_MS>,
-    "chapterId": "<CHAPTER_ID>",
-    "cellId":    "<CELL_ID>",
-    "meta":      {
-      "type":        "SCREEN",
-      "title":       "<screen.title>",
-      "description": "<screen.description — 'Shows X. Arrived via: Y. Actions: user can do A, user can do B.'>"
-    },
-    "node":      { "id": "<SCREEN_NODE_ID>", "data": {} }
-  }]'
+mcp__eventmodelers__create_screen {
+  "boardId": "<BOARD_ID>",
+  "contentType": "image",
+  "nodeId": "<SCREEN_NODE_ID>",
+  "chapterId": "<CHAPTER_ID>",
+  "cellName": "<CELL_NAME>",
+  "imageBase64": "<base64-encoded contents of screen.filepath, no data: URI prefix>",
+  "mimeType": "image/png",
+  "description": "<screen.description — 'Shows X. Arrived via: Y. Actions: user can do A, user can do B.'>"
+}
 ```
 
-Verify the response contains `"hashes"`. If it fails, log the error and continue to the next screen — do not stop the entire run.
-
-### 7d — Verify the screen
-
-Confirm the node and its uploaded screenshot both actually exist:
-
+**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):
 ```bash
-curl -s "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/screens/$SCREEN_NODE_ID/verify" \
-  -H "x-token: $TOKEN"
+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"
 ```
 
-If `valid` is `false`, read the `error` field. If `imageExists` is `false`, the screenshot upload in 7b failed silently — retry it once. Log any screen that still fails verification in the final report and continue to the next screen.
+Response: `204` on success. Log failures in the final report but continue to the next screen — do not stop the entire run.
 
-### 7e — Report per-screen progress
+### 7d — Report per-screen progress
 
 After each screen: print one line, e.g.:
 ```
@@ -355,8 +370,7 @@ Discover Storyboard complete.
 Flows created (N total):
   • "Login & Authentication" — chapter <id> — 3 screens
   • "Product Browsing" — chapter <id> — 5 screens
-
-Screens uploaded: N of M (list any failures, including screens that failed 7d verification)
+Screens uploaded: N of M (list any failures)
 
 Next steps:
   - Open the board to review the storyboard timelines

package/stacks/modeling-kit/templates/.claude/skills/eventmodeling-applying-conways-law/SKILL.md

@@ -9,7 +9,7 @@ allowed-tools:
 
 # Applying Conway's Law
 
-> **Before doing anything else**, invoke the `connect` skill to resolve `TOKEN`, `BOARD_ID`, `ORG_ID`, and `BASE_URL`. Then invoke the `learn-eventmodelers-api` skill to load the full API reference. Do not proceed until both skills have been loaded.
+> **Before doing anything else**, invoke the `connect` skill — if not already connected — to resolve `TOKEN`, `BOARD_ID`, `ORG_ID`, and `BASE_URL`. Do not proceed until it has completed. Consult `learn-eventmodelers-api` only if you need to look up a specific endpoint or field this file doesn't cover — don't load it eagerly.
 
 ## Interview Phase (Optional)
 

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

@@ -9,7 +9,9 @@ allowed-tools:
 
 # Brainstorming Events
 
-> **Before doing anything else**, invoke the `connect` skill to resolve `TOKEN`, `BOARD_ID`, `ORG_ID`, and `BASE_URL`. Then invoke the `learn-eventmodelers-api` skill to load the full API reference. Do not proceed until both skills have been loaded.
+> **Before doing anything else**, invoke the `connect` skill — if not already connected — to resolve `TOKEN`, `BOARD_ID`, `ORG_ID`, and `BASE_URL`. Do not proceed until it has completed. Consult `learn-eventmodelers-api` only if you need to look up a specific endpoint or field this file doesn't cover — don't load it eagerly.
+
+Prefer `mcp__eventmodelers__*` tools when available (registered by the `connect` skill) — the curl blocks below are the fallback for sessions without MCP connected.
 
 ## Interview Phase (Optional)
 
@@ -118,6 +120,12 @@ This section feeds into subsequent steps (plotting, storyboarding, etc.)
 
 Before brainstorming, check for EVENT nodes already on the board to avoid duplicating events from a previous session:
 
+**Prefer MCP:**
+```
+mcp__eventmodelers__get_nodes { "boardId": "<BOARD_ID>", "type": "EVENT" }
+```
+
+**Fallback (no MCP):**
 ```bash
 curl -s -H "x-token: $TOKEN" -H "x-board-id: $BOARD_ID" \
   "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes?type=EVENT"
@@ -125,6 +133,12 @@ curl -s -H "x-token: $TOKEN" -H "x-board-id: $BOARD_ID" \
 
 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:
 
+**Prefer MCP:**
+```
+mcp__eventmodelers__get_nodes { "boardId": "<BOARD_ID>", "type": "CHAPTER" }
+```
+
+**Fallback (no MCP):**
 ```bash
 curl -s -H "x-token: $TOKEN" -H "x-board-id: $BOARD_ID" \
   "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes?type=CHAPTER"
@@ -147,7 +161,13 @@ If all events belong to a single flow, one timeline is correct — do not split
 
 For each group, create a chapter on the board **before placing any events**. Reuse an existing chapter if one already matches the workflow name.
 
-**Create a chapter:**
+**Prefer MCP — create a chapter:**
+```
+mcp__eventmodelers__create_chapter { "boardId": "<BOARD_ID>", "x": 0, "y": 1200 }
+```
+(`x`/`y` are optional — see the vertical-stacking note below. Response includes the new `timelineId`.)
+
+**Fallback (no MCP) — create a chapter:**
 ```bash
 curl -s -X POST "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/chapters" \
   -H "x-token: $TOKEN" -H "x-board-id: $BOARD_ID" \
@@ -156,6 +176,23 @@ curl -s -X POST "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/chapters" \
 ```
 
 **Immediately set its title** (use the workflow / bounded-context name):
+
+**Prefer MCP:**
+```
+mcp__eventmodelers__submit_node_events {
+  "boardId": "<BOARD_ID>",
+  "events": [{
+    "id": "<uuid>",
+    "eventType": "node:changed",
+    "nodeId": "<chapterId>",
+    "boardId": "<BOARD_ID>",
+    "timestamp": 1234567890,
+    "meta": {"type": "CHAPTER", "title": "Reservation & Lending"}
+  }]
+}
+```
+
+**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" \
@@ -171,8 +208,14 @@ curl -s -X POST "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/events" \
 ```
 
 **Stack timelines vertically so they do not overlap.**
-After creating each chapter, position it below the previous one. Use `y = index * 1200` (0-based creation order), `x = 0`. If existing chapters are already on the board, query their positions first and place the new chapter below the lowest one (`y = maxExistingY + 1200`):
+After creating each chapter, position it below the previous one. Use `y = index * 1200` (0-based creation order), `x = 0`. If existing chapters are already on the board, query their positions first and place the new chapter below the lowest one (`y = maxExistingY + 1200`). Pass this directly as `x`/`y` on `create_chapter` above, or reposition an existing chapter with:
 
+**Prefer MCP:**
+```
+mcp__eventmodelers__move_timeline_position { "boardId": "<BOARD_ID>", "timelineId": "<TL>", "x": 0, "y": 1200 }
+```
+
+**Fallback (no MCP):**
 ```bash
 curl -s -X PUT "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/timelines/$TL/position" \
   -H "x-token: $TOKEN" -H "x-board-id: $BOARD_ID" \
@@ -197,11 +240,11 @@ Fields use this structure inside `meta`:
   "type": "EVENT",
   "title": "OrderPlaced",
   "fields": [
-    {"name": "orderId",    "type": "String",  "example": "order-abc123"},
-    {"name": "customerId", "type": "String",  "example": "cust-456"},
-    {"name": "total",      "type": "Number",  "example": "149.99"},
-    {"name": "status",     "type": "String",  "example": "Draft"},
-    {"name": "placedAt",   "type": "Date",    "example": "2026-05-29T10:00:00Z"}
+    {"name": "orderId",    "type": "String",   "example": "order-abc123"},
+    {"name": "customerId", "type": "String",   "example": "cust-456"},
+    {"name": "total",      "type": "Decimal",  "example": "149.99"},
+    {"name": "status",     "type": "String",   "example": "Draft"},
+    {"name": "placedAt",   "type": "DateTime", "example": "2026-05-29T10:00:00Z"}
   ]
 }
 ```
@@ -225,6 +268,13 @@ When a chapter is available, place each event directly into it. **Include `cellI
 For each event:
 
 **Step A — Create a column** (append at end of the chapter):
+
+**Prefer MCP:**
+```
+mcp__eventmodelers__add_column { "boardId": "<BOARD_ID>", "timelineId": "<CHAPTER_ID>" }
+```
+
+**Fallback (no MCP):**
 ```bash
 curl -s -X POST "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/timelines/$CHAPTER_ID/columns" \
   -H "x-token: $TOKEN" -H "x-board-id: $BOARD_ID" -H "x-user-id: brainstorming-events" \
@@ -233,6 +283,13 @@ curl -s -X POST "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/timelines/$CHAPTER_I
 ```
 
 **Step B — Fetch the chapter to find the swimlane row ID** (only needed once per chapter):
+
+**Prefer MCP:**
+```
+mcp__eventmodelers__get_node { "boardId": "<BOARD_ID>", "nodeId": "<CHAPTER_ID>" }
+```
+
+**Fallback (no MCP):**
 ```bash
 curl -s -H "x-token: $TOKEN" -H "x-board-id: $BOARD_ID" \
   "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/$CHAPTER_ID"
@@ -241,7 +298,36 @@ curl -s -H "x-token: $TOKEN" -H "x-board-id: $BOARD_ID" \
 
 **Step C — Compute:** `cellId = swimlaneRow.id + "-" + columnId`
 
-**Step D — Create the event with `cellId`:**
+**Step D — Create the event with `cellId`.**
+
+**Prefer MCP** — pass the same shape to `submit_node_events` (`events` is a tool arg, not a `-d` body):
+```
+mcp__eventmodelers__submit_node_events {
+  "boardId": "<BOARD_ID>",
+  "events": [{
+    "id": "<event-uuid>",
+    "eventType": "node:created",
+    "nodeId": "<node-uuid>",
+    "boardId": "<BOARD_ID>",
+    "timestamp": 1234567890,
+    "chapterId": "<chapterId>",
+    "cellId": "<swimlaneRowId>-<columnId>",
+    "meta": {
+      "type": "EVENT",
+      "title": "BookReserved",
+      "fields": [
+        {"name": "reservationId", "type": "String",   "example": "res-789"},
+        {"name": "copyId",        "type": "String",   "example": "copy-42"},
+        {"name": "memberId",      "type": "String",   "example": "mbr-101"},
+        {"name": "expiresAt",     "type": "DateTime", "example": "2026-06-01T00:00:00Z"},
+        {"name": "reservedAt",    "type": "DateTime", "example": "2026-05-29T10:00:00Z"}
+      ]
+    }
+  }]
+}
+```
+
+**Fallback (no MCP) — same body via `POST .../nodes/events`:**
 ```json
 [{
   "id": "<event-uuid>",
@@ -255,11 +341,11 @@ curl -s -H "x-token: $TOKEN" -H "x-board-id: $BOARD_ID" \
     "type": "EVENT",
     "title": "BookReserved",
     "fields": [
-      {"name": "reservationId", "type": "String", "example": "res-789"},
-      {"name": "copyId",        "type": "String", "example": "copy-42"},
-      {"name": "memberId",      "type": "String", "example": "mbr-101"},
-      {"name": "expiresAt",     "type": "Date",   "example": "2026-06-01T00:00:00Z"},
-      {"name": "reservedAt",    "type": "Date",   "example": "2026-05-29T10:00:00Z"}
+      {"name": "reservationId", "type": "String",   "example": "res-789"},
+      {"name": "copyId",        "type": "String",   "example": "copy-42"},
+      {"name": "memberId",      "type": "String",   "example": "mbr-101"},
+      {"name": "expiresAt",     "type": "DateTime", "example": "2026-06-01T00:00:00Z"},
+      {"name": "reservedAt",    "type": "DateTime", "example": "2026-05-29T10:00:00Z"}
     ]
   }
 }]

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

@@ -8,12 +8,22 @@ allowed-tools:
 
 # Checking Completeness
 
-> **Before doing anything else**, invoke the `connect` skill to resolve `TOKEN`, `BOARD_ID`, `ORG_ID`, and `BASE_URL`. Then invoke the `learn-eventmodelers-api` skill to load the full API reference. Do not proceed until both skills have been loaded.
+> **Before doing anything else**, invoke the `connect` skill — if not already connected — to resolve `TOKEN`, `BOARD_ID`, `ORG_ID`, and `BASE_URL`. Do not proceed until it has completed. Consult `learn-eventmodelers-api` only if you need to look up a specific endpoint or field this file doesn't cover — don't load it eagerly.
+
+Prefer `mcp__eventmodelers__*` tools when available (registered by the `connect` skill) — the curl blocks below are the fallback for sessions without MCP connected.
 
 ## Board Context
 
 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:**
+```
+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" }
+```
+
+**Fallback (no MCP):**
 ```bash
 # All nodes (events, commands, read models, screens)
 curl -s -H "x-token: $TOKEN" -H "x-board-id: $BOARD_ID" \
@@ -152,6 +162,16 @@ Status: All fields sourced
 
 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:
+```
+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" }
+```
+
+**Fallback (no MCP):**
 ```bash
 curl -s -H "x-token: $TOKEN" -H "x-board-id: $BOARD_ID" \
   "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes?type=SLICE_BORDER"
@@ -435,7 +455,7 @@ Present as:
 ### Issues Found
 1. Estimated delivery date missing
    - Fix: Add to OrderShipped event
-   - Type: string (ISO 8601 date)
+   - Type: DateTime (ISO 8601)
    - Source: Calculated from carrier API
    - Status: Will add in next iteration
 

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

@@ -9,7 +9,7 @@ allowed-tools:
 
 # Designing Event Models
 
-> **Before doing anything else**, invoke the `connect` skill to resolve `TOKEN`, `BOARD_ID`, `ORG_ID`, and `BASE_URL`. Then invoke the `learn-eventmodelers-api` skill to load the full API reference. Do not proceed until both skills have been loaded.
+> **Before doing anything else**, invoke the `connect` skill — if not already connected — to resolve `TOKEN`, `BOARD_ID`, `ORG_ID`, and `BASE_URL`. Do not proceed until it has completed. Consult `learn-eventmodelers-api` only if you need to look up a specific endpoint or field this file doesn't cover — don't load it eagerly.
 
 ## Interview Phase (Optional)
 

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

@@ -9,7 +9,9 @@ allowed-tools:
 
 # Elaborating Scenarios
 
-> **Before doing anything else**, invoke the `connect` skill to resolve `TOKEN`, `BOARD_ID`, `ORG_ID`, and `BASE_URL`. Then invoke the `learn-eventmodelers-api` skill to load the full API reference. Do not proceed until both skills have been loaded.
+> **Before doing anything else**, invoke the `connect` skill — if not already connected — to resolve `TOKEN`, `BOARD_ID`, `ORG_ID`, and `BASE_URL`. Do not proceed until it has completed. Consult `learn-eventmodelers-api` only if you need to look up a specific endpoint or field this file doesn't cover — don't load it eagerly.
+
+Prefer `mcp__eventmodelers__*` tools when available (registered by the `connect` skill) — the curl blocks below are the fallback for sessions without MCP connected.
 
 ## Interview Phase (Optional)
 
@@ -571,8 +573,14 @@ 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.
+
+**Prefer MCP:**
+```
+mcp__eventmodelers__get_nodes { "boardId": "<BOARD_ID>", "type": "CHAPTER" }
+```
 
+**Fallback (no MCP):**
 ```bash
 curl -s "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes?type=CHAPTER" \
   -H "x-token: $TOKEN"
@@ -584,8 +592,14 @@ For each command or view being specified, find its column: fetch the chapter nod
 
 ### Step 2 — Load valid step elements
 
-For each target timeline, call spec-info to discover the node IDs that may appear in given/when/then:
+For each target timeline, call spec-info to discover the node IDs that may appear in given/when/then.
 
+**Prefer MCP:**
+```
+mcp__eventmodelers__get_spec_info { "boardId": "<BOARD_ID>", "timelineId": "<TL>" }
+```
+
+**Fallback (no MCP):**
 ```bash
 curl -s "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/timelines/$TL/spec-info" \
   -H "x-token: $TOKEN"
@@ -602,8 +616,20 @@ See `learn-eventmodelers-api` for the full step item format, scenario object sha
 
 ### Step 4 — Post all scenarios for a column in one call
 
-Group all scenarios for the same column and POST them as an array. The SCENARIO spec node is created automatically — no pre-creation needed.
+Group all scenarios for the same column and post them as an array. The SCENARIO spec node is created automatically — no pre-creation needed.
+
+**Prefer MCP:**
+```
+mcp__eventmodelers__add_scenario {
+  "boardId": "<BOARD_ID>",
+  "timelineId": "<TL>",
+  "columnId": "<COL>",
+  "scenarios": [...scenario objects, same shape as below...]
+}
+```
+`given`/`when`/`then` are arrays of `{id, title?, type?, ...}` objects — **not** bare nodeId strings (this differs from the raw REST body shown in the fallback below). The examples in Steps 4b/4c/§Rejection already use this object shape; pass them straight through as the `scenarios` array. For a state-view scenario whose `when` needs to represent a query rather than a COMMAND, `when` may hold a single inline object that is **not** a board node: `{"id": "<generated-uuid>", "type": "QUERY", "title": "...", "fields": [{"name": "...", "example": "..."}]}`. Same server-side rules apply either way (see below).
 
+**Fallback (no MCP):**
 ```bash
 curl -s -X POST \
   "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/timelines/$TL/columns/$COL/scenarios" \