@eventmodelers/cli 0.0.27 → 0.0.29

package/README.md

@@ -68,7 +68,17 @@ npx @eventmodelers/cli init --bridge --target spec-kitty
 npx @eventmodelers/cli bridge
 ```
 
-`init --bridge` installs a `.bridge-kit/` (mirrors `.build-kit/`'s realtime + task-queue loop) plus only the skills for the chosen `--target` (`shared/bridge/<target>/`) — a `spec-kitty` bridge never installs Kiro's skills, and vice versa. `bridge` starts the loop: on every board slice change (not just "Planned", unlike build-kit), it re-runs `bridge-<target>-specify` to regenerate that framework's spec artifacts from the current `.slices/` export. It doesn't build code and doesn't claim slices. Pass `--ollama` for the local-Ollama runner instead of Claude (same caveat as build-kit's `--ollama`: `lib/ollama-agent.js` is shared as-is).
+`init --bridge` installs a `.bridge-kit/` (mirrors `.build-kit/`'s realtime + task-queue loop) plus only the skills for the chosen `--target` (`shared/bridge/<target>/`) — a `spec-kitty` bridge never installs Kiro's skills, and vice versa. `bridge` starts the loop: on every board slice change (not just "Planned", unlike build-kit), it regenerates that framework's spec artifacts from the current board state. It doesn't build code and doesn't claim slices.
+
+For `spec-kitty`, that sync is deterministic and stops well short of writing Spec Kitty's own artifacts — `lib/adapters/spec-kitty-adapter.js` fetches full slice detail and restates it as a plain markdown mission brief (one section per slice, its scenarios verbatim, nothing invented), then calls `spec-kitty intake --force` to install it at `.kittify/mission-brief.md`. It deliberately doesn't create the mission, write `spec.md`, or author work packages — Spec Kitty's own `/spec-kitty.specify` → `/spec-kitty.plan` → `/spec-kitty.tasks` pipeline does that, because those steps need real judgment (work package boundaries, which files a WP owns, which agent profile fits) that only makes sense with actual codebase context, which this adapter doesn't have. What it replaces is Spec Kitty's *interactive discovery interview*: `/spec-kitty.specify`'s own "Brief Context Detection" step reads `.kittify/mission-brief.md` when present and extracts requirements from it instead of asking the user, so the event model — not a live Q&A — becomes the input. No LLM call happens in this adapter's own path, and `bridge` picks it automatically whenever a target has one (`--claude` forces the Claude runner instead). Targets without a static adapter yet fall back to Claude re-running `bridge-<target>-specify`; pass `--ollama` for the local-Ollama runner instead (same caveat as build-kit's `--ollama`: `lib/ollama-agent.js` is shared as-is).
+
+Don't want the standing loop at all? `fetch` can call the same adapter for a single one-shot sync, no `.bridge-kit/` install required:
+
+```bash
+npx @eventmodelers/cli fetch --context Ticketing --spec-kitty
+```
+
+Either way, `spec-kitty init` (Spec Kitty's own project setup) has to have already been run in the project root — the adapter checks for `.kittify/` first and stops with the exact command to run if it's missing, rather than failing deep inside a cryptic `spec-kitty` CLI error. After the sync, run `/spec-kitty.specify` in your coding agent to turn the brief into an actual mission (the plain `spec-kitty specify` CLI command only scaffolds — brief detection is in the agent-driven prompt).
 
 ### Overriding the executor with a hook
 
@@ -79,7 +89,7 @@ npx @eventmodelers/cli init --bridge --target spec-kitty --hook "git add .slices
 npx @eventmodelers/cli bridge
 ```
 
-`init --bridge --hook` persists the command to `.bridge-kit/bridge.json` — a plain, **committed** file (unlike `.eventmodelers/config.json`, which is gitignored for credentials) since the hook is project policy meant to be shared by every teammate and CI runner, not per-machine state. `bridge --hook "<command>"` overrides it for a single run without touching that file. Only one executor runs per invocation — `--ollama` and `--hook` are mutually exclusive.
+`init --bridge --hook` persists the command to `.bridge-kit/bridge.json` — a plain, **committed** file (unlike `.eventmodelers/config.json`, which is gitignored for credentials) since the hook is project policy meant to be shared by every teammate and CI runner, not per-machine state. `bridge --hook "<command>"` overrides it for a single run without touching that file. Only one executor runs per invocation — `--ollama`, `--hook`, and `--claude` are mutually exclusive.
 
 The hook command runs with `BRIDGE_TASK_COUNT`, `BRIDGE_SLICE_ID`/`_TITLE`/`_STATUS` (the most recent change in the batch), and `BRIDGE_BATCH_FILE` (path to the full batch as JSON) in its environment. It's invoked once per batch, not once per slice — any change that arrives while the hook is still running is left queued for the next batch rather than dropped.
 
@@ -225,9 +235,9 @@ npx @eventmodelers/cli run --ollama                 # same, via local Ollama (ra
 npx @eventmodelers/cli run --bash                   # bash-only loop, no realtime (ralph.sh)
 npx @eventmodelers/cli listen                       # start the code-export listener (code-export.mjs) from the installed kit dir
 npx @eventmodelers/cli listen --port 4000           # same, on a different port
-npx @eventmodelers/cli fetch                        # pull full slice detail from every context on the board into <kit-dir>/.slices/ (project root if no kit, or a modeling-kit, is installed)
-npx @eventmodelers/cli fetch --slice-id <id>        # same, then print just that slice
-npx @eventmodelers/cli fetch --slice-title <title>  # same, then print just the slice matching this title
+npx @eventmodelers/cli fetch --context <name>                     # pull full slice detail for one context on the board into <kit-dir>/.slices/ (project root if no kit, or a modeling-kit, is installed)
+npx @eventmodelers/cli fetch --context <name> --slice-id <id>     # same, then print just that slice
+npx @eventmodelers/cli fetch --context <name> --slice-title <title> # same, then print just the slice matching this title
 npx @eventmodelers/cli stacks                       # list available stacks
 npx @eventmodelers/cli status                       # check what's installed
 npx @eventmodelers/cli config                       # print the fully resolved config (file + env), token masked
@@ -238,7 +248,7 @@ npx @eventmodelers/cli uninstall                    # remove everything init/ini
 
 `listen` is the same kind of dispatcher, but for `<kit-dir>/code-export.mjs` — a local HTTP server (port 3001 by default) that the eventmodelers board UI posts slice/screen data to, which then gets written under `<kit-dir>/.slices/`.
 
-`fetch` is the pull-based counterpart to `listen`: instead of waiting for the board UI to push data to a running listener, it lists every `MODEL_CONTEXT` node on the board, calls `slicedata?contextId=<id>` for each (full slice detail — commands/events/readmodels/screens/processors/specifications/comments), and writes the same `.slices/<context>/<slice>/slice.json`, `index.json`, and `context.json` layout — useful in CI or any context where nothing is listening on a port. It does not fetch screen images (those only arrive via `listen`'s push). Unlike every other command, `fetch` also works with no kit installed at all — it only needs credentials, not kit-specific files — and, unique to modeling-kit, writes `.slices/` to the project root instead of nesting it under `.agent-modeling-kit/`, since nothing reads it from there (modeling-kit has no `code-export.mjs`/`listen`). If credentials are missing, it prompts the same way `init-config` does. `--slice-id`/`--slice-title` still fetch and persist everything, then just print the one you asked about.
+`fetch` is the pull-based counterpart to `listen`: instead of waiting for the board UI to push data to a running listener, it calls `slicedata?contextName=<name>` for the required `--context` (full slice detail — commands/events/readmodels/screens/processors/specifications/comments), and writes the same `.slices/<context>/<slice>/slice.json`, `index.json`, and `context.json` layout — useful in CI or any context where nothing is listening on a port. It does not fetch screen images (those only arrive via `listen`'s push). Unlike every other command, `fetch` also works with no kit installed at all — it only needs credentials, not kit-specific files — and, unique to modeling-kit, writes `.slices/` to the project root instead of nesting it under `.agent-modeling-kit/`, since nothing reads it from there (modeling-kit has no `code-export.mjs`/`listen`). If credentials are missing, it prompts the same way `init-config` does. `--slice-id`/`--slice-title` still fetch and persist the whole context, then just print the one slice you asked about.
 
 ### Uninstall
 

package/cli.js

@@ -19,6 +19,7 @@ import { createInterface, emitKeypressEvents, moveCursor, clearScreenDown } from
 import { homedir } from 'os';
 import { randomUUID } from 'crypto';
 import { runFetch, FetchAuthError } from './lib/fetch.js';
+import { run as runSpecKittyAdapter } from './lib/adapters/spec-kitty-adapter.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -631,6 +632,14 @@ async function installStack(stackKey, stackCfg, options = {}) {
     }
     copyDirContents(join(templatesSource, stackCfg.kitSubdir), kitDir, { skip: ['.eventmodelers'] });
 
+    // Static (no-LLM) bridge adapters live once in this package's own lib/
+    // adapters/ — `fetch --spec-kitty` imports them directly, and a bridge
+    // install gets its own copy here so ralph-static.js can run standalone
+    // with no access back to the published package.
+    if (isBridge) {
+      copyDirContents(join(__dirname, 'lib', 'adapters'), join(kitDir, 'adapters'));
+    }
+
     // Make scripts executable
     for (const script of ['ralph.sh', 'lib/agent.sh', 'ralph-claude.js', 'ralph-ollama.js']) {
       const p = join(kitDir, script);
@@ -1393,9 +1402,10 @@ program
 
 program
   .command('bridge')
-  .description('Start the bridge agent loop from the installed .bridge-kit/ — translates board slice changes into another spec framework instead of building code. Claude is the default executor; --ollama or --hook override it.')
-  .option('--ollama', 'Use ralph-ollama.js instead of the default Claude runner')
+  .description('Start the bridge agent loop from the installed .bridge-kit/ — translates board slice changes into another spec framework instead of building code. A deterministic adapter runs with no LLM call if one exists for the configured target (e.g. spec-kitty); otherwise Claude is the default executor. --ollama, --hook, or --claude override the pick.')
+  .option('--ollama', 'Use ralph-ollama.js instead of the default runner')
   .option('--hook <command>', 'Run this shell command instead of an AI agent for each batch of slice changes (e.g. commit + push .slices/ for a CI pipeline to pick up) — overrides any hook persisted via `init --bridge --hook` for this run only')
+  .option('--claude', 'Force the Claude runner even if a static adapter exists for this target')
   .action((opts) => {
     const cwd = process.cwd();
     const kitDir = findAllInstalledKitDirs(cwd).find((d) => d.endsWith(BRIDGE_KIT.kitDirName)) ?? null;
@@ -1404,8 +1414,8 @@ program
       process.exit(1);
     }
 
-    if (opts.ollama && opts.hook) {
-      console.error('❌ --ollama and --hook are mutually exclusive — pick one executor.');
+    if ([opts.ollama, opts.hook, opts.claude].filter(Boolean).length > 1) {
+      console.error('❌ --ollama, --hook, and --claude are mutually exclusive — pick one executor.');
       process.exit(1);
     }
 
@@ -1413,13 +1423,23 @@ program
     // plain sibling file — NOT under .eventmodelers/, which is gitignored (see
     // the comment in `init`'s --bridge branch) and would otherwise make this
     // per-machine instead of a shared, checked-in team/CI convention.
-    const persistedHook = readJsonSafe(join(kitDir, 'bridge.json')).hookCommand;
+    const bridgeCfg = readJsonSafe(join(kitDir, 'bridge.json'));
+    const persistedHook = bridgeCfg.hookCommand;
     const hookCmd = opts.hook || persistedHook;
 
-    // v1 has no --bash equivalent, unlike `run` — the default/--ollama path
-    // needs an actual agent, not a plain shell script; --hook is the escape
-    // hatch for teams who want a plain shell command instead of an AI agent.
-    const runner = hookCmd ? 'ralph-hook.js' : opts.ollama ? 'ralph-ollama.js' : 'ralph-claude.js';
+    // A static adapter (adapters/<target>-adapter.js, e.g. spec-kitty-adapter.js)
+    // is deterministic and costs no LLM call, so it wins over the Claude default
+    // whenever one exists for the configured target — --claude opts back out.
+    const staticAdapterPath = join(kitDir, 'adapters', `${bridgeCfg.target}-adapter.js`);
+    const hasStaticAdapter = bridgeCfg.target && existsSync(staticAdapterPath);
+
+    const runner = hookCmd
+      ? 'ralph-hook.js'
+      : opts.ollama
+        ? 'ralph-ollama.js'
+        : !opts.claude && hasStaticAdapter
+          ? 'ralph-static.js'
+          : 'ralph-claude.js';
     const runnerPath = join(kitDir, runner);
     if (!existsSync(runnerPath)) {
       console.error(`❌ ${relative(cwd, runnerPath)} not found.`);
@@ -1463,9 +1483,11 @@ program
 
 program
   .command('fetch')
-  .description('Pull full slice detail from every context on the board via the slicedata API and write it into .slices/ — the pull-based counterpart to `listen`, without screen images')
+  .description('Pull full slice detail for one context on the board via the slicedata API and write it into .slices/ — the pull-based counterpart to `listen`, without screen images')
+  .requiredOption('--context <name>', 'Name of the MODEL_CONTEXT to fetch')
   .option('--slice-id <id>', 'After fetching, print just the slice with this id')
   .option('--slice-title <title>', 'After fetching, print just the slice with this title (case-insensitive)')
+  .option('--spec-kitty', "After fetching, also restate this context as a Spec Kitty mission brief (.kittify/mission-brief.md via `spec-kitty intake`) — deterministic, no LLM call, no mission/spec.md/tasks created. Run `/spec-kitty.specify` afterward to turn the brief into a mission. Requires `spec-kitty init` to already be set up in this project (see lib/adapters/spec-kitty-adapter.js). One-shot: does not start a loop.")
   .action(async (opts, command) => {
     const cwd = process.cwd();
     const kitDir = findInstalledKitDir(cwd);
@@ -1520,6 +1542,15 @@ program
       await promptForCredentials();
       await runFetch({ cwd, kitDir: slicesKitDir, cfg, opts });
     }
+
+    if (opts.specKitty) {
+      try {
+        await runSpecKittyAdapter({ cfg, projectDir: cwd, contextName: opts.context });
+      } catch (err) {
+        console.error(`❌ ${err.message}`);
+        process.exit(1);
+      }
+    }
   });
 
 program

package/lib/adapters/spec-kitty-adapter.js

@@ -0,0 +1,165 @@
+// Spec Kitty adapter — turns an Eventmodelers context into a Spec Kitty
+// mission brief, deterministically, with no LLM call. It deliberately stops
+// there: Spec Kitty's own `/spec-kitty.specify` → `/spec-kitty.plan` →
+// `/spec-kitty.tasks` pipeline is what creates the mission, spec.md, and work
+// packages, because those steps require real judgment (WP boundaries, which
+// files a WP owns, which agent profile fits) that only make sense with actual
+// codebase context — this adapter has none of that, only the event model.
+//
+// Spec Kitty already has a first-class way to accept structured input instead
+// of running its interactive discovery interview: `spec-kitty intake <path>`
+// writes .kittify/mission-brief.md, and /spec-kitty.specify's own "Brief
+// Context Detection" step reads that file and extracts requirements from it
+// (asking 0-3 gap-filling questions instead of a full interview) — this
+// adapter's whole job is producing a good brief and calling `intake`, nothing
+// more.
+//
+// Lives here (not only inside a bridge-kit install) so it has exactly one
+// entry point regardless of caller: `eventmodelers fetch --spec-kitty` calls
+// it directly for a one-shot sync; `eventmodelers bridge` (via
+// ralph-static.js) calls the same run() from a copy the bridge-kit installer
+// places at .bridge-kit/adapters/ — see installStack in cli.js.
+//
+// Exports run({ cfg, projectDir, contextName }).
+
+import { execFileSync } from 'child_process';
+import { existsSync, unlinkSync, writeFileSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+
+const DEFAULT_BASE_URL = 'https://api.eventmodelers.ai';
+
+function slugify(text) {
+  return (text ?? '')
+    .toString()
+    .toLowerCase()
+    .trim()
+    .replace(/\s+/g, '-')
+    .replace(/[^\w-]+/g, '')
+    .replace(/-+/g, '-')
+    .replace(/^-+/, '')
+    .replace(/-+$/, '');
+}
+
+// Mirrors lib/fetch.js's per-context call rather than importing runFetch
+// directly — this fetches raw JSON only, it never touches .slices/ (fetch.js
+// owns writing that), and a copy of this file also has to run standalone
+// inside an installed .bridge-kit/ with no access to lib/fetch.js at all.
+async function fetchFullSliceData(cfg, contextName) {
+  const baseUrl = cfg.baseUrl || DEFAULT_BASE_URL;
+  const url = `${baseUrl}/api/org/${cfg.organizationId}/boards/${cfg.boardId}/slicedata?contextName=${encodeURIComponent(contextName)}`;
+  const res = await fetch(url, {
+    headers: { 'x-token': cfg.token, 'x-board-id': cfg.boardId, 'x-user-id': 'spec-kitty-adapter' },
+  });
+  if (!res.ok) throw new Error(`slicedata fetch failed for context "${contextName}": HTTP ${res.status}`);
+  return res.json();
+}
+
+// Set on errors that no amount of retrying will fix (missing setup, missing
+// binary) — callers should stop instead of retrying on these: ralph-static.js
+// exits instead of looping forever, `fetch --spec-kitty` just reports and exits.
+function fatal(message) {
+  const err = new Error(message);
+  err.fatal = true;
+  return err;
+}
+
+function assertSpecKittyInitialized(projectDir) {
+  if (!existsSync(join(projectDir, '.kittify'))) {
+    throw fatal(
+      `Spec Kitty isn't initialized in ${projectDir} (no .kittify/ found).\n` +
+        '  Run this once from the project root, then re-sync:\n' +
+        '    spec-kitty init --ai claude --non-interactive',
+    );
+  }
+}
+
+// given/when/then are each arrays of element objects (command/event/etc.,
+// each with its own `title`), not plain strings — confirmed against a real
+// slicedata payload. `title` is the specification's own natural-language
+// summary (e.g. "Cannot move on the opponent's turn") and is populated
+// whenever the board has one, so it's the primary source; the given/when/then
+// element names are only a fallback for specs that somehow lack a title.
+function elementNames(elements) {
+  return (elements || []).map((e) => e?.title).filter(Boolean).join(', ');
+}
+
+function formatScenario(spec) {
+  if (spec?.title) return spec.title;
+  const given = elementNames(spec?.given);
+  const when = elementNames(spec?.when);
+  const then = elementNames(spec?.then);
+  if (given || when || then) {
+    return `Given ${given || '…'}, when ${when || '…'}, then ${then || '…'}.`;
+  }
+  return spec?.description || null;
+}
+
+// Plain prose, in board/timeline order — nothing here is invented. Priority,
+// WP boundaries, and requirement IDs are exactly the judgment calls left to
+// /spec-kitty.specify; this only restates what the event model already says.
+export function buildBrief({ contextName, slices }) {
+  const lines = [
+    `# Event model: ${contextName}`,
+    '',
+    `This is a Spec Kitty mission brief generated from the "${contextName}" context on the Eventmodelers board — not free-text from a user. It restates the event model as-is; it does not add scope, priority, or requirements the board doesn't state.`,
+    '',
+  ];
+
+  for (const slice of slices) {
+    lines.push(`## ${slice.title}`);
+    lines.push('');
+    if (slice.description?.trim()) {
+      lines.push(slice.description.trim());
+      lines.push('');
+    }
+
+    const scenarios = (slice.specifications || []).map(formatScenario).filter(Boolean);
+    if (scenarios.length) {
+      for (const s of scenarios) lines.push(`- ${s}`);
+    } else {
+      lines.push('_No specifications captured for this slice on the board yet._');
+    }
+    lines.push('');
+  }
+
+  return lines.join('\n');
+}
+
+export async function run({ cfg, projectDir, contextName }) {
+  assertSpecKittyInitialized(projectDir);
+
+  console.log(`[spec-kitty-adapter] Fetching context "${contextName}"...`);
+  const payload = await fetchFullSliceData(cfg, contextName);
+  const slices = payload.slices || [];
+  if (!slices.length) {
+    console.log(`[spec-kitty-adapter] No slices in context "${contextName}" — nothing to write.`);
+    return;
+  }
+
+  const contextSlug = slugify(contextName) || 'default';
+  const briefPath = join(tmpdir(), `eventmodelers-brief-${contextSlug}.md`);
+  writeFileSync(briefPath, buildBrief({ contextName, slices }));
+
+  try {
+    execFileSync('spec-kitty', ['intake', briefPath, '--force'], { cwd: projectDir, stdio: 'inherit' });
+  } catch (err) {
+    if (err.code === 'ENOENT') {
+      throw fatal('`spec-kitty` CLI not found on PATH — install spec-kitty-cli first (see https://github.com/dilgerma/spec-kitty).');
+    }
+    throw new Error(`spec-kitty intake failed: ${err.stderr || err.message}`);
+  } finally {
+    try {
+      unlinkSync(briefPath);
+    } catch {
+      // Scratch file in tmpdir — not worth failing the sync over.
+    }
+  }
+
+  console.log(
+    `[spec-kitty-adapter] Brief synced from ${slices.length} slice(s) in "${contextName}" → .kittify/mission-brief.md.\n` +
+      '  Run the `/spec-kitty.specify` slash command in your coding agent to turn it into a mission ' +
+      '(the plain `spec-kitty specify` CLI command only scaffolds — brief detection and requirement ' +
+      'extraction happen in the agent-driven prompt, not the bare CLI).',
+  );
+}

package/lib/fetch.js

@@ -15,6 +15,16 @@ export class FetchAuthError extends Error {
   }
 }
 
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+
+// `--context` accepts any of: a MODEL_CONTEXT name or id, or a timeline (CHAPTER) name or id.
+// /slicedata's contextId/contextName params now both resolve against MODEL_CONTEXT nodes first,
+// then timelines (id matched exactly, name case-insensitively) — including a timeline with no
+// assigned/connected context, which is its own context, not an error (same rule the canvas
+// frontend's resolveContext applies: "an unassigned timeline is its own context"). So there's
+// nothing left to resolve here — just route a uuid-shaped input to contextId, everything else to
+// contextName, and let the server do the actual lookup.
+
 function readJsonSafe(path) {
   if (!path || !existsSync(path)) return {};
   try {
@@ -45,18 +55,24 @@ function sliceFolderName(title) {
   return (title ?? '').replaceAll(' ', '').replaceAll('slice:', '').toLowerCase();
 }
 
-// Pulls full slice detail from every context on a board and writes it into
+// Pulls full slice detail from a single context on a board and writes it into
 // .slices/, mirroring the layout code-export.mjs's /api/generate handler produces
 // (minus screen images, which only ever arrive via that push-based listener).
 //
 // kitDir here is null for modeling-kit (see cli.js's fetch action) — nothing
 // nests .slices/ under .agent-modeling-kit/, so it lands at cwd instead.
-// { cwd, kitDir, cfg: { token, organizationId, boardId, baseUrl }, opts: { sliceId?, sliceTitle? } }
+// { cwd, kitDir, cfg: { token, organizationId, boardId, baseUrl }, opts: { context, sliceId?, sliceTitle? } }
 export async function runFetch({ cwd, kitDir, cfg, opts = {} }) {
   const baseUrl = cfg.baseUrl || DEFAULT_BASE_URL;
   const headers = { 'x-token': cfg.token, 'x-board-id': cfg.boardId, 'x-user-id': 'cli-fetch' };
 
-  async function fetchJson(url, what) {
+  // assertBoardAccess (the guard every one of these routes runs behind) only ever
+  // answers 401/403 for credential/board-access problems — a 404 here always means
+  // "the thing at this path doesn't exist" (e.g. no MODEL_CONTEXT with that name),
+  // never "board not found". Only 401/403 are credential problems worth the
+  // reconfigure-and-retry dance in cli.js; 404 gets reported and the process exits,
+  // same as any other non-auth error.
+  async function fetchJson(url, what, { allow404 = false } = {}) {
     let res;
     try {
       res = await fetch(url, { headers });
@@ -66,7 +82,12 @@ export async function runFetch({ cwd, kitDir, cfg, opts = {} }) {
     }
     if (res.status === 401) throw new FetchAuthError(401, `${what}: invalid or expired token`);
     if (res.status === 403) throw new FetchAuthError(403, `${what}: token's organization does not match this board`);
-    if (res.status === 404) throw new FetchAuthError(404, `${what}: board not found`);
+    if (res.status === 404) {
+      if (allow404) return null;
+      const body = await res.json().catch(() => null);
+      console.error(`❌ ${what}: ${body?.error || 'not found'}`);
+      process.exit(1);
+    }
     if (!res.ok) {
       console.error(`❌ ${what}: HTTP ${res.status}`);
       process.exit(1);
@@ -74,63 +95,49 @@ export async function runFetch({ cwd, kitDir, cfg, opts = {} }) {
     return res.json();
   }
 
-  console.log(`▶ Fetching slices from ${baseUrl} (board ${cfg.boardId})...`);
-
-  // No dedicated "list contexts" endpoint — MODEL_CONTEXT nodes are the contexts,
-  // same as how the connect skill lists CHAPTER nodes for its health check.
-  const contextNodes = await fetchJson(
-    `${baseUrl}/api/org/${cfg.organizationId}/boards/${cfg.boardId}/nodes?type=MODEL_CONTEXT`,
-    'nodes?type=MODEL_CONTEXT',
-  );
-  if (!contextNodes?.length) {
-    console.log('ℹ️  No contexts found on this board.');
-    return;
-  }
-
   // Falls back to cwd when no kit is installed — fetch doesn't need kit-specific
   // files, just somewhere to write .slices/.
   const SLICES_DIR = join(kitDir || cwd, '.slices');
 
+  const contextInput = opts.context;
+
+  console.log(`▶ Fetching context "${contextInput}" from ${baseUrl} (board ${cfg.boardId})...`);
+
   // /slicedata (buildSliceData) is per-context and returns full slice detail —
-  // commands/events/readmodels/screens/processors/specifications/comments — unlike
-  // the lightweight /slicedata/slices summary. There's no "all contexts in one
-  // call" variant, so fetch each context's full data and merge client-side.
-  const allSlices = [];
-  for (const node of contextNodes) {
-    const contextName = node.meta?.title ?? node.node?.data?.title ?? '';
-    // contextId is the normal path (we already have the node id); contextName is
-    // the fallback the endpoint itself supports when an id can't be resolved.
-    const contextQuery = node.id ? `contextId=${encodeURIComponent(node.id)}` : `contextName=${encodeURIComponent(contextName)}`;
-    const payload = await fetchJson(
-      `${baseUrl}/api/org/${cfg.organizationId}/boards/${cfg.boardId}/slicedata?${contextQuery}`,
-      `slicedata?${contextQuery}`,
-    );
-    const { slices } = payload;
-    allSlices.push(...slices);
-
-    if (slices.length) {
-      // Mirrors code-export.mjs's /api/generate: a raw per-context payload dump at
-      // .slices/<context>/config.json, alongside the per-slice output below — kept
-      // for parity with `listen` even though nothing in this repo reads it back.
-      const contextSlug = slugify(slices[0]?.context || contextName || 'default') || 'default';
-      const baseFolder = join(SLICES_DIR, contextSlug);
-      mkdirSync(baseFolder, { recursive: true });
-      writeFileSync(join(baseFolder, 'config.json'), JSON.stringify(payload, null, 2));
-    }
+  // commands/events/readmodels/screens/processors/specifications/comments. It resolves
+  // contextId/contextName against MODEL_CONTEXT nodes first, then timelines, entirely
+  // server-side — including the self-context fallback for a timeline with no assigned
+  // context — so all that's left here is routing a uuid-shaped input to contextId and
+  // everything else to contextName. A 404 (no match) surfaces via fetchJson below.
+  const contextQuery = UUID_RE.test(contextInput)
+    ? `contextId=${encodeURIComponent(contextInput)}`
+    : `contextName=${encodeURIComponent(contextInput)}`;
+  const payload = await fetchJson(
+    `${baseUrl}/api/org/${cfg.organizationId}/boards/${cfg.boardId}/slicedata?${contextQuery}`,
+    `slicedata?${contextQuery}`,
+  );
+  const { slices: allSlices } = payload;
+  const displayContext = allSlices[0]?.context || contextInput;
+
+  if (allSlices.length) {
+    // Mirrors code-export.mjs's /api/generate: a raw per-context payload dump at
+    // .slices/<context>/config.json, alongside the per-slice output below — kept
+    // for parity with `listen` even though nothing in this repo reads it back.
+    const contextSlug = slugify(displayContext || 'default') || 'default';
+    const baseFolder = join(SLICES_DIR, contextSlug);
+    mkdirSync(baseFolder, { recursive: true });
+    writeFileSync(join(baseFolder, 'config.json'), JSON.stringify(payload, null, 2));
   }
 
   if (!allSlices.length) {
-    console.log('ℹ️  No slices found on this board.');
+    console.log(`ℹ️  No slices found in context "${displayContext}".`);
     return;
   }
 
-  const contextNames = new Set();
-
   for (const slice of allSlices) {
     // buildSliceData names this field `context`, not `contextName` (that's the
     // /slicedata/slices summary endpoint's field) — read the one this endpoint sends.
-    const contextName = slice.context || 'default';
-    contextNames.add(contextName);
+    const contextName = slice.context || displayContext || 'default';
     const contextSlug = slugify(contextName) || 'default';
     const baseFolder = join(SLICES_DIR, contextSlug);
     const sliceFolder = sliceFolderName(slice.title);
@@ -165,14 +172,12 @@ export async function runFetch({ cwd, kitDir, cfg, opts = {} }) {
     writeFileSync(indexFile, JSON.stringify(sliceIndices, null, 2));
   }
 
-  // A single shared current_context.json only makes sense when everything fetched
-  // belongs to one context — with several, any one choice would be arbitrary, so
-  // leave whatever `listen`/a prior fetch already wrote there untouched.
-  if (contextNames.size === 1) {
-    writeFileSync(join(SLICES_DIR, 'current_context.json'), JSON.stringify({ name: [...contextNames][0] }, null, 2));
-  }
+  // Persist the *resolved* context name (not the raw --context input, which may
+  // have been a timeline name/id or context id) so the next run's assigned-context
+  // fallback, and shared/build-kit/lib/ralph.js's readCurrentContext, see a real name.
+  writeFileSync(join(SLICES_DIR, 'current_context.json'), JSON.stringify({ name: displayContext }, null, 2));
 
-  console.log(`✅ Fetched ${allSlices.length} slice${allSlices.length === 1 ? '' : 's'} across ${contextNames.size} context${contextNames.size === 1 ? '' : 's'} → ${relative(cwd, SLICES_DIR)}/`);
+  console.log(`✅ Fetched ${allSlices.length} slice${allSlices.length === 1 ? '' : 's'} from context "${displayContext}" → ${relative(cwd, SLICES_DIR)}/`);
 
   // --slice-id/--slice-title mirror load-slice's Step 4/5 — fetch+persist everything
   // regardless, then just report the one the caller asked about.

package/package.json

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

package/{stacks/node/templates/.claude → shared}/skills/load-slice/SKILL.md

@@ -140,4 +140,4 @@ All slices (<count>) — context: <contextSlug>:
   - ...
 ```
 
-Make the matched slice's `id`, `title`, `status`, and local folder path available to subsequent steps in the same session.
+Make the matched slice's `id`, `title`, `status`, and local folder path available to subsequent steps in the same session.

package/stacks/bridge/templates/bridge/ralph-static.js

@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+// Bridge loop that hands each batch of slice changes to a deterministic JS
+// adapter instead of an AI agent or an arbitrary shell hook — no LLM call
+// happens in this mode. Which adapter runs is picked by bridge.json's target
+// (adapters/<target>-adapter.js); if the installed target has no adapter file
+// yet, this exits with a clear error rather than silently doing nothing.
+//
+// Usage: node ralph-static.js [project_dir]
+
+import { startRalph, loadLocalConfig, fetchPlatformConfig } from './lib/ralph.js';
+import { existsSync, readFileSync } from 'fs';
+import { dirname, join, resolve } from 'path';
+import { fileURLToPath, pathToFileURL } from 'url';
+
+const kitDir = dirname(fileURLToPath(import.meta.url));
+const projectDir = process.argv[2] ? resolve(process.argv[2]) : resolve(kitDir, '..');
+
+function loadBridgeConfig() {
+  const p = join(kitDir, 'bridge.json');
+  if (!existsSync(p)) return {};
+  try {
+    return JSON.parse(readFileSync(p, 'utf-8'));
+  } catch {
+    return {};
+  }
+}
+
+const target = loadBridgeConfig().target;
+if (!target) {
+  console.error('[bridge-static] No target configured in bridge.json — run `eventmodelers init --bridge --target <name>` first.');
+  process.exit(1);
+}
+
+const adapterPath = join(kitDir, 'adapters', `${target}-adapter.js`);
+if (!existsSync(adapterPath)) {
+  console.error(`[bridge-static] No static adapter for target "${target}" (expected ${adapterPath}).`);
+  console.error('  Use the default Claude runner for this target instead: `eventmodelers bridge`.');
+  process.exit(1);
+}
+
+const local = loadLocalConfig(kitDir);
+
+// The adapter itself doesn't know about the bridge loop's .slices/ convention
+// (fetch --spec-kitty calls the same run() with a context name of its own) —
+// this is the one place that convention still applies, so resolve it here.
+function readCurrentContext() {
+  const ctxPath = join(kitDir, '.slices', 'current_context.json');
+  if (!existsSync(ctxPath)) return null;
+  try {
+    return JSON.parse(readFileSync(ctxPath, 'utf-8')).name || null;
+  } catch {
+    return null;
+  }
+}
+
+async function runAdapter() {
+  const contextName = readCurrentContext();
+  if (!contextName) {
+    console.log('[bridge-static] No .slices/current_context.json yet — waiting for the first board sync.');
+    return;
+  }
+
+  const { run } = await import(pathToFileURL(adapterPath).href);
+  const cfg = await fetchPlatformConfig(local);
+  try {
+    await run({ cfg, projectDir, contextName });
+  } catch (err) {
+    // lib/ralph.js retries any onTask failure after 60s forever — right for
+    // transient errors (network blips, a slow spec-kitty command), wrong for
+    // a missing one-time setup step that retrying can never fix on its own.
+    // Adapters flag those with `err.fatal` so we stop instead of looping.
+    if (err.fatal) {
+      console.error(`[bridge-static] ${err.message}`);
+      process.exit(1);
+    }
+    throw err;
+  }
+}
+
+startRalph({
+  kitDir,
+  projectDir,
+  onTask: runAdapter,
+  // onPlannedSlice omitted — see ralph-claude.js in this same directory.
+  agentType: 'BRIDGE',
+  queueAllStatuses: true,
+}).catch((err) => {
+  console.error('[ralph] Fatal:', err);
+  process.exit(1);
+});

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

@@ -49,4 +49,6 @@ Outcome: [what changed on the board]
 - `/wdyt` posts QUESTION comments onto nodes — use for analysis only, not modifications.
 - The `board_id`, `timeline_id`, and `organization_id` from each prompt provide full context — pass them to skills that need them.
 - Node events POST to `/api/boards/:boardId/nodes/events` using `node:created`, `node:changed`, `node:deleted`.
-- `/update-slice-status` rejects moving a slice into a status it's already in — this is a concurrency guard so two agents can't both claim the same slice. Treat this as `ALREADY_IN_STATUS`, not a task failure: drop the prompt, move on to the next task, and do not retry the same update.
+- `/update-slice-status` rejects moving a slice into a status it's already in — this is a concurrency guard so two agents can't both claim the same slice. Treat this as `ALREADY_IN_STATUS`, not a task failure: drop the prompt, move on to the next task, and do not retry the same update.
+- macOS/BSD `date` silently ignores GNU-only format specifiers like `%N`/`%3N` (sub-second precision) instead of erroring — it prints the literal characters, producing a malformed timestamp that only fails downstream. Don't shell out to `date` for sub-second precision; use `$(( $(date +%s) * 1000 ))` for whole-second-in-ms, or a runtime call (`Date.now()`, `process.hrtime()`) instead.
+- Before retrying a failed shell command a second time, diagnose why it failed (e.g. a GNU/BSD flag mismatch) rather than re-running it unchanged — repeating the same command produces the same failure and just burns retries.

package/stacks/axon/templates/.claude/skills/load-slice/SKILL.md

@@ -1,141 +0,0 @@
----
-name: load-slice
-description: Load all slices from the board via the slicedata API and persist them to the .build-kit/.slices/ directory hierarchy (index.json with full definitions, per-slice folders). Returns data for a specific slice by ID or title.
----
-
-# Load Slice
-
-> **Before doing anything else**, invoke the `connect` skill to resolve `TOKEN`, `BOARD_ID`, `ORG_ID`, and `BASE_URL`. Do not proceed until the connect skill has completed.
-
----
-
-## Step 1 — Parse arguments
-
-From `$ARGUMENTS`, extract:
-
-| Field | How to find it | Default |
-|-------|---------------|---------|
-| `sliceId` | UUID of the slice (SLICE_BORDER node ID) | optional — prefer over title |
-| `sliceTitle` | slice title (case-insensitive match) | optional — used if sliceId missing |
-
-If neither is provided, load and persist all slices without filtering.
-
----
-
-## Step 2 — Fetch all slices from the slicedata API
-
-```bash
-curl -s \
-  -H "x-token: <TOKEN>" \
-  -H "x-board-id: <BOARD_ID>" \
-  -H "x-user-id: load-slice-skill" \
-  "<BASE_URL>/api/org/<ORG_ID>/boards/<BOARD_ID>/slicedata/slices"
-```
-
-Response shape: `{ "slices": [ { "id": "...", "title": "...", "status": "...", "context": "...", "comments": ["..."], ... } ] }`
-
-Save the full array as `ALL_SLICES`.
-
----
-
-## Step 3 — Persist slices to .build-kit/.slices/ directory
-
-Apply the following logic for every slice in `ALL_SLICES`.
-
-### Derive paths
-
-- `contextName` = `slice.context` if present, otherwise `"default"` — **preserve original casing** (e.g. `"Beta"`, not `"beta"`)
-- `sliceFolder` = `slice.title` lowercased, with all spaces removed and the prefix `"slice:"` stripped  
-  e.g. `"Beta Enable User for Beta Test"` → `"betaenableuserforbetatest"`
-- `baseFolder` = `.build-kit/.slices/<contextName>/`
-- `sliceDir`   = `.build-kit/.slices/<contextName>/<sliceFolder>/`
-
-### Write files
-
-```bash
-mkdir -p ".build-kit/.slices/<contextName>/<sliceFolder>"
-```
-
-**`.build-kit/.slices/current_context.json`** — always overwrite:
-
-```json
-{ "name": "Beta" }
-```
-
-**`.build-kit/.slices/<contextName>/context.json`** — write once per context:
-
-```json
-{ "name": "Beta" }
-```
-
-**`.build-kit/.slices/<contextName>/<sliceFolder>/slice.json`** — the full slice object with the `index` field removed.
-
-### Maintain `.build-kit/.slices/<contextName>/index.json`
-
-Read the file if it exists, otherwise start with `{ "slices": [] }`.
-
-Each entry in `index.json` contains the index metadata **plus** the complete slice definition fetched from the API:
-
-```json
-{
-  "slices": [
-    {
-      "id": "d0dbc70c-f244-4048-886b-1d11e461f466",
-      "slice": "Beta Enable User for Beta Test",
-      "index": 0,
-      "context": "Beta",
-      "folder": "betaenableuserforbetatest",
-      "status": "Created",
-      "definition": {
-        "id": "d0dbc70c-f244-4048-886b-1d11e461f466",
-        "title": "Beta Enable User for Beta Test",
-        "status": "Created",
-        "context": "Beta"
-      }
-    }
-  ]
-}
-```
-
-The `definition` field holds the full object returned by the API for that slice (all fields as-is).
-
-**Merge rules:**
-- If an entry with the same `id` already exists: update all fields and refresh `definition`; preserve any existing `assigned` field.
-- If not found: append the new entry.
-
-Write the updated object back to `.build-kit/.slices/<contextName>/index.json`.
-
----
-
-## Step 4 — Return the requested slice
-
-If `sliceId` was given: find the entry in `ALL_SLICES` where `id === sliceId`.  
-If `sliceTitle` was given: find the entry where `title` matches case-insensitively.  
-If neither: return all slices.
-
-If a specific slice was requested but not found, stop and list the available titles.
-
----
-
-## Step 5 — Output
-
-```
-Slices loaded: <count> total
-Persisted to: .build-kit/.slices/<contextName>/
-
-Requested slice:
-  Title:  <title>
-  ID:     <id>
-  Status: <status>
-  Folder: .build-kit/.slices/<contextName>/<sliceFolder>/slice.json
-```
-
-Or if no filter was given:
-
-```
-All slices (<count>) — context: <contextName>:
-  - <title> [<status>] → .build-kit/.slices/<contextName>/<sliceFolder>/
-  - ...
-```
-
-Make the matched slice's `id`, `title`, `status`, and local folder path available to subsequent steps in the same session.

package/stacks/cratis-csharp/templates/.claude/skills/load-slice/SKILL.md

@@ -1,141 +0,0 @@
----
-name: load-slice
-description: Load all slices from the board via the slicedata API and persist them to the .build-kit/.slices/ directory hierarchy (index.json with full definitions, per-slice folders). Returns data for a specific slice by ID or title.
----
-
-# Load Slice
-
-> **Before doing anything else**, invoke the `connect` skill to resolve `TOKEN`, `BOARD_ID`, `ORG_ID`, and `BASE_URL`. Do not proceed until the connect skill has completed.
-
----
-
-## Step 1 — Parse arguments
-
-From `$ARGUMENTS`, extract:
-
-| Field | How to find it | Default |
-|-------|---------------|---------|
-| `sliceId` | UUID of the slice (SLICE_BORDER node ID) | optional — prefer over title |
-| `sliceTitle` | slice title (case-insensitive match) | optional — used if sliceId missing |
-
-If neither is provided, load and persist all slices without filtering.
-
----
-
-## Step 2 — Fetch all slices from the slicedata API
-
-```bash
-curl -s \
-  -H "x-token: <TOKEN>" \
-  -H "x-board-id: <BOARD_ID>" \
-  -H "x-user-id: load-slice-skill" \
-  "<BASE_URL>/api/org/<ORG_ID>/boards/<BOARD_ID>/slicedata/slices"
-```
-
-Response shape: `{ "slices": [ { "id": "...", "title": "...", "status": "...", "context": "...", "comments": ["..."], ... } ] }`
-
-Save the full array as `ALL_SLICES`.
-
----
-
-## Step 3 — Persist slices to .build-kit/.slices/ directory
-
-Apply the following logic for every slice in `ALL_SLICES`.
-
-### Derive paths
-
-- `contextName` = `slice.context` if present, otherwise `"default"` — **preserve original casing** (e.g. `"Beta"`, not `"beta"`)
-- `sliceFolder` = `slice.title` lowercased, with all spaces removed and the prefix `"slice:"` stripped  
-  e.g. `"Beta Enable User for Beta Test"` → `"betaenableuserforbetatest"`
-- `baseFolder` = `.build-kit/.slices/<contextName>/`
-- `sliceDir`   = `.build-kit/.slices/<contextName>/<sliceFolder>/`
-
-### Write files
-
-```bash
-mkdir -p ".build-kit/.slices/<contextName>/<sliceFolder>"
-```
-
-**`.build-kit/.slices/current_context.json`** — always overwrite:
-
-```json
-{ "name": "Beta" }
-```
-
-**`.build-kit/.slices/<contextName>/context.json`** — write once per context:
-
-```json
-{ "name": "Beta" }
-```
-
-**`.build-kit/.slices/<contextName>/<sliceFolder>/slice.json`** — the full slice object with the `index` field removed.
-
-### Maintain `.build-kit/.slices/<contextName>/index.json`
-
-Read the file if it exists, otherwise start with `{ "slices": [] }`.
-
-Each entry in `index.json` contains the index metadata **plus** the complete slice definition fetched from the API:
-
-```json
-{
-  "slices": [
-    {
-      "id": "d0dbc70c-f244-4048-886b-1d11e461f466",
-      "slice": "Beta Enable User for Beta Test",
-      "index": 0,
-      "context": "Beta",
-      "folder": "betaenableuserforbetatest",
-      "status": "Created",
-      "definition": {
-        "id": "d0dbc70c-f244-4048-886b-1d11e461f466",
-        "title": "Beta Enable User for Beta Test",
-        "status": "Created",
-        "context": "Beta"
-      }
-    }
-  ]
-}
-```
-
-The `definition` field holds the full object returned by the API for that slice (all fields as-is).
-
-**Merge rules:**
-- If an entry with the same `id` already exists: update all fields and refresh `definition`; preserve any existing `assigned` field.
-- If not found: append the new entry.
-
-Write the updated object back to `.build-kit/.slices/<contextName>/index.json`.
-
----
-
-## Step 4 — Return the requested slice
-
-If `sliceId` was given: find the entry in `ALL_SLICES` where `id === sliceId`.  
-If `sliceTitle` was given: find the entry where `title` matches case-insensitively.  
-If neither: return all slices.
-
-If a specific slice was requested but not found, stop and list the available titles.
-
----
-
-## Step 5 — Output
-
-```
-Slices loaded: <count> total
-Persisted to: .build-kit/.slices/<contextName>/
-
-Requested slice:
-  Title:  <title>
-  ID:     <id>
-  Status: <status>
-  Folder: .build-kit/.slices/<contextName>/<sliceFolder>/slice.json
-```
-
-Or if no filter was given:
-
-```
-All slices (<count>) — context: <contextName>:
-  - <title> [<status>] → .build-kit/.slices/<contextName>/<sliceFolder>/
-  - ...
-```
-
-Make the matched slice's `id`, `title`, `status`, and local folder path available to subsequent steps in the same session.

package/stacks/supabase/templates/.claude/skills/load-slice/SKILL.md

@@ -1,143 +0,0 @@
----
-name: load-slice
-description: Load all slices from the board via the slicedata API and persist them to the .build-kit/.slices/ directory hierarchy (index.json with full definitions, per-slice folders). Returns data for a specific slice by ID or title.
----
-
-# Load Slice
-
-> **Before doing anything else**, invoke the `connect` skill to resolve `TOKEN`, `BOARD_ID`, `ORG_ID`, and `BASE_URL`. Do not proceed until the connect skill has completed.
-
----
-
-## Step 1 — Parse arguments
-
-From `$ARGUMENTS`, extract:
-
-| Field | How to find it | Default |
-|-------|---------------|---------|
-| `sliceId` | UUID of the slice (SLICE_BORDER node ID) | optional — prefer over title |
-| `sliceTitle` | slice title (case-insensitive match) | optional — used if sliceId missing |
-
-If neither is provided, load and persist all slices without filtering.
-
----
-
-## Step 2 — Fetch all slices from the slicedata API
-
-```bash
-curl -s \
-  -H "x-token: <TOKEN>" \
-  -H "x-board-id: <BOARD_ID>" \
-  -H "x-user-id: load-slice-skill" \
-  "<BASE_URL>/api/org/<ORG_ID>/boards/<BOARD_ID>/slicedata/slices"
-```
-
-Response shape: `{ "slices": [ { "id": "...", "title": "...", "status": "...", "contextName": "...", "contextId": "...", "comments": ["..."], ... } ] }`
-
-Save the full array as `ALL_SLICES`.
-
----
-
-## Step 3 — Persist slices to .build-kit/.slices/ directory
-
-Apply the following logic for every slice in `ALL_SLICES`.
-
-### Derive paths
-
-- `contextSlug` = slugify `slice.contextName` if present, otherwise `"default"` — lowercase, spaces to hyphens, non-alphanumeric removed (e.g. `"My Ctx"` → `"my-ctx"`)
-- `sliceFolder` = `slice.title` lowercased, with all spaces removed and the prefix `"slice:"` stripped  
-  e.g. `"Beta Enable User for Beta Test"` → `"betaenableuserforbetatest"`
-- `baseFolder` = `.build-kit/.slices/<contextSlug>/`
-- `sliceDir`   = `.build-kit/.slices/<contextSlug>/<sliceFolder>/`
-
-### Write files
-
-```bash
-mkdir -p ".build-kit/.slices/<contextSlug>/<sliceFolder>"
-```
-
-**`.build-kit/.slices/current_context.json`** — always overwrite:
-
-```json
-{ "name": "Beta" }
-```
-
-**`.build-kit/.slices/<contextSlug>/context.json`** — write once per context:
-
-```json
-{ "name": "Beta" }
-```
-
-**`.build-kit/.slices/<contextSlug>/<sliceFolder>/slice.json`** — the full slice object with the `index` field removed.
-
-### Maintain `.build-kit/.slices/<contextSlug>/index.json`
-
-Read the file if it exists, otherwise start with `{ "slices": [] }`.
-
-Each entry in `index.json` contains the index metadata **plus** the complete slice definition fetched from the API:
-
-```json
-{
-  "slices": [
-    {
-      "id": "d0dbc70c-f244-4048-886b-1d11e461f466",
-      "slice": "Beta Enable User for Beta Test",
-      "index": 0,
-      "contextName": "Beta",
-      "contextSlug": "beta",
-      "folder": "betaenableuserforbetatest",
-      "status": "Created",
-      "definition": {
-        "id": "d0dbc70c-f244-4048-886b-1d11e461f466",
-        "title": "Beta Enable User for Beta Test",
-        "status": "Created",
-        "contextName": "Beta",
-        "contextId": "..."
-      }
-    }
-  ]
-}
-```
-
-The `definition` field holds the full object returned by the API for that slice (all fields as-is).
-
-**Merge rules:**
-- If an entry with the same `id` already exists: update all fields and refresh `definition`; preserve any existing `assigned` field.
-- If not found: append the new entry.
-
-Write the updated object back to `.build-kit/.slices/<contextSlug>/index.json`.
-
----
-
-## Step 4 — Return the requested slice
-
-If `sliceId` was given: find the entry in `ALL_SLICES` where `id === sliceId`.  
-If `sliceTitle` was given: find the entry where `title` matches case-insensitively.  
-If neither: return all slices.
-
-If a specific slice was requested but not found, stop and list the available titles.
-
----
-
-## Step 5 — Output
-
-```
-Slices loaded: <count> total
-Persisted to: .build-kit/.slices/<contextSlug>/
-
-Requested slice:
-  Title:  <title>
-  ID:     <id>
-  Status: <status>
-  Folder: .build-kit/.slices/<contextSlug>/<sliceFolder>/slice.json
-```
-
-Or if no filter was given:
-
-```
-All slices (<count>) — context: <contextSlug>:
-  - <title> [<status>] → .build-kit/.slices/<contextSlug>/<sliceFolder>/
-  - ...
-```
-
-Make the matched slice's `id`, `title`, `status`, and local folder path available to subsequent steps in the same session.