@eventmodelers/cli 0.0.1

package/stacks/cratis-csharp/templates/root/appsettings.Development.json

@@ -0,0 +1,9 @@
+{
+    "Logging": {
+        "LogLevel": {
+            "Default": "Debug",
+            "System": "Information",
+            "Microsoft": "Information"
+        }
+    }
+}

package/stacks/cratis-csharp/templates/root/appsettings.json

@@ -0,0 +1,26 @@
+{
+    "Logging": {
+        "LogLevel": {
+            "Default": "Information",
+            "Microsoft.AspNetCore": "Warning"
+        }
+    },
+    "AllowedHosts": "*",
+    "Cratis": {
+        "Arc": {
+            "GeneratedApis": {
+                "RoutePrefix": "api",
+                "IncludeCommandNameInRoute": false,
+                "SegmentsToSkipForRoute": 1
+            }
+        },
+        "Chronicle": {
+            "EventStore": "CratisApp",
+            "ConnectionString": "chronicle://chronicle-dev-client:chronicle-dev-secret@localhost:35000"
+        },
+        "MongoDB": {
+            "Server": "mongodb://localhost:27017",
+            "Database": "CratisApp"
+        }
+    }
+}

package/stacks/cratis-csharp/templates/root/docker-compose.yml

@@ -0,0 +1,23 @@
+services:
+  chronicle:
+    image: cratis/chronicle:latest-development
+    pull_policy: always
+    environment:
+      - OTEL_EXPORTER_OTLP_ENDPOINT=http://aspire-dashboard:18889
+    ports:
+      - 27017:27017
+      - 8080:8080
+      - 11111:11111
+      - 30000:30000
+      - 35000:35000
+
+  aspire-dashboard:
+    image: mcr.microsoft.com/dotnet/aspire-dashboard:latest
+    environment:
+      - DOTNET_DASHBOARD_UNSECURED_ALLOW_ANONYMOUS=true
+      - DOTNET_DASHBOARD_OTLP_ENDPOINT_URL=http://chronicle:18889
+      - ALLOW_UNSECURED_TRANSPORT=true
+      - DOTNET_ENVIRONMENT=Development
+    ports:
+      - 18888:18888
+      - 4317:18889

package/stacks/cratis-csharp/templates/root/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "cratisapp",
+  "private": true,
+  "version": "0.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite --config .frontend/vite.config.ts",
+    "build": "tsc -b .frontend/tsconfig.json && vite build --config .frontend/vite.config.ts",
+    "preview": "vite preview --config .frontend/vite.config.ts"
+  },
+  "dependencies": {
+    "@cratis/arc.react": "^20.3.1",
+    "@cratis/arc.vite": "^20.3.1",
+    "@cratis/components": "^2.5.0",
+    "primeicons": "^7.0.0",
+    "primereact": "^10.9.7",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "react-icons": "^5.5.0",
+    "react-router-dom": "^7.0.0",
+    "ts-deepmerge": "^7.0.0",
+    "usehooks-ts": "^3.1.0"
+  },
+  "devDependencies": {
+    "@tailwindcss/vite": "^4.0.0",
+    "@types/react": "^19.0.0",
+    "@types/react-dom": "^19.0.0",
+    "@vitejs/plugin-react": "^4.0.0",
+    "tailwindcss": "^4.0.0",
+    "typescript": "^5.5.0",
+    "vite": "^6.0.0"
+  }
+}

package/stacks/cratis-csharp/templates/root/tsconfig.json

@@ -0,0 +1,3 @@
+{
+    "extends": "./.frontend/tsconfig.json"
+}

package/stacks/modeling-kit/templates/.claude/settings.local.json

@@ -0,0 +1,13 @@
+{
+  "permissions": {
+    "allow": [
+      "Skill(connect)",
+      "Bash(curl *)",
+      "Bash(python3 -c \"import uuid; print\\(uuid.uuid4\\(\\)\\)\")",
+      "Bash(python3 -c ' *)",
+      "Read(//tmp/**)",
+      "Bash(python3 -m json.tool)",
+      "Bash(npm run *)"
+    ]
+  }
+}

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

@@ -0,0 +1,215 @@
+---
+name: analyze-existing-model
+description: Analyze the existing event model on a board — summarizes contexts, slices, element counts, status breakdown, spec coverage, and structural gaps. Read-only, no board modifications.
+---
+
+# Analyze Existing Model
+
+> **Before doing anything else**, invoke the `connect` skill to resolve `TOKEN`, `BOARD_ID`, `ORG_ID`, and `BASE_URL`. Do not proceed until the connect skill has completed.
+
+Read the full event model from a board and produce a structured analysis: what contexts exist, how many slices are in each state, which slices have GWT specs, and where the visible gaps are. This skill is read-only — it never posts comments or modifies the board.
+
+---
+
+## Step 1 — Parse arguments
+
+From `$ARGUMENTS`, extract:
+
+| Field | How to find it | Default |
+|-------|---------------|---------|
+| `contextName` | bounded context to focus on, e.g. `Ordering` | all contexts |
+| `boardId` | a board UUID | from `connect` skill (`BOARD_ID`) |
+
+If `boardId` is explicitly passed it overrides `BOARD_ID` from `connect`.
+
+---
+
+## 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>" }] }`
+
+Save the full slice list. Count total slices and group by status:
+
+| Status values |
+|---------------|
+| `Created`, `Planned`, `InProgress`, `Review`, `Done`, `Blocked`, `Assigned`, `Informational` |
+
+---
+
+## Step 3 — Discover contexts
+
+Fetch all `MODEL_CONTEXT` nodes to identify bounded contexts on the board:
+
+```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"
+```
+
+- If a `contextName` argument was given, filter to that single context and skip others.
+- If no `MODEL_CONTEXT` nodes exist, continue with a single unnamed context scope.
+- Record each context's `id` and `title`.
+
+---
+
+## Step 4 — Fetch slice data per context
+
+For each resolved context, fetch the full element graph:
+
+```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
+
+Fetch all contexts in parallel if there are multiple. Merge results, keyed by context name.
+
+---
+
+## Step 5 — Analyse the model
+
+Work through the collected data and compute the following for each context:
+
+### 5a — Element inventory
+
+Count elements by type across all slices in the context:
+
+| Element type | Count |
+|-------------|-------|
+| EVENT | |
+| COMMAND | |
+| READMODEL | |
+| SCREEN | |
+| AUTOMATION | |
+
+### 5b — Slice status breakdown
+
+Group slices by status. Report counts per status. Flag any status that suggests blocked or stalled work (`Blocked`, `Created` with no changes).
+
+### 5c — Spec coverage
+
+For each slice, check whether `specs` is non-empty. Calculate:
+- Slices **with** at least one GWT scenario
+- Slices **without** any scenarios (grouped by slice type if detectable)
+
+### 5d — Structural gaps per slice
+
+For every slice, determine its type from the elements present and check for common structural issues:
+
+| Slice type | Expect | Flag if missing |
+|-----------|--------|-----------------|
+| Command slice | SCREEN + COMMAND + EVENT | Any of the three absent |
+| State-view slice | SCREEN + READMODEL | Either absent |
+| Automation slice | AUTOMATION + EVENT | Either absent |
+
+Do not flag gaps that are clearly intentional (e.g. a slice named "Internal" with no SCREEN). Use judgement — only surface gaps that look unintentional given the slice title.
+
+### 5e — Orphaned elements
+
+Check whether any EVENT, COMMAND, or READMODEL appears in zero slices (present on the board but not wired into any slice boundary). If the slicedata API does not expose this directly, skip this check and note it.
+
+---
+
+## Step 6 — Report to the user
+
+Output a structured report. Never post anything to the board.
+
+### Report format
+
+```
+## Model Analysis — <BOARD_ID>
+Analysed: <ISO timestamp>
+
+### Contexts (<n> found)
+- <ContextName>: <n> slices
+
+---
+
+### Slice Status
+| Status     | Count |
+|------------|-------|
+| Done       | x     |
+| InProgress | x     |
+| Planned    | x     |
+| Created    | x     |
+| Blocked    | x     |
+| ...        | ...   |
+Total: <n> slices
+
+---
+
+### Element Inventory  [per context]
+| Type        | Count |
+|-------------|-------|
+| EVENT       | x     |
+| COMMAND     | x     |
+| READMODEL   | x     |
+| SCREEN      | x     |
+| AUTOMATION  | x     |
+
+---
+
+### Spec Coverage
+- <n> of <total> slices have at least one GWT scenario (<pct>%)
+- Slices without specs: <list titles, max 10, then "and N more">
+
+---
+
+### Structural Gaps
+<list only genuine gaps — slice title + what's missing>
+(none) if everything looks complete
+
+---
+
+### Summary
+<2–4 sentences: overall model maturity, the most important gap or risk, one concrete suggestion>
+```
+
+If a context was specified but not found, tell the user clearly and list the contexts that do exist.
+
+---
+
+## 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

@@ -0,0 +1,176 @@
+---
+name: attributes
+description: Add a new attribute or rename an existing attribute across a chain of elements from a source cell to a target cell, following inbound dependencies
+---
+
+# 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.
+
+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.
+
+---
+
+## Step 1 — Gather inputs
+
+Ask the user for all required information **in a single message** (do not ask one at a time):
+
+1. **Target cell** — the end of the chain (e.g. `B2`)
+2. **Source cell** — the start of the chain (e.g. `A2`)
+3. **Operation** — `add` a new attribute, or `rename` an existing one
+4. If **rename**: which attribute name to rename FROM, and what to rename it TO
+5. If **add**: the name of the new attribute to add
+
+If any of these were already provided in `$ARGUMENTS`, skip asking for them.
+
+---
+
+## Step 2 — 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:
+
+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:
+```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`.
+
+---
+
+## Step 3 — 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]`.
+
+### 3a — Use node edges
+Each node may have an `edges` array:
+```json
+edges: [{ id, source, target, sourceHandle, targetHandle }]
+```
+An **inbound** edge is one where `edge.target === currentNode.id`. For each inbound edge, fetch the source node:
+```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"
+```
+
+### 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:
+
+In a standard event modeling layout:
+- **READMODEL** in the interaction row → its inbound EVENT is in the swimlane row of the **same column**
+- **EVENT** in the swimlane row → its inbound COMMAND is in the interaction row of the **same column**
+- **COMMAND** in the interaction row → its inbound READMODEL is in the swimlane row of the **previous column**
+
+Fetch candidate nodes by their cellId (live), skip any that don't exist or are already in the chain.
+
+### 3c — Stop condition
+Stop traversal when:
+- You reach `SOURCE_NODE` (id match), OR
+- There are no more inbound nodes to follow, OR
+- You have visited 20 nodes (safety limit — warn the user if hit)
+
+---
+
+## Step 4 — Apply the change to each node in the chain
+
+Process nodes in order: TARGET_NODE first, then backwards to SOURCE_NODE.
+
+For each node:
+
+### If operation is `add`:
+- Check if a field with that name already exists in `meta.fields` — if so, skip this node (log it).
+- Otherwise append a new field:
+```json
+{
+  "name": "<attributeName>",
+  "type": "String",
+  "query": false,
+  "edited": false,
+  "optional": false,
+  "generated": false,
+  "subfields": [],
+  "cardinality": "Single",
+  "idAttribute": false,
+  "showAttributes": false,
+  "technicalAttribute": false
+}
+```
+
+### If operation is `rename`:
+- 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:
+
+```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
+```
+
+Verify HTTP 200 before proceeding to the next node. If a node fails, report the error and stop.
+
+---
+
+## Step 5 — Report back
+
+Tell the user:
+
+- **Operation**: add `"<name>"` / rename `"<old>"` → `"<new>"`
+- **Chain**: list each element in order (type + title + cell)
+- **Updated**: which nodes were changed
+- **Skipped**: which nodes were skipped and why (field already exists / field not found)
+
+Example output:
+```
+Operation: rename "customerId" → "clientId"
+
+Chain traversed (target → source):
+  READMODEL "Customer Overview"   (B2) ✓ renamed
+  EVENT     "Customer Registered" (A3) ✓ renamed
+  COMMAND   "Register Customer"   (A2) — skipped (field not found)
+
+Done.
+```

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

@@ -0,0 +1,182 @@
+---
+name: connect
+description: Resolve eventmodelers connection config (token, boardId, baseUrl) from inline params or .agent-modeling-kit/.eventmodelers/config.json — ask the user for missing values, persist them, and add the file to .gitignore. All other skills invoke this first.
+---
+
+# Connect — Resolve Eventmodelers Config
+
+**Every other skill invokes this skill first** before making any API calls. Do not proceed past this skill until all four values (`TOKEN`, `BOARD_ID`, `ORG_ID`, `BASE_URL`) are resolved.
+
+---
+
+## What this skill produces
+
+After running, the following variables are available for the rest of the session:
+
+| Variable | Header sent to API | Description |
+|----------|--------------------|-------------|
+| `TOKEN` | `x-token` | API token UUID |
+| `BOARD_ID` | `x-board-id` | Target board UUID |
+| `ORG_ID` | — | Organization UUID (used in all board-scoped URLs) |
+| `BASE_URL` | — | Base URL, e.g. `http://localhost:3000` |
+
+Every API call in every skill must include these headers:
+```
+x-token: <TOKEN>
+x-board-id: <BOARD_ID>
+x-user-id: <skill-name>   ← set by each skill individually
+```
+
+All board-scoped URLs follow the pattern: `<BASE_URL>/api/org/<ORG_ID>/boards/<BOARD_ID>/...`
+
+---
+
+## Step 0 — Check for inline parameters
+
+Before reading the config file, scan the prompt/arguments that invoked this skill for inline overrides. Supported formats:
+
+| Pattern | Example |
+|---------|---------|
+| `board=<uuid>` | `board=05cda19d-d5b8-4b51-ae88-c72f2611548a` |
+| `token=<uuid>` | `token=xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx` |
+| `org=<uuid>` | `org=xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx` |
+| `baseUrl=<url>` | `baseUrl=http://localhost:3000` |
+
+If an inline `board=<uuid>` is found, use it as `BOARD_ID` — **it takes priority over the config file**. Same for `token`, `org`, and `baseUrl`. Record which values came from inline params so they are not overwritten in Step 3.
+
+---
+
+## Step 1 — Read config file
+
+Search for `.eventmodelers/config.json` starting from the current working directory and walking up through all parent directories. Also check `.agent-modeling-kit/.eventmodelers/config.json` from the project root:
+
+```bash
+# Walk parent directories for .eventmodelers/config.json
+dir="$PWD"
+config_file=""
+while [ "$dir" != "/" ]; do
+  if [ -f "$dir/.eventmodelers/config.json" ]; then
+    config_file="$dir/.eventmodelers/config.json"
+    break
+  fi
+  dir="$(dirname "$dir")"
+done
+[ -n "$config_file" ] && cat "$config_file"
+# Also check the kit subdirectory
+[ -z "$config_file" ] && cat .agent-modeling-kit/.eventmodelers/config.json 2>/dev/null
+```
+
+If a file is found (at any level), note its path and extract any values **not already set by Step 0**:
+- `token` → `TOKEN`
+- `boardId` → `BOARD_ID`
+- `organizationId` or `orgId` → `ORG_ID` (accept either field name)
+- `baseUrl` → `BASE_URL` (default: `https://api.eventmodelers.ai` if missing)
+
+Resolution priority: **inline param > config file > ask user**
+
+If all four are present (from any source), skip to **Step 4 — Verify**.
+
+---
+
+## Step 2 — Ask for missing values
+
+If after Steps 0 and 1 any required field is still missing, **ask the user one question first**:
+
+> "Do you have a config from the eventmodelers accounts page? (yes / no)"
+
+**If the user answers yes:**
+Stop asking questions. Show this hint and wait for them to paste:
+
+> "Great — please paste your config from https://app.eventmodelers.ai/account here."
+
+When they paste a JSON object, parse it immediately — accept both `orgId` and `organizationId` as the organization field — apply all values, and proceed directly to Step 3.
+
+**If the user answers no** (or pastes only a partial config), ask for each still-missing field one at a time, in this order: `token`, then `boardId`, then `orgId`. Wait for the answer before asking the next.
+
+| Field | What to ask                                                                          |
+|-------|--------------------------------------------------------------------------------------|
+| `token` | "Please provide your eventmodelers API token (a UUID from your workspace settings)." |
+| `boardId` | "Please provide the board ID you want to work with (the UUID from the board URL)."   |
+| `orgId` | "Please provide your organization ID (the UUID from your organization settings)."    |
+| `baseUrl` | Do **not** ask — default to `https://api.eventmodelers.ai` silently.                 |
+
+Where to find the token: users generate API tokens in their workspace settings at the eventmodelers platform. The token is shown only once at creation time. It is a UUID and must belong to the same organization as the board.
+
+---
+
+## Step 3 — Persist config
+
+Once all values are collected, write the config file. Determine the write path: use `.agent-modeling-kit/.eventmodelers/config.json` if the `.agent-modeling-kit/` directory exists in cwd, otherwise use `.eventmodelers/config.json`. When writing, merge with any existing config — do **not** overwrite fields that were provided as inline params with values from a previous config (the inline param is the user's explicit intent for this session, but the persisted value should reflect the most recently user-supplied value):
+
+```bash
+# From project root (most common):
+mkdir -p .agent-modeling-kit/.eventmodelers
+cat > .agent-modeling-kit/.eventmodelers/config.json << 'EOF'
+{
+  "token": "<TOKEN>",
+  "boardId": "<BOARD_ID>",
+  "organizationId": "<ORG_ID>",
+  "baseUrl": "<BASE_URL>"
+}
+EOF
+```
+
+Then ensure `.agent-modeling-kit/.eventmodelers/` is in `.gitignore`. Check whether it is already present:
+
+```bash
+grep -q ".agent-modeling-kit/.eventmodelers/" .gitignore 2>/dev/null || echo "MISSING"
+```
+
+If `MISSING`, append it:
+
+```bash
+echo ".agent-modeling-kit/.eventmodelers/" >> .gitignore
+```
+
+Tell the user: `"Config saved to .agent-modeling-kit/.eventmodelers/config.json and added to .gitignore."`
+
+---
+
+## Step 4 — Verify
+
+Confirm the token and board are valid with a lightweight call:
+
+```bash
+curl -s -o /dev/null -w "%{http_code}" \
+  -H "x-token: <TOKEN>" \
+  -H "x-board-id: <BOARD_ID>" \
+  -H "x-user-id: connect-skill" \
+  "<BASE_URL>/api/org/<ORG_ID>/boards/<BOARD_ID>/nodes?type=CHAPTER"
+```
+
+| Response | Action |
+|----------|--------|
+| `200` | Config is valid. Print one line: `"Connected — board <BOARD_ID>"` and return. |
+| `401` | Token is invalid or missing. Tell the user and re-run from Step 2, clearing `token`. |
+| `403` | Token organization does not match board. Tell the user to check that the token was issued for the correct workspace. Re-run from Step 2 for both fields. |
+| `404` | Board not found. Tell the user and re-run from Step 2, clearing `boardId`. |
+| Any other | Print the status code and raw response. Ask the user how to proceed. |
+
+---
+
+## Config file format
+
+`.agent-modeling-kit/.eventmodelers/config.json`:
+```json
+{
+  "token": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
+  "boardId": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
+  "organizationId": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
+  "baseUrl": "http://localhost:3000"
+}
+```
+
+The `token` field is a secret. It is never logged or shown after initial confirmation.
+
+---
+
+## Security notes
+
+- The config file is workspace-local and gitignored — never commit it.
+- The token grants write access to all boards in its organization — treat it like a password.
+- If a skill receives a `401` or `403` mid-session, re-invoke this skill to refresh the config before retrying.