@eventmodelers/cli 0.0.6 → 0.0.8

package/stacks/cratis-csharp/templates/build-kit/lib/agent.sh

@@ -1,20 +0,0 @@
-#!/bin/bash
-# Runs the AI agent with the given prompt in the project directory.
-# Called by ralph.sh with cwd already set to the project root.
-# Usage: ./agent.sh "<prompt>"
-
-set -euo pipefail
-
-PROMPT="${1:-}"
-if [[ -z "$PROMPT" ]]; then
-  echo "ERROR: No prompt provided"
-  exit 1
-fi
-
-claude --dangerously-skip-permissions -p "$PROMPT"
-
-# --- To use a local Ollama model instead, comment out the line above
-#     and uncomment the block below. Run `ollama serve` first.
-#
-# MODEL="${OLLAMA_MODEL:-qwen3.5:9b}"
-# node "$(dirname "$0")/ollama-agent.js" "$MODEL"

package/stacks/cratis-csharp/templates/build-kit/lib/ralph.js

@@ -1,302 +0,0 @@
-// Common runtime for the ralph loop + realtime agent.
-// Not meant to be run directly — use ralph-claude.js or ralph-ollama.js.
-//
-// startRalph({ kitDir, projectDir, onTask, onPlannedSlice })
-//   onTask(prompt) — called when tasks.json has entries
-//   onPlannedSlice(prompt) — called when .slices/ has a "Planned" entry (omit to skip)
-
-import { createClient } from '@supabase/supabase-js';
-import { readFileSync, mkdirSync, writeFileSync, existsSync, readdirSync } from 'fs';
-import { join } from 'path';
-import { randomUUID } from 'crypto';
-
-// ── HTTP helpers ──────────────────────────────────────────────────────────────
-
-class HttpError extends Error {
-  constructor(status, body) {
-    super(`HTTP ${status}: ${body}`);
-    this.status = status;
-  }
-}
-
-async function fetchJSON(url, options) {
-  const res = await fetch(url, options);
-  if (!res.ok) throw new HttpError(res.status, await res.text());
-  return res.json();
-}
-
-async function retryOn401(label, fn, maxRetries = 3) {
-  for (let attempt = 1; attempt <= maxRetries; attempt++) {
-    try {
-      return await fn();
-    } catch (err) {
-      if (err instanceof HttpError && err.status === 401) {
-        if (attempt < maxRetries) {
-          console.warn(`[agent] ${label} — 401, retrying (${attempt}/${maxRetries})...`);
-          continue;
-        }
-        console.error(`[agent] ${label} — 401 after ${maxRetries} retries, shutting down`);
-        process.exit(1);
-      }
-      throw err;
-    }
-  }
-}
-
-// ── Config ────────────────────────────────────────────────────────────────────
-
-function loadLocalConfig(kitDir) {
-  const configPath = join(kitDir, '.eventmodelers', 'config.json');
-  if (!existsSync(configPath)) {
-    console.warn(`[ralph] Note: no .eventmodelers/config.json found — platform sync disabled.`);
-    console.warn(`        To enable board sync, follow: https://app.eventmodelers.ai/documentation#build-cratis-csharp`);
-    console.warn(`        Code generation from local slice definitions will still run.`);
-    return {};
-  }
-  const cfg = JSON.parse(readFileSync(configPath, 'utf-8'));
-  if (process.env.BASE_URL) cfg.baseUrl = process.env.BASE_URL;
-  return cfg;
-}
-
-function hasCredentials(cfg) {
-  return !!(cfg.token && cfg.organizationId && cfg.boardId && cfg.baseUrl);
-}
-
-async function fetchPlatformConfig(local) {
-  const remote = await fetchJSON(`${local.baseUrl}/api/config`, {
-    headers: { 'x-token': local.token },
-  });
-  return { ...local, ...remote };
-}
-
-// ── Realtime agent ────────────────────────────────────────────────────────────
-
-async function getRealtimeToken(cfg) {
-  const { token } = await fetchJSON(
-    `${cfg.baseUrl}/api/org/${cfg.organizationId}/prompts/realtime-token`,
-    { headers: { 'x-token': cfg.token } },
-  );
-  return token;
-}
-
-function slugify(str) {
-  return str.toLowerCase().replace(/\s+/g, '-').replace(/[^a-z0-9-]/g, '');
-}
-
-async function fetchAndPersistSlices(cfg, kitDir) {
-  const url = `${cfg.baseUrl}/api/org/${cfg.organizationId}/boards/${cfg.boardId}/slicedata/slices`;
-  const { slices } = await fetchJSON(url, {
-    headers: { 'x-token': cfg.token, 'x-board-id': cfg.boardId },
-  });
-  const slicesDir = join(kitDir, '.slices');
-  mkdirSync(slicesDir, { recursive: true });
-
-  // Group by context slug
-  const contexts = {};
-  for (const slice of slices) {
-    const contextSlug = slice.contextName ? slugify(slice.contextName) : 'default';
-    if (!contexts[contextSlug]) contexts[contextSlug] = { name: slice.contextName || 'default', slices: [] };
-    contexts[contextSlug].slices.push(slice);
-  }
-
-  // Write current_context.json pointing to the context with planned work (or first)
-  const ctxPath = join(slicesDir, 'current_context.json');
-  const plannedCtx = Object.keys(contexts).find(c => contexts[c].slices.some(s => (s.status || '').toLowerCase() === 'planned'));
-  const activeCtx = plannedCtx || Object.keys(contexts)[0] || 'default';
-  writeFileSync(ctxPath, JSON.stringify({ name: activeCtx }, null, 2), 'utf-8');
-
-  // Write per-context index.json and per-slice slice.json
-  for (const [contextSlug, { slices: ctxSlices }] of Object.entries(contexts)) {
-    const contextDir = join(slicesDir, contextSlug);
-    mkdirSync(contextDir, { recursive: true });
-
-    const indexSlices = ctxSlices.map((s, i) => {
-      const folder = (s.title ?? s.id).replaceAll(' ', '').toLowerCase();
-      return {
-        id: s.id,
-        slice: s.title,
-        index: i,
-        contextName: s.contextName || contextSlug,
-        contextSlug,
-        folder,
-        status: s.status,
-        definition: { id: s.id, title: s.title, status: s.status },
-      };
-    });
-    writeFileSync(join(contextDir, 'index.json'), JSON.stringify({ slices: indexSlices }, null, 2), 'utf-8');
-
-    for (const slice of ctxSlices) {
-      const folder = (slice.title ?? slice.id).replaceAll(' ', '').toLowerCase();
-      const sliceDir = join(contextDir, folder);
-      mkdirSync(sliceDir, { recursive: true });
-      writeFileSync(join(sliceDir, 'slice.json'), JSON.stringify(slice, null, 2), 'utf-8');
-    }
-  }
-
-  console.log(`[agent] Persisted ${slices.length} slice(s)`);
-}
-
-async function writeTask(payload, kitDir) {
-  const tasksPath = join(kitDir, 'tasks.json');
-  const existing = existsSync(tasksPath) ? JSON.parse(readFileSync(tasksPath, 'utf-8')) : [];
-  const filtered = existing.filter(t => t.payload?.sliceId !== payload.sliceId);
-  const task = { id: randomUUID(), createdAt: new Date().toISOString(), payload };
-  filtered.push(task);
-  writeFileSync(tasksPath, JSON.stringify(filtered, null, 2), 'utf-8');
-  console.log(`[agent] Task written — slice="${payload.sliceTitle}" status="${payload.sliceStatus}"`);
-}
-
-async function startRealtimeAgent(cfg, kitDir) {
-  let realtimeToken = await retryOn401('getRealtimeToken', () => getRealtimeToken(cfg));
-
-  await retryOn401('fetchAndPersistSlices', () => fetchAndPersistSlices(cfg, kitDir)).catch((err) =>
-    console.error('[agent] Initial slice fetch error:', err),
-  );
-
-  const supabase = createClient(cfg.supabaseUrl, cfg.supabaseAnonKey, {
-    realtime: { params: { apikey: cfg.supabaseAnonKey } },
-  });
-  await supabase.realtime.setAuth(realtimeToken);
-
-  const channelName = `board:${cfg.boardId}-slicechanged`;
-
-  supabase
-    .channel(channelName, { config: { private: true } })
-    .on('broadcast', { event: 'message' }, (msg) => {
-      if (msg.payload === 'Exit') {
-        console.log('[agent] Received "Exit" — shutting down');
-        process.exit(0);
-      }
-    })
-    .on('broadcast', { event: 'slice:changed' }, async (msg) => {
-      const payload = msg.payload;
-      console.log(`[agent] slice:changed — slice="${payload.sliceTitle}" status="${payload.sliceStatus}"`);
-      await retryOn401('fetchAndPersistSlices', () => fetchAndPersistSlices(cfg, kitDir)).catch((err) =>
-        console.error('[agent] Slice persist error:', err),
-      );
-      // Planned slices are handled by onPlannedSlice directly — no task needed
-      if ((payload.sliceStatus || '').toLowerCase() !== 'planned') {
-        await writeTask(payload, kitDir).catch((err) => console.error('[agent] writeTask error:', err));
-      }
-    })
-    .subscribe((status) => console.log(`[agent] Channel "${channelName}": ${status}`));
-
-  setInterval(async () => {
-    try {
-      realtimeToken = await retryOn401('getRealtimeToken (refresh)', () => getRealtimeToken(cfg));
-      supabase.realtime.setAuth(realtimeToken);
-      console.log('[agent] Token refreshed');
-    } catch (err) {
-      console.error('[agent] Token refresh failed:', err);
-    }
-  }, 10 * 60 * 1000);
-
-  const ping = async () => {
-    try {
-      const res = await fetch(`${cfg.baseUrl}/api/agent-alive`, {
-        method: 'POST',
-        headers: { Authorization: `Bearer ${realtimeToken}`, 'Content-Type': 'application/json' },
-        body: JSON.stringify({ token: cfg.token }),
-      });
-      if (!res.ok) console.error(`[agent] Ping failed: ${res.status}`);
-    } catch (err) {
-      console.error('[agent] Ping error:', err);
-    }
-  };
-  await ping();
-  setInterval(ping, 30_000);
-}
-
-// ── Ralph loop ────────────────────────────────────────────────────────────────
-
-function hasPendingTasks(kitDir) {
-  const tasksPath = join(kitDir, 'tasks.json');
-  if (!existsSync(tasksPath)) return false;
-  try {
-    const tasks = JSON.parse(readFileSync(tasksPath, 'utf-8'));
-    return Array.isArray(tasks) && tasks.length > 0;
-  } catch {
-    return false;
-  }
-}
-
-function getFirstPlannedSliceTitle(kitDir) {
-  const slicesDir = join(kitDir, '.slices');
-  if (!existsSync(slicesDir)) return null;
-  for (const entry of readdirSync(slicesDir)) {
-    const indexPath = join(slicesDir, entry, 'index.json');
-    if (!existsSync(indexPath)) continue;
-    try {
-      const { slices } = JSON.parse(readFileSync(indexPath, 'utf-8'));
-      const planned = slices && slices.find((s) => (s.status || '').toLowerCase() === 'planned');
-      if (planned) return planned.slice || planned.id || null;
-    } catch {}
-  }
-  return null;
-}
-
-async function runWithRetry(label, fn) {
-  while (true) {
-    try {
-      console.log(`[ralph] ${label}`);
-      await fn();
-      return;
-    } catch (err) {
-      console.error(`[ralph] Error — retrying in 60s:`, err.message);
-      await new Promise((r) => setTimeout(r, 60_000));
-    }
-  }
-}
-
-async function ralphLoop(kitDir, cfg, onTask, onPlannedSlice) {
-  const promptFile = join(kitDir, 'lib', 'prompt.md');
-  const backendPromptFile = join(kitDir, 'lib', 'backend-prompt.md');
-  const credentialed = hasCredentials(cfg);
-
-  while (true) {
-    let didWork = false;
-
-    if (credentialed && hasPendingTasks(kitDir)) {
-      const prompt = readFileSync(promptFile, 'utf-8');
-      await runWithRetry('onTask: loading slice from board...', () => onTask(prompt));
-      await fetchAndPersistSlices(cfg, kitDir).catch(() => {});
-      didWork = true;
-    }
-
-    const plannedTitle = onPlannedSlice && getFirstPlannedSliceTitle(kitDir);
-    if (plannedTitle) {
-      const prompt = readFileSync(backendPromptFile, 'utf-8');
-      await runWithRetry(`onPlannedSlice: building slice "${plannedTitle}"...`, () => onPlannedSlice(prompt));
-      console.log(`[ralph] Slice build complete — waiting for next slice`);
-      if (credentialed) await fetchAndPersistSlices(cfg, kitDir).catch(() => {});
-      didWork = true;
-    }
-
-    if (!didWork) await new Promise((r) => setTimeout(r, 10_000));
-  }
-}
-
-// ── Public API ────────────────────────────────────────────────────────────────
-
-export { loadLocalConfig, fetchPlatformConfig, retryOn401, startRealtimeAgent };
-
-export async function startRalph({ kitDir, projectDir, onTask, onPlannedSlice }) {
-  const local = loadLocalConfig(kitDir);
-
-  console.log(`Ralph — kit: ${kitDir}`);
-  console.log(`         project: ${projectDir}`);
-
-  if (!hasCredentials(local)) {
-    console.log(`         mode: local-only (no platform sync)\n`);
-    await ralphLoop(kitDir, local, onTask, onPlannedSlice);
-    return;
-  }
-
-  const cfg = await retryOn401('fetchPlatformConfig', () => fetchPlatformConfig(local));
-  console.log(`         org=${cfg.organizationId}, board=${cfg.boardId}, base=${cfg.baseUrl}\n`);
-
-  await Promise.all([
-    startRealtimeAgent(cfg, kitDir),
-    ralphLoop(kitDir, cfg, onTask, onPlannedSlice),
-  ]);
-}

package/stacks/cratis-csharp/templates/build-kit/ralph-claude.js

@@ -1,37 +0,0 @@
-#!/usr/bin/env node
-// Ralph loop + realtime agent using Claude Code as the executor.
-// Usage: node ralph-claude.js [project_dir]
-
-import { startRalph, loadLocalConfig } from './lib/ralph.js';
-import { spawn } from 'child_process';
-import { dirname, resolve } from 'path';
-import { fileURLToPath } from 'url';
-
-const kitDir = dirname(fileURLToPath(import.meta.url));
-const projectDir = process.argv[2] ? resolve(process.argv[2]) : resolve(kitDir, '..');
-
-const cfg = loadLocalConfig(kitDir);
-const inlineHeader = cfg.boardId
-  ? `board=${cfg.boardId} token=${cfg.token} org=${cfg.organizationId} baseUrl=${cfg.baseUrl}\n\n`
-  : '';
-
-function runClaude(prompt) {
-  return new Promise((resolve, reject) => {
-    const proc = spawn('claude', ['--dangerously-skip-permissions', '-p', inlineHeader + prompt], {
-      cwd: projectDir,
-      stdio: 'inherit',
-    });
-    proc.on('close', (code) => (code === 0 ? resolve() : reject(new Error(`Claude exited ${code}`))));
-    proc.on('error', reject);
-  });
-}
-
-startRalph({
-  kitDir,
-  projectDir,
-  onTask: runClaude,
-  onPlannedSlice: runClaude,
-}).catch((err) => {
-  console.error('[ralph] Fatal:', err);
-  process.exit(1);
-});

package/stacks/cratis-csharp/templates/build-kit/ralph.sh

@@ -1,98 +0,0 @@
-#!/bin/bash
-# Ralph agent loop — two independent loops, each triggered by their own condition
-#
-# onTask:        tasks.json has entries  → load slice from board, update .build-kit/.slices/
-# onPlannedSlice: .build-kit/.slices/ has a "Planned" slice → build it
-#
-# The loops are NOT causally linked — either can trigger on its own.
-#
-# Usage: ./ralph.sh [iterations] [project_dir]
-#   iterations  — number of loop cycles to run; 0 or omitted means run forever
-#   project_dir — path to the project root; defaults to the parent of .build-kit
-
-set -euo pipefail
-
-KIT_DIR="$(cd "$(dirname "$0")" && pwd)"
-ITERATIONS="${1:-0}"
-PROJECT_DIR="${2:-"$KIT_DIR/.."}"
-TASKS_FILE="$KIT_DIR/tasks.json"
-PROMPT_FILE="$KIT_DIR/lib/prompt.md"
-BACKEND_PROMPT_FILE="$KIT_DIR/lib/backend-prompt.md"
-AGENT_SCRIPT="$KIT_DIR/lib/agent.sh"
-
-HAS_CREDENTIALS=true
-if [[ ! -f "$KIT_DIR/.eventmodelers/config.json" ]]; then
-  echo "[ralph] Note: no .eventmodelers/config.json found — platform sync disabled." >&2
-  echo "        To enable board sync, follow: https://app.eventmodelers.ai/documentation#build-cratis-csharp" >&2
-  echo "        Code generation from local slice definitions will still run." >&2
-  HAS_CREDENTIALS=false
-fi
-
-echo "Ralph — kit: $KIT_DIR  project: $PROJECT_DIR"
-
-# Returns 0 if tasks.json has at least one task
-has_pending_tasks() {
-  [[ -f "$TASKS_FILE" ]] || return 1
-  local content
-  content=$(cat "$TASKS_FILE")
-  [[ "$content" != "[]" && -n "$content" ]]
-}
-
-# Returns 0 if any JSON under .build-kit/.slices/ contains a "Planned" status
-has_planned_slices() {
-  grep -rqi '"status"[[:space:]]*:[[:space:]]*"planned"' "$KIT_DIR/.slices/" --include='index.json' 2>/dev/null
-}
-
-# Returns the title of the first "Planned" slice, or empty string
-get_planned_slice_title() {
-  for index_file in "$KIT_DIR/.slices/"*/index.json; do
-    [[ -f "$index_file" ]] || continue
-    local title
-    title=$(node -e "
-      try {
-        const d = JSON.parse(require('fs').readFileSync(process.argv[1], 'utf-8'));
-        const s = (d.slices||[]).find(s => (s.status||'').toLowerCase() === 'planned');
-        if (s) process.stdout.write(s.slice || s.id || '');
-      } catch(e) {}
-    " "$index_file" 2>/dev/null)
-    if [[ -n "$title" ]]; then
-      echo "$title"
-      return
-    fi
-  done
-}
-
-# Runs agent.sh with the given prompt; retries on non-zero exit
-run_agent() {
-  local label="$1"
-  local prompt="$2"
-  while true; do
-    echo "[$(date -u +%H:%M:%S)] $label"
-    (cd "$PROJECT_DIR" && bash "$AGENT_SCRIPT" "$prompt") 2>&1 && return 0
-    echo "[$(date -u +%H:%M:%S)] Agent error — retrying in 60s..."
-    sleep 60
-  done
-}
-
-cycle=0
-while [[ "$ITERATIONS" -eq 0 || "$cycle" -lt "$ITERATIONS" ]]; do
-  ran_something=false
-
-  if [[ "$HAS_CREDENTIALS" == true ]] && has_pending_tasks; then
-    run_agent "onTask: loading slice from board..." "$(cat "$PROMPT_FILE")"
-    ran_something=true
-  fi
-
-  if has_planned_slices; then
-    slice_title=$(get_planned_slice_title)
-    run_agent "onPlannedSlice: building \"$slice_title\"..." "$(cat "$BACKEND_PROMPT_FILE")"
-    echo "[$(date -u +%H:%M:%S)] Slice \"$slice_title\" build complete — waiting for next slice"
-    ran_something=true
-  fi
-
-  if [[ "$ran_something" == false ]]; then
-    sleep 3
-  fi
-
-  (( cycle++ )) || true
-done

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

@@ -1,178 +0,0 @@
----
-name: connect
-description: Resolve eventmodelers connection config (token, boardId, baseUrl) from inline params or .eventmodelers/config.json — ask the user for missing values, persist them, and add the file to .gitignore. All other skills invoke this first.
----
-
-# Connect — Resolve Eventmodelers Config
-
-**Every other skill invokes this skill first** before making any API calls. Do not proceed past this skill until all four values (`TOKEN`, `BOARD_ID`, `ORG_ID`, `BASE_URL`) are resolved.
-
----
-
-## What this skill produces
-
-After running, the following variables are available for the rest of the session:
-
-| Variable | Header sent to API | Description |
-|----------|--------------------|-------------|
-| `TOKEN` | `x-token` | API token UUID |
-| `BOARD_ID` | `x-board-id` | Target board UUID |
-| `ORG_ID` | — | Organization UUID (used in all board-scoped URLs) |
-| `BASE_URL` | — | Base URL, e.g. `http://localhost:3000` |
-
-Every API call in every skill must include these headers:
-```
-x-token: <TOKEN>
-x-board-id: <BOARD_ID>
-x-user-id: <skill-name>   ← set by each skill individually
-```
-
-All board-scoped URLs follow the pattern: `<BASE_URL>/api/org/<ORG_ID>/boards/<BOARD_ID>/...`
-
----
-
-## Step 0 — Check for inline parameters
-
-Before reading the config file, scan the prompt/arguments that invoked this skill for inline overrides. Supported formats:
-
-| Pattern | Example |
-|---------|---------|
-| `board=<uuid>` | `board=05cda19d-d5b8-4b51-ae88-c72f2611548a` |
-| `token=<uuid>` | `token=xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx` |
-| `org=<uuid>` | `org=xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx` |
-| `baseUrl=<url>` | `baseUrl=http://localhost:3000` |
-
-If an inline `board=<uuid>` is found, use it as `BOARD_ID` — **it takes priority over the config file**. Same for `token`, `org`, and `baseUrl`. Record which values came from inline params so they are not overwritten in Step 3.
-
----
-
-## Step 1 — Read config file
-
-Search for `.eventmodelers/config.json` starting from the current working directory and walking up through all parent directories. This is the same file a build-kit installed in this project reads and writes, so credentials only need to be entered once per project:
-
-```bash
-dir="$PWD"
-config_file=""
-while [ "$dir" != "/" ]; do
-  if [ -f "$dir/.eventmodelers/config.json" ]; then
-    config_file="$dir/.eventmodelers/config.json"
-    break
-  fi
-  dir="$(dirname "$dir")"
-done
-[ -n "$config_file" ] && cat "$config_file"
-```
-
-If a file is found (at any level), note its path and extract any values **not already set by Step 0**:
-- `token` → `TOKEN`
-- `boardId` → `BOARD_ID`
-- `organizationId` or `orgId` → `ORG_ID` (accept either field name)
-- `baseUrl` → `BASE_URL` (default: `https://api.eventmodelers.ai` if missing)
-
-Resolution priority: **inline param > config file > ask user**
-
-If all four are present (from any source), skip to **Step 4 — Verify**.
-
----
-
-## Step 2 — Ask for missing values
-
-If after Steps 0 and 1 any required field is still missing, **ask the user one question first**:
-
-> "Do you have a config from the eventmodelers accounts page? (yes / no)"
-
-**If the user answers yes:**
-Stop asking questions. Show this hint and wait for them to paste:
-
-> "Great — please paste your config from https://app.eventmodelers.ai/account here."
-
-When they paste a JSON object, parse it immediately — accept both `orgId` and `organizationId` as the organization field — apply all values, and proceed directly to Step 3.
-
-**If the user answers no** (or pastes only a partial config), ask for each still-missing field one at a time, in this order: `token`, then `boardId`, then `orgId`. Wait for the answer before asking the next.
-
-| Field | What to ask                                                                          |
-|-------|--------------------------------------------------------------------------------------|
-| `token` | "Please provide your eventmodelers API token (a UUID from your workspace settings)." |
-| `boardId` | "Please provide the board ID you want to work with (the UUID from the board URL)."   |
-| `orgId` | "Please provide your organization ID (the UUID from your organization settings)."    |
-| `baseUrl` | Do **not** ask — default to `https://api.eventmodelers.ai` silently.                 |
-
-Where to find the token: users generate API tokens in their workspace settings at the eventmodelers platform. The token is shown only once at creation time. It is a UUID and must belong to the same organization as the board.
-
----
-
-## Step 3 — Persist config
-
-Once all values are collected, write the config file to `.eventmodelers/config.json` at the project root (the same file the CLI installer writes to, and the one a build-kit installed alongside this modeling-kit reads too). If Step 1 found the config in a parent directory instead of here, write back to that same path rather than creating a second copy. When writing, merge with any existing config — do **not** overwrite fields that were provided as inline params with values from a previous config (the inline param is the user's explicit intent for this session, but the persisted value should reflect the most recently user-supplied value):
-
-```bash
-mkdir -p .eventmodelers
-cat > .eventmodelers/config.json << 'EOF'
-{
-  "token": "<TOKEN>",
-  "boardId": "<BOARD_ID>",
-  "organizationId": "<ORG_ID>",
-  "baseUrl": "<BASE_URL>"
-}
-EOF
-```
-
-Then ensure `.eventmodelers/config.json` is in `.gitignore`. Check whether it is already present:
-
-```bash
-grep -q ".eventmodelers/config.json" .gitignore 2>/dev/null || echo "MISSING"
-```
-
-If `MISSING`, append it:
-
-```bash
-echo ".eventmodelers/config.json" >> .gitignore
-```
-
-Tell the user: `"Config saved to .eventmodelers/config.json and added to .gitignore."`
-
----
-
-## Step 4 — Verify
-
-Confirm the token and board are valid with a lightweight call:
-
-```bash
-curl -s -o /dev/null -w "%{http_code}" \
-  -H "x-token: <TOKEN>" \
-  -H "x-board-id: <BOARD_ID>" \
-  -H "x-user-id: connect-skill" \
-  "<BASE_URL>/api/org/<ORG_ID>/boards/<BOARD_ID>/nodes?type=CHAPTER"
-```
-
-| Response | Action |
-|----------|--------|
-| `200` | Config is valid. Print one line: `"Connected — board <BOARD_ID>"` and return. |
-| `401` | Token is invalid or missing. Tell the user and re-run from Step 2, clearing `token`. |
-| `403` | Token organization does not match board. Tell the user to check that the token was issued for the correct workspace. Re-run from Step 2 for both fields. |
-| `404` | Board not found. Tell the user and re-run from Step 2, clearing `boardId`. |
-| Any other | Print the status code and raw response. Ask the user how to proceed. |
-
----
-
-## Config file format
-
-`.eventmodelers/config.json`:
-```json
-{
-  "token": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
-  "boardId": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
-  "organizationId": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
-  "baseUrl": "http://localhost:3000"
-}
-```
-
-The `token` field is a secret. It is never logged or shown after initial confirmation.
-
----
-
-## Security notes
-
-- The config file is workspace-local and gitignored — never commit it.
-- The token grants write access to all boards in its organization — treat it like a password.
-- If a skill receives a `401` or `403` mid-session, re-invoke this skill to refresh the config before retrying.