@eventmodelers/cli 2.0.3 → 2.0.5

package/cli.js

@@ -3863,8 +3863,10 @@ credentialFlags(program
         }
         // Asked once, for the kit in this directory (the first one found when there is none), and
         // handed to the others — the modeling agent reads this directory's config.
-        const rootDir = dirs.find((dir) => dirname(dir) === cwd) ?? dirs[0];
-        console.log(`\n🔑 Credentials for ${relative(cwd, rootDir) || '.'}, shared by all`);
+        // With no build kit (--modeling alone), the credentials belong to this directory itself:
+        // a kit dir that need not exist, since only its parent is used.
+        const rootDir = dirs.find((dir) => dirname(dir) === cwd) ?? dirs[0] ?? join(cwd, '.agent-modeling-kit');
+        console.log(`\n🔑 Credentials for ${dirs.length ? relative(cwd, rootDir) || '.' : 'the modeling agent'}, shared by all`);
         const { organizationId, boardId, token, baseUrl } = await forceBuildKitCredentials(rootDir, cwd, opts, globalOpts);
         for (const dir of dirs.filter((d) => d !== rootDir)) {
           await forceBuildKitCredentials(dir, cwd, opts, globalOpts, { organizationId, boardId, token, baseUrl });
@@ -5154,5 +5156,12 @@ program
     }
   });
 
-await program.parseAsync();
+try {
+  await program.parseAsync();
+} catch (err) {
+  // A bug or bad input must end as one readable line, not a Node stack trace.
+  console.error(`❌ ${err?.message ?? err}`);
+  if (process.env.EVENTMODELERS_DEBUG && err?.stack) console.error(err.stack);
+  process.exitCode = 1;
+}
 if (sharedRl) sharedRl.close();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eventmodelers/cli",
-  "version": "2.0.3",
+  "version": "2.0.5",
   "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/build-log-share.js

@@ -5,7 +5,7 @@
 //               log, each carrying the slice, the iteration id, the board, the org and the date — and a
 //               `slice-done` after an iteration that settled the slice as Done. Always on.
 //   sync        with --sync, the events that name a slice are uploaded to POST …/boards/:boardId/buildlog,
-//               numbered (the event's own `seq`, which defines the order) and tagged with the kit type (backend, or ui for a kit that picks up from Waiting) —
+//               numbered (only while the slice has an iteration open — an agent records only when it is active; the event's own `seq`, which defines the order) and tagged with the kit type (backend, or ui for a kit that picks up from Waiting) —
 //               constantly, on a short interval for as long as the loop runs, so a live dashboard follows the
 //               build, and once more at the start and end of each iteration.
 //
@@ -21,6 +21,8 @@ import { statusKey } from './slice-state.js';
 
 export const SYNC_STATE_FILE = 'build-log-sync.json';
 export const SYNC_INTERVAL_MS = 2_000;
+// Always shared, even with no iteration open: they are what opens and closes one.
+const BOUNDARY = new Set(['iteration-started', 'iteration-closed', 'slice-done']);
 const NOOP = { iterationStarted: () => null, iterationClosed: () => {}, flush: async () => {}, start: () => {}, stop: () => {} };
 
 function readState(path) {
@@ -61,8 +63,13 @@ export function createBuildLogShare({ kitDir, cfg, meta, agentType = 'BUILD', ki
     const entries = [];
     for (const e of fresh) {
       if (!e.slice) continue;
+      // An agent records only while it is active: events of a slice with no iteration open are not shared. The kit mirrors
+      // every slice's board status as `board-observed`, whether or not it is working on it — that is not the agent's work.
+      // The boundaries themselves (the iteration's start and end, and slice-done after it) always are.
+      if (!iterations[e.slice] && !BOUNDARY.has(e.type)) continue;
       if (e.type === 'iteration-started') iterations[e.slice] = e.iteration;
       entries.push(toBuildLogEntry(e, { agentId: cfg.agentId, iteration: e.iteration ?? iterations[e.slice], boardId: cfg.boardId, organizationId: cfg.organizationId, kitType, seq: e.seq }));
+      if (e.type === 'iteration-closed') delete iterations[e.slice];
     }
     if (entries.length) {
       const res = await fetch(`${cfg.baseUrl}/api/org/${cfg.organizationId}/boards/${cfg.boardId}/buildlog`, {

package/shared/build-kit/lib/ralph.js

@@ -364,7 +364,7 @@ async function fetchFullSlice(cfg, kitDir, sliceId) {
 }
 
 async function handleSliceChanged(payload, cfg, kitDir) {
-  console.log(`[agent] slice:changed — slice="${payload.sliceTitle}" status="${payload.sliceStatus}"`);
+  console.log(`[agent] slice:changed — slice="${payload.sliceTitle ?? payload.sliceId}" status="${payload.sliceStatus}"`);
   // This agent's own status writes (claim → InProgress, → Done, → Blocked) come straight back
   // as slice:changed. Queuing them only buys a turn in which the agent reads its own echo and
   // skips it, and re-reading the slices for them is wasted too: ralphLoop re-reads them right
@@ -372,7 +372,7 @@ async function handleSliceChanged(payload, cfg, kitDir) {
   // is dropped — a person's edit or another agent's, or an event with no attribution at all,
   // is still handled, so a missing field degrades to queuing rather than losing work.
   if (payload?.agentId && cfg.agentId && payload.agentId === cfg.agentId) {
-    console.log(`[agent] Own write — not queued (slice="${payload.sliceTitle}" status="${payload.sliceStatus}")`);
+    console.log(`[agent] Own write — not queued (slice="${payload.sliceTitle ?? payload.sliceId}" status="${payload.sliceStatus}")`);
     return;
   }
   await fetchAndPersistSlices(cfg, kitDir).catch((err) =>
@@ -383,7 +383,7 @@ async function handleSliceChanged(payload, cfg, kitDir) {
   if (statusKey(payload.sliceStatus) !== statusKey(readPickupStatus(kitDir))) {
     try {
       queueTask({ kitDir, payload, meta: eventMeta(cfg) });
-      console.log(`[agent] Task queued — slice="${payload.sliceTitle}" status="${payload.sliceStatus}"`);
+      console.log(`[agent] Task queued — slice="${payload.sliceTitle ?? payload.sliceId}" status="${payload.sliceStatus}"`);
     } catch (err) {
       console.error('[agent] queueTask error:', err);
     }
@@ -824,9 +824,12 @@ async function ralphLoop(kitDir, cfg, onTask, onPlannedSlice, localOnly = false,
 
       const prompt = readFileSync(backendPromptFile, 'utf-8') + taskRequest(planned, cfg, readPickupStatus(kitDir));
       if (credentialed) await fetchFullSlice(cfg, kitDir, planned.id);
+      // The iteration opens first, so the claim (→ InProgress) is part of what the board's build log shows.
+      if (planned.id) share.iterationStarted(planned);
       if (planned.id) {
         const claimed = await claimSlice({ kitDir, planned, board, meta, cleanTree: isTreeClean(kitDir), pickupStatus: readPickupStatus(kitDir) });
         if (claimed !== 'won') {
+          await share.iterationClosed(planned, 'skipped');
           console.log(claimed === 'held'
             ? `[ralph] Another run loop holds "${planned.title}" in this kit — waiting.`
             : `[ralph] Could not claim "${planned.title}" — skipping it this iteration.`);
@@ -836,7 +839,6 @@ async function ralphLoop(kitDir, cfg, onTask, onPlannedSlice, localOnly = false,
         }
       }
       lastReply = null;
-      if (planned.id) share.iterationStarted(planned);
       const built = await runWithRetry(`onPlannedSlice: building slice "${planned.title}"...`, async () => { lastReply = await onPlannedSlice(prompt, {
         sliceId: planned.id,
         sliceTitle: planned.title,
@@ -869,7 +871,7 @@ async function ralphLoop(kitDir, cfg, onTask, onPlannedSlice, localOnly = false,
 
 // ── Public API ────────────────────────────────────────────────────────────────
 
-export { HttpError, loadLocalConfig, fetchPlatformConfig, retryTransient, startRealtimeAgent, ensureLearningsGitRules };
+export { HttpError, eventMeta, loadLocalConfig, fetchPlatformConfig, retryTransient, startRealtimeAgent, ensureLearningsGitRules };
 
 // The connect line a runner puts in front of every prompt. --local must mean zero board
 // contact, so it is empty then — handed live credentials, the agent would treat itself as

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

@@ -0,0 +1,17 @@
+// 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 { redactString } from './redact.js';
+
+// Best effort, like the rest of the sharing: a failed write must not cost the build. `detail` is the one-line
+// account of the call's input, with the token and anything JWT-shaped masked — a Bash command can hold
+// credentials, and this log is shared. Only a planned-slice build (`slice.sliceId`) records anything.
+export function recordToolCall({ kitDir, slice, tool, detail, cfg, meta }) {
+  if (!slice?.sliceId) return;
+  try {
+    appendEvent(kitDir, { type: 'tool-call', slice: slice.sliceId, tool, detail: redactString(detail, [cfg?.token]) }, meta);
+  } catch (err) {
+    console.error(`[ralph] could not record a tool call (${err.message})`);
+  }
+}

package/shared/build-kit/ralph-claude.js

@@ -2,9 +2,10 @@
 // Ralph loop + realtime agent using Claude Code as the executor.
 // Usage: node ralph-claude.js [project_dir]
 
-import { startRalph, loadLocalConfig, resolveAgentIdentity, connectHeader } from './lib/ralph.js';
+import { startRalph, eventMeta, loadLocalConfig, resolveAgentIdentity, connectHeader } from './lib/ralph.js';
 import { createSliceTracer, usageFromClaudeResult } from './lib/tracing.js';
 import { turnTimeoutMs, superviseTurn } from './lib/turn.js';
+import { recordToolCall } from './lib/tool-call-events.js';
 import { spawn } from 'child_process';
 import { dirname, join, resolve } from 'path';
 import { fileURLToPath } from 'url';
@@ -106,6 +107,7 @@ function runClaude(prompt, slice = null, extraEnv = {}) {
           for (const block of msg.message?.content ?? []) {
             if (block.type === 'text' && block.text && verbose) console.log(block.text);
             if (block.type === 'tool_use') {
+              recordToolCall({ kitDir, slice, tool: block.name, detail: describeToolUse(block), cfg, meta: eventMeta(cfg) });
               if (verbose) console.log(`→ ${describeToolUse(block)}`);
               else if (block.name === 'Skill') console.log(`→ Skill: ${block.input?.skill ?? ''}`);
               else console.log(`→ ${block.name}`);