@eventmodelers/cli 0.0.28 → 0.0.30

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.
 

package/cli.js

@@ -14,11 +14,12 @@ import {
   readFileSync,
   appendFileSync,
 } from 'fs';
-import { execSync, spawn } from 'child_process';
+import { execSync, execFileSync, spawn } from 'child_process';
 import { createInterface, emitKeypressEvents, moveCursor, clearScreenDown } from 'readline';
 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);
@@ -545,6 +546,55 @@ function copyDirContents(srcDir, destDir, { skip = [] } = {}) {
   if (count) console.log(`  ✓ Installed ${count} item${count === 1 ? '' : 's'} into ${relative(process.cwd(), destDir) || '.'}`);
 }
 
+// Community/custom build kits (`init --stack <name> --git <url>`) are cloned fresh on
+// every run rather than pulled/updated in place — there's no local state worth
+// preserving between installs, and re-cloning from scratch means a broken or partial
+// previous clone can never linger and cause a confusing stale-file bug. Cached under
+// ~/.eventmodelers (not inside the target project) so it's reusable across projects and
+// definitely not something `uninstall` or the project's own .gitignore need to know about.
+function cloneGitStack(url, branch) {
+  const dest = join(homedir(), '.eventmodelers', 'git-stacks', `${url}${branch ? `#${branch}` : ''}`.replace(/[^a-zA-Z0-9._-]/g, '_'));
+  rmSync(dest, { recursive: true, force: true });
+  mkdirSync(dirname(dest), { recursive: true });
+  console.log(`📥 Cloning ${url}${branch ? ` (branch: ${branch})` : ''}...`);
+  const cloneArgs = ['clone', '--depth', '1', ...(branch ? ['--branch', branch] : []), url, dest];
+  try {
+    execFileSync('git', cloneArgs, { stdio: ['ignore', 'inherit', 'inherit'] });
+  } catch {
+    console.error(`❌ Failed to clone "${url}"${branch ? ` (branch: ${branch})` : ''} — check the URL, the branch name, your git access, and that git is installed, then try again.`);
+    process.exit(1);
+  }
+  return dest;
+}
+
+// A community stack repo must mirror the internal stacks/<key>/templates layout exactly
+// (templates/.claude, templates/root, templates/<kitSubdir>) so installStack() can treat
+// it identically to a built-in stack — see STACKS above for the shape. An optional
+// stack.json at the repo root can declare label/kitSubdir/useShared/needsBoardId;
+// kitDirName is always forced to .build-kit (the same runtime contract every built-in
+// stack already uses), so run/status/uninstall recognize a git-installed stack with no
+// changes of their own.
+function resolveGitStackConfig(clonedDir, name) {
+  const templatesSource = join(clonedDir, 'templates');
+  if (!existsSync(templatesSource)) {
+    console.error(`❌ ${relative(process.cwd(), clonedDir) || clonedDir} has no templates/ directory — a build kit repo needs templates/.claude, templates/root, and templates/<kitSubdir>, the same layout this CLI's own stacks/<name>/templates use.`);
+    process.exit(1);
+  }
+  const manifest = readJsonSafe(join(clonedDir, 'stack.json'));
+  const kitSubdir = manifest.kitSubdir || 'build-kit';
+  if (!existsSync(join(templatesSource, kitSubdir))) {
+    console.error(`❌ ${relative(process.cwd(), templatesSource) || templatesSource} is missing its kit subdirectory "${kitSubdir}/" (from stack.json, or the "build-kit" default) — nothing to install.`);
+    process.exit(1);
+  }
+  return {
+    label: manifest.label || name,
+    kitSubdir,
+    kitDirName: '.build-kit',
+    useShared: manifest.useShared !== false,
+    needsBoardId: manifest.needsBoardId !== false,
+  };
+}
+
 async function resolveStack(cliStack) {
   if (cliStack) {
     if (!STACKS[cliStack]) {
@@ -565,7 +615,9 @@ async function installStack(stackKey, stackCfg, options = {}) {
     console.log(`Using: ${stackKey} (${stackCfg.label})\n`);
 
     const targetDir = process.cwd();
-    const templatesSource = join(__dirname, 'stacks', stackKey, 'templates');
+    // `init --git <url>` passes a resolved clone dir's templates/ here instead — every
+    // other input (STACKS, MODELING_KIT, BRIDGE_KIT) keeps using the built-in path.
+    const templatesSource = options.templatesSource || join(__dirname, 'stacks', stackKey, 'templates');
     const sharedBuildKit = join(__dirname, 'shared', 'build-kit');
     // Skills with no stack-specific content (connect, learn-eventmodelers-api,
     // update-slice-status, ...) live once here instead of being copy-pasted into
@@ -631,6 +683,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);
@@ -1153,8 +1213,10 @@ function credentialOverridesFromOpts(opts) {
 credentialFlags(program
   .command('init')
   .alias('install')
-  .description('Scaffold a stack + install the agent kit into the current directory (or --modeling for skills + agent loop only, no backend scaffold; or --bridge to translate board slices into another spec framework)')
-  .option('--stack <name>', `Stack to install (${Object.keys(STACKS).join(', ')})`)
+  .description('Scaffold a stack + install the agent kit into the current directory (or --modeling for skills + agent loop only, no backend scaffold; or --bridge to translate board slices into another spec framework; or --git to install a community/custom build kit from a git repo)')
+  .option('--stack <name>', `Stack to install (${Object.keys(STACKS).join(', ')}), or a name of your choosing when combined with --git`)
+  .option('--git <url>', 'Install a build kit not built into this CLI by cloning this git repo (used with --stack <name> to name it) — the repo must mirror the templates/.claude, templates/root, templates/<kitSubdir> layout of this CLI\'s own stacks/<name>/templates, optionally with a stack.json declaring label/kitSubdir/useShared/needsBoardId')
+  .option('--branch <name>', 'Branch to clone — only meaningful with --git (defaults to the repo\'s default branch)')
   .option('--modeling', 'Install skills + the agent loop only — no backend scaffold. Mutually exclusive with --stack/--bridge.')
   .option('--bridge', 'Install a bridge kit — translates board slices into another spec framework instead of building code. Mutually exclusive with --stack/--modeling. Requires --target.')
   .option('--target <name>', `Bridge target framework (${Object.keys(BRIDGE_TARGETS).join(', ')}) — only meaningful with --bridge`)
@@ -1165,8 +1227,8 @@ credentialFlags(program
     const globalOpts = command.optsWithGlobals();
 
     if (opts.modeling || opts.bridge) {
-      if (opts.stack || (opts.modeling && opts.bridge)) {
-        console.error('❌ --stack, --modeling, and --bridge are mutually exclusive — pick one.');
+      if (opts.stack || opts.git || (opts.modeling && opts.bridge)) {
+        console.error('❌ --stack/--git, --modeling, and --bridge are mutually exclusive — pick one.');
         process.exit(1);
       }
     }
@@ -1213,6 +1275,33 @@ credentialFlags(program
       return;
     }
 
+    if (opts.branch && !opts.git) {
+      console.error('❌ --branch only applies to --git — nothing to clone without it.');
+      process.exit(1);
+    }
+
+    if (opts.git) {
+      if (!opts.stack) {
+        console.error('❌ --git requires --stack <name> to name the installed stack.');
+        process.exit(1);
+      }
+      if (STACKS[opts.stack]) {
+        console.error(`❌ "${opts.stack}" is already a built-in stack (${Object.keys(STACKS).join(', ')}) — --git is only for installing a stack that isn't built in.`);
+        process.exit(1);
+      }
+      const clonedDir = cloneGitStack(opts.git, opts.branch);
+      const stackCfg = resolveGitStackConfig(clonedDir, opts.stack);
+      await installStack(opts.stack, stackCfg, {
+        configPath: globalOpts.config,
+        print: globalOpts.print,
+        global: opts.global,
+        force: opts.force,
+        credentialOverrides: credentialOverridesFromOpts(opts),
+        templatesSource: join(clonedDir, 'templates'),
+      });
+      return;
+    }
+
     const stackKey = await resolveStack(opts.stack);
     await installStack(stackKey, STACKS[stackKey], {
       configPath: globalOpts.config,
@@ -1393,9 +1482,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 +1494,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 +1503,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.`);
@@ -1467,6 +1567,7 @@ program
   .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);
@@ -1521,6 +1622,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 {
@@ -56,7 +66,13 @@ 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,42 +95,49 @@ export async function runFetch({ cwd, kitDir, cfg, opts = {} }) {
     return res.json();
   }
 
-  console.log(`▶ Fetching context "${opts.context}" from ${baseUrl} (board ${cfg.boardId})...`);
-
   // 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. It
-  // resolves contextName by exact match, so no separate "list contexts" lookup
-  // is needed first.
-  const contextQuery = `contextName=${encodeURIComponent(opts.context)}`;
+  // 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(allSlices[0]?.context || opts.context || 'default') || 'default';
+    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 in context "${opts.context}".`);
+    console.log(`ℹ️  No slices found in context "${displayContext}".`);
     return;
   }
 
   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 || opts.context || 'default';
+    const contextName = slice.context || displayContext || 'default';
     const contextSlug = slugify(contextName) || 'default';
     const baseFolder = join(SLICES_DIR, contextSlug);
     const sliceFolder = sliceFolderName(slice.title);
@@ -144,9 +172,12 @@ export async function runFetch({ cwd, kitDir, cfg, opts = {} }) {
     writeFileSync(indexFile, JSON.stringify(sliceIndices, null, 2));
   }
 
-  writeFileSync(join(SLICES_DIR, 'current_context.json'), JSON.stringify({ name: opts.context }, 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'} from context "${opts.context}" → ${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.28",
+  "version": "0.0.30",
   "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.