@eventmodelers/cli 1.0.79 → 1.0.81

package/README.md

@@ -335,7 +335,20 @@ SGLang all serve. Everything above the transport is identical, which is why anyt
 OpenAI-compatible works by pointing `LOCAL_AI_URL` at it. The `LOCAL_AI_*` vars are the same
 ones a build kit's local runner reads (`LOCAL_AI_TARGET`, `LOCAL_AI_URL`, `LOCAL_AI_API`,
 `LOCAL_AI_MODEL`, `LOCAL_AI_API_KEY`, `LOCAL_AI_NUM_CTX`), or set them once as `localAi` in
-`.eventmodelers/config.json`.
+`.eventmodelers/config.json` — env wins over the file, the file over the preset:
+
+```json
+{
+  "boardId": "...",
+  "token": "...",
+  "localAi": {
+    "target": "ollama",
+    "url": "http://localhost:11434",
+    "model": "qwen3.5:9b",
+    "numCtx": 49152
+  }
+}
+```
 
 **What you get and what you don't.** The loop around the turn is unchanged — the prompt queue,
 the standalone board-change lane with all its damping, the idle review, the alive-ping, and the
@@ -349,9 +362,9 @@ than read from `.agent-modeling-kit/CLAUDE.md`. `--max-agents` has nothing to ca
 
 Give it room: the platform's MCP tool schemas alone run to ~16k tokens, so Ollama's default
 `num_ctx` of 4096 would silently truncate the tool block and leave the model inventing tool
-names. The runner raises it to 32768 by default (`LOCAL_AI_NUM_CTX`) and warns when the schemas
+names. The runner raises it to 49152 by default (`LOCAL_AI_NUM_CTX`) and warns when the schemas
 still fill more than 60% of it. On an OpenAI-compatible server the context is fixed at launch
-instead, so start it accordingly (vLLM: `--max-model-len 32768`, llama.cpp: `-c 32768`) —
+instead, so start it accordingly (vLLM: `--max-model-len 49152`, llama.cpp: `-c 49152`) —
 overflow there surfaces as an HTTP 400, which the runner reports with that advice attached.
 A turn is capped at 24 tool iterations, which ends a model that has lost the plot without
 ending the session.
@@ -361,6 +374,44 @@ different thing, and `anthropicBaseUrl` below is that path — but note that it
 speaking Anthropic's own `/v1/messages`, which Ollama does not serve. Pointing it straight at
 `localhost:11434` gets you a 404; a translating proxy has to sit in between.
 
+### Running headless, in a container
+
+`run` normally confirms which board it is about to drive and where that board's credentials
+come from. Those questions are worth one keystroke at a terminal and fatal anywhere else, so
+`--non-interactive` turns them off: the board and credentials that resolve from flags,
+`EVENTMODELERS_*` env vars and the config files are taken as final, and an incomplete set fails
+the run with the reason instead of being interviewed for.
+
+A missing TTY already implied this, which covers CI and most process supervisors — but not a
+container started with `-it`, or a loop started from a terminal: stdin is a TTY nobody is
+watching, and the run stops on a question forever. Pass the flag rather than relying on how
+stdin happens to be wired.
+
+```bash
+docker run --rm \
+  -e EVENTMODELERS_TOKEN=<token> \
+  -e EVENTMODELERS_ORGANIZATION_ID=<uuid> \
+  -e EVENTMODELERS_BOARD_ID=<uuid> \
+  -e LOCAL_AI_URL=http://host.docker.internal:11434 \
+  node:20 npx -y @eventmodelers/cli run --standalone --local-ai --non-interactive
+```
+
+Two things a container needs that a laptop already had:
+
+- **A writable `HOME`.** With no kit in the working directory the agent installs one under
+  `~/.eventmodelers/kit` and keeps per-board credentials in `~/.eventmodelers/boards/` (`0600`,
+  in a `0700` directory). Run as a user whose home exists and is writable, or mount a volume
+  there to keep the kit across restarts instead of reinstalling it on every boot.
+- **A reachable model server.** `localhost` inside the container is the container, not the host
+  — point `LOCAL_AI_URL` at `host.docker.internal` (Docker Desktop), the host's LAN address, or
+  the service name if Ollama/vLLM is a sibling container.
+
+`EVENTMODELERS_TOKEN` now also answers the credentials question on its own, the way
+`EVENTMODELERS_BOARD_ID` always answered the board question — an env var that wins over every
+config file anyway makes asking where the credentials come from moot. So a fully env-driven run
+is silent even without the flag; pass it anyway, so a half-set environment fails loudly instead
+of waiting for an answer.
+
 ### Installing skills globally
 
 By default, skills are copied into the project's own `.claude/skills/`. Pass `--global` to `init` or `init-modeling` to install them into `~/.claude/skills/` instead — available in every project without re-running the installer each time:

package/RELEASE_NOTES.md

@@ -1,7 +1,9 @@
 ## Unreleased
 
 ### Features
-- `run --modeling`/`run --standalone` accept `--local-ai`, so the modeling agent can be driven by a local or self-hosted model instead of Claude. It was previously rejected as a build-kit-only flag, which conflated two different things: `--bash`/`--exec` select a *queue* the modeling loop has no equivalent of, while `--local-ai` selects a *model*. Both wire dialects are supported — `--local-ai` (bare) or `--local-ai ollama` for Ollama's native `POST /api/chat`, and `--local-ai vllm`/`lmstudio`/`llamacpp` for the OpenAI-compatible `POST /v1/chat/completions` that vLLM, LM Studio, llama.cpp-server, TGI and SGLang serve; anything else OpenAI-compatible works via `LOCAL_AI_URL`. The loop itself is untouched: the prompt queue, the standalone board-change lane and its damping, the idle review and the platform's full MCP tool set all behave as before, because everything Claude-specific already sat behind a single `runTurn(text)` seam. What a local model cannot bring along is the part that is not a wire format — the skills (`/place-element`, `/timeline`, `eventmodeling-*`) and the subagent fan-out are Claude Code features — so a self-directed turn does the most valuable piece of work itself, inline, and the board rules it needs come from the new runner's system prompt (`lib/modeling-local-ai.js`) instead of `.agent-modeling-kit/CLAUDE.md`. `--max-agents` is ignored in this mode. Ollama's `num_ctx` is raised to 32768 by default (the MCP tool schemas alone are ~16k tokens, well past Ollama's 4096 default, which would silently truncate the tool block), with a warning when the schemas still fill >60% of it and a turn cap of 24 tool iterations.
+- `run --modeling`/`run --standalone` accept `--local-ai`, so the modeling agent can be driven by a local or self-hosted model instead of Claude. It was previously rejected as a build-kit-only flag, which conflated two different things: `--bash`/`--exec` select a *queue* the modeling loop has no equivalent of, while `--local-ai` selects a *model*. Both wire dialects are supported — `--local-ai` (bare) or `--local-ai ollama` for Ollama's native `POST /api/chat`, and `--local-ai vllm`/`lmstudio`/`llamacpp` for the OpenAI-compatible `POST /v1/chat/completions` that vLLM, LM Studio, llama.cpp-server, TGI and SGLang serve; anything else OpenAI-compatible works via `LOCAL_AI_URL`. The loop itself is untouched: the prompt queue, the standalone board-change lane and its damping, the idle review and the platform's full MCP tool set all behave as before, because everything Claude-specific already sat behind a single `runTurn(text)` seam. What a local model cannot bring along is the part that is not a wire format — the skills (`/place-element`, `/timeline`, `eventmodeling-*`) and the subagent fan-out are Claude Code features — so a self-directed turn does the most valuable piece of work itself, inline, and the board rules it needs come from the new runner's system prompt (`lib/modeling-local-ai.js`) instead of `.agent-modeling-kit/CLAUDE.md`. `--max-agents` is ignored in this mode. Ollama's `num_ctx` is raised to 49152 by default (the MCP tool schemas alone are ~16k tokens, well past Ollama's 4096 default, which would silently truncate the tool block), with a warning when the schemas still fill >60% of it and a turn cap of 24 tool iterations.
+
+- `run --non-interactive` never asks anything: the board and credentials that resolve from flags, `EVENTMODELERS_*` env vars and the config files are final, and an incomplete set fails the run with the reason instead of being interviewed for. A missing TTY already implied this, which covered CI and most supervisors, but not a container started with `-it` or a loop started from a terminal — stdin is a TTY nobody is watching, and the run stopped on the board confirmation or the credentials question forever. `EVENTMODELERS_TOKEN` also now answers the credentials question on its own, the way `EVENTMODELERS_BOARD_ID` always answered the board question: an env var that outranks every config file makes asking where the credentials come from moot. The README gains a container recipe, including the two things a container needs that a laptop already had — a writable HOME for the global kit and per-board credentials, and a `LOCAL_AI_URL` that isn't `localhost`.
 
 ### Docs
 - The `anthropicBaseUrl` option no longer implies Ollama works behind it. That route keeps Claude Code and swaps only the endpoint, so the server has to speak Anthropic's own `/v1/messages`; Ollama does not, and pointing it at `localhost:11434` returns a 404. For Ollama, `--local-ai` is the supported route, and the README now says which of the two to reach for.

package/cli.js

@@ -1568,10 +1568,22 @@ async function fetchDefaultBoardId(baseUrl, token) {
 // .eventmodelers/config.json up the tree beat ~/.eventmodelers/config.json. So
 // `run --standalone --board-id <uuid>` is enough for a board used before, and any run can
 // be pointed somewhere else entirely with --token/--organization-id.
-async function resolveModelingCredentials(cwd, flags, explicitConfigPath, print) {
+async function resolveModelingCredentials(cwd, flags, explicitConfigPath, print, nonInteractive = false) {
   const walked = loadEffectiveConfig(cwd, null, explicitConfigPath).config;
   const explicit = Object.fromEntries(Object.entries(flags ?? {}).filter(([, v]) => v));
 
+  // Whether there is anyone to ask, decided once. A TTY was the only signal before, which is
+  // right for a supervisor or CI (no stdin, so nothing to ask) but wrong for a loop started
+  // from a terminal: stdin is a TTY nobody is watching, and the run stops on a question.
+  // --non-interactive says so explicitly; --print never asks either.
+  const interactive = !print && !nonInteractive && process.stdin.isTTY;
+
+  // An EVENTMODELERS_TOKEN set for this run answers the credentials question below as
+  // squarely as --token does — applyEnvOverrides makes it win over every file anyway, so
+  // asking where this board's credentials come from could not change the outcome. The board
+  // question has always treated its env var this way; this is the same rule for the token.
+  const credentialsNamed = !!(explicit.token || process.env.EVENTMODELERS_TOKEN);
+
   // Which board comes first — everything else is stored per board, so there is nothing to
   // look up until we know which board this run is for.
   let boardId = explicit.boardId || process.env.EVENTMODELERS_BOARD_ID || walked.boardId || null;
@@ -1583,7 +1595,7 @@ async function resolveModelingCredentials(cwd, flags, explicitConfigPath, print)
   // non-interactive stdin such as CI or a process supervisor), where the resolved value
   // stands on its own exactly as before.
   let boardChosen = !!(explicit.boardId || process.env.EVENTMODELERS_BOARD_ID);
-  if (!boardChosen && !print && process.stdin.isTTY) {
+  if (!boardChosen && interactive) {
     const answer = await prompt(boardId ? `\n  Board ID [${boardId}]: ` : '\n  Board ID: ');
     if (answer) {
       boardId = answer;
@@ -1613,7 +1625,7 @@ async function resolveModelingCredentials(cwd, flags, explicitConfigPath, print)
   // implied — explicit credentials on the command line — or when there is no one to ask:
   // --print, or a non-interactive stdin such as CI or a supervisor that would otherwise
   // hang here forever (those keep using whatever is on file, silently).
-  if (!print && !explicit.token && process.stdin.isTTY) {
+  if (interactive && !credentialsNamed) {
     const hasAccountWide = !!(walked.token && walked.organizationId);
 
     // What "keep" would keep. A pointer entry is deliberately not offered: it says the
@@ -1678,9 +1690,10 @@ async function resolveModelingCredentials(cwd, flags, explicitConfigPath, print)
     : { ...applyEnvOverrides({ ...walked, ...stored }), ...explicit };
   if (boardId) config.boardId = boardId;
 
-  if (!config.token || !config.organizationId) {
+  if ((!config.token || !config.organizationId) && interactive) {
     // Nothing anywhere — ask once, and save it account-wide rather than into this
-    // directory, so every later run from anywhere is silent.
+    // directory, so every later run from anywhere is silent. Headless, there is nobody to
+    // interview, so this is skipped and the check below fails the run with the reason.
     console.log('🔐 No Eventmodelers credentials found — configuring them once, account-wide.\n');
     config = await configureCredentials({
       config,
@@ -3107,6 +3120,7 @@ credentialFlags(program
   .option('--exec [command]', 'Hand each prompt to an external agent command instead of the default Claude runner, via ralph-exec.js (build-kit stacks only) — for agentic harnesses that bring their own tool loop, e.g. "codex exec --full-auto" or "opencode run". The prompt is appended as a quoted argument and also written to the file named by RALPH_PROMPT_FILE. Bare --exec uses localAi.exec from .eventmodelers/config.json. Claude remains the default when this flag is absent.')
   .option('--bash', 'Use the bash-only ralph.sh loop (build-kit stacks only, no realtime)')
   .option('--modeling', 'Keep one Claude process warm across prompts instead of spawning a fresh one per task, for low-latency voice/live use. Runs from a modeling-kit install in this directory, or from the global install (~/.eventmodelers/kit) when there is none. Built into the CLI, not a per-project file.')
+  .option('--non-interactive', 'Never ask anything: take the board and credentials that resolve from flags, EVENTMODELERS_* env vars and the config files, and fail with the reason if they are incomplete instead of interviewing for them. A TTY was previously the only signal — right for CI or a supervisor, wrong for a loop started from a terminal, where stdin is a TTY nobody is watching and the run stops on a question. Only affects the modeling loop (--modeling/--standalone/--global).')
   .option('--standalone', 'Let the modeling agent work the board in the background, on its own initiative: on top of direct prompts it subscribes to the board\'s change channel (like the build agents do) and, whenever the board goes quiet after an edit — or has simply been idle for a while — it takes a turn nobody asked for. Changed nodes are a notification, not the task: it judges the model as a whole and fans the work out over parallel subagents, one per changed area (examples on a new node, specs for a new command or read model, a missing attribute along a chain, a screen, a question comment). Filling that detail in while the human keeps modeling is the point — it does not wait for the board to be finished. Implies --modeling.')
   .option('--max-agents <n>', 'Cap how many subagents a self-directed --standalone turn may dispatch at once, to bound what an unattended agent can spend per turn. The agent merges work that shares a slice or chain first, then takes the most valuable pieces up to this many and leaves the rest for a later turn. 1 makes it do the single most valuable piece itself, without spawning anything. Default 5. Ignored without --standalone — prompt turns are one piece of work by definition.', '5')
   .option('--exclusive', 'Work only the prompts addressed to this agent\'s id — the board\'s "preferred agent" (the star in the prompts panel) — and hand every untargeted prompt straight back to the queue for another agent to take. Without it an agent also works everything nobody addressed to anyone, which is what you want for a single agent and exactly what you do not want for a dedicated one (a board with a general agent plus a specialist, or an agent a supervisor drives by id). Pair it with --id so the same agent is addressable across restarts — --global/--standalone otherwise mint a fresh id per run, and prompts addressed to the previous run\'s id are never claimed. Leaves --standalone alone: a self-directed turn is nobody\'s prompt, so an exclusive standalone agent still works the board on its own initiative.')
@@ -3201,7 +3215,7 @@ credentialFlags(program
           ...(opts.credentials ? parseCredentialsArg(opts.credentials) : {}),
           ...Object.fromEntries(Object.entries(credentialOverridesFromOpts(opts)).filter(([, v]) => v)),
         };
-        const config = await resolveModelingCredentials(cwd, flags, globalOpts.config, globalOpts.print);
+        const config = await resolveModelingCredentials(cwd, flags, globalOpts.config, globalOpts.print, !!opts.nonInteractive);
         projectDir = await ensureGlobalKit(config.baseUrl);
         kitDir = join(projectDir, MODELING_KIT.kitDirName);
         overrides = config;
@@ -3581,11 +3595,11 @@ program
           ...agentHeaders(cfg),
         },
         body: JSON.stringify([{
+          // The event id is the caller's and required; boardId/timestamp are the server's —
+          // it derives both from the request and ignores anything sent here.
           id: randomUUID(),
           eventType: 'node:changed',
           nodeId: slice.id,
-          boardId: cfg.boardId,
-          timestamp: Date.now(),
           changedAttributes: ['sliceStatus'],
           meta: { sliceStatus: newStatus },
         }]),

package/lib/modeling-local-ai.js

@@ -47,7 +47,7 @@ const PRESETS = {
 };
 
 const DEFAULT_MODEL = 'qwen3.5:9b';
-const DEFAULT_NUM_CTX = 32768;
+const DEFAULT_NUM_CTX = 49152;
 // A modeling turn is read-then-write (get_nodes, then a placement or a field change),
 // so it needs more round trips than the build kit's 12 — but a local model that has
 // lost the plot loops on one tool forever, and this is what ends that turn instead of
@@ -77,7 +77,22 @@ export function resolveLocalAiTarget({ target, localAi = {} } = {}) {
     throw new Error(`Unknown local-AI dialect "${dialect}" — one of: ${Object.keys(DIALECTS).join(', ')}`);
   }
 
-  const rawCtx = process.env.LOCAL_AI_NUM_CTX || localAi.numCtx;
+  // Configured the same way every other knob here is: env wins over config.json's `localAi`,
+  // and the default stands when neither says otherwise. Validated rather than coerced, because
+  // Number('32k') is NaN, which JSON.stringify turns into `num_ctx: null` — a request Ollama
+  // accepts and silently answers with its own 4096 default, which is the exact failure the
+  // default below exists to prevent.
+  const rawCtx = process.env.LOCAL_AI_NUM_CTX ?? localAi.numCtx;
+  let numCtx = DEFAULT_NUM_CTX;
+  if (rawCtx !== undefined && rawCtx !== null && String(rawCtx).trim() !== '') {
+    numCtx = Number(rawCtx);
+    if (!Number.isInteger(numCtx) || numCtx <= 0) {
+      throw new Error(
+        `Invalid context size "${rawCtx}" (LOCAL_AI_NUM_CTX or localAi.numCtx) — a positive whole number of tokens, e.g. ${DEFAULT_NUM_CTX}`,
+      );
+    }
+  }
+
   return {
     url,
     dialect,
@@ -87,7 +102,7 @@ export function resolveLocalAiTarget({ target, localAi = {} } = {}) {
     // num_ctx is per-request in Ollama and its default (4096) is far below what the
     // MCP tool schemas alone need; on an OpenAI-compatible server the context is fixed
     // at launch, so there is nothing to send and overflow surfaces as an HTTP 400.
-    numCtx: dialect === 'ollama' ? (rawCtx ? Number(rawCtx) : DEFAULT_NUM_CTX) : null,
+    numCtx: dialect === 'ollama' ? numCtx : null,
   };
 }
 
@@ -200,7 +215,7 @@ export function createModelingLocalAiRunner({ cfg, target, log, verbose = false,
         throw new Error(
           `${t.dialect} HTTP 400 — the request exceeds the server's context window. The MCP tool schemas alone ` +
             `are ~${approxTokens(tools)} tokens; restart the server with a larger context ` +
-            `(vLLM: --max-model-len 32768, llama.cpp: -c 32768).\n${text.slice(0, 300)}`,
+            `(vLLM: --max-model-len 49152, llama.cpp: -c 49152).\n${text.slice(0, 300)}`,
         );
       }
       throw new Error(`${t.dialect} HTTP ${res.status}: ${text.slice(0, 300)}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eventmodelers/cli",
-  "version": "1.0.79",
+  "version": "1.0.81",
   "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/skills/connect/SKILL.md

@@ -283,15 +283,17 @@ The same discipline applies to writes: `submit_node_events` takes `events[]`, so
 
 Where per-node calls genuinely can't be avoided, issue them together in one message so they run concurrently rather than in sequence.
 
-### Ids and timestamps
+### Ids
 
-Elements you create carry client-side ids, and every `node:created` event carries a timestamp. Mint them **once per turn, in a single call**, and take from that pool as you assemble the event array:
+Elements you create carry client-side ids — one `nodeId` per new node — and **every event carries its own `id`**, a fresh uuid per event, never the node's. Mint them **once per turn, in a single call**, and take from that pool as you assemble the event array:
 
 ```bash
-for i in $(seq 5); do uuidgen; done; echo $(( $(date +%s) * 1000 ))
+for i in $(seq 8); do uuidgen; done
 ```
 
-Nothing in that depends on anything you're about to read, so splitting it across three shells is three round trips bought for nothing. Never reach for GNU-only `date` specifiers (`%N`, `%3N`) here: BSD/macOS `date` prints them literally instead of failing, so the malformed timestamp survives until something downstream rejects it.
+Nothing in that depends on anything you're about to read, so splitting it across several shells is round trips bought for nothing.
+
+The event `id` is **required** — an event without one is rejected as an invalid shape. It is what keys the returned `hashes` map, and what makes a resubmit idempotent: the same event sent twice under the same id writes one board event, not two. An event's `boardId` and `timestamp`, by contrast, are **not** yours to send — the server takes the board from the call and stamps the time itself, and ignores both if you send them.
 
 ---
 

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

@@ -20,12 +20,12 @@ Server name: `eventmodelers`. Every tool takes `boardId` explicitly; none need `
 | Tool | Args | Purpose | REST equivalent |
 |---|---|---|---|
 | `list_boards` | — | List boards for the org | §1 `GET /api/boards` (org-scoped) |
-| `get_nodes` | `boardId`, `type?`, `name?`, `chapterId?`, `nodeIds?`, `projection?` (`"line"`) | List nodes, optionally by type and/or a partial case-insensitive title match. `chapterId` scopes to one timeline — prefer this over an unscoped board-wide call whenever the step is working within one chapter (the common case); `nodeIds` fetches a known, scattered subset in one call (e.g. re-verifying exactly the nodes just touched by a batch write) instead of a full `type` refetch; `projection: "line"` maps each match to `{id, type, title}` only | §3 `GET .../nodes` |
-| `get_node` | `boardId`, `nodeId`, `projection?` (`"cells"` \| `"edges"`) | Get one node. `projection: "cells"` (CHAPTER nodes only) returns just `{rows, columns, cells}` instead of the full `timelineData` — use whenever only the grid/occupancy is needed, not the whole chapter; `projection: "edges"` returns just that node's inbound/outbound connections instead of `findNodeById`'s full record. Both are opt-in — omitting `projection` is the unchanged full response | §3 `GET .../nodes/:nodeId` |
+| `get_nodes` | `boardId`, `type?`, `name?`, `chapterId?`, `nodeIds?`, `projection?` (`"line"`) | List nodes, optionally by type and/or a partial case-insensitive title match. `chapterId` scopes to one timeline — prefer this over an unscoped board-wide call whenever the step is working within one chapter (the common case); `nodeIds` fetches a known, scattered subset in one call (e.g. re-verifying exactly the nodes just touched by a batch write) instead of a full `type` refetch; `projection: "line"` maps each match to `{id, type, title}` only. Every node carries `cellName`, its cell address in the chapter it is placed in (absent when unplaced) — read the cell names the cell-addressed tools need from here, never derive or invent one | §3 `GET .../nodes` |
+| `get_node` | `boardId`, `nodeId`, `projection?` (`"cells"` \| `"edges"`) | Get one node — the full response carries `cellName`, its cell address in the chapter it is placed in. `projection: "cells"` (CHAPTER nodes only) returns just `{rows, columns, cells}` instead of the full `timelineData` — use whenever only the grid/occupancy is needed, not the whole chapter; `projection: "edges"` returns just that node's inbound/outbound connections instead of `findNodeById`'s full record. Both are opt-in — omitting `projection` is the unchanged full response | §3 `GET .../nodes/:nodeId` |
 | `get_node_comments` | `boardId`, `nodeId` | List comments on a node | §1 `GET .../nodes/:nodeId/comments` |
 | `get_board_events` | `boardId` | All board events, in sequence | §1 `GET .../events` |
 | `search_board_events` | `boardId`, `name` | Search events by node name | §1 `GET .../events/search` |
-| `submit_node_events` | `boardId`, `events[]`, `autoConnect?`, `compact?` | Create/update nodes (raw `NodeChangeEvent`/edge events). Every event property is described on the tool's own `events[]` schema — read that rather than this skill when all you need is the event shape. `autoConnect: false` places freshly-created nodes without wiring them to their own/previous-column neighbors (avoids a stray nearest-left edge); `compact: true` returns `{persisted: <count>}` instead of the per-node hash map | §3 `POST .../nodes/events` |
+| `submit_node_events` | `boardId`, `events[]`, `autoConnect?`, `compact?` | Create/update nodes (raw `NodeChangeEvent`/edge events). Every event property is described on the tool's own `events[]` schema — read that rather than this skill when all you need is the event shape. An event needs its own `id` (required — a fresh uuid per event, never the node id) and its `eventType`, plus the keys of its kind (`nodeId`/`meta`/`node`, or `edgeId`/`source`/`target`). The `id` keys the returned `hashes` map and makes a resubmit idempotent — the same event sent twice under one id writes a single board event. Don't send `boardId` or `timestamp` per event — the server takes the board from the call and stamps the time itself, and ignores both if sent. `autoConnect: false` places freshly-created nodes without wiring them to their own/previous-column neighbors (avoids a stray nearest-left edge); `compact: true` returns `{persisted: <count>}` instead of the per-node hash map | §3 `POST .../nodes/events` |
 | `delete_node` | `boardId`, `nodeId` | Delete a node. Deleting a chapter (timeline) cascades — every node placed in one of its cells, plus any node parented to it (e.g. SLICE_BORDER), is deleted too, along with all their edges | (via `node:deleted` event, §3) |
 | `create_drawing` / `create_drawings` | `boardId`, `kind`, `x`, `y`, `width`, `height`, ... (plural: `drawings[]`) | Freehand canvas annotation (path/rect/text/sticky) — never placed in a cell. Use the plural form whenever an annotation is more than one stroke (a loop plus its arrows and label is one annotation, not three calls) | — (REST `POST .../drawing/draw` accepts a single drawing or an array) |
 | `find_nodes_in_drawing` | `boardId`, `drawingId` | Nodes fully contained inside a drawing's bounding box | — (no REST equivalent; MCP-only) |
@@ -48,7 +48,7 @@ Server name: `eventmodelers`. Every tool takes `boardId` explicitly; none need `
 | `update_slice_status` | `boardId`, `newStatus`, plus exactly one of `sliceId` / `sliceTitle` / `columnId` | Change a SLICE_BORDER's `sliceStatus`. With a title or column id there is no need to call `list_slices` first; an ambiguous title comes back with its candidates. A slice being created takes its status from `create_slice`/`create_slice_definition` instead | — (via `node:changed` event, §3) |
 | `get_slice_data` | `boardId`, `contextName?`, `contextId?`, `sliceId?` | Full element graph for slices in a context | §8 `GET /slicedata` |
 | `get_spec_info` | `boardId`, `timelineId`, `elementTypes?` | EVENT/COMMAND/READMODEL nodes valid in GWT steps. Pass `elementTypes` (subset of `EVENT`/`COMMAND`/`READMODEL`) to avoid pulling the full element list when only one or two types are needed — filtered server-side, not just after a full fetch | §6 `GET .../spec-info` |
-| `get_board_outline` | `boardId`, `chapterId` | One chapter's structure, compact: per-column node lists (`{id, type, title, lane}`) + a flat edge list, no HTML pages / field bodies / meta. The cheap "what is where and how is it wired" read — prefer over `get_nodes` (no projection) for orientation checks | — (MCP-only convenience) |
+| `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 one read that gives you every address in a chapter at once. 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 as cell names 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` |
@@ -61,7 +61,7 @@ Server name: `eventmodelers`. Every tool takes `boardId` explicitly; none need `
 | `create_screen` | `boardId`, `contentType` (`'image'\|'sketch'\|'html'`), `nodeId?`, `chapterId`, `cellId?`/`cellName?`, plus content fields (`imageBase64`/`mimeType`, `elements[]`, or `pages[]`/`backgroundColor`), `title?`, `description?`, `fields?`, `autoConnect?` | Create + place a new screen node (SCREEN or HTML_SCREEN) atomically, in one call. `title` names the node (`meta.title`) in the same call — no follow-up `node:changed` just to label the screen; `create_screens` takes it per entry. Batch form `create_screens` takes `screens[]` (HTML only) + `autoConnect?`. `autoConnect: false` places without wiring to timeline neighbors | §4 `POST .../images/:id/sketch` + `image-nodes` |
 | `render_screen` | `boardId`, `nodeId`, `elements[]?` (SCREEN) or `pages[]?`+`backgroundColor?` (HTML_SCREEN), `description?` | Update an existing screen's content — exactly one of `elements`/`pages` | §4 `POST .../images/:id/sketch` + `image-nodes` |
 | `add_field_examples` | `boardId`, `nodeId?`, `name?`, `cellName?`, `timelineId?` | Fill empty field examples using linked-node context | — (MCP-only convenience) |
-| `get_attribute_chain` | `boardId`, `timelineId`, `targetCellName`, `sourceCellName` | Resolve every node between two cells, ordered target→source | — (MCP-only convenience) |
+| `get_attribute_chain` | `boardId`, `timelineId`, `targetCellName`, `sourceCellName` | Resolve every node between two cells, ordered target→source. Both cell names must come from a node's reported `cellName` (`get_board_outline`, `get_nodes`, `get_node`) — a guessed address that happens to exist silently resolves the wrong chain | — (MCP-only convenience) |
 | `verify_screen` | `boardId`, `nodeId` | Check a screen node exists and has rendered content — works for both SCREEN and HTML_SCREEN, dispatching on the node's actual type | — (MCP-only convenience) |
 | `get_image_snapshot_description` | `boardId`, `nodeId` | Load the `{elements:[...]}` sketch description from storage | — (reads what §4 sketch endpoints write) |
 | `validate_slice_data` | `sliceData` | Offline validation of a `SliceDataOutput` payload — no board access | — (MCP-only, pure function) |
@@ -337,8 +337,6 @@ Place a free-text markdown note in that lane the same way any other node is plac
   "id": "<event-uuid>",
   "eventType": "node:created",
   "nodeId": "<node-uuid>",
-  "boardId": "<boardId>",
-  "timestamp": 1234567890,
   "chapterId": "<chapterId>",
   "cellId": "<feedbackRowId>-<columnId>",
   "meta": {
@@ -370,13 +368,16 @@ A `node:deleted` event cascades: if the deleted node is a chapter (timeline), ev
 
 **Request body**: `NodeChangeEvent[]`
 
+Every event carries its own `id` — **required**, a fresh uuid per event and never the node id. An event without one is rejected (`400`, invalid event shape). It keys the response's `hashes` map, and it is what makes a resubmit safe: the board-event insert ignores a conflicting id, so the same batch sent twice writes one history row per event rather than two.
+
+Don't send `boardId` or `timestamp` per event: the board is the path's (the one this request was authorized for) and the timestamp is the server's. Both are ignored if sent — older payloads that include them still work.
+
 ```typescript
 interface NodeChangeEvent {
-  id: string                    // uuid
+  id: string                    // required — fresh uuid per event, NOT the node id; keys the response's hashes map
   eventType: 'node:created' | 'node:changed' | 'node:deleted'
   nodeId: string
-  boardId: string
-  timestamp: number             // unix ms
+  // boardId / timestamp: don't send them — server-derived, ignored if present
   userId?: string
   hash?: string                 // content hash
   changedAttributes?: string[]  // dot-paths e.g. 'meta.title'

package/shared/skills/request-feedback/SKILL.md

@@ -128,8 +128,6 @@ curl -s -X POST "<BASE_URL>/api/org/<ORG_ID>/boards/<BOARD_ID>/nodes/events" \
     "id": "<new-random-uuid>",
     "eventType": "node:changed",
     "nodeId": "<SLICE_NODE_ID>",
-    "boardId": "<BOARD_ID>",
-    "timestamp": <Date.now()>,
     "changedAttributes": ["sliceStatus"],
     "meta": {
       "sliceStatus": "Blocked"

package/shared/skills/update-slice-status/SKILL.md

@@ -89,8 +89,6 @@ curl -s -X POST "<BASE_URL>/api/org/<ORG_ID>/boards/<BOARD_ID>/nodes/events" \
     "id": "<new-random-uuid>",
     "eventType": "node:changed",
     "nodeId": "<SLICE_NODE_ID>",
-    "boardId": "<BOARD_ID>",
-    "timestamp": <Date.now()>,
     "changedAttributes": ["sliceStatus"],
     "meta": {
       "sliceStatus": "<newStatus>"

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

@@ -42,6 +42,8 @@ mcp__eventmodelers__get_attribute_chain {
 
 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.
 
+**Both cell names must be real.** When the task named a node (an id, a title, a comment on it) instead of a cell, read that node's `cellName` off `get_board_outline` (every node in the chapter, with its address), `get_nodes`, or `get_node` — all three report it. Never compute an address from where a node appeared in a list, and never hand `get_attribute_chain` an address you have not read: a cell that exists but holds a different node resolves a wrong chain without any error.
+
 ### Fallback (no MCP) — resolve both cells to nodes
 
 For each cell (target and source), resolve it to a node using the exact same cell-resolution steps as the `examples` skill's "2c — Cell name" section (fetch chapters, fetch the chapter fresh to decode the grid, decode the cell name into a `CELL_ID`, then always fetch the cell live — `get_nodes` has no `cellId` filter) — see there for the full mechanics, substituting `x-user-id: attributes-skill`.
@@ -149,8 +151,6 @@ mcp__eventmodelers__submit_node_events {
       "id": "<uuid>",
       "eventType": "node:changed",
       "nodeId": "<NODE_ID_1>",
-      "boardId": "$BOARD_ID",
-      "timestamp": <epoch-ms>,
       "changedAttributes": ["meta.fields"],
       "meta": { "fields": "<updated_fields_array_1>" }
     },

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

@@ -15,13 +15,11 @@ Build the payload with Python to avoid JSON escaping issues, then POST it:
 
 ```bash
 python3 - <<EOF > /tmp/attributes_payload.json
-import json, time, uuid
+import json, 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>

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

@@ -232,8 +232,6 @@ mcp__eventmodelers__submit_node_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": {} }

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

@@ -22,8 +22,6 @@ curl -s -X POST "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/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": {} }

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

@@ -107,8 +107,6 @@ mcp__eventmodelers__submit_node_events {
     "id": "<uuid>",
     "eventType": "node:changed",
     "nodeId": "<chapterId>",
-    "boardId": "<BOARD_ID>",
-    "timestamp": 1234567890,
     "meta": {"type": "CHAPTER", "title": "Reservation & Lending"}
   }]
 }
@@ -200,8 +198,6 @@ mcp__eventmodelers__submit_node_events {
     "id": "<event-uuid>",
     "eventType": "node:created",
     "nodeId": "<node-uuid>",
-    "boardId": "<BOARD_ID>",
-    "timestamp": 1234567890,
     "chapterId": "<chapterId>",
     "cellId": "<swimlaneRowId>-<columnId>",
     "meta": {

package/stacks/modeling-kit/templates/.claude/skills/eventmodeling-brainstorming-events/references/api-fallback.md

@@ -35,8 +35,6 @@ curl -s -X POST "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/events" \
     "id": "<uuid>",
     "eventType": "node:changed",
     "nodeId": "<chapterId>",
-    "boardId": "<boardId>",
-    "timestamp": 1234567890,
     "meta": {"type": "CHAPTER", "title": "Reservation & Lending"}
   }]'
 ```
@@ -78,8 +76,6 @@ Same body via `POST .../nodes/events`:
   "id": "<event-uuid>",
   "eventType": "node:created",
   "nodeId": "<node-uuid>",
-  "boardId": "<boardId>",
-  "timestamp": 1234567890,
   "chapterId": "<chapterId>",
   "cellId": "<swimlaneRowId>-<columnId>",
   "meta": {

package/stacks/modeling-kit/templates/.claude/skills/eventmodeling-designing-automation-chains/SKILL.md

@@ -95,7 +95,6 @@ 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": "NotificationsToSend", "fields": [...], "listElement": true}
   }]
 }

package/stacks/modeling-kit/templates/.claude/skills/eventmodeling-designing-automation-chains/references/api-fallback.md

@@ -14,7 +14,6 @@ Only needed when MCP is not connected. Every call below has an MCP equivalent in
      -H "Content-Type: application/json" \
      -d '[{
        "id":"<event-uuid>","eventType":"node:created","nodeId":"<node-uuid>",
-       "boardId":"<BOARD_ID>","timestamp":1234567890,
        "chapterId":"<CHAPTER_ID>","cellId":"<interactionRowId>-<columnId>",
        "meta":{"type":"READMODEL","title":"NotificationsToSend","fields":[...]}
      }]'

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

@@ -160,8 +160,6 @@ mcp__eventmodelers__submit_node_events {
     "id": "<event-uuid>",
     "eventType": "node:changed",
     "nodeId": "<returned-node-id>",
-    "boardId": "<BOARD_ID>",
-    "timestamp": 1234567890,
     "meta": {
       "type": "COMMAND",
       "title": "ReserveBike",

package/stacks/modeling-kit/templates/.claude/skills/eventmodeling-identifying-inputs/references/api-fallback.md

@@ -34,8 +34,6 @@ curl -X POST "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/events" \
     "id": "<event-uuid>",
     "eventType": "node:created",
     "nodeId": "<node-uuid>",
-    "boardId": "<boardId>",
-    "timestamp": 1234567890,
     "chapterId": "<chapterId>",
     "cellId": "<interactionRowId>-<columnId>",
     "meta": {

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

@@ -267,7 +267,6 @@ 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": [...]}
   }]
 }

package/stacks/modeling-kit/templates/.claude/skills/eventmodeling-identifying-outputs/references/api-fallback.md

@@ -26,8 +26,6 @@ Only needed when MCP is not connected. Every call below has an MCP equivalent in
        "id": "<event-uuid>",
        "eventType": "node:created",
        "nodeId": "<node-uuid>",
-       "boardId": "<BOARD_ID>",
-       "timestamp": 1234567890,
        "chapterId": "<CHAPTER_ID>",
        "cellId": "<interactionRowId>-<columnId>",
        "meta": {"type": "READMODEL", "title": "ActiveReservationView", "fields": [...]}

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

@@ -431,7 +431,6 @@ Not delegated to a separate skill — performed directly by this orchestrating s
      "boardId": "$BOARD_ID",
      "events": [{
        "id": "<event-uuid>", "eventType": "node:created", "nodeId": "<node-uuid>",
-       "boardId": "$BOARD_ID", "timestamp": 1234567890,
        "chapterId": "$CHAPTER_ID", "cellId": "<feedbackLaneId>-<firstColumnId>",
        "meta": { "type": "MARKDOWN", "title": "Modeling Reasoning — <Chapter Name>", "description": "<full markdown body>" }
      }]

package/stacks/modeling-kit/templates/.claude/skills/eventmodeling-orchestrating-event-modeling/references/api-fallback.md

@@ -17,8 +17,8 @@ done
 curl -s -X POST "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/events" \
   -H "x-token: $TOKEN" -H "x-user-id: orchestrator" \
   -H "Content-Type: application/json" \
-  -d '[{"id":"<uuid>","eventType":"node:changed","nodeId":"<nodeId>","boardId":"<BOARD_ID>",
-        "timestamp":1234567890,"chapterId":"<chapterId>","cellId":"<rowId>-<colId>",
+  -d '[{"id":"<event-uuid>","eventType":"node:changed","nodeId":"<nodeId>",
+        "chapterId":"<chapterId>","cellId":"<rowId>-<colId>",
         "meta":{"type":"<TYPE>","title":"<title>"}}]'
 ```
 
@@ -45,7 +45,7 @@ curl -s -X POST "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/timelines/$CHAPTER_I
 curl -s -X POST "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/events" \
   -H "x-token: $TOKEN" -H "x-user-id: orchestrator" \
   -H "Content-Type: application/json" \
-  -d '[{"id":"<event-uuid>","eventType":"node:created","nodeId":"<node-uuid>","boardId":"<BOARD_ID>",
-        "timestamp":1234567890,"chapterId":"<CHAPTER_ID>","cellId":"<feedbackLaneId>-<firstColumnId>",
+  -d '[{"id":"<event-uuid>","eventType":"node:created","nodeId":"<node-uuid>",
+        "chapterId":"<CHAPTER_ID>","cellId":"<feedbackLaneId>-<firstColumnId>",
         "meta":{"type":"MARKDOWN","title":"Modeling Reasoning — <Chapter Name>","description":"<full markdown body>"}}]'
 ```

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

@@ -256,8 +256,6 @@ mcp__eventmodelers__submit_node_events {
     "id": "<event-uuid>",
     "eventType": "node:created",
     "nodeId": "<node-uuid>",
-    "boardId": "<BOARD_ID>",
-    "timestamp": 1234567890,
     "chapterId": "<CHAPTER_ID>",
     "cellId": "<actorRowId>-<columnId>",
     "meta": {"type": "SCREEN", "title": "<Screen Title>", "fields": [...]}

package/stacks/modeling-kit/templates/.claude/skills/eventmodeling-storyboarding-events/references/api-fallback.md

@@ -52,8 +52,6 @@ curl -s -X POST "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/events" \
     "id": "<event-uuid>",
     "eventType": "node:created",
     "nodeId": "<node-uuid>",
-    "boardId": "<BOARD_ID>",
-    "timestamp": 1234567890,
     "chapterId": "<CHAPTER_ID>",
     "cellId": "<actorRowId>-<columnId>",
     "meta": {"type": "SCREEN", "title": "<Screen Title>", "fields": [...]}

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

@@ -43,7 +43,7 @@ A run that opens each element with its own `get_node` to "read existing examples
 
 - `target` is a UUID → pass `nodeId`
 - `target` is a name → pass `name`
-- `target` is a cell name (e.g. `B3`) → pass `cellName` + `timelineId` (the chapter id — if multiple chapters exist on the board, resolve which one first using 2c-fallback's chapter lookup, or `mcp__eventmodelers__get_nodes { "boardId": "$BOARD_ID", "type": "CHAPTER" }`, and ask the user if ambiguous)
+- `target` is a cell name (e.g. `B3`) → pass `cellName` + `timelineId` (the chapter id — if multiple chapters exist on the board, resolve which one first using 2c-fallback's chapter lookup, or `mcp__eventmodelers__get_nodes { "boardId": "$BOARD_ID", "type": "CHAPTER" }`, and ask the user if ambiguous). Only pass a cell name you were given or read back as a node's `cellName` (`get_board_outline`/`get_nodes`/`get_node` all report it) — if all you have is a node id or title, pass that instead rather than constructing an address.
 
 ```
 mcp__eventmodelers__add_field_examples { "boardId": "$BOARD_ID", "nodeId": "<target, if a UUID>" }
@@ -105,8 +105,6 @@ mcp__eventmodelers__submit_node_events {
     "id": "<uuid>",
     "eventType": "node:changed",
     "nodeId": "<TARGET_NODE.id>",
-    "boardId": "$BOARD_ID",
-    "timestamp": <epoch-ms>,
     "changedAttributes": ["meta.fields"],
     "meta": { "fields": "<updated-fields-array>" }
   }]

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

@@ -94,13 +94,11 @@ Build the payload with Python to avoid shell JSON-escaping issues, then POST it:
 
 ```bash
 python3 - <<EOF > /tmp/examples_payload.json
-import json, time, uuid
+import json, uuid
 payload = [{
   "id": str(uuid.uuid4()),
   "eventType": "node:changed",
   "nodeId": "<TARGET_NODE.id>",
-  "boardId": "<BOARD_ID>",
-  "timestamp": int(time.time() * 1000),
   "changedAttributes": ["meta.fields"],
   "meta": {
     "fields": <updated-fields-array as Python list>

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

@@ -97,7 +97,6 @@ mcp__eventmodelers__submit_node_events {
   "boardId": "<BOARD_ID>",
   "events": [{
     "id": "<event-uuid>", "eventType": "node:changed", "nodeId": "<NODE_ID>",
-    "boardId": "<BOARD_ID>", "timestamp": <NOW_MS>,
     "meta": {
       "type": "HTML_SCREEN",
       "title": "<Screen Title>",
@@ -174,7 +173,6 @@ mcp__eventmodelers__submit_node_events {
   "boardId": "<BOARD_ID>",
   "events": [{
     "id": "<event-uuid>", "eventType": "node:changed", "nodeId": "<NODE_ID>",
-    "boardId": "<BOARD_ID>", "timestamp": <NOW_MS>,
     "changedAttributes": ["meta.fields"],
     "meta": { "type": "HTML_SCREEN", "fields": [
       {"name": "status", "type": "String", "example": "confirmed", "mapping": "ActiveReservationView.status", "cardinality": "Single"}

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

@@ -39,7 +39,6 @@ curl -s -X POST "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/events" \
   -H "Content-Type: application/json" \
   -d '[{
     "id": "<event-uuid>", "eventType": "node:changed", "nodeId": "<NODE_ID>",
-    "boardId": "<BOARD_ID>", "timestamp": <NOW_MS>,
     "changedAttributes": ["meta.fields"],
     "meta": { "type": "HTML_SCREEN", "fields": [
       {"name": "status", "type": "String", "example": "confirmed", "mapping": "ActiveReservationView.status", "cardinality": "Single"}

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

@@ -321,10 +321,9 @@ This step applies to `SCREEN` (view/output conflict case), `AUTOMATION`, `SCENAR
 mcp__eventmodelers__submit_node_events {
   "boardId": "<BOARD_ID>",
   "events": [{
+    "id": "<event-uuid>",
     "eventType": "node:created",
     "nodeId": "<node-uuid>",
-    "boardId": "<BOARD_ID>",
-    "timestamp": <Date.now()>,
     "chapterId": "<TIMELINE_ID>",
     "cellId": "<CELL_ID>",
     "meta": { "type": "<ELEMENT_TYPE>", "title": "<title>" },
@@ -343,10 +342,9 @@ mcp__eventmodelers__submit_node_events {
 mcp__eventmodelers__submit_node_events {
   "boardId": "<BOARD_ID>",
   "events": [{
+    "id": "<event-uuid>",
     "eventType": "node:created",
     "nodeId": "<node-uuid>",
-    "boardId": "<BOARD_ID>",
-    "timestamp": <Date.now()>,
     "chapterId": "<TIMELINE_ID>",
     "cellName": "<CELL_NAME>",
     "meta": { "type": "<ELEMENT_TYPE>", "title": "<title>" },
@@ -357,7 +355,7 @@ mcp__eventmodelers__submit_node_events {
 
 **Fallback (no MCP):** see `references/api-fallback.md` — "Step 7b — Create any other node type (fast path, `cellName`)".
 
-Response: `{ "hashes": { "<event-uuid>": "<hash>" } }`
+Response: `{ "hashes": { "<event-id>": "<hash>" } }` — keyed by the `id` you sent on each event, which is how you match a hash back to the event that produced it.
 
 > **`node:created` with `cellId`/`cellName` IS the placement** — do NOT also call the `drop` endpoint afterwards. The `drop` endpoint adds a second cell reference without removing the first, causing the node to appear in two columns simultaneously. Use `node:created` with `cellId` or `cellName` for all initial placements.
 

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

@@ -124,10 +124,9 @@ curl -s -X POST "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/events" \
   -H "x-user-id: agent" \
   -H "Content-Type: application/json" \
   -d '[{
+    "id": "<event-uuid>",
     "eventType": "node:created",
     "nodeId": "<node-uuid>",
-    "boardId": "<BOARD_ID>",
-    "timestamp": <Date.now()>,
     "chapterId": "<TIMELINE_ID>",
     "cellId": "<CELL_ID>",
     "meta": {
@@ -148,10 +147,9 @@ curl -s -X POST "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/events" \
   -H "x-user-id: agent" \
   -H "Content-Type: application/json" \
   -d '[{
+    "id": "<event-uuid>",
     "eventType": "node:created",
     "nodeId": "<node-uuid>",
-    "boardId": "<BOARD_ID>",
-    "timestamp": <Date.now()>,
     "chapterId": "<TIMELINE_ID>",
     "cellName": "<CELL_NAME>",
     "meta": {
@@ -162,7 +160,7 @@ curl -s -X POST "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/events" \
   }]'
 ```
 
-Response: `{ "hashes": { "<event-uuid>": "<hash>" } }`
+Response: `{ "hashes": { "<event-id>": "<hash>" } }` — keyed by the `id` you sent on each event, which is how you match a hash back to the event that produced it.
 
 ## Full worked example — place an EVENT via curl, start to finish
 
@@ -188,8 +186,6 @@ curl -s -X POST "http://localhost:3000/api/org/<ORG_ID>/boards/<BOARD_ID>/nodes/
     "id": "<event-uuid>",
     "eventType": "node:created",
     "nodeId": "<node-uuid>",
-    "boardId": "<BOARD_ID>",
-    "timestamp": 1714900000000,
     "chapterId": "<TIMELINE_ID>",
     "cellId": "<CELL_ID>",
     "meta": { "type": "EVENT", "title": "Order Placed" },
@@ -197,4 +193,4 @@ curl -s -X POST "http://localhost:3000/api/org/<ORG_ID>/boards/<BOARD_ID>/nodes/
   }]'
 ```
 
-Replace `<TIMELINE_ID>`, `<BOARD_ID>`, `<CELL_ID>`, `<event-uuid>`, and `<node-uuid>` with real UUIDs. Use `Date.now()` or a current unix-ms timestamp for `timestamp`.
+Replace `<TIMELINE_ID>`, `<BOARD_ID>`, `<CELL_ID>`, `<event-uuid>` and `<node-uuid>` with real values — you mint two uuids here: the node's and the event's own `id`, which is required. `boardId`/`timestamp` are omitted on purpose: the server derives both from the request and ignores them if sent.

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

@@ -224,7 +224,6 @@ mcp__eventmodelers__submit_node_events {
   "boardId": "<BOARD_ID>",
   "events": [{
     "id": "<event-uuid>", "eventType": "node:changed", "nodeId": "<SCREEN_NODE_ID>",
-    "boardId": "<BOARD_ID>", "timestamp": <NOW_MS>,
     "changedAttributes": ["meta.fields"],
     "meta": { "type": "HTML_SCREEN", "fields": [ /* planned fields */ ] }
   }]

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

@@ -67,7 +67,6 @@ curl -s -X POST "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/events" \
   -H "Content-Type: application/json" \
   -d '[{
     "id": "<event-uuid>", "eventType": "node:changed", "nodeId": "<SCREEN_NODE_ID>",
-    "boardId": "<BOARD_ID>", "timestamp": <NOW_MS>,
     "changedAttributes": ["meta.fields"],
     "meta": { "type": "HTML_SCREEN", "fields": [ /* planned fields */ ] }
   }]'

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

@@ -122,7 +122,6 @@ mcp__eventmodelers__submit_node_events {
   "boardId": "<BOARD_ID>",
   "events": [{
     "id": "<event-uuid>", "eventType": "node:changed", "nodeId": "<NODE_ID>",
-    "boardId": "<BOARD_ID>", "timestamp": <NOW_MS>,
     "changedAttributes": ["meta.fields"],
     "meta": { "type": "SCREEN", "fields": [
       {"name": "status", "type": "String", "example": "confirmed", "mapping": "ActiveReservationView.status", "cardinality": "Single"}

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

@@ -33,7 +33,6 @@ curl -s -X POST "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/events" \
   -H "Content-Type: application/json" \
   -d '[{
     "id": "<event-uuid>", "eventType": "node:changed", "nodeId": "<NODE_ID>",
-    "boardId": "<BOARD_ID>", "timestamp": <NOW_MS>,
     "changedAttributes": ["meta.fields"],
     "meta": { "type": "SCREEN", "fields": [
       {"name": "status", "type": "String", "example": "confirmed", "mapping": "ActiveReservationView.status", "cardinality": "Single"}

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

@@ -246,8 +246,6 @@ mcp__eventmodelers__submit_node_events {
     "id": "<event-uuid>",
     "eventType": "node:created",
     "nodeId": "<node-uuid>",
-    "boardId": "<BOARD_ID>",
-    "timestamp": <Date.now()>,
     "chapterId": "<CHAPTER_ID>",
     "cellId": "<CELL_ID>",
     "meta": { "type": "EVENT", "title": "<EventName>" },
@@ -302,8 +300,6 @@ mcp__eventmodelers__submit_node_events {
     "id": "<new-uuid>",
     "eventType": "node:changed",
     "nodeId": "<eventNodeId>",
-    "boardId": "<BOARD_ID>",
-    "timestamp": <Date.now()>,
     "changedAttributes": ["meta.title"],
     "meta": { "type": "EVENT", "title": "<NewTitle>" },
     "node": { "id": "<eventNodeId>", "data": {} }

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

@@ -48,8 +48,6 @@ curl -s -X POST "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/events" \
     "id": "<event-uuid>",
     "eventType": "node:created",
     "nodeId": "<node-uuid>",
-    "boardId": "<BOARD_ID>",
-    "timestamp": <Date.now()>,
     "chapterId": "<CHAPTER_ID>",
     "cellId": "<CELL_ID>",
     "meta": { "type": "EVENT", "title": "<EventName>" },
@@ -67,8 +65,6 @@ curl -s -X POST "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/events" \
     "id": "<new-uuid>",
     "eventType": "node:changed",
     "nodeId": "<eventNodeId>",
-    "boardId": "<BOARD_ID>",
-    "timestamp": <Date.now()>,
     "changedAttributes": ["meta.title"],
     "meta": { "type": "EVENT", "title": "<NewTitle>" },
     "node": { "id": "<eventNodeId>", "data": {} }
@@ -84,8 +80,6 @@ curl -s -X POST "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/events" \
   -d '[{
     "id": "<new-uuid>",
     "eventType": "node:deleted",
-    "nodeId": "<eventNodeId>",
-    "boardId": "<BOARD_ID>",
-    "timestamp": <Date.now()>
+    "nodeId": "<eventNodeId>"
   }]'
 ```

package/stacks/modeling-kit/templates/kit/AGENTS.md

@@ -14,9 +14,10 @@ ones in a compressed, reusable form; only add if not already covered here.
 - `/update-slice-status` rejects moving a slice into a status it's already in — this is a concurrency guard so two agents can't both claim the same slice. Treat this as `ALREADY_IN_STATUS`, not a task failure: drop the prompt, move on to the next task, and do not retry the same update.
 - macOS/BSD `date` silently ignores GNU-only format specifiers like `%N`/`%3N` (sub-second precision) instead of erroring — it prints the literal characters, producing a malformed timestamp that only fails downstream. Don't shell out to `date` for sub-second precision; use `$(( $(date +%s) * 1000 ))` for whole-second-in-ms, or a runtime call (`Date.now()`, `process.hrtime()`) instead.
 - Before retrying a failed shell command a second time, diagnose why it failed (e.g. a GNU/BSD flag mismatch) rather than re-running it unchanged — repeating the same command produces the same failure and just burns retries.
+- A cell address (`B2`, `AE6`) is always read, never computed: `get_board_outline`, `get_nodes` and `get_node` each report a node's `cellName`. An address inferred from a column letter plus a node's place in a list is a guess, and a guess that happens to name an occupied cell is accepted silently by every cell-addressed tool.
 - Orientation and working set are two different reads, in that order: `get_board_outline` (or `get_nodes` with `projection: "line"`) answers *where is the work*, and only then does one full-`meta` `get_nodes`, scoped by `chapterId`/`nodeIds`, cover the nodes actually being touched. Opening with an unscoped full-`meta` read pulls every field body and rendered HTML page on the board to answer the cheapest question of the turn.
 - Both reads are once per turn. A chapter's outline and grid don't move unless something writes to them, so re-read only after a structural write. Three `get_board_outline` calls in one turn means the first two were thrown away.
-- Mint ids and timestamps once per turn, in one shell: `for i in $(seq <n>); do uuidgen; done; echo $(( $(date +%s) * 1000 ))`. Nothing in it depends on anything being read, so splitting it across three calls buys three round trips for nothing.
+- Mint ids once per turn, in one shell: `for i in $(seq <n>); do uuidgen; done` — one per new node, plus one per event, since every event needs its own fresh `id` (required; not the node id). Nothing in it depends on anything being read, so splitting it across several calls buys round trips for nothing. Never mint a per-event `boardId` or `timestamp` — both are server-derived and ignored if sent.
 - A subagent is a fresh session: it gets `token=`/`org=`/`baseUrl=`/`board=` inline as already-resolved values (which satisfies `connect` at its Step 0 — tell it not to invoke `/connect`) plus the board state already read for it, inline. Handed bare node ids instead, it has exactly one way to recover the rest — re-reading the whole board, once per agent.
 - Dispatch executor agents with `model:` set to the session header's `subagent_model` (default `sonnet`). The judging happened before the dispatch, on this session's model; what's left is execution against a written brief. Keep an agent on the session model only where its piece re-derives modeling structure (a chain's shape, a slice boundary).
 - Only slices in status `Created` may be modified. `get_nodes` returns `sliceStatus` per node and `get_board_outline` per column, so the board read at `/connect` Step 5 already answers it — absent means the element is in no slice (writable), not locked. Never spend a `list_slices`/`get_slice_data` call just to check whether you may write.

package/stacks/modeling-kit/templates/kit/CLAUDE.md

@@ -96,7 +96,7 @@ stale. Then a single full-`meta` `get_nodes`, scoped by
 `chapterId` or `nodeIds`, covering the nodes you concluded you will touch. Both tiers are once per turn: keep what
 came back and answer later questions from it instead of re-fetching a chapter you already hold. `/connect` Step 5
 carries the full discipline — the two tiers, the one-call `submit_node_events` rule for writes, and the per-turn
-pool for the ids and timestamps a `node:created` needs. Whatever you hand a subagent comes out of that same read,
+pool for the ids a `node:created` needs (one for the node, one for the event itself). Whatever you hand a subagent comes out of that same read,
 never out of a second one it pays for itself (step 2).
 
 **Every prompt gets exactly two `/update-prompt-status` calls per turn — never zero, never one.** `IN_PROGRESS` before you start the work (step 4), `DONE` after you finish it (step 6). This holds even for a prompt that turns out to be trivial or a no-op — the board UI has no other way to know the agent picked it up and finished it.