@eventmodelers/cli 2.0.50 → 2.0.53

package/cli.js

@@ -42,7 +42,7 @@ import { recordAgentStatus } from './shared/build-kit/lib/slice-run.js';
 import { findSliceDir, fingerprint, readBaseline, writeBaseline, compare } from './lib/ui-baseline.js';
 import { defaultAgentName, withInstanceSuffix } from './shared/build-kit/lib/agent-name.js';
 import { acquireAgentId } from './shared/build-kit/lib/agent-lock.js';
-import { readEvents } from './shared/build-kit/lib/slice-events.js';
+import { readEvents, appendEvent, locationOf } from './shared/build-kit/lib/slice-events.js';
 import { findPromptEvent, replayRequest } from './shared/build-kit/lib/prompt-replay.js';
 import { prunableEvents, pruneLog, rememberPruneAnswer, shouldOfferPrune } from './shared/build-kit/lib/event-prune.js';
 import { fold } from './shared/build-kit/lib/slice-state.js';
@@ -893,7 +893,16 @@ function loadEffectiveConfig(cwd, kitDir, explicitPath) {
   const kitConfigExists = kitConfigPath && existsSync(kitConfigPath);
   const parentConfigPath = findConfigInParents(cwd);
 
-  const merged = { ...readJsonSafe(parentConfigPath), ...(kitConfigExists ? readJsonSafe(kitConfigPath) : {}) };
+  // Credentials are inherited from a parent config, an agent identity never is: every project keeps its
+  // own `agentIds` (see ensureAgentId). Callers write this merged object back into the project's own
+  // config.json, so inheriting it would copy the parent's id into a nested project (an app and its `web/`
+  // UI kit) and both loops would then run as one agent and fight over each other's claims.
+  const parentConfig = readJsonSafe(parentConfigPath);
+  if (parentConfigPath && resolve(parentConfigPath) !== resolve(cwd, '.eventmodelers', 'config.json')) {
+    delete parentConfig.agentIds;
+    delete parentConfig.agentId;
+  }
+  const merged = { ...parentConfig, ...(kitConfigExists ? readJsonSafe(kitConfigPath) : {}) };
   const sources = [parentConfigPath, kitConfigExists ? kitConfigPath : null].filter(Boolean);
 
   return {
@@ -1051,15 +1060,28 @@ async function resolveStack(cliStack) {
   );
 }
 
+// Names what is installed now (from the kit's install manifest) and what this run installs.
+function printInstallVersions(kitDir, stackKey) {
+  const prev = readJsonSafe(join(kitDir, '.eventmodelers', 'install-manifest.json'));
+  if (prev.version) {
+    const same = prev.version === CLI_VERSION;
+    console.log(`Installed: v${prev.version}${prev.stack ? ` (${prev.stack})` : ''}`);
+    console.log(`Installing: v${CLI_VERSION}${stackKey ? ` (${stackKey})` : ''}${same ? ' — same version, files are refreshed' : ''}\n`);
+  } else {
+    console.log(`Installed: nothing yet\nInstalling: v${CLI_VERSION}${stackKey ? ` (${stackKey})` : ''}\n`);
+  }
+}
+
 async function installStack(stackKey, stackCfg, options = {}) {
-    console.log('🚀 Eventmodelers CLI\n');
-    console.log(`Using: ${stackKey} (${stackCfg.label})\n`);
+    console.log(`🚀 Eventmodelers CLI v${CLI_VERSION}\n`);
+    console.log(`Using: ${stackKey} (${stackCfg.label})`);
 
     // Almost always the cwd. The exception is the global modeling install, which is
     // scaffolded into ~/.eventmodelers/kit from wherever `run --standalone` was invoked
     // (see ensureGlobalKit) — the mirror image of options.templatesSource below: where we
     // install TO, versus where we install FROM.
     const targetDir = options.targetDir ? resolve(options.targetDir) : process.cwd();
+    printInstallVersions(join(targetDir, stackCfg.kitDirName), stackKey);
     // `init --git <url>` passes a resolved clone dir's templates/ here instead — every
     // other input (STACKS, MODELING_KIT) keeps using the built-in path.
     const templatesSource = options.templatesSource || join(__dirname, 'stacks', stackKey, 'templates');
@@ -1478,6 +1500,8 @@ async function configureCredentials({ config, configPath, targetDir, requiredFie
 // `re-init` for a build kit: re-copy shared/build-kit (ralph.js, the runners, tracing, adapters)
 // over the installed kit, then re-run the config steps. Stack templates and skills are untouched.
 async function refreshSharedRuntime({ targetDir, kitDir, globalOpts, opts }) {
+  console.log(`🚀 Eventmodelers CLI v${CLI_VERSION}\n`);
+  printInstallVersions(kitDir, readJsonSafe(join(kitDir, '.eventmodelers', 'install-manifest.json')).stack);
   console.log(`📦 Refreshing the shared runtime in ${relative(targetDir, kitDir)}/ (stack files untouched)...`);
   copyDirContents(join(__dirname, 'shared', 'build-kit'), kitDir);
   // The kit is now this CLI's runtime — record that, so the startup "kit is outdated" hint stops.
@@ -5341,6 +5365,10 @@ program
     if (!wanted) {
       const claimed = Object.entries(fold(readEvents(kitDir)).slices).filter(([, s]) => s.claim);
       if (claimed.length !== 1) {
+        if (!claimed.length) {
+          // Where it looked: an agent running from another kit's directory finds no claim in that kit's log.
+          try { appendEvent(kitDir, { type: 'claim-not-found', command: 'build-baseline', claimed: 0, ...locationOf(kitDir, cwd) }, agentEventMeta(cwd, kitDir, command)); } catch { /* best effort */ }
+        }
         console.error(`❌ ${claimed.length ? `${claimed.length} slices are claimed` : 'No slice is claimed by the run loop'} — name the slice with --slice.`);
         process.exit(1);
       }

package/package.json

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

package/shared/build-kit/lib/events-view.js

@@ -26,8 +26,10 @@ function describe(e) {
       return [e.slice, e.status ?? ''];
     case 'claimed': {
       const tree = e.cleanTree === true ? 'clean tree' : e.cleanTree === false ? 'dirty tree' : 'not a git tree';
-      return [e.slice, `pid ${e.pid}, ${tree}${e.base ? `, ${e.base.branch}@${String(e.base.head).slice(0, 8)}` : ''}${e.ticketNumber ? `, ticket ${e.ticketNumber}` : ''}${e.assignee ? `, assignee ${e.assignee}` : ''}`];
+      return [e.slice, `pid ${e.pid}, ${tree}${e.kitDir ? `, kit ${e.kitDir}` : ''}${e.base ? `, ${e.base.branch}@${String(e.base.head).slice(0, 8)}` : ''}${e.ticketNumber ? `, ticket ${e.ticketNumber}` : ''}${e.assignee ? `, assignee ${e.assignee}` : ''}`];
     }
+    case 'claim-not-found':
+      return [e.slice ?? e.wanted ?? '', `${e.command ?? 'command'} looked in ${e.kitDir ?? '?'} (cwd ${e.cwd ?? '?'}), ${e.claimed ?? 0} claimed there`];
     case 'claim-confirmed':
       return [e.slice, ''];
     case 'released':

package/shared/build-kit/lib/ralph.js

@@ -491,9 +491,21 @@ async function startRealtimeAgent(cfg, kitDir, { agentType = 'BUILD', createAdap
   }, 10 * 60 * 1000);
 
   let lastPingFailed = false;
+  // Backoff: a failing ping (e.g. 402 AGENT_LIMIT_REACHED) doubles the wait, 15s → 5min, so a refused agent
+  // doesn't hammer the platform and flood the log. Any success resets it. `shutting_down` always goes out.
+  const PING_BASE_MS = 15_000, PING_MAX_MS = 5 * 60_000;
+  let pingDelayMs = PING_BASE_MS;
+  let nextPingAt = 0;
+  const failPing = () => {
+    lastPingFailed = true;
+    nextPingAt = Date.now() + pingDelayMs;
+    console.error(`[agent] ${ts()} Next ping in ${Math.round(pingDelayMs / 1000)}s`);
+    pingDelayMs = Math.min(pingDelayMs * 2, PING_MAX_MS);
+  };
   // `status`: 'shutting_down' is the last ping before an exit the board asked for; every other ping says what the agent is
   // doing right now — building (modeling, for a MODELING agent) while a turn runs, idle otherwise.
   const ping = async (status) => {
+    if (status !== 'shutting_down' && Date.now() < nextPingAt) return;
     const agentStatus = status === 'shutting_down' ? status : turnsInFlight > 0 ? (agentType === 'MODELING' ? 'modeling' : 'building') : 'idle';
     try {
       const res = await fetch(`${cfg.baseUrl}/api/agent-alive`, {
@@ -504,7 +516,8 @@ async function startRealtimeAgent(cfg, kitDir, { agentType = 'BUILD', createAdap
       });
       if (!res.ok) {
         console.error(`[agent] ${ts()} Ping failed: ${res.status} ${await res.text().catch(() => '')}`);
-        lastPingFailed = true;
+        failPing();
+        agentRefused = res.status === 402 || res.status === 403 ? `HTTP ${res.status}` : null;
         if (res.status === 401) {
           await refreshToken('ping-401').catch((err) => console.error(`[agent] ${ts()} Token refresh after 401 ping failed:`, err));
         }
@@ -512,9 +525,12 @@ async function startRealtimeAgent(cfg, kitDir, { agentType = 'BUILD', createAdap
       }
       if (lastPingFailed) console.log(`[agent] ${ts()} Ping recovered`);
       lastPingFailed = false;
+      agentRefused = null;
+      pingDelayMs = PING_BASE_MS;
+      nextPingAt = 0;
     } catch (err) {
       console.error(`[agent] ${ts()} Ping error:`, err);
-      lastPingFailed = true;
+      failPing();
     }
   };
   await ping();
@@ -713,6 +729,9 @@ export async function blockStuckSlice(kitDir, cfg, credentialed, planned, attemp
 // otherwise. A change is reported at once (`reportStatus`, set once the heartbeat exists) instead of at the next 15s ping.
 let turnsInFlight = 0;
 let reportStatus = () => {};
+// Set while the platform refuses this agent's heartbeat with 402/403 (e.g. AGENT_LIMIT_REACHED): the agent isn't
+// a connected build agent, so the loop must not claim slices or change their status until a ping is accepted.
+let agentRefused = null;
 
 async function runWithRetry(label, fn) {
   for (let attempt = 1; ; attempt++) {
@@ -865,6 +884,13 @@ async function ralphLoop(kitDir, cfg, onTask, onPlannedSlice, localOnly = false,
   while (true) {
     let didWork = false;
 
+    // Not accepted as a connected agent (license/agent limit): touch nothing on the board, just wait for the heartbeat to recover.
+    if (credentialed && agentRefused) {
+      console.log(`[ralph] Heartbeat refused by the platform (${agentRefused}) — not claiming slices until it is accepted.`);
+      await sleep(30_000);
+      continue;
+    }
+
     // A claim still open here is a leftover: its process died mid-build, or settling failed last time.
     await settleLeftoverClaims({ kitDir, board, meta, pickupStatus: readPickupStatus(kitDir) });
 

package/shared/build-kit/lib/slice-events.js

@@ -8,6 +8,7 @@
 import { appendFileSync, closeSync, existsSync, fstatSync, mkdirSync, openSync, readFileSync, readSync, renameSync, writeFileSync } from 'fs';
 import { randomUUID } from 'crypto';
 import { join } from 'path';
+import { homedir } from 'os';
 
 export const EVENTS_DIR = 'events';
 export const INDEX_FILE = 'events.log';
@@ -85,6 +86,14 @@ function nextSeq(kitDir) {
 // concurrent processes never interleave however large the event. After a torn index line the new id
 // starts on a fresh line instead of being glued onto the fragment. Every event gets the next sequence number
 // (`seq`), which — not the timestamp — defines the order. Returns the event id.
+// Where a process ran, for events: the kit it works against and its working directory. The log is shared with
+// everyone who can open the board, so the home directory is shown as `~` rather than the user's name.
+export function locationOf(kitDir, cwd = process.cwd()) {
+  const home = homedir();
+  const tidy = (p) => (home && p && (p === home || p.startsWith(home + '/')) ? `~${p.slice(home.length)}` : p);
+  return { kitDir: tidy(kitDir), cwd: tidy(cwd) };
+}
+
 export function appendEvent(kitDir, event, meta) {
   const dir = join(kitDir, EVENTS_DIR);
   mkdirSync(dir, { recursive: true });

package/shared/build-kit/lib/slice-run.js

@@ -5,7 +5,7 @@
 // `board` is injected: { setStatus(sliceId, status), claim(sliceId, fromStatus), readStatus(sliceId) → status | null }. null means
 // no board (--local): nothing is pushed or read, the log alone decides.
 
-import { appendEvent, readEvents } from './slice-events.js';
+import { appendEvent, readEvents, locationOf } from './slice-events.js';
 import { fold, decideSettle, decideRecovery, statusKey } from './slice-state.js';
 import { adoptAgentEdits, projectStatus } from './slice-projection.js';
 import { discardUnfinishedWork, gitBase } from './slice-git.js';
@@ -35,17 +35,25 @@ export function isProcessAlive(pid) {
 // take the stale file for an edit.
 export function recordAgentStatus({ kitDir, status, sliceId, meta }) {
   const claimed = Object.entries(fold(readEvents(kitDir)).slices).filter(([, s]) => s.claim);
+  // A refusal is recorded with where it looked: the usual cause is an agent running from another kit's
+  // directory (an app with a root kit and a web/ kit), whose log has no claim for the slice.
+  const refuse = (message) => {
+    try {
+      appendEvent(kitDir, { type: 'claim-not-found', ...(sliceId ? { wanted: sliceId } : {}), claimed: claimed.length, command: 'slice-status', ...locationOf(kitDir) }, meta);
+    } catch { /* best effort: the refusal itself is what matters */ }
+    throw new Error(message);
+  };
   let match;
   if (sliceId) {
     const wanted = sliceId.trim().toLowerCase();
     match = claimed.find(([id, s]) => id === sliceId || s.claim.title?.toLowerCase() === wanted);
-    if (!match) throw new Error(`slice "${sliceId}" is not claimed by the run loop — only a slice the loop is building has its status recorded here`);
+    if (!match) refuse(`slice "${sliceId}" is not claimed by the run loop — only a slice the loop is building has its status recorded here`);
   } else if (claimed.length === 1) {
     match = claimed[0];
   } else if (claimed.length > 1) {
     throw new Error(`${claimed.length} slices are claimed (${claimed.map(([, s]) => s.claim.title).join(', ')}) — name one with --slice`);
   } else {
-    throw new Error('no slice is claimed by the run loop. For a task from tasks.json, set the status with the update-slice-status skill instead');
+    refuse('no slice is claimed by the run loop. For a task from tasks.json, set the status with the update-slice-status skill instead');
   }
   const [id, { claim }] = match;
   recordEvent(kitDir, { type: 'agent-recorded', slice: id, status }, meta);
@@ -78,7 +86,7 @@ export async function claimSlice({ kitDir, planned, board, meta, cleanTree, pid
     }
   }
   const state = recordEvent(kitDir, {
-    type: 'claimed', slice: planned.id, ctx: planned.ctx, title: planned.title, pid, base: gitBase(kitDir), cleanTree,
+    type: 'claimed', slice: planned.id, ctx: planned.ctx, title: planned.title, pid, base: gitBase(kitDir), cleanTree, ...locationOf(kitDir),
     // What the board says about the slice at build time, when it says anything: both can change between builds.
     ...(planned.ticketNumber ? { ticketNumber: planned.ticketNumber } : {}),
     ...(planned.assignee ? { assignee: planned.assignee } : {}),

package/shared/build-kit/lib/tool-call-events.js

@@ -1,7 +1,7 @@
 // A slice build's tool calls as events in the slice-state log, so `run --sync` can show them on the board. Any
 // runner that sees its agent's individual tool calls records them through here, so every runner logs the same shape.
 
-import { appendEvent } from './slice-events.js';
+import { appendEvent, locationOf } from './slice-events.js';
 
 // Only the tool's name is recorded — never its input. A Bash command, a skill's arguments or a path can hold
 // credentials or local details, and this log is shared with everyone who can open the board. Best effort, like the
@@ -9,7 +9,7 @@ import { appendEvent } from './slice-events.js';
 export function recordToolCall({ kitDir, slice, tool, meta }) {
   if (!slice?.sliceId) return;
   try {
-    appendEvent(kitDir, { type: 'tool-call', slice: slice.sliceId, tool }, meta);
+    appendEvent(kitDir, { type: 'tool-call', slice: slice.sliceId, tool, ...locationOf(kitDir) }, meta);
   } catch (err) {
     console.error(`[ralph] could not record a tool call (${err.message})`);
   }

package/shared/skills/learn-eventmodelers-api/references/mcp-tool-catalog.md

@@ -43,8 +43,8 @@ Write tools take their items as an array (`nodeIds[]`, `elements[]`, `connection
 | `get_board_outline` | `boardId`, `chapterId` | One chapter's structure, compact: per-column node lists (`{id, type, title, lane, cellName}`) + a flat edge list, no HTML pages / field bodies / meta. `cellName` is each node's real cell address (column letter + row number) — the only read that returns cell names at all; use it when a placement needs a cell address. For an empty target cell, take the column's `letter` plus the lane's 1-based position in the outline's `lanes` list (e.g. `letter: "C"`, second lane → `C2`) — never convert array indexes yourself. The cheap "what is where and how is it wired" read — prefer over `get_nodes` (no projection) for orientation checks | — (MCP-only convenience) |
 | `get_connected_nodes` | `boardId`, `nodeId`, `chapterId?`, `direction?` (`inbound`/`outbound`/`both`), `depth?`, `types?`, `includeFields?` | Neighbours of **one** node — what feeds it and what it feeds. Answers from a single anchor, unlike `get_attribute_chain` (which needs both ends of the chain up front). `depth` follows a whole chain; `types` filters the result only, never the traversal. Each neighbour carries `via`: `"edge"` for a real connection, `"layout"` when the node has none in that direction and the neighbour was inferred from the grid using auto-connect's own window (own column + adjacent one, forward-only pairs). Real edges always win. The `layout` fallback is what makes hand-built/imported chapters — which routinely carry **zero** edges — readable instead of falsely empty | — (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 — created automatically, and a scenario `id` is generated when omitted. A given/when/then step may be addressed by `{title, type}` instead of a node id, resolved against that timeline, so no `get_spec_info` call is needed first (an ambiguous title is reported with its candidates). `compact: true` returns `{specNodeId, added, scenarioCount, isNewNode}` instead of echoing every scenario back | §6 `POST .../scenarios` |
-| `add_storyline` | `boardId`, `timelineId`, `columnId`, `storylines[]`, `compact?` | Append storyline(s) (ordered, branchable beats over existing elements) to a column's spec node. Storyline and beat ids are generated when omitted, and a beat may name its element by `{title, type}` instead of `refId` (same addressing as `add_scenario`; an ambiguous title is reported with its candidates). Use whenever `eventmodeling-elaborating-scenarios`'s GWT-vs-storyline decision rule calls for one (e.g. a todo list's open→close lifecycle) — not only when a user explicitly names "storyline"; that skill's own per-read-model judgment is the trigger, this catalog entry isn't a stricter gate on top of it. `compact: true` suppresses the full storyline echo | §6 `POST .../storylines` |
+| `add_scenario` | `boardId`, `timelineId`, `columnId`, `scenarios[]`, `compact?` | Append GWT scenario(s) to a column's spec node — **the column of the original element, never of a `meta.linkedTo` copy** (follow `linkedTo` to the origin first); created automatically, and a scenario `id` is generated when omitted. A given/when/then step may be addressed by `{title, type}` instead of a node id, resolved against that timeline, so no `get_spec_info` call is needed first (an ambiguous title is reported with its candidates). `compact: true` returns `{specNodeId, added, scenarioCount, isNewNode}` instead of echoing every scenario back | §6 `POST .../scenarios` |
+| `add_storyline` | `boardId`, `timelineId`, `columnId`, `storylines[]`, `compact?` | Append storyline(s) (ordered, branchable beats over existing elements) to a column's spec node — **the original's column, never a `meta.linkedTo` copy's**. Storyline and beat ids are generated when omitted, and a beat may name its element by `{title, type}` instead of `refId` (same addressing as `add_scenario`; an ambiguous title is reported with its candidates). Use whenever `eventmodeling-elaborating-scenarios`'s GWT-vs-storyline decision rule calls for one (e.g. a todo list's open→close lifecycle) — not only when a user explicitly names "storyline"; that skill's own per-read-model judgment is the trigger, this catalog entry isn't a stricter gate on top of it. `compact: true` suppresses the full storyline echo | §6 `POST .../storylines` |
 | `set_connection` | `boardId`, `connections[]` (each `source`, `target`, `action` `'connect'\|'remove'`), `compact?` | Add or remove type-checked directed edges, applied in order (a later entry can rely on an earlier edge); answers `{results}`, or with `compact: true` a `{connected, existed, removed, notFound, failed, errors}` tally | — (via `edges` on §3 events) |
 | `auto_connect_node` | `boardId`, `nodeIds[]` | Re-run auto-connect for nodes — incompatible neighbours come back in `skipped`, not as an error; answers `{results}` | §3 `POST .../nodes/:nodeId/auto-connect` |
 | `link_element` | `boardId`, `nodeId`, plus either `targetNodeId` or `timelineId` (+ `columnIndex?`, `lane?`) | Turn a node into a linked copy of `nodeId` — it receives a full copy of that node's meta plus `meta.linkedTo`. Name an existing `targetNodeId`, or pass `timelineId` to have the copy placed and linked in this one call (inheriting the original's type and title), which is what a translation or automation chain wants | §3 `POST .../nodes/:nodeId/link` |

package/shared/skills/learn-eventmodelers-api/references/s06-specifications.md

@@ -66,6 +66,8 @@ Get the elements a scenario's given/when/then steps may legally reference (EVENT
 An ordered, branchable walkthrough of existing board elements ("beats"), stored alongside GWT
 scenarios on the same SCENARIO spec node, in a sibling `meta.storylines` collection.
 
+> **Scenarios and storylines belong to the original element's column.** If the node has `meta.linkedTo` it is a copy: follow it to the origin and post to the origin's timeline/column. The API does not reject a copy's column, so the caller must resolve it.
+
 ### POST `/api/org/:orgId/boards/:boardId/timelines/:timelineId/columns/:columnId/storylines`
 Append one or more storylines to a column's spec node. The spec node is auto-created if missing
 (shared with scenarios).

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

@@ -346,6 +346,8 @@ if Conway's Law boundaries are not relevant to the project.
 
 Invoke `eventmodeling-elaborating-scenarios` with the Skill tool **before the first `add_scenario` call** — its scenario types, business-rules-only rule and payload shape are not repeated here, so scenarios written from this file alone come out wrong.
 
+**Linked copies get no scenarios.** A command/read model with `meta.linkedTo` is a copy; add its scenarios and storylines to the origin's column (its own timeline), never the copy's.
+
 **Input**: Commands and read models.
 **Output to carry forward**: Given-When-Then specifications (or storylines, for
 walkthrough-style coverage) for every command **and every read model**, posted

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

@@ -128,6 +128,8 @@ After resolving `columnId` (from step 3, or from step 5 if a new column was just
 
 **Prefer MCP:**
 
+> **Original only:** if the target COMMAND/READMODEL has `meta.linkedTo` it is a copy — resolve to the origin (no `linkedTo`) and use the origin's `timelineId`/`columnId`; never put a spec on a copy's column. Same for `add_storyline`. See `eventmodeling-core-rules`.
+
 ```
 mcp__eventmodelers__add_scenario {
   "boardId": "<BOARD_ID>",