@eventmodelers/cli 0.0.39 → 1.0.0

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

@@ -11,6 +11,8 @@ allowed-tools:
 
 > **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.
 
+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)
 
 **When to Interview**: Skip if the user has already identified UI actions/commands and processor triggers. Interview when it's unclear which actions are user-initiated vs. processor-automated.
@@ -342,11 +344,11 @@ If an event field has **no** corresponding command field and **no** derivation r
   "type": "COMMAND",
   "title": "ReserveBike",
   "fields": [
-    {"name": "customerId",  "type": "String",  "example": "cust-42",               "mapping": "session:customerId", "generated": false},
-    {"name": "bikeId",      "type": "String",  "example": "bike-17",               "mapping": "user-input",         "generated": false},
-    {"name": "stationId",   "type": "String",  "example": "stn-03",                "mapping": "user-input",         "generated": false},
-    {"name": "startTime",   "type": "Date",    "example": "2026-06-01T09:00:00Z",  "mapping": "user-input",         "generated": false},
-    {"name": "endTime",     "type": "Date",    "example": "2026-06-01T17:00:00Z",  "mapping": "user-input",         "generated": false}
+    {"name": "customerId",  "type": "String",   "example": "cust-42",               "mapping": "session:customerId", "generated": false},
+    {"name": "bikeId",      "type": "String",   "example": "bike-17",               "mapping": "user-input",         "generated": false},
+    {"name": "stationId",   "type": "String",   "example": "stn-03",                "mapping": "user-input",         "generated": false},
+    {"name": "startTime",   "type": "DateTime", "example": "2026-06-01T09:00:00Z",  "mapping": "user-input",         "generated": false},
+    {"name": "endTime",     "type": "DateTime", "example": "2026-06-01T17:00:00Z",  "mapping": "user-input",         "generated": false}
   ]
 }
 ```
@@ -366,7 +368,41 @@ Commands go in the `interaction` lane — same column as their resulting event.
 
 **Every `node:created` call MUST include `cellId`.** Without it the node has no cell reference and will appear stranded at position 0,0 — not in any timeline column.
 
-Commands go in the **interaction lane**, same column as the event they produce. Before creating each command:
+Commands go in the **interaction lane**, same column as the event they produce.
+
+**Prefer MCP** — `place_element` collapses the entire find-row → find/append-column → compute-cellId → create-node → auto-connect sequence (Steps A–D below) into one call:
+```
+mcp__eventmodelers__place_element {
+  "boardId": "<BOARD_ID>",
+  "timelineId": "<CHAPTER_ID>",
+  "elementType": "COMMAND",
+  "title": "ReserveBike"
+}
+```
+`place_element` finds/creates the empty cell in the interaction lane in the correct column and places the node — but it does not accept `fields`. Immediately follow up with `submit_node_events` (`node:changed`) to set `meta.fields` (with `mapping`/`generated`/`cardinality` per the rules above) on the node it returned:
+```
+mcp__eventmodelers__submit_node_events {
+  "boardId": "<BOARD_ID>",
+  "events": [{
+    "id": "<event-uuid>",
+    "eventType": "node:changed",
+    "nodeId": "<returned-node-id>",
+    "boardId": "<BOARD_ID>",
+    "timestamp": 1234567890,
+    "meta": {
+      "type": "COMMAND",
+      "title": "ReserveBike",
+      "fields": [
+        {"name": "customerId", "type": "String",   "example": "cust-42",             "mapping": "session:customerId"},
+        {"name": "bikeId",     "type": "String",   "example": "bike-17",             "mapping": "user-input"},
+        {"name": "startTime",  "type": "DateTime", "example": "2026-06-01T09:00:00Z","mapping": "user-input"}
+      ]
+    }
+  }]
+}
+```
+
+**Fallback (no MCP)** — the full manual sequence `place_element` replaces. Before creating each command:
 
 **Step A — Find the event's column ID.** Query the event node to read its current cell:
 ```bash
@@ -406,9 +442,9 @@ curl -X POST "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/events" \
       "type": "COMMAND",
       "title": "ReserveBike",
       "fields": [
-        {"name": "customerId", "type": "String", "example": "cust-42",             "mapping": "session:customerId"},
-        {"name": "bikeId",     "type": "String", "example": "bike-17",             "mapping": "user-input"},
-        {"name": "startTime",  "type": "Date",   "example": "2026-06-01T09:00:00Z","mapping": "user-input"}
+        {"name": "customerId", "type": "String",   "example": "cust-42",             "mapping": "session:customerId"},
+        {"name": "bikeId",     "type": "String",   "example": "bike-17",             "mapping": "user-input"},
+        {"name": "startTime",  "type": "DateTime", "example": "2026-06-01T09:00:00Z","mapping": "user-input"}
       ]
     }
   }]'
@@ -432,7 +468,18 @@ The timeline must always read left-to-right: SCREEN and COMMAND belong in the sa
 
 After `place-element` returns the COMMAND node ID, create the arrows that complete the slice:
 
-1. **SCREEN → COMMAND** — find the SCREEN node in the actor row of the same column:
+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:
+   ```
+   mcp__eventmodelers__get_node { "boardId": "<BOARD_ID>", "nodeId": "<CHAPTER_ID>" }
+   ```
+   Read `meta.timelineData.cells["<actorRowId>-<columnId>"]` for the occupying node id (a cell id absent from that sparse array is empty — no SCREEN placed yet). Then connect with the type-checked edge tool, which auto-corrects direction and skips duplicates:
+   ```
+   mcp__eventmodelers__set_connection { "boardId": "<BOARD_ID>", "source": "<screenNodeId>", "target": "<commandNodeId>", "action": "connect" }
+   ```
+
+   **Fallback (no MCP):**
    ```bash
    curl -s "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes?cellId=<actorRowId>-<columnId>" \
      -H "x-token: $TOKEN" -H "x-board-id: $BOARD_ID" -H "x-user-id: eventmodeling-identifying-inputs"
@@ -445,7 +492,18 @@ After `place-element` returns the COMMAND node ID, create the arrows that comple
      -d '{"source":"<screenNodeId>","target":"<commandNodeId>"}'
    ```
 
-2. **COMMAND → EVENT** — find the EVENT node in the swimlane row of the same column:
+2. **COMMAND → EVENT** — find the EVENT node in the swimlane row of the same column.
+
+   **Prefer MCP** — same cell-map lookup, then connect:
+   ```
+   mcp__eventmodelers__get_node { "boardId": "<BOARD_ID>", "nodeId": "<CHAPTER_ID>" }
+   ```
+   Read `meta.timelineData.cells["<swimlaneRowId>-<columnId>"]` for the occupying node id, then:
+   ```
+   mcp__eventmodelers__set_connection { "boardId": "<BOARD_ID>", "source": "<commandNodeId>", "target": "<eventNodeId>", "action": "connect" }
+   ```
+
+   **Fallback (no MCP):**
    ```bash
    curl -s "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes?cellId=<swimlaneRowId>-<columnId>" \
      -H "x-token: $TOKEN" -H "x-board-id: $BOARD_ID" -H "x-user-id: eventmodeling-identifying-inputs"
@@ -458,6 +516,8 @@ After `place-element` returns the COMMAND node ID, create the arrows that comple
      -d '{"source":"<commandNodeId>","target":"<eventNodeId>"}'
    ```
 
+   *Note:* `get_nodes` has no `cellId` filter (only `type`) — the `get_node`-on-CHAPTER + `meta.timelineData.cells` lookup above is the only way to check single-cell occupancy via MCP.
+
 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"`.
 
 After all commands are placed and wired, present the Command Catalog summary as text to the user.

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

@@ -11,6 +11,8 @@ allowed-tools:
 
 > **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.
 
+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)
 
 **When to Interview**: Skip if the user has clearly identified: read model queries needed by UI, processor needs, and refresh patterns. Interview when unclear which data queries are critical or how frequently they're accessed.
@@ -408,12 +410,12 @@ Every field must also set `"cardinality"` — use `"Single"` unless the field ge
   "type": "READMODEL",
   "title": "ActiveReservationView",
   "fields": [
-    {"name": "reservationId",  "type": "String",  "example": "res-001",               "mapping": "BikeReserved.reservationId",          "generated": false},
-    {"name": "customerId",     "type": "String",  "example": "cust-42",               "mapping": "BikeReserved.customerId",              "generated": false},
-    {"name": "bikeId",         "type": "String",  "example": "bike-17",               "mapping": "BikeReserved.bikeId",                  "generated": false},
-    {"name": "stationId",      "type": "String",  "example": "stn-03",                "mapping": "BikeReserved.stationId",               "generated": false},
-    {"name": "expiresAt",      "type": "Date",    "example": "2026-06-01T09:30:00Z",  "mapping": "ReservationConfirmed.expiresAt",       "generated": false},
-    {"name": "status",         "type": "String",  "example": "confirmed",             "mapping": "latest:ReservationConfirmed.status",   "generated": false}
+    {"name": "reservationId",  "type": "String",   "example": "res-001",               "mapping": "BikeReserved.reservationId",          "generated": false},
+    {"name": "customerId",     "type": "String",   "example": "cust-42",               "mapping": "BikeReserved.customerId",              "generated": false},
+    {"name": "bikeId",         "type": "String",   "example": "bike-17",               "mapping": "BikeReserved.bikeId",                  "generated": false},
+    {"name": "stationId",      "type": "String",   "example": "stn-03",                "mapping": "BikeReserved.stationId",               "generated": false},
+    {"name": "expiresAt",      "type": "DateTime", "example": "2026-06-01T09:30:00Z",  "mapping": "ReservationConfirmed.expiresAt",       "generated": false},
+    {"name": "status",         "type": "String",   "example": "confirmed",             "mapping": "latest:ReservationConfirmed.status",   "generated": false}
   ]
 }
 ```
@@ -428,6 +430,35 @@ Read models go in the `interaction` lane — **in the same column as the SCREEN
 
 **For a READMODEL** (interaction lane):
 
+**Prefer MCP** — `place_element` collapses finding/creating the empty interaction cell (including inserting a new column when the target column is already occupied by a COMMAND) and creating the node into one call:
+```
+mcp__eventmodelers__place_element {
+  "boardId": "<BOARD_ID>",
+  "timelineId": "<CHAPTER_ID>",
+  "elementType": "READMODEL",
+  "title": "ActiveReservationView",
+  "columnIndex": <consumerScreenOrAutomationColumnIndex>
+}
+```
+Then set `meta.fields` (with `mapping`/`generated`/`cardinality`) on the returned node id:
+```
+mcp__eventmodelers__submit_node_events {
+  "boardId": "<BOARD_ID>",
+  "events": [{
+    "id": "<event-uuid>", "eventType": "node:changed", "nodeId": "<returned-node-id>",
+    "boardId": "<BOARD_ID>", "timestamp": 1234567890,
+    "meta": {"type": "READMODEL", "title": "ActiveReservationView", "fields": [...]}
+  }]
+}
+```
+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:
+```
+mcp__eventmodelers__get_node { "boardId": "<BOARD_ID>", "nodeId": "<CHAPTER_ID>" }
+# → meta.timelineData.rows (find "interaction"/"actor" rows) and meta.timelineData.cells (sparse; absent id = empty)
+```
+
+**Fallback (no MCP)** — the full manual sequence:
+
 1. Find the column where the consumer SCREEN or AUTOMATION lives. Fetch the timeline to get the interaction row ID:
    ```bash
    curl -s -H "x-token: $TOKEN" -H "x-board-id: $BOARD_ID" \
@@ -460,6 +491,9 @@ Read models go in the `interaction` lane — **in the same column as the SCREEN
 
 **For an AUTOMATION** (actor lane, same column as its READMODEL):
 
+**Prefer MCP** — same `place_element` call with `"elementType": "AUTOMATION"`, then `submit_node_events` for fields, as above.
+
+**Fallback (no MCP):**
 1. Get the actor row ID from the same timeline fetch (row where `type === "actor"`).
 2. `cellId = actorRow.id + "-" + columnId`
 3. Create the AUTOMATION node using the same `node:created` pattern above with `"type": "AUTOMATION"` in `meta`.
@@ -492,7 +526,16 @@ For each view screen S that queries this read model:
 
 After `place-element` returns the READMODEL node ID, create the arrows that complete the slice:
 
-1. **EVENT → READMODEL** — find the primary source EVENT node in the swimlane row of the same column:
+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, then connect with the type-checked edge tool (auto-corrects direction, skips duplicates):
+   ```
+   mcp__eventmodelers__get_node { "boardId": "<BOARD_ID>", "nodeId": "<CHAPTER_ID>" }
+   # → read meta.timelineData.cells["<swimlaneRowId>-<columnId>"] for the occupying node id
+   mcp__eventmodelers__set_connection { "boardId": "<BOARD_ID>", "source": "<eventNodeId>", "target": "<readmodelNodeId>", "action": "connect" }
+   ```
+
+   **Fallback (no MCP):**
    ```bash
    curl -s "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes?cellId=<swimlaneRowId>-<columnId>" \
      -H "x-token: $TOKEN" -H "x-board-id: $BOARD_ID" -H "x-user-id: eventmodeling-identifying-outputs"
@@ -505,7 +548,14 @@ After `place-element` returns the READMODEL node ID, create the arrows that comp
      -d '{"source":"<eventNodeId>","target":"<readmodelNodeId>"}'
    ```
 
-2. **READMODEL → SCREEN** — connect to the existing SCREEN node in the actor row of the next column (screens are typically already placed from Step 3):
+2. **READMODEL → SCREEN** — connect to the existing SCREEN node in the actor row of the next column (screens are typically already placed from Step 3).
+
+   **Prefer MCP:**
+   ```
+   mcp__eventmodelers__set_connection { "boardId": "<BOARD_ID>", "source": "<readmodelNodeId>", "target": "<screenNodeId>", "action": "connect" }
+   ```
+
+   **Fallback (no MCP):**
    ```bash
    curl -s -X POST "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/connections" \
      -H "x-token: $TOKEN" -H "x-board-id: $BOARD_ID" -H "x-user-id: eventmodeling-identifying-outputs" \
@@ -516,6 +566,13 @@ After `place-element` returns the READMODEL node ID, create the arrows that comp
 3. **READMODEL → AUTOMATION** — if the read model is consumed by an automatic process (scheduler, background job, external trigger), place the AUTOMATION node and connect it:
    - Place the AUTOMATION in the automation lane, in the column immediately to the right of its read model (same rule as screens).
    - Then connect:
+
+   **Prefer MCP:**
+   ```
+   mcp__eventmodelers__set_connection { "boardId": "<BOARD_ID>", "source": "<readmodelNodeId>", "target": "<automationNodeId>", "action": "connect" }
+   ```
+
+   **Fallback (no MCP):**
    ```bash
    curl -s -X POST "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/connections" \
      -H "x-token: $TOKEN" -H "x-board-id: $BOARD_ID" -H "x-user-id: eventmodeling-identifying-outputs" \

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

@@ -11,6 +11,8 @@ allowed-tools:
 
 > **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.
 
+Prefer `mcp__eventmodelers__*` tools when available (registered by the `connect` skill) — the curl blocks below are the fallback for sessions without MCP connected.
+
 Coordinates the 10-step Event Modeling workflow. Each step delegates to a
 specialized skill — this skill holds the sequence, transition conditions, and
 what to carry forward between steps.
@@ -37,7 +39,15 @@ Placing all read models in new columns at the very end of the timeline severs th
 
 After each step that creates elements (Steps 1–5), scan for any nodes that have no cell reference and are stranded at the default canvas position (0,0). These arise when `node:created` is called without `cellId`.
 
-For each timeline in scope, check all node types that should be in cells:
+For each timeline in scope, check all node types that should be in cells.
+
+**Prefer MCP:** call `get_nodes` once per type (each call returns the full node objects, including `meta.chapterId`/cell placement, so no separate cell-occupancy lookup is needed):
+```
+mcp__eventmodelers__get_nodes { "boardId": "$BOARD_ID", "type": "EVENT" }
+```
+Repeat with `"type": "COMMAND"`, `"READMODEL"`, `"SCREEN"`, `"AUTOMATION"`.
+
+**Fallback (no MCP):**
 ```bash
 for TYPE in EVENT COMMAND READMODEL SCREEN AUTOMATION; do
   curl -s -H "x-token: $TOKEN" -H "x-board-id: $BOARD_ID" \
@@ -48,7 +58,14 @@ done
 For each returned node, check whether it has a valid cell assignment. A node without a `cellId` (or with `chapterId` missing) is unplaced.
 
 **For each unplaced node:**
-- **If it belongs in the current model** → compute the correct `cellId` and call `node:changed` to assign it:
+- **If it belongs in the current model** → compute the correct `cellId` and place it.
+
+  **Prefer MCP:** the node already exists but has never been assigned a cell, so this is a placement, not a repositioning — use `drop_node_to_cell` (not `move_node_in_timeline`, which is for moving a node that already occupies a different cell):
+  ```
+  mcp__eventmodelers__drop_node_to_cell { "boardId": "$BOARD_ID", "timelineId": "<chapterId>", "cellId": "<rowId>-<colId>", "nodeId": "<nodeId>", "nodeType": "<TYPE>" }
+  ```
+
+  **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: orchestrator" \
@@ -57,7 +74,14 @@ For each returned node, check whether it has a valid cell assignment. A node wit
           "timestamp":1234567890,"chapterId":"<chapterId>","cellId":"<rowId>-<colId>",
           "meta":{"type":"<TYPE>","title":"<title>"}}]'
   ```
-- **If it is an orphan (duplicate or no longer needed)** → delete it:
+- **If it is an orphan (duplicate or no longer needed)** → delete it.
+
+  **Prefer MCP:**
+  ```
+  mcp__eventmodelers__delete_node { "boardId": "$BOARD_ID", "nodeId": "<nodeId>" }
+  ```
+
+  **Fallback (no MCP):**
   ```bash
   curl -s -X DELETE "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/<nodeId>" \
     -H "x-token: $TOKEN" -H "x-board-id: $BOARD_ID"
@@ -194,7 +218,7 @@ Invoke `eventmodeling-storyboarding-events`.
 human role, showing what data each screen displays and collects.
 **Gate**: Every human role from the Role Catalog has at least one screen.
 
-Use the Story-Board-Screen skill to sketch and provide Mockups. 
+Use the `html-screen` skill to render a real HTML/CSS mockup for every screen — this is the default for each screen. Fall back to `storyboard-screen` (wireframe sketch) only when the user explicitly asked for sketches/wireframes.
 
 You can reuse columns if screens can be matched to existing events, place the screen in the same
 column as the event in the actor lane

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

@@ -10,6 +10,8 @@ allowed-tools:
 
 > **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.
 
+Prefer `mcp__eventmodelers__*` tools when available (registered by the `connect` skill) — the curl blocks below are the fallback for sessions without MCP connected.
+
 Arrange all brainstormed events chronologically to create a logical sequence that makes sense as a narrative timeline. Show how events flow and depend on each other.
 
 ## Workflow
@@ -101,6 +103,12 @@ Timelines (chapters) are **created and assigned during Step 1 (Brainstorming)**.
 
 Before placing events, resolve the target timeline:
 
+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"

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

@@ -1,6 +1,6 @@
 ---
 name: eventmodeling-slicing-event-models
-description: "Identify feature slices directly from a completed event model's timeline and create slice definitions on the board — each COMMAND becomes a state-change slice, each READMODEL becomes a state-view slice, each AUTOMATION becomes an automation slice. Use after completing event modeling to define slice boundaries and note event dependencies between them. Do not use for: organizational team structure based on Conway's Law (use eventmodeling-applying-conways-law) or planning before the event model is complete (complete the full model first using eventmodeling-orchestrating-event-modeling)."
+description: "Identify feature slices directly from a completed event model's timeline and create slice definitions on the board — each COMMAND becomes a state-change slice, each READMODEL becomes a state-view slice, each AUTOMATION becomes an automation slice. Use after completing event modeling to define slice boundaries and note event dependencies between them. Do not use for: organizational team structure based on Conway's Law (use eventmodeling-applying-conways-law), planning before the event model is complete (complete the full model first using eventmodeling-orchestrating-event-modeling), or 'add the next slice' when every existing element already has one (use add-next-slice — this skill only makes existing elements explicit, it never invents new ones)."
 allowed-tools:
   - AskUserQuestion
   - Write
@@ -11,6 +11,8 @@ allowed-tools:
 
 > **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 (in particular the **Slices** section). Do not proceed until both skills have been loaded.
 
+> Prefer `mcp__eventmodelers__*` tools when available (registered by the `connect` skill) — the curl blocks below are the fallback for sessions without MCP connected.
+
 **Purpose**: Turn a completed event model's timeline into explicit slice definitions on the board, and note the event dependencies between them.
 
 **When to Use**:
@@ -55,6 +57,12 @@ Walk the timeline column by column:
 
 `$TL` (the timeline/chapter UUID) is required for every call below. If it wasn't given up front, resolve it before doing anything else:
 
+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"
 ```
@@ -67,6 +75,12 @@ curl -s "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes?type=CHAPTER"
 
 Use `spec-info` (or existing board knowledge) to list every COMMAND, READMODEL, and AUTOMATION node across the resolved timeline:
 
+Prefer MCP:
+```
+mcp__eventmodelers__get_spec_info { "boardId": "<BOARD_ID>", "timelineId": "<TL>" }
+```
+
+**Fallback (no MCP):**
 ```bash
 curl "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/timelines/$TL/spec-info" -H "x-token: $TOKEN"
 # → { timelineId, elements: [{ id, title, type }] }
@@ -76,6 +90,12 @@ Filter to `type` in `COMMAND`, `READMODEL`, `AUTOMATION`.
 
 `spec-info` doesn't include the column each element sits in, so fetch the chapter node to resolve it:
 
+Prefer MCP:
+```
+mcp__eventmodelers__get_node { "boardId": "<BOARD_ID>", "nodeId": "<TL>" }
+```
+
+**Fallback (no MCP):**
 ```bash
 curl -s "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/$TL" -H "x-token: $TOKEN"
 # → meta.timelineData.columns: [{ id, index }]
@@ -86,6 +106,12 @@ For each filtered element, find the cell whose `nodeId` matches the element's `i
 
 Check which columns already have a slice, so you don't create duplicates:
 
+Prefer MCP:
+```
+mcp__eventmodelers__list_slices { "boardId": "<BOARD_ID>" }
+```
+
+**Fallback (no MCP):**
 ```bash
 curl $BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/slicedata/slices -H "x-token: $TOKEN"
 # → { slices: [{ id, title, status }] }
@@ -97,6 +123,12 @@ A column already has a slice if its element's title matches an existing slice's
 
 For each column from Step 2 that doesn't already have a matching slice, mark that **existing** column as a slice via the **slice-definitions** endpoint:
 
+Prefer MCP:
+```
+mcp__eventmodelers__create_slice_definition { "boardId": "<BOARD_ID>", "timelineId": "<TL>", "columnId": "<colId>", "title": "PlaceOrder" }
+```
+
+**Fallback (no MCP):**
 ```bash
 curl -X POST $BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/timelines/$TL/slice-definitions \
   -H "x-token: $TOKEN" -H "Content-Type: application/json" \
@@ -108,7 +140,9 @@ curl -X POST $BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/timelines/$TL/slice-defi
 - READMODEL column → title = read model name (state-view slice)
 - AUTOMATION column → title = automation name, or the command it issues (automation slice)
 
-Use **`slice-definitions`**, never the plain **`slices`** endpoint here — `slices` creates a brand-new column with its own swimlane/content nodes, which would duplicate the element already placed on the timeline. `slice-definitions` only adds a `SLICE_BORDER` node to the column you already resolved in Step 2. `title` always comes from the request body — it is never derived automatically from the command/read model/automation node.
+Use **`create_slice_definition`/`slice-definitions`**, never `create_slice`/the plain **`slices`** endpoint here — `create_slice`/`slices` creates a brand-new column with its own swimlane/content nodes, which would duplicate the element already placed on the timeline. `create_slice_definition`/`slice-definitions` only adds a `SLICE_BORDER` node to the column you already resolved in Step 2. `title` always comes from the request body — it is never derived automatically from the command/read model/automation node.
+
+**If Step 2 finds nothing to slice** (every COMMAND/READMODEL/AUTOMATION on the timeline already has a matching `SLICE_BORDER`), this skill's job is done — there is no existing element left to make explicit. Do not invent new model content here; that is out of scope for a skill whose whole design assumes the model is already complete. Invoke the `add-next-slice` skill instead — it owns deciding on and creating a genuinely new slice from scratch.
 
 ## Step 4 (Optional): Note Dependencies Between Slices