@eventmodelers/cli 2.0.51 → 2.0.54

package/cli.js

@@ -42,9 +42,9 @@ 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 { clearLog, prunableEvents, pruneLog, rememberPruneAnswer, shouldOfferPrune } from './shared/build-kit/lib/event-prune.js';
 import { fold } from './shared/build-kit/lib/slice-state.js';
 import { filterEvents, baselineIds, formatEvent, formatPayload, sliceTitles, summarize } from './shared/build-kit/lib/events-view.js';
 import { stableGlobalAgentId } from './lib/global-agent-id.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);
       }
@@ -5489,6 +5508,9 @@ program
   .option('--verbose', 'Print each event\'s payload under its line — for a tool call, the input it was sent (recorded by runs started with --verbose). Also shows the baseline events: the kit\'s first look at each slice (a fresh kit records every slice already on the board), which are hidden by default. `--type board-observed` and `--json` show them too.')
   .option('--state', 'Print the state the log folds to (slices, queue, open prompts, learnings) instead of the events')
   .option('--prune', 'Delete the events nothing reads any more — the journal of finished prompts — and stop. Slice state, learnings and open prompts are kept; the same prune a run offers at every 1000 events.')
+  .option('--clear', "Delete the whole log, state included, so the kit starts over (it looks at the board again; attempt counts, blocks and failure history are gone). Lists what it would delete and stops unless --yes is given. Refuses while a run holds a claim, unless --force.")
+  .option('--yes', 'With --clear: really delete')
+  .option('--force', 'With --clear: delete even while a run holds a claim')
   .option('--follow', 'Keep running and print events as they are appended')
   .option('--watch', 'Same as --follow')
   .action(async (opts) => {
@@ -5502,6 +5524,19 @@ program
     const prototypeLog = join(cwd, '.prototype');
     const inPrototype = !opts.global && !opts.kit && !findInstalledKitDir(cwd) && existsSync(join(prototypeLog, 'events.log'));
     const kitDir = opts.global ? globalLog : opts.kit ? resolve(cwd, opts.kit) : inPrototype ? prototypeLog : requireBuildKitDir(cwd);
+    if (opts.clear) {
+      try {
+        const where = relative(cwd, kitDir) || kitDir;
+        const { removed } = clearLog(kitDir, { force: opts.force, dryRun: !opts.yes });
+        console.log(opts.yes
+          ? `Cleared ${removed} events from ${where}.`
+          : `Would delete all ${removed} events from ${where} — state included. Nothing was deleted; run again with --yes to do it.`);
+      } catch (err) {
+        console.error(`❌ ${err.message}`);
+        process.exit(1);
+      }
+      return;
+    }
     if (opts.prune) {
       try {
         const { removed, kept } = pruneLog(kitDir);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eventmodelers/cli",
-  "version": "2.0.51",
+  "version": "2.0.54",
   "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/event-prune.js

@@ -7,8 +7,9 @@
 import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'fs';
 import { isDeepStrictEqual } from 'util';
 import { join } from 'path';
-import { EVENTS_DIR, INDEX_FILE, readEvents } from './slice-events.js';
+import { EVENTS_DIR, INDEX_FILE, SEQ_FILE, readEvents } from './slice-events.js';
 import { fold } from './slice-state.js';
+import { isProcessAlive } from './slice-run.js';
 
 export const PRUNE_EVERY = 1000;
 const ASKED_FILE = '.prune-asked'; // inside events/, which readEvents never lists and the kit's git rules already cover
@@ -40,6 +41,24 @@ export function pruneLog(kitDir) {
   return { removed: doomed.size, kept: rest.length };
 }
 
+// Deletes the whole log — every event, state included — so the kit starts over as if freshly installed: it looks at
+// the board again and every slice's attempt count, block and failure history is gone. Refuses while a live process
+// holds a claim (its build would end without a trace) unless `force`. Returns { removed, liveClaims }; with
+// `dryRun` nothing is deleted.
+export function clearLog(kitDir, { force = false, dryRun = false } = {}) {
+  const events = readEvents(kitDir);
+  const liveClaims = Object.entries(fold(events).slices)
+    .filter(([, s]) => s.claim && isProcessAlive(s.claim.pid))
+    .map(([id, s]) => s.claim.title ?? id);
+  if (liveClaims.length && !force) throw new Error(`a run is building ${liveClaims.join(', ')} — stop it first, or pass --force`);
+  if (dryRun) return { removed: events.length, liveClaims };
+  const dir = join(kitDir, EVENTS_DIR);
+  rmSync(dir, { recursive: true, force: true });
+  rmSync(join(kitDir, INDEX_FILE), { force: true });
+  rmSync(join(kitDir, SEQ_FILE), { force: true });
+  return { removed: events.length, liveClaims };
+}
+
 // Asked when the log has reached a multiple of PRUNE_EVERY it has not been asked at yet — 1000, then 2000, … — so a
 // "no" is not repeated on every start. `remember` records the size the answer was given at.
 const askedPath = (kitDir) => join(kitDir, EVENTS_DIR, ASKED_FILE);

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})`);
   }