@eventmodelers/cli 2.0.10 → 2.0.11

package/README.md

@@ -695,6 +695,7 @@ Flow: `Ready → Planned → InProgress → Waiting → InProgress → Done`. Pr
 - **The platform must know the `Ready` / `Waiting` statuses.**
 - A kit declares what it claims in `lib/kit.json` — `{ "pickupStatus": "Waiting" }`; absent means `Planned`.
 - `run --status-trigger <status>` overrides that pickup status for a single run (e.g. `--status-trigger Ready`); nothing is saved.
+- `run --feature <name>` picks up only the slices that belong to that feature (the names set per slice on the board, matched case-insensitively); without it every slice in the pickup status is built. Slices without a feature wait for a run without the flag. Nothing is saved.
 
 The contract itself is the shared `ui-contract` skill's job (see above); it also owns the rule for which status a slice ends at.
 

package/cli.js

@@ -3305,7 +3305,7 @@ program
 // dir: a modeling run falls back to the global install (see ensureGlobalKit) rather than
 // requiring one here, and the build-kit branch reports a better-targeted error of its own
 // than this generic gate can.
-const NO_INIT_REQUIRED = new Set(['init', 'scaffold', 'init-templates', 'init-config', 'stacks', 'status', 'config', 'uninstall', 'fetch', 'activate-context', 'set-slice-status', 'release-notes', 'run', 'listen', 'events', 'replay', 'bridge']);
+const NO_INIT_REQUIRED = new Set(['init', 'scaffold', 'init-templates', 'init-config', 'stacks', 'status', 'config', 'uninstall', 'fetch', 'export', 'activate-context', 'set-slice-status', 'release-notes', 'run', 'listen', 'events', 'replay', 'bridge']);
 
 // Commands that install or refresh the kit themselves — a "your kit is outdated" hint in
 // front of them would only be noise.
@@ -3816,6 +3816,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('--feature <name>', 'Build kit: only pick up slices that belong to this feature (the free-text names set per slice on the board, matched case-insensitively), for this run only. Other slices wait for a run without it or with their own feature. 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.')
@@ -4106,7 +4107,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_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 } : {}) } });
+      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_FEATURE: opts.feature ? String(opts.feature).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);
     }
@@ -4210,6 +4211,139 @@ program
     }
   });
 
+const EXPORT_TYPES = ['eventcatalog'];
+
+program
+  .command('export')
+  .description('Export the event model into another tool\'s format. --type eventcatalog writes an EventCatalog project (domain, flow, events, commands, queries). Reads the board by default; --local reads .slices/ or config.json instead')
+  .requiredOption('--type <type>', `Export target: ${EXPORT_TYPES.join(', ')}`)
+  .option('--context <name>', 'Name or id of the context to export. Omitted (or not found) on the board: pick from the board\'s contexts. Filters --local')
+  .option('--local [path]', 'Read local files instead of the board: ./.slices/, then ./config.json, or the given path')
+  .option('--out <dir>', 'Directory to write into (the catalog root)', '.')
+  .option('--owner <id>', 'Owner (team or user id from the catalog) set on every exported resource; repeat for several', (v, all) => [...all, v], [])
+  .option('--check', 'Compare the model with what the last export wrote and exit 1 if they differ — writes nothing (for CI)')
+  .option('-f, --force', 'Overwrite resources that already exist in the catalog, and re-prompt for credentials when reading the board')
+  .action(async (opts, command) => {
+    if (!EXPORT_TYPES.includes(opts.type)) {
+      console.error(`❌ Unknown export type "${opts.type}". Supported: ${EXPORT_TYPES.join(', ')}`);
+      process.exit(1);
+    }
+    const cwd = process.cwd();
+    const ext = await import('./extensions/eventcatalog/index.js');
+    // Checked first, before any credentials or board access: the export only makes sense inside a catalog.
+    if (!ext.isCatalog(resolve(cwd, opts.out))) {
+      console.error(`❌ ${resolve(cwd, opts.out)} is not an EventCatalog project (no eventcatalog.config.* and no @eventcatalog/core dependency).`);
+      console.error('   Run this inside your catalog, or point --out at it. Create one with: npx @eventcatalog/create-eventcatalog@latest my-catalog --empty');
+      process.exit(1);
+    }
+    let slices;
+    try {
+      if (opts.local) {
+        slices = ext.loadFromLocal({ cwd, local: opts.local, context: opts.context });
+      } else {
+        const kitDir = findInstalledKitDir(cwd);
+        const globalOpts = command.optsWithGlobals();
+        const explicitConfig = globalOpts.config;
+        let cfg = loadEffectiveConfig(cwd, kitDir, explicitConfig).config;
+        const configPath = explicitConfig ? resolve(cwd, explicitConfig) : join(cwd, '.eventmodelers', 'config.json');
+        const requiredFields = ['organizationId', 'boardId', 'token'];
+        const promptForCredentials = async (force = false) => {
+          cfg = await configureCredentials({ config: cfg, configPath, targetDir: cwd, requiredFields, boardIdOptional: false, overrides: {}, print: globalOpts.print, force });
+          if (requiredFields.some((f) => !cfg[f])) {
+            console.error('❌ Still missing token/organizationId/boardId — re-run `eventmodelers export` once configured.');
+            process.exit(1);
+          }
+        };
+        // --force re-asks for credentials, like `init --force` / `init-config --force`.
+        if (opts.force || requiredFields.some((f) => !cfg[f])) await promptForCredentials(opts.force);
+        // A 401/403 re-asks for the token, like `fetch`; any other failure goes to the caller.
+        const withAuthRetry = async (fn) => {
+          try {
+            return await fn();
+          } catch (err) {
+            if (err.status !== 401 && err.status !== 403 && err.status !== 404) throw err;
+            console.error(`❌ ${err.message}`);
+            if (err.status === 404) delete cfg.boardId;
+            else delete cfg.token;
+            await promptForCredentials();
+            return fn();
+          }
+        };
+        const pickContext = async (question) => {
+          const contexts = await withAuthRetry(() => ext.listContexts({ cfg }));
+          if (!contexts.length) throw new Error(`Board ${cfg.boardId} has no contexts with slices.`);
+          return selectPrompt(question, contexts.map((c) => ({ label: `${c.name} (${c.slices} slice${c.slices === 1 ? '' : 's'})`, value: c.name })));
+        };
+        let context = opts.context || (await pickContext('Which context do you want to export?'));
+        try {
+          console.log(`▶ Reading context "${context}" from the board...`);
+          slices = await withAuthRetry(() => ext.loadFromBoard({ cfg, context }));
+        } catch (err) {
+          if (!(err instanceof ext.ContextNotFoundError)) throw err;
+          console.error(`❌ ${err.message}`);
+          context = await pickContext(`No context named "${context}" — pick one of the contexts on this board:`);
+          console.log(`▶ Reading context "${context}" from the board...`);
+          slices = await withAuthRetry(() => ext.loadFromBoard({ cfg, context }));
+        }
+        opts.context = context;
+      }
+    } catch (err) {
+      console.error(`❌ ${err.message}`);
+      process.exit(1);
+    }
+    const outDir = resolve(cwd, opts.out);
+    if (opts.check) {
+      const result = ext.check({ slices, outDir, context: opts.context });
+      if (!result) {
+        console.log('ℹ️  No slices found — nothing to check.');
+        return;
+      }
+      if (result.new.length) console.log(`new (${result.new.length}):\n${result.new.map((l) => `   ${l}`).join('\n')}`);
+      if (result.changed.length) {
+        console.log(`changed (${result.changed.length}):`);
+        for (const { label, changes, renamedFrom } of result.changed) console.log(`   ${label}${renamedFrom ? ` (renamed from ${renamedFrom})` : ''}\n${changes.map((c) => `      ${c}`).join('\n')}`);
+      }
+      if (result.removed.length) console.log(`removed from the model (${result.removed.length}):\n${result.removed.map((l) => `   ${l}`).join('\n')}`);
+      if (result.inSync) {
+        console.log(`✅ "${result.context}" is in sync with the catalog (${result.unchanged.length} resources).`);
+        return;
+      }
+      console.log(`❌ "${result.context}" is out of sync. Run \`eventmodelers export --type eventcatalog --context "${result.context}"\` (add --force to update resources already in the catalog).`);
+      process.exit(1);
+    }
+    // The SDK comes from the catalog, never from this CLI. Missing → offer to install it there.
+    let sdk = await ext.loadSdk(outDir);
+    if (!sdk) {
+      console.log(`@eventcatalog/sdk is not installed in ${outDir}.`);
+      const install = await selectPrompt('Install @eventcatalog/sdk into this catalog now (npm install)?', [
+        { label: 'Yes, run `npm install @eventcatalog/sdk` there', value: true },
+        { label: 'No, cancel the export', value: false },
+      ]);
+      if (!install) {
+        console.error('❌ The export needs @eventcatalog/sdk in the catalog. Install it (npm install @eventcatalog/sdk) and re-run.');
+        process.exit(1);
+      }
+      try {
+        ext.installSdk(outDir);
+        sdk = await ext.loadSdk(outDir);
+      } catch (err) {
+        console.error(`❌ Could not install @eventcatalog/sdk: ${err.message}`);
+        process.exit(1);
+      }
+      if (!sdk) {
+        console.error('❌ @eventcatalog/sdk still cannot be resolved from the catalog after installing.');
+        process.exit(1);
+      }
+    }
+    const { written, skipped, model } = await ext.run({ slices, outDir, context: opts.context, force: opts.force, owners: opts.owner, sdk });
+    if (!model) {
+      console.log('ℹ️  No slices found — nothing exported.');
+      return;
+    }
+    console.log(`✅ Exported "${model.domain.name}" to ${outDir}: ${written.length} files written${skipped.length ? `, ${skipped.length} skipped (already in the catalog; use --force to overwrite)` : ''}.`);
+    for (const f of skipped) console.log(`   skipped ${f}`);
+  });
+
 program
   .command('scaffold <target> [args...]')
   .description('`scaffold add-user <email> <password> [dir]` adds a sign-in user to a scaffolded app (run in its folder, or pass dir). `scaffold re-init [dir]` refreshes every kit the app has (root and web/) from this CLI version — `re-init --stack` for each, the skeleton itself untouched. Otherwise: generate a runnable app skeleton from the board — sign-in, navigation with one entry per timeline, a page shell per screen, 501 for every unbuilt endpoint, hot reload — and install the build kits of the chosen --type into it, ready for `run` to add slices. <target> is an empty or new directory, or a skeleton made earlier (which is refreshed from the current model).')

package/extensions/eventcatalog/README.md

@@ -0,0 +1,23 @@
+# EventCatalog export
+
+```
+eventmodelers export --type eventcatalog [--context <name>] [--local [path]] [--out <dir>] [--owner <id>]... [-f, --force]
+```
+
+Reads the slices of an event model and writes EventCatalog resources into `--out` (default: cwd), using the
+**EventCatalog SDK** (`@eventcatalog/sdk`).
+
+- Source: the board by default (no `--context` → pick from the board's contexts). `--local` reads `./.slices/`, then `./config.json`, or the path you give.
+- The SDK is resolved from the target catalog's `node_modules` — it is not a dependency of this CLI. If the catalog lacks it, the CLI asks before running `npm install @eventcatalog/sdk` there.
+- `--owner <id>` (repeatable) sets `owners` on every resource; the id must be a team or user in the catalog, or the linter flags it.
+- Resources already in the catalog (same id and version) are skipped. `--force` overwrites them, and — reading the board — asks for credentials again.
+
+| Event model | EventCatalog |
+|---|---|
+| context | `domains/<Context>` |
+| chapter | `flows/<Chapter>Flow` (steps ordered by first appearance, edges from dependencies) |
+| events, commands | `events/`, `commands/` with `schema.json` (de-duplicated by title) |
+| read models | `queries/` with `schema.json` |
+| processors, screens | not exported: the event model has no services, so none is imported or created |
+
+`model.js` (slices → model) and `render.js` (model → SDK resources) are pure; `write.js` is the only part that touches the catalog.

package/extensions/eventcatalog/index.js

@@ -0,0 +1,32 @@
+// `eventmodelers export --type eventcatalog` — writes an EventCatalog project's resources
+// (domain, flow, events, commands, queries) from the slices of an event model, through the
+// EventCatalog SDK. Exports run({ slices, outDir, context, force, owners, sdk }).
+
+import { buildModel } from './model.js';
+import { toResources } from './render.js';
+import { writeResources } from './write.js';
+import { diffAgainst, readManifest, snapshotsOf, updateManifest } from './manifest.js';
+
+export { loadFromBoard, loadFromLocal, listContexts, ContextNotFoundError } from './load.js';
+export { loadSdk, installSdk, isCatalog } from './write.js';
+
+// `export --check`: compares the model with what the last export recorded. Writes nothing, needs no SDK.
+export function check({ slices, outDir, context }) {
+  if (!slices.length) return null;
+  const model = buildModel(slices, { context });
+  const diff = diffAgainst(readManifest(outDir), model.domain.name, snapshotsOf(model));
+  return { context: model.domain.name, ...diff, inSync: !diff.new.length && !diff.changed.length && !diff.removed.length };
+}
+
+// `sdk` is the SDK's factory (see loadSdk); the catalog at `outDir` is where it writes.
+export async function run({ slices, outDir, context, force = false, owners = [], sdk }) {
+  if (!slices.length) return { written: [], skipped: [], model: null };
+  const model = buildModel(slices, { context });
+  const resources = toResources(model, { owners });
+  const { written, skipped } = await writeResources(sdk(outDir), resources, { force });
+  // Only what was actually written is recorded: a skipped resource keeps its old snapshot (or none), so
+  // `--check` keeps reporting it until it is really brought up to date.
+  const snapshots = snapshotsOf(model);
+  updateManifest(outDir, model.domain.name, Object.fromEntries(written.map((label) => [label, snapshots[label]])));
+  return { written, skipped, model };
+}

package/extensions/eventcatalog/load.js

@@ -0,0 +1,78 @@
+// Where the slices come from: the board (default) or local files (--local).
+
+import { existsSync, readdirSync, readFileSync, statSync } from 'fs';
+import { join, resolve } from 'path';
+import { FetchAuthError } from '../../lib/fetch.js';
+
+export class ContextNotFoundError extends Error {}
+
+const DEFAULT_BASE_URL = 'https://api.eventmodelers.ai';
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+
+const readJson = (p) => JSON.parse(readFileSync(p, 'utf-8'));
+
+// Every context on the board, as the server resolves them — a timeline with no assigned context counts as its own
+// context. Derived from the slice summaries, so contexts without slices do not show up (there is nothing to export).
+export async function listContexts({ cfg }) {
+  const baseUrl = cfg.baseUrl || DEFAULT_BASE_URL;
+  const res = await fetch(`${baseUrl}/api/org/${cfg.organizationId}/boards/${cfg.boardId}/slicedata/slices`, { headers: { 'x-token': cfg.token, 'x-user-id': 'cli-export' } });
+  if (res.status === 401) throw new FetchAuthError(401, 'slicedata/slices: invalid or expired token');
+  if (res.status === 403) throw new FetchAuthError(403, "slicedata/slices: token's organization does not match this board");
+  if (res.status === 404) throw new FetchAuthError(404, `slicedata/slices: board ${cfg.boardId} not found`);
+  if (!res.ok) throw new Error(`slicedata/slices: HTTP ${res.status}`);
+  const counts = new Map();
+  for (const s of (await res.json()).slices ?? []) {
+    const name = s.contextName || 'default';
+    counts.set(name, (counts.get(name) ?? 0) + 1);
+  }
+  return [...counts].map(([name, slices]) => ({ name, slices }));
+}
+
+// Same endpoint `fetch` uses (json format); throws FetchAuthError on 401/403 so the CLI can re-prompt.
+export async function loadFromBoard({ cfg, context }) {
+  if (!context) throw new Error('No context given.');
+  const baseUrl = cfg.baseUrl || DEFAULT_BASE_URL;
+  const query = UUID_RE.test(context) ? `contextId=${encodeURIComponent(context)}` : `contextName=${encodeURIComponent(context)}`;
+  const url = `${baseUrl}/api/org/${cfg.organizationId}/boards/${cfg.boardId}/slicedata?${query}&format=json`;
+  const res = await fetch(url, { headers: { 'x-token': cfg.token, 'x-user-id': 'cli-export' } });
+  if (res.status === 401) throw new FetchAuthError(401, 'slicedata: invalid or expired token');
+  if (res.status === 403) throw new FetchAuthError(403, "slicedata: token's organization does not match this board");
+  if (res.status === 404) {
+    const body = await res.json().catch(() => null);
+    throw new ContextNotFoundError(`slicedata: ${body?.error || `no context or timeline named "${context}"`} (board ${cfg.boardId})`);
+  }
+  if (!res.ok) throw new Error(`slicedata: HTTP ${res.status}`);
+  return (await res.json()).slices ?? [];
+}
+
+// `local` is true (auto-detect) or a path to a config.json, a .slices/ folder, a context folder, or a slice.json.
+// Auto-detect tries ./.slices/ first, then ./config.json.
+export function loadFromLocal({ cwd, local, context }) {
+  const candidates = typeof local === 'string' ? [resolve(cwd, local)] : [join(cwd, '.slices'), join(cwd, 'config.json')];
+  const path = candidates.find((p) => existsSync(p));
+  if (!path) throw new Error(`No local slices found (looked for ${candidates.join(', ')}).`);
+  const slices = statSync(path).isDirectory() ? fromFolder(path) : fromFile(path);
+  const wanted = context?.toLowerCase();
+  return wanted ? slices.filter((s) => (s.context ?? '').toLowerCase() === wanted) : slices;
+}
+
+function fromFile(path) {
+  const data = readJson(path);
+  return Array.isArray(data.slices) ? data.slices : [data];
+}
+
+// A .slices/ folder holds <context>/<slice>/slice.json (and a <context>/config.json dump of the same data).
+function fromFolder(dir) {
+  const slices = [];
+  const walk = (d, depth) => {
+    for (const entry of readdirSync(d, { withFileTypes: true })) {
+      const p = join(d, entry.name);
+      if (entry.isDirectory() && depth < 3) walk(p, depth + 1);
+      else if (entry.name === 'slice.json') slices.push(readJson(p));
+    }
+  };
+  walk(dir, 0);
+  // slice.json drops `index`; order from the context's index.json when there is one.
+  slices.forEach((s, i) => { if (s.index === undefined) s.index = i; });
+  return slices;
+}

package/extensions/eventcatalog/manifest.js

@@ -0,0 +1,139 @@
+// What the last export wrote, so `export --check` can tell what moved in the model since — and say what.
+// Only the parts EM-Studio owns are recorded and compared (name, summary from the description, fields,
+// flow steps). Everything else in a catalog resource belongs to the catalog and is never looked at.
+// Kept in the catalog, per context: label ("events/OrderPlaced") → snapshot.
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { dirname, join } from 'path';
+
+const FILE = join('.eventmodelers', 'eventcatalog-export.json');
+
+const field = (f) => ({
+  name: f.name,
+  type: f.type ?? 'String',
+  cardinality: f.cardinality ?? 'Single',
+  optional: Boolean(f.optional),
+  ...(f.example ? { example: f.example } : {}),
+  ...(f.subfields?.length ? { subfields: f.subfields.map(field) } : {}),
+});
+
+// The summary is only EM-Studio's when the model has a description; otherwise null = "not ours".
+const message = (n) => ({ name: n.name, summary: n.description || null, keys: [...n.elementIds].sort(), fields: n.fields.map(field) });
+
+export function snapshotsOf(model) {
+  const out = {};
+  for (const [folder, list] of [['events', model.events], ['commands', model.commands], ['queries', model.queries]]) {
+    for (const n of list) out[`${folder}/${n.id}`] = message(n);
+  }
+  for (const flow of model.flows) {
+    out[`flows/${flow.id}`] = {
+      name: flow.name,
+      steps: flow.steps.map((s) => ({
+        id: s.id, title: s.node.name, keys: [...s.node.elementIds].sort(),
+        // next carries the target's keys too, so a renamed target is still the same target
+        next: s.next.map((nid) => { const t = flow.steps.find((x) => x.id === nid).node; return { id: nid, keys: [...t.elementIds].sort() }; }),
+      })),
+    };
+  }
+  out[`domains/${model.domain.id}`] = { name: model.domain.name };
+  return out;
+}
+
+export function readManifest(catalogDir) {
+  const path = join(catalogDir, FILE);
+  if (!existsSync(path)) return {};
+  try {
+    return JSON.parse(readFileSync(path, 'utf-8'));
+  } catch {
+    return {}; // unreadable → treated as "nothing exported yet"
+  }
+}
+
+// Merges `snapshots` into the context's entry.
+export function updateManifest(catalogDir, context, snapshots) {
+  const manifest = readManifest(catalogDir);
+  manifest[context] = { resources: { ...(manifest[context]?.resources ?? {}), ...snapshots }, exportedAt: new Date().toISOString() };
+  const path = join(catalogDir, FILE);
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, JSON.stringify(manifest, null, 2) + '\n');
+}
+
+const same = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+const quote = (s) => (s === null || s === undefined ? '(none)' : `"${s}"`);
+
+function describeFields(before, after, prefix = '') {
+  const lines = [];
+  const was = new Map(before.map((f) => [f.name, f]));
+  const now = new Map(after.map((f) => [f.name, f]));
+  for (const [name, f] of now) {
+    const old = was.get(name);
+    if (!old) { lines.push(`+ field ${prefix}${name} (${f.type}${f.cardinality === 'Single' ? '' : ` ${f.cardinality}`}${f.optional ? ', optional' : ''})`); continue; }
+    const parts = [];
+    if (old.type !== f.type) parts.push(`type ${old.type} → ${f.type}`);
+    if (old.cardinality !== f.cardinality) parts.push(`cardinality ${old.cardinality} → ${f.cardinality}`);
+    if (old.optional !== f.optional) parts.push(f.optional ? 'now optional' : 'now required');
+    if (old.example !== f.example) parts.push(`example ${quote(old.example)} → ${quote(f.example)}`);
+    if (parts.length) lines.push(`~ field ${prefix}${name}: ${parts.join(', ')}`);
+    if (old.subfields || f.subfields) lines.push(...describeFields(old.subfields ?? [], f.subfields ?? [], `${prefix}${name}.`));
+  }
+  for (const name of was.keys()) if (!now.has(name)) lines.push(`- field ${prefix}${name}`);
+  return lines;
+}
+
+// Two entries are the same element when they share a board id; entries without ids (stubs) match by id.
+const matches = (a, b) => (a.keys?.length && b.keys?.length ? a.keys.some((k) => b.keys.includes(k)) : a.id === b.id);
+const nextIds = (list) => list.map((n) => n.id).join(', ') || '(none)';
+
+function describeSteps(before, after) {
+  const lines = [];
+  const used = new Set();
+  for (const s of after) {
+    const old = before.find((b) => !used.has(b) && matches(b, s));
+    if (!old) { lines.push(`+ step ${s.id}`); continue; }
+    used.add(old);
+    if (old.id !== s.id) lines.push(`~ step ${old.id} → ${s.id}`);
+    const oldNext = old.next.map((n) => (typeof n === 'string' ? { id: n } : n));
+    const gone = oldNext.filter((o) => !s.next.some((n) => matches(o, n)));
+    const added = s.next.filter((n) => !oldNext.some((o) => matches(o, n)));
+    if (gone.length || added.length) lines.push(`~ step ${s.id}: next ${nextIds(oldNext)} → ${nextIds(s.next)}`);
+  }
+  for (const b of before) if (!used.has(b)) lines.push(`- step ${b.id}`);
+  return lines;
+}
+
+// The human-readable changes between two snapshots of one resource.
+export function describeChange(before, after) {
+  const lines = [];
+  if (before.name !== after.name) lines.push(`name: ${quote(before.name)} → ${quote(after.name)}`);
+  // A summary only counts when the model has a description (see `message`).
+  if (after.summary !== null && after.summary !== undefined && before.summary !== after.summary) lines.push(`summary: ${quote(before.summary)} → ${quote(after.summary)}`);
+  if (after.fields) lines.push(...describeFields(before.fields ?? [], after.fields));
+  if (after.steps) lines.push(...describeSteps(before.steps ?? [], after.steps));
+  return lines;
+}
+
+// new: not exported yet · changed: [{ label, changes, renamedFrom? }] · removed: exported before, gone from the model.
+// A "new" and a "removed" resource of the same kind that share a board element id are one resource, renamed.
+export function diffAgainst(manifest, context, snapshots) {
+  const before = manifest[context]?.resources ?? {};
+  const result = { new: [], changed: [], removed: [], unchanged: [] };
+  const kind = (label) => label.split('/')[0];
+  const missing = Object.keys(before).filter((label) => !(label in snapshots));
+
+  for (const [label, snap] of Object.entries(snapshots)) {
+    const old = before[label];
+    if (old && typeof old === 'object') {
+      const changes = describeChange(old, snap);
+      if (changes.length) result.changed.push({ label, changes });
+      else result.unchanged.push(label);
+      continue;
+    }
+    const was = snap.keys?.length ? missing.find((m) => kind(m) === kind(label) && before[m]?.keys?.some((k) => snap.keys.includes(k))) : null;
+    if (!was) { result.new.push(label); continue; }
+    missing.splice(missing.indexOf(was), 1);
+    const id = (l) => l.split('/').slice(1).join('/');
+    result.changed.push({ label, renamedFrom: was, changes: [`id: ${id(was)} → ${id(label)}`, ...describeChange(before[was], snap)] });
+  }
+  result.removed = missing;
+  return result;
+}

package/extensions/eventcatalog/model.js

@@ -0,0 +1,111 @@
+// Slices → a neutral EventCatalog model: one domain, one flow per chapter, and the events, commands and queries
+// (read models) of the event model. Processors, screens and services are not part of it — the model has no
+// such thing as a service, so none is imported or invented. Pure — no I/O — so it is testable without a catalog.
+
+const ELEMENT_KINDS = [
+  ['commands', 'command'],
+  ['events', 'event'],
+  ['readmodels', 'query'],
+];
+const DEP_KINDS = { COMMAND: 'command', EVENT: 'event', READMODEL: 'query' };
+
+// "Payment confirmed" / "Payment Confirmed" / "payment_confirmed" are one element.
+const normalize = (title) => String(title ?? '').toLowerCase().replace(/[^a-z0-9]/g, '');
+
+export function pascal(title) {
+  return String(title ?? '')
+    .split(/[^A-Za-z0-9]+/)
+    .filter(Boolean)
+    .map((w) => w[0].toUpperCase() + w.slice(1))
+    .join('');
+}
+
+const clean = (title) => String(title ?? '').trim().replace(/\s+/g, ' ');
+
+export function buildModel(slices, { context } = {}) {
+  const ordered = [...slices].sort((a, b) => (a.index ?? 0) - (b.index ?? 0));
+  const contextName = clean(context || ordered[0]?.context || 'Default');
+  const nodes = new Map(); // `${kind}:${normalized}` → node
+  const byElementId = new Map(); // board element id (and linkedId) → node
+  const edges = new Map(); // `${from}>${to}` → { from, to }
+
+  function node(kind, title, slice) {
+    const key = `${kind}:${normalize(title)}`;
+    let n = nodes.get(key);
+    if (!n) {
+      n = { key, kind, id: pascal(title), name: clean(title), description: '', fields: [], slices: [], elementIds: [] };
+      nodes.set(key, n);
+    }
+    if (slice && !n.slices.includes(slice)) n.slices.push(slice);
+    return n;
+  }
+
+  function mergeFields(n, fields = []) {
+    for (const f of fields) if (!n.fields.some((x) => x.name === f.name)) n.fields.push(f);
+  }
+
+  const link = (from, to) => edges.set(`${from.key}>${to.key}`, { from, to });
+
+  const pending = [];
+  for (const slice of ordered) {
+    for (const [prop, kind] of ELEMENT_KINDS) {
+      for (const el of slice[prop] ?? []) {
+        const n = node(kind, el.title, slice.title);
+        if (!n.description && el.description) n.description = el.description;
+        mergeFields(n, el.fields);
+        byElementId.set(el.id, n);
+        if (el.linkedId) byElementId.set(el.linkedId, n);
+        // The board's ids survive a rename of the title, so a later export can tell a rename from a new element.
+        for (const id of [el.id, el.linkedId]) if (id && !n.elementIds.includes(id)) n.elementIds.push(id);
+        pending.push([n, el]);
+      }
+    }
+  }
+
+  // Dependencies are resolved after every element is known, by id first and by title second.
+  // A target nothing in the slices defines (e.g. a read model from another context) becomes a stub.
+  for (const [n, el] of pending) {
+    for (const dep of el.dependencies ?? []) {
+      const kind = DEP_KINDS[dep.elementType];
+      if (!kind) continue;
+      // A message nothing defines (e.g. from another context) becomes a stub. Dependencies on processors
+      // and screens never get here: DEP_KINDS doesn't know them, so they are dropped above.
+      const target = byElementId.get(dep.id) ?? nodes.get(`${kind}:${normalize(dep.title)}`) ?? node(kind, dep.title);
+      if (dep.type === 'INBOUND') link(target, n);
+      else link(n, target);
+    }
+  }
+
+  const real = [...nodes.values()];
+
+  const ctxId = pascal(contextName);
+  const find = (kind) => real.filter((n) => n.kind === kind);
+
+  // The flow: one step per element in order of first appearance, edges from the dependencies.
+  const inFlow = real;
+  const stepId = (n) => `${n.kind}-${n.id}`;
+  const steps = inFlow.map((n) => {
+    const next = [...edges.values()].filter((e) => e.from === n && inFlow.includes(e.to)).map((e) => stepId(e.to));
+    return { id: stepId(n), node: n, next };
+  });
+
+  const chapters = new Set(ordered.map((s) => clean(s.chapter || contextName)));
+  const flows = [...chapters].map((chapter) => {
+    const inChapter = new Set(ordered.filter((s) => clean(s.chapter || contextName) === chapter).map((s) => s.title));
+    const chapterSteps = steps.filter((s) => s.node.slices.some((t) => inChapter.has(t)));
+    const ids = new Set(chapterSteps.map((s) => s.id));
+    return {
+      id: `${pascal(chapter)}Flow`,
+      name: chapter,
+      steps: chapterSteps.map((s) => ({ ...s, next: s.next.filter((x) => ids.has(x)) })),
+    };
+  });
+
+  return {
+    domain: { id: ctxId, name: contextName },
+    events: find('event'),
+    commands: find('command'),
+    queries: find('query'),
+    flows,
+  };
+}

package/extensions/eventcatalog/render.js

@@ -0,0 +1,82 @@
+// Model → file contents. Everything returned is `{ path, content }`, relative to the catalog root.
+
+const JSON_TYPES = {
+  string: { type: 'string' },
+  text: { type: 'string' },
+  uuid: { type: 'string', format: 'uuid' },
+  date: { type: 'string', format: 'date' },
+  datetime: { type: 'string', format: 'date-time' },
+  time: { type: 'string', format: 'time' },
+  boolean: { type: 'boolean' },
+  int: { type: 'integer' },
+  integer: { type: 'integer' },
+  long: { type: 'integer' },
+  double: { type: 'number' },
+  float: { type: 'number' },
+  decimal: { type: 'number' },
+  number: { type: 'number' },
+};
+
+function fieldSchema(f) {
+  const base = f.subfields?.length ? objectSchema(f.subfields) : { ...(JSON_TYPES[String(f.type ?? '').toLowerCase()] ?? { type: 'string' }) };
+  if (f.example !== undefined && f.example !== '') base.examples = [f.example];
+  if (f.description) base.description = f.description;
+  return /^(list|multiple|array)$/i.test(f.cardinality ?? '') ? { type: 'array', items: base } : base;
+}
+
+function objectSchema(fields) {
+  const properties = {};
+  for (const f of fields) properties[f.name] = fieldSchema(f);
+  const required = fields.filter((f) => !f.optional).map((f) => f.name);
+  return { type: 'object', properties, ...(required.length ? { required } : {}) };
+}
+
+export function toJsonSchema(fields) {
+  return { $schema: 'http://json-schema.org/draft-07/schema#', ...objectSchema(fields) };
+}
+
+const KIND_LABEL = { event: 'Event', command: 'Command', query: 'Query' };
+const VERSION = '1.0.0';
+
+// EventCatalog's linter requires a summary; fall back to a plain statement when the model has no description.
+const summary = (n, context) => n.description || `${KIND_LABEL[n.kind]} ${n.name} of ${context}.`;
+const usedIn = (n) => (n.slices.length ? `\nUsed in: ${n.slices.join(', ')}.\n` : '\n');
+
+// Model → resources in the shape the EventCatalog SDK writes (`writeEvent`, `writeQuery`, …), plus the
+// schema files to attach afterwards. Nothing is written here.
+export function toResources(model, { owners = [] } = {}) {
+  const ctx = model.domain.name;
+  const owned = owners.length ? { owners } : {};
+  const message = (n) => ({
+    resource: {
+      id: n.id, name: n.name, version: VERSION, summary: summary(n, ctx), ...owned,
+      ...(n.fields.length ? { schemaPath: 'schema.json' } : {}),
+      markdown: `## Overview\n\n${n.name}.${usedIn(n)}`,
+    },
+    schema: n.fields.length ? JSON.stringify(toJsonSchema(n.fields), null, 2) + '\n' : null,
+  });
+  return {
+    events: model.events.map(message),
+    commands: model.commands.map(message),
+    queries: model.queries.map(message),
+    flows: model.flows.map((flow) => ({
+      resource: {
+        id: flow.id, name: flow.name, version: VERSION, summary: `Event model of ${flow.name}.`, ...owned,
+        steps: flow.steps.map((s) => ({
+          id: s.id,
+          title: s.node.name,
+          message: { id: s.node.id },
+          ...(s.next.length > 1 ? { next_steps: s.next } : s.next.length ? { next_step: s.next[0] } : {}),
+        })),
+        markdown: `## Overview\n\nGenerated from the event model chapter "${flow.name}".\n`,
+      },
+    })),
+    domain: {
+      resource: {
+        id: model.domain.id, name: ctx, version: VERSION, summary: `Event model context ${ctx}.`, ...owned,
+        ...(model.flows.length ? { flows: model.flows.map((f) => ({ id: f.id })) } : {}),
+        markdown: `## Overview\n\nExported from the Eventmodelers context "${ctx}".\n`,
+      },
+    },
+  };
+}

package/extensions/eventcatalog/write.js

@@ -0,0 +1,63 @@
+// Writes the resources through the EventCatalog SDK, which the *catalog* provides: it is resolved from the
+// target directory's node_modules, never bundled with this CLI, so it always matches the catalog's version.
+
+import { execFileSync } from 'child_process';
+import { existsSync, readFileSync } from 'fs';
+import { createRequire } from 'module';
+import { join } from 'path';
+
+const PACKAGE = '@eventcatalog/sdk';
+
+// An EventCatalog project has an eventcatalog.config.* file and/or depends on @eventcatalog/core.
+export function isCatalog(dir) {
+  if (['js', 'mjs', 'cjs', 'ts'].some((ext) => existsSync(join(dir, `eventcatalog.config.${ext}`)))) return true;
+  try {
+    const pkg = JSON.parse(readFileSync(join(dir, 'package.json'), 'utf-8'));
+    return Boolean({ ...pkg.dependencies, ...pkg.devDependencies }['@eventcatalog/core']);
+  } catch {
+    return false;
+  }
+}
+
+// The SDK's `utils` factory, or null when the catalog doesn't have the package.
+export async function loadSdk(catalogDir) {
+  let file;
+  try {
+    file = createRequire(join(catalogDir, 'package.json')).resolve(PACKAGE);
+  } catch {
+    return null;
+  }
+  const mod = await import(file);
+  return typeof mod.default === 'function' ? mod.default : mod.default.default; // CJS entry nests the factory
+}
+
+// `npm install` into the catalog — adds the SDK to the *catalog's* package.json, not this CLI's.
+export function installSdk(catalogDir) {
+  execFileSync('npm', ['install', PACKAGE], { cwd: catalogDir, stdio: 'inherit' });
+}
+
+// [resources key, SDK name part, singular for `<x>HasVersion`, label folder]
+const KINDS = [
+  ['events', 'Event', 'event', 'events'], ['commands', 'Command', 'command', 'commands'], ['queries', 'Query', 'query', 'queries'],
+  ['flows', 'Flow', 'flow', 'flows'], ['domain', 'Domain', 'domain', 'domains'],
+];
+
+// Existing resources (same id and version) are left alone — they may have been edited. `force` overwrites them.
+// The schema file is attached after the resource (its `schemaPath` is already in the frontmatter).
+export async function writeResources(utils, resources, { force = false } = {}) {
+  const written = [];
+  const skipped = [];
+  for (const [key, Name, singular, folder] of KINDS) {
+    const items = key === 'domain' ? [resources.domain] : resources[key];
+    for (const { resource, schema } of items) {
+      const label = `${folder}/${resource.id}`;
+      if (await utils[`${singular}HasVersion`](resource.id, resource.version)) {
+        if (!force) { skipped.push(label); continue; }
+      }
+      await utils[`write${Name}`](resource, { override: force });
+      if (schema) await utils[`addSchemaTo${Name}`](resource.id, { schema, fileName: 'schema.json' }, resource.version);
+      written.push(label);
+    }
+  }
+  return { written, skipped };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eventmodelers/cli",
-  "version": "2.0.10",
+  "version": "2.0.11",
   "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": {
@@ -12,6 +12,7 @@
   "files": [
     "cli.js",
     "lib",
+    "extensions",
     "shared",
     "stacks",
     "README.md",

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

@@ -320,9 +320,9 @@ export async function fetchAndPersistSlices(cfg, kitDir) {
       mkdirSync(sliceDir, { recursive: true });
       const sliceJsonPath = join(sliceDir, 'slice.json');
       const existingSlice = existsSync(sliceJsonPath) ? JSON.parse(readFileSync(sliceJsonPath, 'utf-8')) : {};
-      // The summary omits ticketNumber and assignee when the slice has none, so a cleared one must be cleared
+      // The summary omits ticketNumber, assignee and features when the slice has none, so a cleared one must be cleared
       // here too — otherwise the old one survives the merge and lands on the next build.
-      writeFileSync(sliceJsonPath, JSON.stringify({ ...existingSlice, ...slice, status: statusOf(state, slice), ticketNumber: slice.ticketNumber ?? null, assignee: slice.assignee ?? null }, null, 2), 'utf-8');
+      writeFileSync(sliceJsonPath, JSON.stringify({ ...existingSlice, ...slice, status: statusOf(state, slice), ticketNumber: slice.ticketNumber ?? null, assignee: slice.assignee ?? null, features: slice.features ?? null }, null, 2), 'utf-8');
     }
   }
 
@@ -508,6 +508,25 @@ export function readPickupStatus(kitDir) {
   return 'Planned';
 }
 
+// `run --feature <name>` (RALPH_FEATURE): only slices that belong to this feature are picked up.
+// Matched like the board does — trimmed, case-insensitive. Empty means no filter.
+export function readFeatureFilter() {
+  return (process.env.RALPH_FEATURE || '').trim().toLowerCase();
+}
+
+// Whether a slice is in the feature — its `features` as of the last fetch, from its slice.json. A slice
+// whose slice.json is missing or has no features is not in any feature, so a filter skips it.
+export function sliceInFeature(kitDir, ctx, folder, feature) {
+  if (!feature) return true;
+  if (!folder) return false;
+  try {
+    const { features } = JSON.parse(readFileSync(join(kitDir, '.slices', ctx, folder, 'slice.json'), 'utf-8'));
+    return Array.isArray(features) && features.some((f) => typeof f === 'string' && f.trim().toLowerCase() === feature);
+  } catch {
+    return false;
+  }
+}
+
 function readCurrentContext(kitDir) {
   const ctxPath = join(kitDir, '.slices', 'current_context.json');
   if (!existsSync(ctxPath)) return null;
@@ -531,7 +550,7 @@ function readSliceMeta(kitDir, ctx, folder) {
 // before the next one starts. When the current context has no planned work, the first other
 // context that does becomes the current one (current_context.json is rewritten), so a slice
 // set to Planned in any context is eventually built. Ids in `skipIds` are passed over.
-function getFirstPlannedSlice(kitDir, skipIds = new Set()) {
+export function getFirstPlannedSlice(kitDir, skipIds = new Set()) {
   const slicesDir = join(kitDir, '.slices');
   const currentCtx = readCurrentContext(kitDir);
   let others = [];
@@ -539,13 +558,14 @@ function getFirstPlannedSlice(kitDir, skipIds = new Set()) {
     others = readdirSync(slicesDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort();
   } catch {}
   const pickup = statusKey(readPickupStatus(kitDir));
+  const feature = readFeatureFilter();
   const candidates = [...(currentCtx ? [currentCtx] : []), ...others.filter((c) => c !== currentCtx)];
   for (const ctx of candidates) {
     const indexPath = join(slicesDir, ctx, 'index.json');
     if (!existsSync(indexPath)) continue;
     try {
       const { slices } = JSON.parse(readFileSync(indexPath, 'utf-8'));
-      const planned = slices && slices.find((s) => statusKey(s.status) === pickup && !skipIds.has(s.id));
+      const planned = slices && slices.find((s) => statusKey(s.status) === pickup && !skipIds.has(s.id) && sliceInFeature(kitDir, ctx, s.folder, feature));
       if (!planned) continue;
       if (ctx !== currentCtx) {
         writeFileSync(join(slicesDir, 'current_context.json'), JSON.stringify({ name: ctx }, null, 2), 'utf-8');
@@ -561,13 +581,14 @@ function getFirstPlannedSlice(kitDir, skipIds = new Set()) {
 function listPlannedIds(kitDir) {
   const slicesDir = join(kitDir, '.slices');
   const pickup = statusKey(readPickupStatus(kitDir));
+  const feature = readFeatureFilter();
   const ids = new Set();
   try {
     for (const d of readdirSync(slicesDir, { withFileTypes: true })) {
       if (!d.isDirectory()) continue;
       try {
         const { slices } = JSON.parse(readFileSync(join(slicesDir, d.name, 'index.json'), 'utf-8'));
-        for (const s of slices ?? []) if (statusKey(s.status) === pickup) ids.add(s.id);
+        for (const s of slices ?? []) if (statusKey(s.status) === pickup && sliceInFeature(kitDir, d.name, s.folder, feature)) ids.add(s.id);
       } catch {}
     }
   } catch {}
@@ -770,6 +791,7 @@ async function ralphLoop(kitDir, cfg, onTask, onPlannedSlice, localOnly = false,
   const board = credentialed ? createBoard(cfg) : null;
   const meta = eventMeta(cfg);
   ensureLearningsGitRules(kitDir);
+  if (readFeatureFilter()) console.log(`[ralph] --feature "${process.env.RALPH_FEATURE.trim()}" — only slices of that feature are picked up.`);
   // 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.');

package/shared/skills/learn-eventmodelers-api/SKILL.md

@@ -831,6 +831,29 @@ Build structured slice data from board state.
 
 ---
 
+### Slice features (`features`)
+
+A slice can belong to one or more **features** — free-text names such as `Seat reservation` that group slices across chapters (the people on the board see them in the Features list in the toolbar, where picking one fades every column that isn't part of it). They live on the slice's SLICE_BORDER as `meta.features`, an array of strings.
+
+- **Read**: the slice data of a slice carries `features` (omitted when it has none), next to `ticketNumber` and `assignee`.
+- **Use**: treat `features` as context — slices sharing a feature belong together, so when a build touches shared concepts, look at the sibling slices of the same feature before inventing a new name or shape. It never changes what a slice must do, and an empty list is normal.
+- **Set** (only when the user asks you to group slices): a `node:changed` event on the SLICE_BORDER, same shape as the status update. Send the **whole** list — it replaces the old one — and reuse an existing feature's exact spelling instead of adding a near-duplicate (`Booking` vs `booking`; the board treats them as one, but keep them tidy):
+
+```bash
+curl -s -X POST "<BASE_URL>/api/org/<ORG_ID>/boards/<BOARD_ID>/nodes/events" \
+  -H "Content-Type: application/json" \
+  -H "x-token: <TOKEN>" \
+  -d '[{
+    "id": "<new-random-uuid>",
+    "eventType": "node:changed",
+    "nodeId": "<SLICE_NODE_ID>",
+    "changedAttributes": ["features"],
+    "meta": { "type": "SLICE_BORDER", "features": ["Seat reservation"] }
+  }]'
+```
+
+---
+
 ### GET `/api/org/:orgId/boards/:boardId/slicedata/slices`
 List all slices on a board.
 

package/shared/skills/load-slice/SKILL.md

@@ -57,7 +57,7 @@ This returns `{ "slices": [ { "id": "...", "title": "...", "status": "..." } ] }
 mcp__eventmodelers__get_slice_data { "boardId": "<BOARD_ID>", "contextName": "<name>" }
 ```
 
-This call stays full (no `projection`): Step 3 persists the complete slice object as `slice.json`, which the build skills read fields, specs and comments from. When only one slice is needed, pass `sliceId` as well.
+This call stays full (no `projection`): Step 3 persists the complete slice object as `slice.json`, which the build skills read fields, specs and comments from. It also carries the slice's `features` (names grouping slices across chapters, see `learn-eventmodelers-api` → "Slice features"), `ticketNumber` and `assignee` when it has them. When only one slice is needed, pass `sliceId` as well.
 
 (`get_slice_data` requires a `contextName` or `contextId`. If the context isn't already known, list the context names in one call — `mcp__eventmodelers__get_nodes { "boardId": "<BOARD_ID>", "type": "MODEL_CONTEXT", "projection": "line" }` (only titles needed; a timeline name works as `contextName` too, so fall back to `type: "CHAPTER"` with `projection: "line"` when there are no MODEL_CONTEXT nodes) — then map slices to contexts with `list_slices { "boardId": "<BOARD_ID>", "contextName": "<name>" }` per context. Don't `get_node` each `SLICE_BORDER`.)