@eventmodelers/cli 1.0.70 → 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) |
@@ -416,6 +419,18 @@ npx @eventmodelers/cli run --id <id>                           # pin ONE identit
 
 `run --id` is what you want when an agent has to keep the same identity every time it starts: a supervisor that already knows the id, a second agent of the same type in one *project* (which would otherwise share the project's single minted id), or an agent a board has starred as its **preferred agent** — that star addresses prompts to one id, so an agent whose id changes per run loses it on restart. `run --id`/`run --name` are per-run only: nothing is written to disk.
 
+#### Working only what you were addressed (`--exclusive`)
+
+By default an agent claims two kinds of prompt: the ones addressed to its own id, and every prompt nobody addressed to anyone. That's right for the single agent on a board, and wrong for a dedicated one — a specialist sitting next to a general agent, or an agent a supervisor drives by id, ends up answering whatever the queue happens to hold. `--exclusive` drops that second kind:
+
+```bash
+npx @eventmodelers/cli run --standalone --board-id <uuid> --id <agent-uuid> --exclusive
+```
+
+Only prompts carrying this agent's id are worked. Anything untargeted is handed straight back to the queue (status `ADDED`) for another agent to take — the addressee filter lives in the queue's claim query, which hands an agent its own prompts *and* the untargeted ones, so claiming is the only way to find out which arrived. An exclusive run therefore claims as usual and gives back what wasn't meant for it, once it has walked past it to its own work.
+
+Pair it with `--id`: a `--standalone`/`--global` run mints a fresh id per run, so prompts addressed to the previous run's id are never claimed. `--exclusive` applies to the prompt queue only — a `--standalone` agent's self-directed turns are nobody's prompt, and it keeps taking them.
+
 ### Env vars and `--config` (scripted/CI installs)
 
 Every config field can be set via an `EVENTMODELERS_*` env var instead of the interactive prompts — these always win over whatever's in `config.json`, so a fully env-driven install never prompts for credentials or Claude execution settings:

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));
 }
@@ -1672,7 +1680,13 @@ async function ensureGlobalKit(baseUrl) {
 // question, sketch a screen. Without the flag that channel is still subscribed on
 // the same connection and every event on it is dropped, so the two modes differ by
 // one filter rather than by a whole second realtime stack.
-async function runModeling(kitDir, projectDir, verbose = false, standalone = false, overrides = null, maxAgents = DEFAULT_MAX_AGENTS, identity = {}) {
+//
+// `exclusive` narrows the prompt lane to this agent alone: only a prompt the user
+// addressed to this agent id (the board's "preferred agent") is worked, and anything
+// untargeted is handed straight back to the queue for another agent to take. It says
+// nothing about the standalone lane — a self-directed turn is nobody's task, so an
+// exclusive standalone agent still works the board on its own initiative.
+async function runModeling(kitDir, projectDir, { verbose = false, standalone = false, exclusive = false, overrides = null, maxAgents = DEFAULT_MAX_AGENTS, identity = {} } = {}) {
   const configLibPath = join(kitDir, 'lib', 'config.js');
   if (!existsSync(configLibPath)) {
     console.error(`❌ ${relative(process.cwd(), configLibPath)} not found — --modeling needs a kit installed via \`init --modeling\`.`);
@@ -1710,6 +1724,12 @@ async function runModeling(kitDir, projectDir, verbose = false, standalone = fal
     console.error('❌ --modeling needs a boardId — a modeling agent always runs for exactly one board. Run `/connect board=<uuid>` once, or add boardId to .eventmodelers/config.json.');
     process.exit(1);
   }
+  // Nothing can be addressed to an agent with no id, so an exclusive run without one would
+  // hand every prompt back and sit idle forever — a silent no-op worth failing on instead.
+  if (exclusive && !cfg.agentId) {
+    console.error('❌ --exclusive needs an agent id — that is what a prompt is addressed to. Pass `run --id <uuid>` (or let the kit mint one) and address the prompt to it on the board.');
+    process.exit(1);
+  }
 
   const subagentModel = cfg.subagentModel || DEFAULT_SUBAGENT_MODEL;
 
@@ -1928,6 +1948,13 @@ async function runModeling(kitDir, projectDir, verbose = false, standalone = fal
       ? `standalone: ON — reacting to direct prompts AND to board changes on its own initiative (max ${maxAgents} subagent(s) per self-directed turn)`
       : 'standalone: off — reacting to direct prompts only (board changes are dropped)',
   );
+  if (exclusive) {
+    log(`exclusive: ON — only prompts addressed to ${cfg.agentId} are worked; every untargeted prompt is handed back to the queue`);
+    // A global/standalone run mints its id per run (see resolveModelingCredentials), so an id
+    // someone addressed a prompt to yesterday is not this agent — worth saying out loud here,
+    // where the alternative is an agent that looks healthy and quietly works nothing.
+    if (overrides && !identity.agentId) log('exclusive: this run minted a fresh agent id — star it on the board now, or restart with `--id <uuid>` to keep one addressable identity');
+  }
   warmUpSession();
 
   async function getRealtimeToken() {
@@ -1947,15 +1974,47 @@ async function runModeling(kitDir, projectDir, verbose = false, standalone = fal
     return res.json();
   }
 
+  // Puts a prompt this agent claimed but will not work back on the queue (CLAIMED -> ADDED),
+  // so whichever agent it was actually open to can still take it. `x-token` only — the status
+  // endpoint is meant to be called by the agent holding the prompt.
+  async function releasePrompt(promptId) {
+    const res = await fetch(`${cfg.baseUrl}/api/org/${cfg.organizationId}/prompts/${promptId}/status`, {
+      method: 'POST',
+      headers: { 'x-token': cfg.token, 'Content-Type': 'application/json', ...agentHeaders(cfg) },
+      body: JSON.stringify({ status: 'ADDED' }),
+    });
+    if (!res.ok) throw new Error(`prompts/${promptId}/status: HTTP ${res.status}`);
+  }
+
   let realtimeToken = await getRealtimeToken();
 
   let draining = false;
   async function drain() {
     if (draining) return;
     draining = true;
+    // --exclusive only: prompts claimed in this pass that weren't addressed to this agent,
+    // handed back once the pass is over (see below).
+    const handBack = [];
     try {
       let p;
       while ((p = await fetchNextPrompt(realtimeToken)) !== null) {
+        // The queue can't filter by addressee for us: `prompts/next` hands an agent both the
+        // prompts addressed to it and every untargeted one (`agent_id IS NULL`) — claiming is
+        // what reveals which kind arrived — so an exclusive run claims as usual and gives back
+        // what wasn't meant for it.
+        //
+        // The hand-back is deferred to the end of the pass on purpose: a prompt released
+        // mid-loop goes straight back to the head of the very queue this loop is reading, so
+        // the next fetch would return the prompt just released instead of the addressed one
+        // queued behind it, and the agent would never reach its own work. Holding them CLAIMED
+        // until the queue runs dry walks past them instead. The cost is a brief CLAIMED blip on
+        // someone else's prompt, and — if no other agent happens to be draining when the
+        // hand-back lands — that prompt waiting for the next `prompt:created` to be noticed.
+        if (exclusive && (p.agent_id ?? null) !== cfg.agentId) {
+          log(`prompt ${p.id} ${p.agent_id ? `is addressed to agent ${p.agent_id}` : 'is addressed to no agent'} — handing it back (--exclusive)`);
+          handBack.push(p.id);
+          continue;
+        }
         log(`prompt received: "${p.prompt}" (board=${p.board_id ?? cfg.boardId ?? 'n/a'}, priority=${p.priority})`);
         try {
           await runClaudeWarm(buildTurn(p));
@@ -1964,6 +2023,16 @@ async function runModeling(kitDir, projectDir, verbose = false, standalone = fal
         }
       }
     } finally {
+      for (const id of handBack) {
+        try {
+          await releasePrompt(id);
+        } catch (err) {
+          // Left CLAIMED, which is worse for whoever sent it than a retry would be — but
+          // retrying here risks wedging the loop, and the next pass claims nothing new
+          // while this one is still unwinding. Say so and move on.
+          log(`handing prompt ${id} back failed, it stays CLAIMED: ${err.message}`);
+        }
+      }
       draining = false;
       // A prompt turn counts as activity: the board isn't idle just because nobody edited
       // it while the agent was busy answering someone.
@@ -1983,20 +2052,22 @@ async function runModeling(kitDir, projectDir, verbose = false, standalone = fal
   // 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
@@ -2016,10 +2087,11 @@ async function runModeling(kitDir, projectDir, verbose = false, standalone = fal
   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;
@@ -2036,6 +2108,16 @@ async function runModeling(kitDir, projectDir, verbose = false, standalone = fal
     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`);
@@ -2046,12 +2128,26 @@ async function runModeling(kitDir, projectDir, verbose = false, standalone = fal
     // 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();
@@ -2060,7 +2156,17 @@ async function runModeling(kitDir, projectDir, verbose = false, standalone = fal
       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());
   }
 
@@ -2125,10 +2231,17 @@ async function runModeling(kitDir, projectDir, verbose = false, standalone = fal
     '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}`,
@@ -2177,6 +2290,15 @@ async function runModeling(kitDir, projectDir, verbose = false, standalone = fal
 
   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) {
@@ -2194,17 +2316,20 @@ async function runModeling(kitDir, projectDir, verbose = false, standalone = fal
     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);
@@ -2806,6 +2931,7 @@ credentialFlags(program
   .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('--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.')
   .option('--global', 'Run the modeling agent from the global install (~/.eventmodelers/kit), initializing it on first use, and ignore any kit in this directory. This is also what --modeling/--standalone fall back to on their own when nothing is installed here — pass it explicitly to prefer the global install over a local one. Credentials come from the flags below, EVENTMODELERS_* env vars, or ~/.eventmodelers/boards/<board>.json, so nothing is written into the current directory.')
   .option('--local', 'Skip platform config/credential lookup entirely and run the local-only loop (no board sync, no realtime agent) — even if .eventmodelers/config.json has credentials (build-kit stacks only)')
   .option('--verbose', 'Log every tool call\'s full input (commands, skill args, file paths) and assistant reasoning text. Default is condensed, high-level per-step logging only.')
@@ -2822,6 +2948,11 @@ credentialFlags(program
     if (command.getOptionValueSource('maxAgents') === 'cli' && !opts.standalone) {
       console.log('ℹ️  --max-agents only applies to --standalone turns; ignoring it here.');
     }
+    // The build-kit runners claim their work from the same queue but have no addressee
+    // filter, so the flag would silently do nothing there rather than half of what it says.
+    if (opts.exclusive && !(opts.modeling || opts.standalone || opts.global)) {
+      console.log('ℹ️  --exclusive only applies to the modeling loop (--modeling/--standalone/--global); ignoring it here.');
+    }
     // --id/--name are what the platform will see for this run, so a blank one is a
     // mistake worth failing on rather than silently falling back to the stored identity.
     const identity = {
@@ -2902,7 +3033,7 @@ credentialFlags(program
       const shown = relative(cwd, kitDir);
       await new Promise((res) => process.stdout.write(`▶ Starting modeling loop (warm Claude process) for ${shown && !shown.startsWith('..') ? shown : kitDir}...\n\n`, res));
       try {
-        await runModeling(kitDir, projectDir, !!opts.verbose, !!opts.standalone, overrides, maxAgents, identity);
+        await runModeling(kitDir, projectDir, { verbose: !!opts.verbose, standalone: !!opts.standalone, exclusive: !!opts.exclusive, overrides, maxAgents, identity });
       } catch (err) {
         console.error('[modeling] Fatal:', err);
         process.exit(1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eventmodelers/cli",
-  "version": "1.0.70",
+  "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

@@ -860,6 +860,8 @@ Claim the next pending (`ADDED`) prompt for a board — atomically flips it to `
 
 Send `x-agent-id` here too: a prompt the user addressed to one preferred agent (`prompts.agent_id`) is only ever handed to the agent claiming with that id, and a caller without the header claims untargeted prompts only. Addressing one is `POST /api/org/:orgId/prompts` with `agent_id: "<uuid>"` — the board's prompts panel does it when someone stars an agent.
 
+Note what this endpoint does *not* do: an agent that sends its id still gets every untargeted prompt on top of its own. A caller that wants only what was addressed to it has to hand the rest back itself (`POST /prompts/:id/status` with `status: 'ADDED'`), which is what `eventmodelers run --exclusive` does.
+
 **Query params**: `board_id` (required)
 **Response**: `200` — the claimed row (now `status: "CLAIMED"`), including its parsed `context` and the `hidden` flag · `404` — no `ADDED` prompts available
 
@@ -879,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.