@eventmodelers/cli 2.0.2 → 2.0.4

package/README.md

@@ -166,6 +166,7 @@ npx @eventmodelers/cli run --agent <name>           # pick the agent: claude (de
 npx @eventmodelers/cli run --agent <name> --model <id>  # …on a given model: -m for opencode/codex/gemini, --model for Claude, LOCAL_AI_MODEL for --local-ai
 npx @eventmodelers/cli run --exec "<command>"        # manual fallback for any other harness (ralph-exec.js) — agent tracing needs its JSON flag, e.g. "codex exec --json --full-auto"
 npx @eventmodelers/cli run --local                  # skip platform config/credential lookup entirely — local-only, no board sync
+npx @eventmodelers/cli run --sync                   # share this build agent's event log with the board, constantly, for a live dashboard (see agent-build-log.md)
 npx @eventmodelers/cli run --modeling               # modeling-kit: warm Claude process driven by the board's prompt queue
 npx @eventmodelers/cli run --standalone             # same, plus acting on board changes unprompted — and needs no install at all
 npx @eventmodelers/cli run --standalone --board-id <uuid>  # …from any directory, against any board (see Power users)

package/cli.js

@@ -46,6 +46,7 @@ import { filterEvents, baselineIds, formatEvent, formatPayload, sliceTitles, sum
 import { stableGlobalAgentId } from './lib/global-agent-id.js';
 import { ensureLearningsGitRules } from './shared/build-kit/lib/ralph.js';
 import { createCallTracker, heldPromptsRequest, journalPromptAction, shouldJournalCall, journalPromptFinished, journalPromptReceived, recoverOwnPrompts } from './shared/build-kit/lib/prompt-journal.js';
+import { INFO_KINDS, infoComment, recordInfo, recordTurnInfos } from './shared/build-kit/lib/slice-info.js';
 import { listLearnings, mergeLearnings, recordLearning, recordTurnLearnings, retractLearning, syncLearnings } from './shared/build-kit/lib/slice-learnings.js';
 
 const __filename = fileURLToPath(import.meta.url);
@@ -2681,15 +2682,18 @@ async function runModeling(kitDir, projectDir, { codeDir = null, verbose = false
         try {
           turnPromptId = p.id;
           const reply = await runTurn(buildTurn(p));
-          // The agent cannot run `learn` (locked-down Bash), so it states learnings in its reply and they are recorded here.
-          // Best effort: a failed write never takes the prompt queue down.
-          if (keepsRecord) {
-            try {
+          // The agent cannot run `learn` or `info` (locked-down Bash), so it states them in its reply and they are recorded here.
+          // Best effort: a failed write never takes the prompt queue down. Infos are events stamped with their board, so every
+          // run records them — standalone included; learnings are kept only where `keepsRecord` (they feed AGENTS.md).
+          try {
+            if (keepsRecord) {
               const n = recordTurnLearnings({ kitDir, reply, meta: journalMeta });
               if (n) log(`recorded ${n} learning${n === 1 ? '' : 's'} from the turn`);
-            } catch (err) {
-              log(`could not record the turn's learnings: ${err.message}`);
             }
+            const infos = recordTurnInfos({ kitDir, reply, meta: journalMeta });
+            if (infos) log(`recorded ${infos} info event${infos === 1 ? '' : 's'} from the turn`);
+          } catch (err) {
+            log(`could not record the turn's learnings or infos: ${err.message}`);
           }
           journal(() => journalPromptFinished({ kitDir, id: p.id, outcome: 'worked', meta: journalMeta }));
         } catch (err) {
@@ -3826,6 +3830,7 @@ credentialFlags(program
   .option('--browser', 'Give the locked-down modeling agent a browser: the Playwright MCP server (npx @playwright/mcp) next to the eventmodelers one, for discover-storyboard. Off by default because a browser can reach any site, which the lockdown otherwise rules out. Default Claude runner only; --dangerously-skip-permissions already loads every MCP server the machine configures.')
   .option('--handover', 'Backend build kit: for this run only, finish slices that have a UI at `Waiting` instead of `Done` (same as the project setting `handover: true`, which `init --handover` / `config --handover on` save — this flag writes nothing). Without it the project setting applies; without both, slices end at `Done`.')
   .option('--status-trigger <status>', 'Build kit: the slice status the agent picks work up from, for this run only (e.g. Ready, Planned, Waiting). Defaults to the kit\'s own pickup status — `Planned` for backend kits, `Handover` for the UI kits. Nothing is written to disk.')
+  .option('--sync', 'Build kit: share this agent\'s event log with the board — events that name a slice are uploaded constantly (POST …/buildlog) for a live dashboard. The platform keeps one iteration per slice, 1000 entries at most. A no-op for --modeling/--standalone, and with --local.')
   .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.')
   .option('--id <id>', 'Pin the agent id this run identifies itself with on the platform. Without it an agent keeps one id: a project install per project, a --global/--standalone run per board and repo (the directory it is started in) — the same agent on every restart, with its chat, its star on the board and the prompts it holds. If another live process already runs under that id, this one gets a fresh id instead (two agents must not share a heartbeat row). Pass --id when a supervisor already knows the id you want, or for a second agent on purpose; it is used as given, with no such check. Per-run only: nothing is written to disk.')
   .option('--name <name>', 'A human-readable name for this agent, sent with every heartbeat so the board shows which agent is live rather than a bare uuid (e.g. "ci-builder", "martins-laptop"). Per-run only, like --id: the persistent name is `agentName` in config.json (set via `init --name` / `init-config --name`), and this overrides it for one run without writing anything.')
@@ -3858,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 });
@@ -3949,6 +3956,7 @@ credentialFlags(program
     // no meaning for a build kit, which is scaffolded per project by definition.
     if (opts.modeling || opts.standalone || opts.worker || opts.global) {
       const picked = opts.modeling ? '--modeling' : opts.standalone ? '--standalone' : opts.worker ? '--worker' : '--global';
+      if (opts.sync) console.log(`ℹ️  --sync shares a build agent's log — it does nothing with ${picked}.`);
       // --local-ai and --exec name what does a turn, not a queue, and the modeling loop has its own
       // runner for each (lib/modeling-local-ai.js, lib/modeling-exec.js).
       const modelingLocalAi = resolveLocalAiTarget(opts);
@@ -4114,7 +4122,7 @@ credentialFlags(program
       // path with no stream-json parsing to gate. RALPH_LOCAL is read by ralph.js's startRalph to force
       // the local-only branch even when .eventmodelers/config.json has valid credentials.
       // RALPH_AGENT_ID/RALPH_AGENT_NAME (--id/--name) are read there too.
-      execSync(cmd, { cwd: kitDir, stdio: 'inherit', env: { ...process.env, RALPH_VERBOSE: opts.verbose ? '1' : '', RALPH_LOCAL: opts.local ? '1' : '', RALPH_HANDOVER: opts.handover ? '1' : '', RALPH_STATUS_TRIGGER: opts.statusTrigger ? String(opts.statusTrigger).trim() : '', RALPH_AGENT_ID: identity.agentId ?? '', RALPH_AGENT_NAME: identity.agentName ?? '', ...(typeof localAiTarget === 'string' ? { LOCAL_AI_TARGET: localAiTarget } : {}), ...(typeof opts.exec === 'string' ? { RALPH_EXEC_CMD: opts.exec } : {}) } });
+      execSync(cmd, { cwd: kitDir, stdio: 'inherit', env: { ...process.env, RALPH_VERBOSE: opts.verbose ? '1' : '', RALPH_SYNC: opts.sync ? '1' : '', RALPH_LOCAL: opts.local ? '1' : '', RALPH_HANDOVER: opts.handover ? '1' : '', RALPH_STATUS_TRIGGER: opts.statusTrigger ? String(opts.statusTrigger).trim() : '', RALPH_AGENT_ID: identity.agentId ?? '', RALPH_AGENT_NAME: identity.agentName ?? '', ...(typeof localAiTarget === 'string' ? { LOCAL_AI_TARGET: localAiTarget } : {}), ...(typeof opts.exec === 'string' ? { RALPH_EXEC_CMD: opts.exec } : {}) } });
     } catch (err) {
       process.exit(err.status || 1);
     }
@@ -4740,6 +4748,42 @@ program
     }
   });
 
+program
+  .command('info <text>')
+  .description("For a build agent: record something that is not a reusable learning — what you cannot change and why (limitation), a decision you took, a note. It is an event in the log and a comment on the slice. Reusable knowledge about the codebase or model is a `learn`, not an info.")
+  .option('--kind <kind>', `${INFO_KINDS.join(' · ')} (default note)`, 'note')
+  .option('--slice <idOrTitle>', 'The slice it is about (default: the one the run loop has claimed)')
+  .option('--tag <tag>', 'Label the info (repeatable)', (tag, tags) => [...tags, tag], [])
+  .action(async (text, opts, command) => {
+    const cwd = process.cwd();
+    const kitDir = requireBuildKitDir(cwd);
+    const meta = agentEventMeta(cwd, kitDir, command);
+    try {
+      let sliceId;
+      if (opts.slice) sliceId = findSliceDir(kitDir, opts.slice)?.slice.id ?? opts.slice;
+      else {
+        const claimed = Object.entries(fold(readEvents(kitDir)).slices).filter(([, s]) => s.claim);
+        if (claimed.length === 1) sliceId = claimed[0][0];
+      }
+      const info = recordInfo({ kitDir, text, kind: opts.kind, slice: sliceId, tags: opts.tag, meta });
+      console.log(`✅ Recorded ${info.kind} (${info.id.slice(0, 8)}).`);
+      if (!sliceId) return console.log('ℹ️  No slice named or claimed — not posted to the board.');
+      // Best effort: the event is the record, the comment is how the board shows it.
+      const cfg = loadEffectiveConfig(cwd, kitDir, command.optsWithGlobals().config).config;
+      if (['organizationId', 'boardId', 'token'].some((f) => !cfg[f])) return console.log('ℹ️  No board credentials — not posted to the board.');
+      const res = await fetch(`${cfg.baseUrl || DEFAULT_BASE_URL}/api/org/${cfg.organizationId}/boards/${cfg.boardId}/nodes/${sliceId}/comments`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', 'x-token': cfg.token, 'x-user-id': 'cli-info', ...agentHeaders(cfg) },
+        body: JSON.stringify({ text: infoComment(info), type: 'COMMENT', author: 'build-agent' }),
+        signal: AbortSignal.timeout(15_000),
+      });
+      console.log(res.ok ? '✅ Posted as a comment on the slice.' : `⚠️  Board returned HTTP ${res.status} — the info is only in the event log.`);
+    } catch (err) {
+      console.error(`❌ ${err.message}`);
+      process.exit(1);
+    }
+  });
+
 program
   .command('events')
   .description("Decode a kit's event log in the terminal: one line per event (claims, settles, learnings, tasks, prompts …) with the slice's title and the agent that wrote it. Filter it, print the raw events, or print the state the log folds to.")
@@ -5112,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.2",
+  "version": "2.0.4",
   "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

@@ -0,0 +1,156 @@
+// A build agent shares its event log with the board — two capabilities, both build-agent only (a modeling
+// agent gets no-ops):
+//
+//   iterations  every slice build turn is an iteration: `iteration-started` / `iteration-closed` events in the
+//               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 (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.
+//
+// Best effort, like tracing: a cursor (the last event id sent) lives next to the log and only moves forward
+// when the upload succeeded, so a failed upload is simply sent again with the next one. The server holds one
+// iteration per slice and kit type — every `iteration-started` resets that log — and at most 1000 entries.
+
+import { randomUUID } from 'crypto';
+import { existsSync, readFileSync, renameSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { appendEvent, readEvents } from './slice-events.js';
+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) {
+  try { return JSON.parse(readFileSync(path, 'utf-8')); } catch { return {}; }
+}
+
+function writeState(path, state) {
+  const tmp = `${path}.${process.pid}.tmp`;
+  writeFileSync(tmp, JSON.stringify(state), 'utf-8');
+  renameSync(tmp, path);
+}
+
+// The wire shape of one log event: the envelope the endpoint reads, everything else as payload.
+export function toBuildLogEntry(e, { agentId, iteration, boardId, organizationId, kitType, seq }) {
+  const { id, at, type, slice, meta: _meta, tags: _tags, ...rest } = e;
+  return { ...rest, id, type, sliceId: slice, agentId, iteration, occurredAt: at, boardId, organizationId, kitType, seq };
+}
+
+// A kit that picks slices up from Waiting builds the UI; any other builds the backend.
+export const kitTypeOf = (pickupStatus) => (String(pickupStatus ?? '').trim().toLowerCase() === 'waiting' ? 'ui' : 'backend');
+
+export function createBuildLogShare({ kitDir, cfg, meta, agentType = 'BUILD', kitType = 'backend', sync = false, enabled = true, intervalMs = SYNC_INTERVAL_MS, log = () => {} } = {}) {
+  if (agentType !== 'BUILD') return NOOP;
+  const statePath = join(kitDir, SYNC_STATE_FILE);
+  const canUpload = !!(sync && enabled && cfg?.baseUrl && cfg?.token && cfg?.organizationId && cfg?.boardId && cfg?.agentId);
+  const open = new Map(); // slice → the iteration in progress
+  let timer = null;
+  let inFlight = null;
+  let warned = false;
+
+  async function upload() {
+    const state = readState(statePath);
+    const events = readEvents(kitDir);
+    const from = state.cursor ? events.findIndex((e) => e.id === state.cursor) + 1 : 0; // a pruned cursor re-sends; the server drops duplicates
+    const fresh = events.slice(from);
+    if (!fresh.length) return;
+    const iterations = { ...(state.iterations ?? {}) };
+    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`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', 'x-token': cfg.token, 'x-agent-id': cfg.agentId },
+        body: JSON.stringify({ events: entries }),
+        signal: AbortSignal.timeout(15_000),
+      });
+      if (!res.ok) {
+        const reason = `HTTP ${res.status}${await res.text().then((t) => `: ${t}`).catch(() => '')}`;
+        // A batch the platform rejects as invalid can never succeed: skip it rather than resend it every interval.
+        if (res.status !== 400) throw new Error(reason);
+        log(`info: the platform did not take ${entries.length} build log entries (${reason}) — skipped`);
+      }
+    }
+    writeState(statePath, { cursor: fresh[fresh.length - 1].id, iterations });
+  }
+
+  // One upload at a time. A call that arrives while one runs asks for another pass right after it, so events
+  // appended in between are never left to wait for the interval.
+  let again = false;
+  function flush() {
+    if (!canUpload) return Promise.resolve();
+    if (inFlight) { again = true; return inFlight; }
+    inFlight = (async () => {
+      do {
+        again = false;
+        try { await upload(); warned = false; } catch (err) {
+          if (!warned) { warned = true; log(`info: build log upload failed (${err.message}) — will send it with the next one`); }
+          break;
+        }
+      } while (again);
+    })().finally(() => { inFlight = null; });
+    return inFlight;
+  }
+
+  return {
+    iterationStarted(planned) {
+      const iteration = randomUUID();
+      try {
+        appendEvent(kitDir, { type: 'iteration-started', slice: planned.id, iteration, title: planned.title, kitType, boardId: cfg?.boardId, organizationId: cfg?.organizationId }, meta);
+      } catch (err) {
+        log(`info: could not record the start of an iteration (${err.message}) — the build goes on`);
+        return null;
+      }
+      open.set(planned.id, iteration);
+      flush();
+      return iteration;
+    },
+    async iterationClosed(planned, status) {
+      const iteration = open.get(planned.id);
+      if (!iteration) return;
+      open.delete(planned.id);
+      try {
+        appendEvent(kitDir, { type: 'iteration-closed', slice: planned.id, iteration, status, kitType, boardId: cfg?.boardId, organizationId: cfg?.organizationId }, meta);
+      } catch (err) {
+        log(`info: could not record the end of an iteration (${err.message}) — the build goes on`);
+        return;
+      }
+      // The iteration that settled the slice as Done ends with `slice-done`; if it is the slice's newest entry when
+      // the next iteration starts, the platform knows the slice was reopened and starts its log over.
+      try {
+        const events = readEvents(kitDir);
+        const from = events.findLastIndex((e) => e.type === 'iteration-started' && e.iteration === iteration);
+        if (events.slice(from + 1).some((e) => e.type === 'settled' && e.slice === planned.id && statusKey(e.status) === 'done')) {
+          appendEvent(kitDir, { type: 'slice-done', slice: planned.id, iteration, kitType, boardId: cfg?.boardId, organizationId: cfg?.organizationId }, meta);
+        }
+      } catch (err) {
+        log(`info: could not record that the slice is done (${err.message}) — the build goes on`);
+      }
+      await flush();
+    },
+    flush,
+    start() {
+      if (!canUpload || timer) return;
+      timer = setInterval(flush, intervalMs);
+      timer.unref?.();
+    },
+    stop() {
+      if (timer) clearInterval(timer);
+      timer = null;
+    },
+  };
+}

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

@@ -51,6 +51,8 @@ function describe(e) {
       return ['', `${plural(e.sources?.length ?? e.learnings?.length ?? 0, 'learning')} → ${oneLine(e.text, 120)}${e.reason ? ` — ${oneLine(e.reason, 80)}` : ''}`];
     case 'learnings-curated':
       return ['', ''];
+    case 'info-recorded':
+      return [e.slice, `[${e.kind ?? 'note'}] ${oneLine(e.text, 160)}`];
     case 'prompt-received':
       return [e.prompt?.id, `"${oneLine(e.prompt?.text, 80)}"${e.prompt?.priority ? ', priority' : ''}, pid ${e.pid}`];
     case 'prompt-action':

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

@@ -20,6 +20,7 @@ import { readEvents } from './slice-events.js';
 import { claimSlice, recordEvent, settleSlice, settleLeftoverClaims } from './slice-run.js';
 import { isTreeClean } from './slice-git.js';
 import { syncLearnings } from './slice-learnings.js';
+import { createBuildLogShare, kitTypeOf, SYNC_STATE_FILE } from './build-log-share.js';
 import { curateIfDue } from './slice-curation.js';
 import { queueTask, workNextTask } from './slice-tasks.js';
 import { defaultAgentName, withInstanceSuffix } from './agent-name.js';
@@ -739,7 +740,7 @@ function ensureLearningsGitRules(kitDir) {
   const projectDir = dirname(kitDir);
   if (!existsSync(join(projectDir, '.git'))) return;
   const rules = [
-    ['info/exclude', [`${basename(kitDir)}/events/`, `${basename(kitDir)}/events.log`]],
+    ['info/exclude', [`${basename(kitDir)}/events/`, `${basename(kitDir)}/events.log`, `${basename(kitDir)}/events.seq`, `${basename(kitDir)}/${SYNC_STATE_FILE}`]],
     ['info/attributes', [`${basename(kitDir)}/AGENTS.md merge=union`]],
   ];
   for (const [name, lines] of rules) {
@@ -769,6 +770,10 @@ async function ralphLoop(kitDir, cfg, onTask, onPlannedSlice, localOnly = false,
   const board = credentialed ? createBoard(cfg) : null;
   const meta = eventMeta(cfg);
   ensureLearningsGitRules(kitDir);
+  // Sharing the event log with the board (`run --sync`): needs the board, so never with --local.
+  const share = createBuildLogShare({ kitDir, cfg, meta, agentType: cfg?.agentType ?? 'BUILD', kitType: kitTypeOf(readPickupStatus(kitDir)), sync: process.env.RALPH_SYNC === '1', enabled: credentialed, log: (line) => console.log(`[ralph] ${line}`) });
+  if (process.env.RALPH_SYNC === '1' && !credentialed) console.log('[ralph] --sync needs board credentials — the build log stays local.');
+  share.start();
   let lastIdleCtx;
   // The build agent's final reply on the most recent planned-slice turn — quoted in the Blocked note.
   let lastReply = null;
@@ -831,6 +836,7 @@ 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,
@@ -842,6 +848,7 @@ async function ralphLoop(kitDir, cfg, onTask, onPlannedSlice, localOnly = false,
       }); });
       if (built) console.log(`[ralph] Slice build complete — waiting for next slice`);
       if (planned.id) await settleSlice({ kitDir, planned, board, meta, pickupStatus: readPickupStatus(kitDir), details: { built, lastReply } });
+      if (planned.id) await share.iterationClosed(planned, built ? 'ok' : 'error');
       if (credentialed) await fetchAndPersistSlices(cfg, kitDir).catch(() => {});
       didWork = true;
     }

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

@@ -11,6 +11,7 @@ import { join } from 'path';
 
 export const EVENTS_DIR = 'events';
 export const INDEX_FILE = 'events.log';
+export const SEQ_FILE = 'events.seq';
 
 const ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
 
@@ -49,10 +50,41 @@ export function normalizeMeta(meta) {
   return clean;
 }
 
+// The last sequence number handed out is remembered next to the index (SEQ_FILE), so numbers keep climbing
+// when events are pruned or the log is rebuilt. A kit that has no such file yet (a log written before events
+// were numbered) continues from its newest event: its own `seq`, or how many events precede it. Two processes
+// appending in the same instant can draw the same number — nothing enforces uniqueness, here or on the server:
+// the index order decides, and readEvents renumbers so a reader still sees a strictly increasing sequence.
+function newestEventSeq(kitDir) {
+  const index = join(kitDir, INDEX_FILE);
+  if (!existsSync(index)) return 0;
+  const ids = readFileSync(index, 'utf-8').split('\n').map((l) => l.trim()).filter((l) => ID.test(l));
+  for (let i = ids.length - 1; i >= 0; i--) {
+    try {
+      const { seq } = JSON.parse(readFileSync(join(kitDir, EVENTS_DIR, `${ids[i]}.json`), 'utf-8'));
+      return Number.isInteger(seq) ? seq : i + 1;
+    } catch { /* unreadable — look at the one before */ }
+  }
+  return 0;
+}
+
+// Takes the next number and remembers it.
+function nextSeq(kitDir) {
+  const file = join(kitDir, SEQ_FILE);
+  let remembered = 0;
+  try { remembered = Number.parseInt(readFileSync(file, 'utf-8'), 10) || 0; } catch { /* none yet */ }
+  const seq = Math.max(remembered, newestEventSeq(kitDir)) + 1;
+  const tmp = `${file}.${randomUUID()}.tmp`;
+  writeFileSync(tmp, String(seq), 'utf-8');
+  renameSync(tmp, file);
+  return seq;
+}
+
 // The event file is written whole (temp file, then rename) before its id is indexed, so a reader that
 // finds the id finds a complete file. The index line is one short append-mode write, so lines from
 // 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. Returns the event 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.
 export function appendEvent(kitDir, event, meta) {
   const dir = join(kitDir, EVENTS_DIR);
   mkdirSync(dir, { recursive: true });
@@ -67,6 +99,7 @@ export function appendEvent(kitDir, event, meta) {
     ...rest,
     ...(cleanTags.length ? { tags: cleanTags } : {}),
     ...(Object.keys(cleanMeta).length ? { meta: cleanMeta } : {}),
+    seq: nextSeq(kitDir),
     id,
   }, null, 2), 'utf-8');
   renameSync(tmp, join(dir, `${id}.json`));
@@ -75,7 +108,7 @@ export function appendEvent(kitDir, event, meta) {
   return id;
 }
 
-// All events in index order; with `tag`, only those carrying it.
+// All events in index order, each with its `seq`; with `tag`, only those carrying it.
 export function readEvents(kitDir, { tag } = {}) {
   const index = join(kitDir, INDEX_FILE);
   if (!existsSync(index)) return [];
@@ -89,5 +122,12 @@ export function readEvents(kitDir, { tag } = {}) {
       events.push(JSON.parse(readFileSync(join(kitDir, EVENTS_DIR, `${id}.json`), 'utf-8')));
     } catch { /* indexed but missing or unreadable — skipped */ }
   }
+  // Strictly increasing in index order: an event from before numbering, or one that drew the same number as its
+  // predecessor, takes the next free one.
+  let prev = 0;
+  for (const e of events) {
+    if (!Number.isInteger(e.seq) || e.seq <= prev) e.seq = prev + 1;
+    prev = e.seq;
+  }
   return tag === undefined ? events : events.filter((e) => e.tags?.includes(tag));
 }

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

@@ -0,0 +1,52 @@
+// Info events: what an agent reports that is not a reusable learning — "I can't change X because Y", a
+// decision it took, a note for whoever reads the board. A learning is true of the codebase or the model for
+// every later build (slice-learnings.js); an info is about this slice, now. Infos feed no projection — the
+// event is the record — and are also posted as a comment on the slice, so the board shows them.
+
+import { appendEvent } from './slice-events.js';
+
+export const INFO_KINDS = ['limitation', 'decision', 'note'];
+const MAX_INFO_LENGTH = 500;
+
+export function recordInfo({ kitDir, text, kind = 'note', slice, tags, meta }) {
+  const clean = String(text ?? '').trim();
+  if (!clean) throw new Error('the info is empty');
+  if (!INFO_KINDS.includes(kind)) throw new Error(`kind must be ${INFO_KINDS.join(', ')}, not "${kind}"`);
+  const id = appendEvent(kitDir, { type: 'info-recorded', kind, text: clean.slice(0, MAX_INFO_LENGTH), ...(slice ? { slice } : {}), tags }, meta);
+  return { id, text: clean.slice(0, MAX_INFO_LENGTH), kind };
+}
+
+// The comment the board shows for an info.
+export function infoComment({ kind, text }) {
+  return `[${kind}] ${text}`;
+}
+
+// ── infos a turn states in its reply ────────────────────────────────────────────
+// Same contract as learnings: the locked-down modeling agent ends a reply with `Info [<kind>]: <line>` and
+// the CLI records it. At most five per reply, each capped, so what a board collaborator can talk the agent
+// into saying stays small.
+const MAX_TURN_INFOS = 5;
+const TURN_INFO = /^\s*(?:[-*]\s+)?info(?:\s*\[([^\]]{1,20})\])?:\s*(.*?)\s*$/i;
+
+export function parseTurnInfos(reply) {
+  const found = [];
+  let fenced = false;
+  for (const line of String(reply ?? '').split('\n')) {
+    if (line.trim().startsWith('```')) { fenced = !fenced; continue; }
+    if (fenced) continue;
+    const m = TURN_INFO.exec(line);
+    if (!m) continue;
+    const text = m[2];
+    if (!text || /^none\.?$/i.test(text) || text.length > MAX_INFO_LENGTH) continue;
+    const kind = m[1]?.trim().toLowerCase();
+    found.push({ kind: INFO_KINDS.includes(kind) ? kind : 'note', text });
+    if (found.length === MAX_TURN_INFOS) break;
+  }
+  return found;
+}
+
+export function recordTurnInfos({ kitDir, reply, meta }) {
+  const infos = parseTurnInfos(reply);
+  for (const { kind, text } of infos) recordInfo({ kitDir, text, kind, tags: ['modeling'], meta });
+  return infos.length;
+}

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

@@ -4,7 +4,7 @@
 //
 // Events (one writer per type): board-observed, claimed, claim-confirmed, agent-recorded, settled,
 // released, attempt-failed, blocked, learning-recorded, learning-retracted, learning-merged, learnings-curated,
-// task-queued, task-done, prompt-received, prompt-finished. Unknown types are ignored, so a
+// info-recorded (read by nothing here — it is the record), task-queued, task-done, prompt-received, prompt-finished. Unknown types are ignored, so a
 // newer loop's log is readable.
 
 const emptySlice = () => ({

package/shared/scaffold/supabase/generate.mjs

@@ -164,7 +164,7 @@ const pageList = [...pages.values()].map(({name, title, route, hasParams, slices
 write('web/src/app/model.ts', `// GENERATED by "eventmodelers scaffold" from the event model. Do not edit by hand: re-run the command.
 // Navigation has one entry per timeline (chapter). Pages are one per distinct screen title (web kit convention).
 
-export type SliceInfo = { title: string; type: string; endpoint?: string };
+export type SliceInfo = { title: string; type?: string; endpoint?: string };
 export type TimelineInfo = { title: string; slug: string; pages: string[]; slices: SliceInfo[] };
 export type PageInfo = { name: string; title: string; route: string; hasParams: boolean; slices: string[] };
 

package/shared/scaffold/supabase/template/web/src/app/TimelinePage.tsx.tmpl

@@ -60,7 +60,7 @@ export function TimelinePage() {
             {timeline.slices.map((s) => (
               <tr key={s.title}>
                 <td>{s.title}</td>
-                <td>{TYPE_LABEL[s.type] ?? s.type}</td>
+                <td>{s.type ? TYPE_LABEL[s.type] ?? s.type : '—'}</td>
                 <td><code>{s.endpoint ?? '—'}</code></td>
                 <td>{s.type === 'STATE_VIEW' && s.endpoint ? <ReadModelStatus slice={s} /> : <span className="has-text-grey">—</span>}</td>
               </tr>

package/stacks/axon/templates/build-kit/lib/backend-prompt.md

@@ -64,6 +64,16 @@ npx @eventmodelers/cli learn "<one terse line>" --topic "<topic>"
 - `--scope system` for what is true of the modeled domain (a business rule, a naming convention of the model); `repo` (the default) for the codebase and its tooling. `--tag <tag>` labels it (repeatable).
 - One in `.build-kit/AGENTS.md` that turned out wrong or obsolete: `npx @eventmodelers/cli learnings --ids` lists each with its id, `npx @eventmodelers/cli learn --retract <id>` removes it.
 
+### Recording Info
+
+Something that is **not** a reusable learning — you cannot change something and why, a decision you took, a note for whoever reads the board — is an info, not a learning. Never leave it only in your reply:
+
+```
+npx @eventmodelers/cli info "<one terse line>" --kind limitation|decision|note
+```
+
+It is recorded as an event and posted as a comment on the slice you are building (`--slice <id>` to name another). Reusable knowledge stays a `learn`.
+
 ## Update AGENTS.md Files
 
 Before committing, check if any edited files have learnings worth preserving in nearby AGENTS.md files:

package/stacks/axon/templates/build-kit/lib/prompt.md

@@ -112,6 +112,16 @@ npx @eventmodelers/cli learn "<one terse line>" --topic "<topic>"
 - `--scope system` for what is true of the modeled domain (a business rule, a naming convention of the model); `repo` (the default) for the codebase and its tooling. `--tag <tag>` labels it (repeatable).
 - One in `.build-kit/AGENTS.md` that turned out wrong or obsolete: `npx @eventmodelers/cli learnings --ids` lists each with its id, `npx @eventmodelers/cli learn --retract <id>` removes it.
 
+### Recording Info
+
+Something that is **not** a reusable learning — you cannot change something and why, a decision you took, a note for whoever reads the board — is an info, not a learning. Never leave it only in your reply:
+
+```
+npx @eventmodelers/cli info "<one terse line>" --kind limitation|decision|note
+```
+
+It is recorded as an event and posted as a comment on the slice you are building (`--slice <id>` to name another). Reusable knowledge stays a `learn`.
+
 ## Important
 
 - Process **one task per iteration**.

package/stacks/blank/templates/build-kit/lib/backend-prompt.md

@@ -54,6 +54,16 @@ npx @eventmodelers/cli learn "<one terse line>" --topic "<topic>"
 - `--scope system` for what is true of the modeled domain (a business rule, a naming convention of the model); `repo` (the default) for the codebase and its tooling. `--tag <tag>` labels it (repeatable).
 - One in `.build-kit/AGENTS.md` that turned out wrong or obsolete: `npx @eventmodelers/cli learnings --ids` lists each with its id, `npx @eventmodelers/cli learn --retract <id>` removes it.
 
+### Recording Info
+
+Something that is **not** a reusable learning — you cannot change something and why, a decision you took, a note for whoever reads the board — is an info, not a learning. Never leave it only in your reply:
+
+```
+npx @eventmodelers/cli info "<one terse line>" --kind limitation|decision|note
+```
+
+It is recorded as an event and posted as a comment on the slice you are building (`--slice <id>` to name another). Reusable knowledge stays a `learn`.
+
 ## Update AGENTS.md Files
 
 Before committing, check if any edited files have learnings worth preserving in nearby AGENTS.md files — API patterns/conventions, gotchas, dependencies between files, testing approaches, configuration/environment requirements.

package/stacks/blank/templates/build-kit/lib/prompt.md

@@ -112,6 +112,16 @@ npx @eventmodelers/cli learn "<one terse line>" --topic "<topic>"
 - `--scope system` for what is true of the modeled domain (a business rule, a naming convention of the model); `repo` (the default) for the codebase and its tooling. `--tag <tag>` labels it (repeatable).
 - One in `.build-kit/AGENTS.md` that turned out wrong or obsolete: `npx @eventmodelers/cli learnings --ids` lists each with its id, `npx @eventmodelers/cli learn --retract <id>` removes it.
 
+### Recording Info
+
+Something that is **not** a reusable learning — you cannot change something and why, a decision you took, a note for whoever reads the board — is an info, not a learning. Never leave it only in your reply:
+
+```
+npx @eventmodelers/cli info "<one terse line>" --kind limitation|decision|note
+```
+
+It is recorded as an event and posted as a comment on the slice you are building (`--slice <id>` to name another). Reusable knowledge stays a `learn`.
+
 ## Important
 
 - Process **one task per iteration**.

package/stacks/classic/templates/build-kit/lib/backend-prompt.md

@@ -58,6 +58,16 @@ npx @eventmodelers/cli learn "<one terse line>" --topic "<topic>"
 - `--scope system` for what is true of the modeled domain (a business rule, a naming convention of the model); `repo` (the default) for the codebase and its tooling. `--tag <tag>` labels it (repeatable).
 - One in `.build-kit/AGENTS.md` that turned out wrong or obsolete: `npx @eventmodelers/cli learnings --ids` lists each with its id, `npx @eventmodelers/cli learn --retract <id>` removes it.
 
+### Recording Info
+
+Something that is **not** a reusable learning — you cannot change something and why, a decision you took, a note for whoever reads the board — is an info, not a learning. Never leave it only in your reply:
+
+```
+npx @eventmodelers/cli info "<one terse line>" --kind limitation|decision|note
+```
+
+It is recorded as an event and posted as a comment on the slice you are building (`--slice <id>` to name another). Reusable knowledge stays a `learn`.
+
 ## Update AGENTS.md Files
 
 Before committing, check if any edited files have learnings worth preserving in nearby AGENTS.md files — API patterns/conventions, gotchas, dependencies between files, testing approaches, configuration/environment requirements.

package/stacks/classic/templates/build-kit/lib/prompt.md

@@ -116,6 +116,16 @@ npx @eventmodelers/cli learn "<one terse line>" --topic "<topic>"
 - `--scope system` for what is true of the modeled domain (a business rule, a naming convention of the model); `repo` (the default) for the codebase and its tooling. `--tag <tag>` labels it (repeatable).
 - One in `.build-kit/AGENTS.md` that turned out wrong or obsolete: `npx @eventmodelers/cli learnings --ids` lists each with its id, `npx @eventmodelers/cli learn --retract <id>` removes it.
 
+### Recording Info
+
+Something that is **not** a reusable learning — you cannot change something and why, a decision you took, a note for whoever reads the board — is an info, not a learning. Never leave it only in your reply:
+
+```
+npx @eventmodelers/cli info "<one terse line>" --kind limitation|decision|note
+```
+
+It is recorded as an event and posted as a comment on the slice you are building (`--slice <id>` to name another). Reusable knowledge stays a `learn`.
+
 ## Important
 
 - Process **one task per iteration**.

package/stacks/kurrent/templates/build-kit/lib/backend-prompt.md

@@ -64,6 +64,16 @@ npx @eventmodelers/cli learn "<one terse line>" --topic "<topic>"
 - `--scope system` for what is true of the modeled domain (a business rule, a naming convention of the model); `repo` (the default) for the codebase and its tooling. `--tag <tag>` labels it (repeatable).
 - One in `.build-kit/AGENTS.md` that turned out wrong or obsolete: `npx @eventmodelers/cli learnings --ids` lists each with its id, `npx @eventmodelers/cli learn --retract <id>` removes it.
 
+### Recording Info
+
+Something that is **not** a reusable learning — you cannot change something and why, a decision you took, a note for whoever reads the board — is an info, not a learning. Never leave it only in your reply:
+
+```
+npx @eventmodelers/cli info "<one terse line>" --kind limitation|decision|note
+```
+
+It is recorded as an event and posted as a comment on the slice you are building (`--slice <id>` to name another). Reusable knowledge stays a `learn`.
+
 ## Update AGENTS.md Files
 
 Before committing, check if any edited files have learnings worth preserving in nearby AGENTS.md files:

package/stacks/kurrent/templates/build-kit/lib/prompt.md

@@ -112,6 +112,16 @@ npx @eventmodelers/cli learn "<one terse line>" --topic "<topic>"
 - `--scope system` for what is true of the modeled domain (a business rule, a naming convention of the model); `repo` (the default) for the codebase and its tooling. `--tag <tag>` labels it (repeatable).
 - One in `.build-kit/AGENTS.md` that turned out wrong or obsolete: `npx @eventmodelers/cli learnings --ids` lists each with its id, `npx @eventmodelers/cli learn --retract <id>` removes it.
 
+### Recording Info
+
+Something that is **not** a reusable learning — you cannot change something and why, a decision you took, a note for whoever reads the board — is an info, not a learning. Never leave it only in your reply:
+
+```
+npx @eventmodelers/cli info "<one terse line>" --kind limitation|decision|note
+```
+
+It is recorded as an event and posted as a comment on the slice you are building (`--slice <id>` to name another). Reusable knowledge stays a `learn`.
+
 ## Important
 
 - Process **one task per iteration**.

package/stacks/modeling-kit/templates/.claude/skills/prototype/SKILL.md

@@ -35,6 +35,8 @@ From `$ARGUMENTS`: the context (a MODEL_CONTEXT name or a timeline name) and opt
 
 The unit is the **effective context**: a timeline assigned to or connected with a MODEL_CONTEXT belongs to that context; a timeline with neither is its own context. Either name returns the whole effective context — every timeline in it, each slice carrying its `chapter`.
 
+**Pass the id, not the name, whenever you have it** — the turn's `timelineId` (or a MODEL_CONTEXT's id) goes straight into `--context "<id>"`. A chapter may have no name at all; never rename a chapter to make the lookup work, and never ask about it.
+
 No context given, or a name that matches nothing: list the options once —
 
 ```

package/stacks/modeling-kit/templates/.claude/skills/prototype/assets/prototype.mjs

@@ -97,10 +97,12 @@ async function status() {
     return res.json();
   };
 
-  const ctx = encodeURIComponent(args.context);
+  // --context is a name, or the id of a MODEL_CONTEXT / timeline (a chapter without a name has only that).
+  const contextIsId = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(args.context);
+  const ctx = `${contextIsId ? 'contextId' : 'contextName'}=${encodeURIComponent(args.context)}`;
   const [fields, specs] = await Promise.all([
-    get(`/slicedata?contextName=${ctx}&projection=fields&format=json`),
-    get(`/slicedata?contextName=${ctx}&projection=specs&format=json`),
+    get(`/slicedata?${ctx}&projection=fields&format=json`),
+    get(`/slicedata?${ctx}&projection=specs&format=json`),
   ]);
   const specsById = Object.fromEntries((specs.slices || []).map((s) => [s.id, s]));
 
@@ -127,7 +129,7 @@ async function status() {
   // The baseline whose blocks can be kept: the page the platform stores for this context — what everyone
   // plays, and there in any session or folder (its sanitizer leaves the blocks byte for byte) — else a
   // local one, from an earlier run whose upload failed. Neither: every slice is new.
-  const contextId = args['context-id'] || (await contextIdOf(get, args.context));
+  const contextId = contextIsId ? args.context : await contextIdOf(get, args.context);
   const storedRes = await fetch(`${api}/prototype/${encodeURIComponent(contextId)}`, { headers });
   if (!storedRes.ok && storedRes.status !== 404) fail(`GET /prototype/${contextId} → ${storedRes.status} ${await storedRes.text()}`);
   const stored = storedRes.ok ? await storedRes.text() : null;
@@ -158,7 +160,7 @@ async function status() {
   const removed = existing.filter((b) => !current.has(b.id)).map(({ id, title }) => ({ id, title }));
   const cssFramework = Object.entries(frameworkVotes).sort((a, b) => b[1] - a[1])[0]?.[0] || 'bulma';
 
-  const report = { context: args.context, contextId, baseline, cssFramework, mixedFrameworks: Object.keys(frameworkVotes).length > 1, slices, removed };
+  const report = { context: fields.contextName || args.context, contextId, baseline, cssFramework, mixedFrameworks: Object.keys(frameworkVotes).length > 1, slices, removed };
   writeFileSync(join(WORK, 'status.json'), JSON.stringify(report, null, 2));
   for (const s of slices) console.log(`${s.state.padEnd(9)} ${s.hash}  ${s.id}  ${s.title}`);
   for (const r of removed) console.log(`removed   ${''.padEnd(16)}  ${r.id}  ${r.title}`);

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

@@ -199,7 +199,7 @@ Steps:
    ever get here in a `standalone=on` session, which is ad-hoc: its kit dir is shared across
    every board and nobody reads it afterwards. The board is the only place anything is kept, so
    anything reusable — including what a subagent reported back — goes there, as a comment on the
-   node it concerns.
+   node it concerns. The exception: end the reply with `Info [limitation|decision|note]: <one terse line>` for anything you could not change (and why) or decided — the CLI records it as an event, standalone included.
 8. Reply `<promise>DONE</promise>`, naming what you dispatched and what each agent did, or —
    when step 2 turned up nothing worth doing — change nothing at all and reply
    `<promise>NOOP</promise>`. A NOOP is a perfectly good outcome, and the CLI widens the gap

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

@@ -19,7 +19,7 @@ session: it belongs to no project, its kit dir is a `~/.eventmodelers/kit` share
 and nobody goes looking in there afterwards. So in a `standalone=on` session the **board is the
 only place anything is kept** — comments, elements, slice statuses, scenarios. Write no file at
 all: no `Learning:` lines in your reply (step 8), no `.agent-modeling-kit/AGENTS.md`, and nothing a skill's
-own instructions suggest writing down either. Anything worth keeping goes on the board, as a
+own instructions suggest writing down either. The one exception is `Info [kind]:` lines (step 8): the CLI records those as events in every session, standalone included. Anything worth keeping goes on the board, as a
 comment on the node it concerns. This overrides every "write it down" instruction elsewhere in this
 file and in any skill.
 
@@ -151,6 +151,7 @@ mention it in the `DONE` comment, and leave it for a self-directed turn (or for
 6. **Mark the prompt as finished** — invoke `/update-prompt-status` with this turn's `prompt_id`, `newStatus=DONE`, and a `comment` that summarizes what you actually did (e.g. "Added the OrderPlaced event and wired it to the read model"). Do this once, right after the work is done — not per skill call within the turn.
 7. If this turn has a `comment_id` field, invoke `/handle-comment` with `action=resolve`, `nodeId` from the resolved `NODE_ID` (step 3), `commentId` from `comment_id`.
 8. **`standalone=off` only** — if you noticed something reusable this turn (a pattern, a gotcha, useful context about this model), end your reply with one line per learning: `Learning [<topic>]: <one terse line>` (the topic is optional, at most five lines). The CLI records them — never write them into a file yourself, and add nothing that is already in `.agent-modeling-kit/AGENTS.md`. In a `standalone=on` session skip this: that session writes no files (see Mode), so note anything worth keeping as a board comment instead.
+   **In every session, `standalone=on` too:** anything that is *not* a reusable learning — something you could not change and why, a decision you took — goes the same way as `Info [limitation|decision|note]: <one terse line>` (at most five lines). The CLI records each as an event; never leave it only in prose.
 9. Reply `<promise>DONE</promise>` and wait for the next turn.
 
 

package/stacks/node/templates/build-kit/lib/backend-prompt.md

@@ -58,6 +58,16 @@ npx @eventmodelers/cli learn "<one terse line>" --topic "<topic>"
 - `--scope system` for what is true of the modeled domain (a business rule, a naming convention of the model); `repo` (the default) for the codebase and its tooling. `--tag <tag>` labels it (repeatable).
 - One in `.build-kit/AGENTS.md` that turned out wrong or obsolete: `npx @eventmodelers/cli learnings --ids` lists each with its id, `npx @eventmodelers/cli learn --retract <id>` removes it.
 
+### Recording Info
+
+Something that is **not** a reusable learning — you cannot change something and why, a decision you took, a note for whoever reads the board — is an info, not a learning. Never leave it only in your reply:
+
+```
+npx @eventmodelers/cli info "<one terse line>" --kind limitation|decision|note
+```
+
+It is recorded as an event and posted as a comment on the slice you are building (`--slice <id>` to name another). Reusable knowledge stays a `learn`.
+
 ## Update AGENTS.md Files
 
 Before committing, check if any edited files have learnings worth preserving in nearby AGENTS.md files:

package/stacks/node/templates/build-kit/lib/prompt.md

@@ -94,6 +94,16 @@ npx @eventmodelers/cli learn "<one terse line>" --topic "<topic>"
 - `--scope system` for what is true of the modeled domain (a business rule, a naming convention of the model); `repo` (the default) for the codebase and its tooling. `--tag <tag>` labels it (repeatable).
 - One in `.build-kit/AGENTS.md` that turned out wrong or obsolete: `npx @eventmodelers/cli learnings --ids` lists each with its id, `npx @eventmodelers/cli learn --retract <id>` removes it.
 
+### Recording Info
+
+Something that is **not** a reusable learning — you cannot change something and why, a decision you took, a note for whoever reads the board — is an info, not a learning. Never leave it only in your reply:
+
+```
+npx @eventmodelers/cli info "<one terse line>" --kind limitation|decision|note
+```
+
+It is recorded as an event and posted as a comment on the slice you are building (`--slice <id>` to name another). Reusable knowledge stays a `learn`.
+
 ## Important
 
 - Process **one task per iteration**.

package/stacks/opencqrs/templates/build-kit/lib/backend-prompt.md

@@ -64,6 +64,16 @@ npx @eventmodelers/cli learn "<one terse line>" --topic "<topic>"
 - `--scope system` for what is true of the modeled domain (a business rule, a naming convention of the model); `repo` (the default) for the codebase and its tooling. `--tag <tag>` labels it (repeatable).
 - One in `.build-kit/AGENTS.md` that turned out wrong or obsolete: `npx @eventmodelers/cli learnings --ids` lists each with its id, `npx @eventmodelers/cli learn --retract <id>` removes it.
 
+### Recording Info
+
+Something that is **not** a reusable learning — you cannot change something and why, a decision you took, a note for whoever reads the board — is an info, not a learning. Never leave it only in your reply:
+
+```
+npx @eventmodelers/cli info "<one terse line>" --kind limitation|decision|note
+```
+
+It is recorded as an event and posted as a comment on the slice you are building (`--slice <id>` to name another). Reusable knowledge stays a `learn`.
+
 ## Update AGENTS.md Files
 
 Before committing, check if any edited files have learnings worth preserving in nearby AGENTS.md files:

package/stacks/opencqrs/templates/build-kit/lib/prompt.md

@@ -112,6 +112,16 @@ npx @eventmodelers/cli learn "<one terse line>" --topic "<topic>"
 - `--scope system` for what is true of the modeled domain (a business rule, a naming convention of the model); `repo` (the default) for the codebase and its tooling. `--tag <tag>` labels it (repeatable).
 - One in `.build-kit/AGENTS.md` that turned out wrong or obsolete: `npx @eventmodelers/cli learnings --ids` lists each with its id, `npx @eventmodelers/cli learn --retract <id>` removes it.
 
+### Recording Info
+
+Something that is **not** a reusable learning — you cannot change something and why, a decision you took, a note for whoever reads the board — is an info, not a learning. Never leave it only in your reply:
+
+```
+npx @eventmodelers/cli info "<one terse line>" --kind limitation|decision|note
+```
+
+It is recorded as an event and posted as a comment on the slice you are building (`--slice <id>` to name another). Reusable knowledge stays a `learn`.
+
 ## Important
 
 - Process **one task per iteration**.

package/stacks/react/templates/build-kit/lib/backend-prompt.md

@@ -54,6 +54,16 @@ npx @eventmodelers/cli learn "<one terse line>" --topic "<topic>"
 - `--scope system` for what is true of the modeled domain (a business rule, a naming convention of the model); `repo` (the default) for the codebase and its tooling. `--tag <tag>` labels it (repeatable).
 - One in `.build-kit/AGENTS.md` that turned out wrong or obsolete: `npx @eventmodelers/cli learnings --ids` lists each with its id, `npx @eventmodelers/cli learn --retract <id>` removes it.
 
+### Recording Info
+
+Something that is **not** a reusable learning — you cannot change something and why, a decision you took, a note for whoever reads the board — is an info, not a learning. Never leave it only in your reply:
+
+```
+npx @eventmodelers/cli info "<one terse line>" --kind limitation|decision|note
+```
+
+It is recorded as an event and posted as a comment on the slice you are building (`--slice <id>` to name another). Reusable knowledge stays a `learn`.
+
 ## Update AGENTS.md Files
 
 Before committing, check if any edited files have learnings worth preserving in nearby AGENTS.md files — API patterns/conventions, gotchas, dependencies between files, testing approaches, configuration/environment requirements.

package/stacks/react/templates/build-kit/lib/prompt.md

@@ -125,6 +125,16 @@ npx @eventmodelers/cli learn "<one terse line>" --topic "<topic>"
 - `--scope system` for what is true of the modeled domain (a business rule, a naming convention of the model); `repo` (the default) for the codebase and its tooling. `--tag <tag>` labels it (repeatable).
 - One in `.build-kit/AGENTS.md` that turned out wrong or obsolete: `npx @eventmodelers/cli learnings --ids` lists each with its id, `npx @eventmodelers/cli learn --retract <id>` removes it.
 
+### Recording Info
+
+Something that is **not** a reusable learning — you cannot change something and why, a decision you took, a note for whoever reads the board — is an info, not a learning. Never leave it only in your reply:
+
+```
+npx @eventmodelers/cli info "<one terse line>" --kind limitation|decision|note
+```
+
+It is recorded as an event and posted as a comment on the slice you are building (`--slice <id>` to name another). Reusable knowledge stays a `learn`.
+
 ## Important
 
 - Process **one task per iteration**.

package/stacks/supabase/templates/build-kit/lib/backend-prompt.md

@@ -58,6 +58,16 @@ npx @eventmodelers/cli learn "<one terse line>" --topic "<topic>"
 - `--scope system` for what is true of the modeled domain (a business rule, a naming convention of the model); `repo` (the default) for the codebase and its tooling. `--tag <tag>` labels it (repeatable).
 - One in `.build-kit/AGENTS.md` that turned out wrong or obsolete: `npx @eventmodelers/cli learnings --ids` lists each with its id, `npx @eventmodelers/cli learn --retract <id>` removes it.
 
+### Recording Info
+
+Something that is **not** a reusable learning — you cannot change something and why, a decision you took, a note for whoever reads the board — is an info, not a learning. Never leave it only in your reply:
+
+```
+npx @eventmodelers/cli info "<one terse line>" --kind limitation|decision|note
+```
+
+It is recorded as an event and posted as a comment on the slice you are building (`--slice <id>` to name another). Reusable knowledge stays a `learn`.
+
 ## Update AGENTS.md Files
 
 Before committing, check if any edited files have learnings worth preserving in nearby AGENTS.md files:

package/stacks/supabase/templates/build-kit/lib/prompt.md

@@ -95,6 +95,16 @@ npx @eventmodelers/cli learn "<one terse line>" --topic "<topic>"
 - `--scope system` for what is true of the modeled domain (a business rule, a naming convention of the model); `repo` (the default) for the codebase and its tooling. `--tag <tag>` labels it (repeatable).
 - One in `.build-kit/AGENTS.md` that turned out wrong or obsolete: `npx @eventmodelers/cli learnings --ids` lists each with its id, `npx @eventmodelers/cli learn --retract <id>` removes it.
 
+### Recording Info
+
+Something that is **not** a reusable learning — you cannot change something and why, a decision you took, a note for whoever reads the board — is an info, not a learning. Never leave it only in your reply:
+
+```
+npx @eventmodelers/cli info "<one terse line>" --kind limitation|decision|note
+```
+
+It is recorded as an event and posted as a comment on the slice you are building (`--slice <id>` to name another). Reusable knowledge stays a `learn`.
+
 ## Important
 
 - Process **one task per iteration**.

package/stacks/supabase-react/templates/build-kit/lib/backend-prompt.md

@@ -54,6 +54,16 @@ npx @eventmodelers/cli learn "<one terse line>" --topic "<topic>"
 - `--scope system` for what is true of the modeled domain (a business rule, a naming convention of the model); `repo` (the default) for the codebase and its tooling. `--tag <tag>` labels it (repeatable).
 - One in `.build-kit/AGENTS.md` that turned out wrong or obsolete: `npx @eventmodelers/cli learnings --ids` lists each with its id, `npx @eventmodelers/cli learn --retract <id>` removes it.
 
+### Recording Info
+
+Something that is **not** a reusable learning — you cannot change something and why, a decision you took, a note for whoever reads the board — is an info, not a learning. Never leave it only in your reply:
+
+```
+npx @eventmodelers/cli info "<one terse line>" --kind limitation|decision|note
+```
+
+It is recorded as an event and posted as a comment on the slice you are building (`--slice <id>` to name another). Reusable knowledge stays a `learn`.
+
 ## Update AGENTS.md Files
 
 Before committing, check if any edited files have learnings worth preserving in nearby AGENTS.md files — API patterns/conventions, gotchas, dependencies between files, testing approaches, configuration/environment requirements.

package/stacks/supabase-react/templates/build-kit/lib/prompt.md

@@ -135,6 +135,16 @@ npx @eventmodelers/cli learn "<one terse line>" --topic "<topic>"
 - `--scope system` for what is true of the modeled domain (a business rule, a naming convention of the model); `repo` (the default) for the codebase and its tooling. `--tag <tag>` labels it (repeatable).
 - One in `.build-kit/AGENTS.md` that turned out wrong or obsolete: `npx @eventmodelers/cli learnings --ids` lists each with its id, `npx @eventmodelers/cli learn --retract <id>` removes it.
 
+### Recording Info
+
+Something that is **not** a reusable learning — you cannot change something and why, a decision you took, a note for whoever reads the board — is an info, not a learning. Never leave it only in your reply:
+
+```
+npx @eventmodelers/cli info "<one terse line>" --kind limitation|decision|note
+```
+
+It is recorded as an event and posted as a comment on the slice you are building (`--slice <id>` to name another). Reusable knowledge stays a `learn`.
+
 ## Important
 
 - Process **one task per iteration**.

package/stacks/umadb/templates/build-kit/lib/backend-prompt.md

@@ -64,6 +64,16 @@ npx @eventmodelers/cli learn "<one terse line>" --topic "<topic>"
 - `--scope system` for what is true of the modeled domain (a business rule, a naming convention of the model); `repo` (the default) for the codebase and its tooling. `--tag <tag>` labels it (repeatable).
 - One in `.build-kit/AGENTS.md` that turned out wrong or obsolete: `npx @eventmodelers/cli learnings --ids` lists each with its id, `npx @eventmodelers/cli learn --retract <id>` removes it.
 
+### Recording Info
+
+Something that is **not** a reusable learning — you cannot change something and why, a decision you took, a note for whoever reads the board — is an info, not a learning. Never leave it only in your reply:
+
+```
+npx @eventmodelers/cli info "<one terse line>" --kind limitation|decision|note
+```
+
+It is recorded as an event and posted as a comment on the slice you are building (`--slice <id>` to name another). Reusable knowledge stays a `learn`.
+
 ## Update AGENTS.md Files
 
 Before committing, check if any edited files have learnings worth preserving in nearby AGENTS.md files:

package/stacks/umadb/templates/build-kit/lib/prompt.md

@@ -112,6 +112,16 @@ npx @eventmodelers/cli learn "<one terse line>" --topic "<topic>"
 - `--scope system` for what is true of the modeled domain (a business rule, a naming convention of the model); `repo` (the default) for the codebase and its tooling. `--tag <tag>` labels it (repeatable).
 - One in `.build-kit/AGENTS.md` that turned out wrong or obsolete: `npx @eventmodelers/cli learnings --ids` lists each with its id, `npx @eventmodelers/cli learn --retract <id>` removes it.
 
+### Recording Info
+
+Something that is **not** a reusable learning — you cannot change something and why, a decision you took, a note for whoever reads the board — is an info, not a learning. Never leave it only in your reply:
+
+```
+npx @eventmodelers/cli info "<one terse line>" --kind limitation|decision|note
+```
+
+It is recorded as an event and posted as a comment on the slice you are building (`--slice <id>` to name another). Reusable knowledge stays a `learn`.
+
 ## Important
 
 - Process **one task per iteration**.