@eventmodelers/cli 2.0.51 → 2.0.53

package/cli.js

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

package/package.json

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

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

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

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

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

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

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

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

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