@eventmodelers/cli 1.0.71 → 1.0.72

package/README.md

@@ -272,9 +272,12 @@ the turn's own instructions rather than being enforced from outside — the `cla
 what spawns the agents — so it's a budget the agent is told to keep, not a hard ceiling.
 
 Every event that arrives is remembered until a turn carries it — including events that land
-while a turn is running. Its own writes come back on that same channel and the platform can't
-tell them apart from a human's, so those are *labelled* for the agent rather than discarded,
-and the lane is damped on timing instead: it waits for a quiet period (but not forever), waits
+while a turn is running. Its own writes come back on that same channel, and each event says who
+made it (`agent_id` from the writer's `x-agent-id` header, `user_id` for a browser), so the
+agent's own echo is recognized exactly: a burst that is nothing but its own writes is dropped
+without spending a turn, and one that is mixed lists its own lines marked as such. Only a write
+that reached the platform with neither id falls back to the echo window's guess and is labelled
+"possibly your own". The lane is damped on timing on top of that: it waits for a quiet period (but not forever), waits
 out the echo window of its last turn, never fires twice in quick succession, and widens that
 floor each time it answers `NOOP`, so a finished board goes quiet by itself. Override the
 windows if the defaults don't suit your board:
@@ -283,7 +286,7 @@ windows if the defaults don't suit your board:
 |---|---|---|
 | `EVENTMODELERS_STANDALONE_DEBOUNCE_MS` | `8000` | quiet period before buffered board changes turn into a turn |
 | `EVENTMODELERS_STANDALONE_MAX_WAIT_MS` | `90000` | cap on that quiet period, so a board being edited continuously still gets a turn |
-| `EVENTMODELERS_STANDALONE_ECHO_WINDOW_MS` | `20000` | after a turn, how long incoming changes are labelled as probably the agent's own echo |
+| `EVENTMODELERS_STANDALONE_ECHO_WINDOW_MS` | `20000` | after a turn, how long an *unattributed* incoming change is labelled as probably the agent's own echo (attributed ones are identified outright) |
 | `EVENTMODELERS_STANDALONE_MIN_INTERVAL_MS` | `60000` | floor between two self-directed turns |
 | `EVENTMODELERS_STANDALONE_BACKOFF_CAP_MS` | `900000` | ceiling that floor doubles up to while turns keep answering `NOOP` |
 | `EVENTMODELERS_STANDALONE_IDLE_MS` | `900000` | with nothing happening at all, how long before the agent reviews the model anyway (`0` disables it) |

package/cli.js

@@ -1310,7 +1310,15 @@ function configureHooks({ hooksSrc, targetDir }) {
 // per task, or a long-lived warm process) must call this first — a `.mcp.json`
 // written mid-session by the process itself is too late for that same process.
 // The token itself is never written to disk here — `${EVENTMODELERS_TOKEN}` is
-// resolved by `claude` from its own process env, which the caller must set.
+// resolved by `claude` from its own process env, which the caller must set. Same for
+// `${EVENTMODELERS_AGENT_ID}`: without it on the transport, every MCP write this agent makes
+// reaches the platform unattributed (board_events.agent_id null), and the board shows one
+// anonymous robot for it instead of this agent's name. It belongs here rather than only in the
+// skill's Step 3.5 because this entry is rewritten on every run — it would otherwise overwrite
+// the header the skill just added — and because a `.mcp.json` fixed mid-session comes too late
+// for the `claude` process already running. An unset var arrives at the server as the literal
+// `${EVENTMODELERS_AGENT_ID}` text, which it drops (it only accepts a uuid), so the entry is the
+// same one for a human's session and an agent's.
 function ensureMcpRegistered(projectDir, baseUrl) {
   const mcpConfigPath = join(projectDir, '.mcp.json');
   const mcpConfig = readJsonSafe(mcpConfigPath);
@@ -1318,7 +1326,7 @@ function ensureMcpRegistered(projectDir, baseUrl) {
   mcpConfig.mcpServers.eventmodelers = {
     type: 'http',
     url: `${baseUrl}/mcp`,
-    headers: { 'x-token': '${EVENTMODELERS_TOKEN}' },
+    headers: { 'x-token': '${EVENTMODELERS_TOKEN}', 'x-agent-id': '${EVENTMODELERS_AGENT_ID}' },
   };
   writeFileSync(mcpConfigPath, JSON.stringify(mcpConfig, null, 2));
 }
@@ -2044,20 +2052,22 @@ async function runModeling(kitDir, projectDir, { verbose = false, standalone = f
   // later adds to these payloads lands here without a client change.
   const BOARD_CHANGE_EVENTS = ['node:created', 'node:changed', 'node:deleted', 'edge:added', 'edge:removed', 'board:cleared'];
 
-  // Four knobs, because a board event can't tell you who caused it: the platform
-  // attributes an API token's writes to the org owner's user_id, so on this channel the
-  // agent's own edits are indistinguishable from the human's. They all govern *when* a
-  // self-directed turn fires — never whether an event is remembered. Everything that
-  // arrives is buffered (see onBoardEvent): an event seen while a turn runs, or inside the
-  // echo window, is only *marked* as possibly the agent's own write, so a burst that
+  // Four knobs. They govern *when* a self-directed turn fires — never whether an event is
+  // remembered: everything that arrives is buffered (see onBoardEvent), so a burst that
   // straddles a turn boundary still reaches the next turn instead of being thrown away and
   // leaving the agent looking at whichever single event happened to land last.
+  // Who wrote an event is *read off the event*, not inferred from these windows: the payload
+  // carries `agent_id` (stamped from the writer's `x-agent-id` header) and `user_id` (a
+  // browser session), so this agent's own echo is identified exactly and dropped without
+  // costing a turn. The windows below only cover the one case attribution can't: a write that
+  // carries neither id.
   //   DEBOUNCE     — one gesture (place a node, drag a column) fans out into several
   //                  events; wait for the board to fall quiet, then send a single turn.
   //   MAX_WAIT     — cap on that quiet period: a board someone keeps editing never falls
   //                  quiet, and the debounce alone would slide forever.
-  //   ECHO_WINDOW  — how long after a turn its own writes are expected back; changes in
-  //                  that window are labelled, and the next turn waits it out.
+  //   ECHO_WINDOW  — how long after a turn its own writes are expected back; an
+  //                  *unattributed* change in that window is labelled a possible echo, and
+  //                  the next turn waits it out so a write and its echo don't each get one.
   //   MIN_INTERVAL — a floor between self-directed turns, so a mistake upstream can't
   //                  become a self-feeding loop burning tokens unattended. Doubles per
   //                  consecutive NOOP up to BACKOFF_CAP, and resets as soon as a turn
@@ -2077,10 +2087,11 @@ async function runModeling(kitDir, projectDir, { verbose = false, standalone = f
   const STANDALONE_BACKOFF_CAP_MS = envMs('EVENTMODELERS_STANDALONE_BACKOFF_CAP_MS', 15 * 60_000);
   const STANDALONE_IDLE_MS = envMs('EVENTMODELERS_STANDALONE_IDLE_MS', 15 * 60_000);
 
-  // node_id (or '(board)') -> { types: Set<string>, count: number, maybeOwn: boolean }
-  // for everything seen since the last self-directed turn. `maybeOwn` stays true only
-  // while every event for that node arrived while a turn was running or inside the echo
-  // window — one event from outside that window and the node is a real change again.
+  // node_id (or '(board)') -> { types: Set<string>, count, own, other, maybe } for
+  // everything seen since the last self-directed turn, each event counted into exactly one
+  // origin bucket: `own` = attributed to this agent's own id, `other` = attributed to a human
+  // or another agent, `maybe` = carries no attribution at all and landed inside the echo
+  // window, so it *might* be this agent's. Only `maybe` is a guess.
   const observed = new Map();
   let observedCount = 0;
   let seqLo = null;
@@ -2097,6 +2108,16 @@ async function runModeling(kitDir, projectDir, { verbose = false, standalone = f
     return Math.min(STANDALONE_MIN_INTERVAL_MS * 2 ** noopStreak, STANDALONE_BACKOFF_CAP_MS);
   }
 
+  // Empties the buffer — every field of it, which is why it is one function and not five
+  // lines repeated at each place a burst stops being pending.
+  function resetObserved() {
+    observed.clear();
+    observedCount = 0;
+    seqLo = null;
+    seqHi = null;
+    firstObservedAt = 0;
+  }
+
   function onBoardEvent(type, payload) {
     if (!standalone) {
       if (verbose) log(`board event ${type} dropped — not running with --standalone`);
@@ -2107,12 +2128,26 @@ async function runModeling(kitDir, projectDir, { verbose = false, standalone = f
     // The warm-up turn is read-only, so a change that lands while it runs is somebody
     // else's — labelling it "possibly your own write" would only teach the agent to
     // discount the very edits it just came up to work on.
-    const maybeOwn = (!!pending && !warmingUp) || draining || inEchoWindow;
+    const guessOwn = (!!pending && !warmingUp) || draining || inEchoWindow;
+    // Attribution beats the clock in both directions. `agent_id === ours` is this agent's own
+    // write, certainly, whenever it comes back. Any *other* id — a person's user_id, another
+    // agent's — is certainly not ours, which is the half the timer used to get wrong: a human
+    // editing while this agent worked had their change written off as an echo of it.
+    const writerAgent = payload?.agent_id || null;
+    const writerUser = payload?.user_id || null;
+    const origin =
+      writerAgent && cfg.agentId && writerAgent === cfg.agentId
+        ? 'own'
+        : writerAgent || writerUser
+          ? 'other'
+          : guessOwn
+            ? 'maybe'
+            : 'other';
     const nodeId = payload?.node_id ?? '(board)';
-    const entry = observed.get(nodeId) ?? { types: new Set(), count: 0, maybeOwn };
+    const entry = observed.get(nodeId) ?? { types: new Set(), count: 0, own: 0, other: 0, maybe: 0 };
     entry.types.add(type);
     entry.count += 1;
-    if (!maybeOwn) entry.maybeOwn = false;
+    entry[origin] += 1;
     observed.set(nodeId, entry);
     observedCount += 1;
     if (!firstObservedAt) firstObservedAt = Date.now();
@@ -2121,7 +2156,17 @@ async function runModeling(kitDir, projectDir, { verbose = false, standalone = f
       if (seqLo === null || seq < seqLo) seqLo = seq;
       if (seqHi === null || seq > seqHi) seqHi = seq;
     }
-    log(`board change: ${type} node=${nodeId}${Number.isFinite(seq) ? ` seq=${seq}` : ''}${maybeOwn ? ' (maybe own write)' : ''}`);
+    const writtenBy =
+      origin === 'own'
+        ? ' — own write'
+        : origin === 'maybe'
+          ? ' — unattributed, maybe own write'
+          : writerUser
+            ? ' — by a person'
+            : writerAgent
+              ? ` — by agent ${writerAgent.slice(0, 8)}`
+              : '';
+    log(`board change: ${type} node=${nodeId}${Number.isFinite(seq) ? ` seq=${seq}` : ''}${writtenBy}`);
     armStandaloneTurn(nextDelayMs());
   }
 
@@ -2186,10 +2231,17 @@ async function runModeling(kitDir, projectDir, { verbose = false, standalone = f
     'nothing, change nothing and reply <promise>NOOP</promise>.';
 
   function buildStandaloneTurn() {
-    const lines = [...observed.entries()].map(
-      ([nodeId, entry]) =>
-        `- ${nodeId}: ${[...entry.types].join(', ')} (${entry.count}×)${entry.maybeOwn ? ' — possibly your own earlier write' : ''}`,
-    );
+    const lines = [...observed.entries()].map(([nodeId, entry]) => {
+      const origin =
+        entry.own === entry.count
+          ? ' — YOUR OWN earlier write, echoed back'
+          : entry.own
+            ? ` — ${entry.own} of ${entry.count} are YOUR OWN earlier writes, the rest are not`
+            : entry.maybe === entry.count
+              ? ' — unattributed, possibly your own earlier write'
+              : '';
+      return `- ${nodeId}: ${[...entry.types].join(', ')} (${entry.count}×)${origin}`;
+    });
     const header = [
       'BOARD_CHANGE',
       `board_id=${cfg.boardId}`,
@@ -2238,6 +2290,15 @@ async function runModeling(kitDir, projectDir, { verbose = false, standalone = f
 
   async function dispatchStandaloneTurn({ idle = false } = {}) {
     if (!idle && !observed.size) return;
+    // Every buffered event is provably this agent's own write coming back — attribution says
+    // so, not a timer. There is nothing new on the board, so it costs no turn; if the board
+    // then stays quiet the idle review still comes around.
+    if (!idle && [...observed.values()].every((entry) => entry.own === entry.count)) {
+      log(`standalone turn skipped: ${observedCount} board event(s) on ${observed.size} node(s), all own writes`);
+      resetObserved();
+      armIdleReview();
+      return;
+    }
     // A direct message always outranks the agent's own initiative — re-arm instead of
     // queueing behind the prompt lane, so the buffer just keeps collecting meanwhile.
     if (pending || draining) {
@@ -2255,17 +2316,20 @@ async function runModeling(kitDir, projectDir, { verbose = false, standalone = f
     if (idle) {
       log(`standalone review turn: board quiet for ${Math.round(STANDALONE_IDLE_MS / 1000)}s`);
     } else {
-      const ownOnly = [...observed.values()].every((entry) => entry.maybeOwn);
+      const totals = [...observed.values()].reduce(
+        (acc, entry) => ({ own: acc.own + entry.own, maybe: acc.maybe + entry.maybe }),
+        { own: 0, maybe: 0 },
+      );
+      const breakdown = [
+        totals.own ? `${totals.own} own` : null,
+        totals.maybe ? `${totals.maybe} unattributed` : null,
+      ].filter(Boolean);
       log(
         `standalone turn: ${observedCount} board event(s) on ${observed.size} node(s)` +
-          `${ownOnly ? ' (all possibly own writes)' : ''}`,
+          `${breakdown.length ? ` (${breakdown.join(', ')})` : ''}`,
       );
     }
-    observed.clear();
-    observedCount = 0;
-    seqLo = null;
-    seqHi = null;
-    firstObservedAt = 0;
+    resetObserved();
     lastStandaloneAt = Date.now();
     try {
       const result = await runClaudeWarm(text);

package/package.json

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

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

@@ -881,7 +881,7 @@ Set a prompt's status, optionally attaching a progress comment. Auth: `x-token`
 ```
 
 **Response**: `200` — the updated row
-**Errors**: `400` invalid/missing `status` · `403` token not for this prompt's org · `404` prompt not found
+**Errors**: `400` invalid/missing `status` · `403` token not for this prompt's org · `404` prompt not found · `409` (`PROMPT_STATUS_ALREADY_SET`) the prompt already carries that status — another agent already made this transition, so don't retry it
 
 ---
 

package/stacks/modeling-kit/templates/.claude/skills/update-prompt-status/SKILL.md

@@ -52,6 +52,7 @@ Omit `comment` entirely when there isn't one — don't pass an empty string.
 |----------|---------|--------|
 | `400` | `status` missing or not a valid value | Fix the value and retry — do not retry with the same bad value. |
 | `404` | Prompt not found | The prompt may have been deleted by its author while you were working. Report this and move on — do not treat it as a failure of your actual task work. |
+| `409` | The prompt already carries the status you asked for (`PROMPT_STATUS_ALREADY_SET`) | Somebody else — usually another agent working the same queue — already made this transition. Do not retry it; treat the transition as done and carry on. |
 | `401`/`403` | Token invalid or wrong organization | Re-run `connect` to refresh credentials, then retry once. |
 
 ---

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

@@ -199,6 +199,9 @@ Steps:
 
 Keep these turns finished within the turn: wait for the subagents you dispatched, don't leave
 work trailing. Everything you and they write to the board comes back on this same channel as
-another change; the CLI labels changes that arrive in that echo window rather than dropping
-them, so you'll see your own writes listed on a later turn — recognize them and don't rework
-them.
+another change. A burst that is *only* your own writes never becomes a turn at all, so a
+change list you are handed always contains something that isn't yours — but it may still list
+yours alongside it, marked `YOUR OWN earlier write`. Take that mark literally: those lines are
+there for context, not to be reworked. A line marked `unattributed, possibly your own earlier
+write` is the one uncertain case (a write that reached the platform without an agent id);
+anything unmarked was written by someone else and is real work to look at.