@eventmodelers/cli 0.0.7 → 0.0.8

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

@@ -1,110 +0,0 @@
----
-name: update-slice-status
-description: Update the status of a single slice on an eventmodelers board by changing the SLICE_BORDER node's sliceStatus field
----
-
-# Update Slice Status
-
-> **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 |
-|-------|---------------|---------|
-| `sliceName` | the slice title to update (case-insensitive match) | **required** |
-| `newStatus` | the target status value | **required** |
-
-Valid status values (case-sensitive):
-
-| Value | Meaning |
-|-------|---------|
-| `Created` | Default — slice has been created but not started |
-| `Planned` | Work is planned |
-| `InProgress` | Work is actively in progress |
-| `Review` | Ready for review |
-| `Done` | Completed |
-| `Blocked` | Blocked by something |
-| `Assigned` | Assigned to someone |
-| `Informational` | Informational / reference slice |
-
-If `newStatus` is not one of these exact values, stop and tell the user the valid options.
-
----
-
-## Step 2 — List all slices
-
-Fetch all slices on the board:
-
-```bash
-curl -s \
-  -H "x-token: <TOKEN>" \
-  -H "x-board-id: <BOARD_ID>" \
-  -H "x-user-id: update-slice-status-skill" \
-  "<BASE_URL>/api/org/<ORG_ID>/boards/<BOARD_ID>/slicedata/slices"
-```
-
-Response: `{ "slices": [{ "id": "<nodeId>", "title": "<title>", "status": "<status>" }] }`
-
-The `id` here is the `SLICE_BORDER` node ID — use it directly in Step 3.
-
-Find the slice whose `title` matches `sliceName` (case-insensitive). If no match is found, stop and list the available slice titles so the user can pick one.
-
-Save the matched slice as:
-- `SLICE_NODE_ID` — the node ID of the SLICE_BORDER
-- `CURRENT_STATUS` — the current status value
-
----
-
-## Step 3 — Update the slice status
-
-Send a `node:changed` event to update the `sliceStatus` field in the SLICE_BORDER node's meta:
-
-```bash
-curl -s -X POST "<BASE_URL>/api/org/<ORG_ID>/boards/<BOARD_ID>/nodes/events" \
-  -H "Content-Type: application/json" \
-  -H "x-token: <TOKEN>" \
-  -H "x-board-id: <BOARD_ID>" \
-  -H "x-user-id: update-slice-status-skill" \
-  -d '[{
-    "id": "<new-random-uuid>",
-    "eventType": "node:changed",
-    "nodeId": "<SLICE_NODE_ID>",
-    "boardId": "<BOARD_ID>",
-    "timestamp": <Date.now()>,
-    "changedAttributes": ["sliceStatus"],
-    "meta": {
-      "sliceStatus": "<newStatus>"
-    }
-  }]'
-```
-
-Response: `{ "hashes": { "<eventId>": "<hash>" } }`
-
-### If the API rejects the update because the slice is already in `newStatus`
-
-The API refuses to move a slice into a status it is already in — this is a deliberate concurrency guard so two agents racing to claim the same slice can't both succeed. If Step 3 fails with an error indicating the slice is already at `<newStatus>` (e.g. a `409`, or an error body mentioning "already"), this is **not a failure to surface as broken** — it means another agent already claimed or moved the slice first. Report this as a distinct `ALREADY_IN_STATUS` outcome (see Step 4) rather than a generic error, and do not retry the same update. Callers trying to claim a `Planned` slice for building should treat this as a signal to pick a different slice, not to stop.
-
----
-
-## Step 4 — Report back
-
-Tell the user:
-
-- **Slice**: the title that was updated
-- **Previous status**: `CURRENT_STATUS`
-- **New status**: `newStatus`
-- **Node ID**: `SLICE_NODE_ID`
-- **Outcome**: `SUCCESS`, `ALREADY_IN_STATUS` (another agent got there first — see above), or `ERROR`
-- **Any errors**: raw API message if something failed for a reason other than `ALREADY_IN_STATUS`
-
-Example success output:
-```
-Updated: "Order Placed" slice
-  Before: InProgress
-  After:  Done
-Node ID: a1b2c3d4-…
-```

package/stacks/supabase/templates/build-kit/README.md

@@ -1,86 +0,0 @@
-# .build-kit
-
-Ralph's runtime directory. Contains the agent loop, realtime subscription, prompts, and Claude skills.
-
-## Quick start
-
-```bash
-# Claude (default)
-node .build-kit/ralph-claude.js
-
-# Local Ollama model — run `ollama serve` first
-OLLAMA_MODEL=qwen3:8b node .build-kit/ralph-ollama.js
-
-# Custom project directory (defaults to the parent of .build-kit)
-node .build-kit/ralph-claude.js /path/to/project
-```
-
-## Files
-
-**Entry points** (top level):
-
-| File | Purpose |
-|------|---------|
-| `ralph-claude.js` | Runs the full loop using Claude Code as the executor |
-| `ralph-ollama.js` | Runs the full loop using a local Ollama model |
-| `ralph.sh` | Shell-based loop — alternative to the JS entry points |
-| `realtime-agent.js` | Standalone realtime agent — only needed to run it in a separate terminal |
-
-**Internals** (`lib/`):
-
-| File | Purpose |
-|------|---------|
-| `lib/ralph.js` | Shared library — realtime agent + loop logic; imported by the entry points |
-| `lib/ollama-agent.js` | Ollama executor — called by `ralph-ollama.js`, can also run manually |
-| `lib/agent.sh` | Thin shell wrapper around `claude` — called by `ralph.sh` |
-| `lib/prompt.md` | Phase 1 prompt: tells Claude how to load a slice from the board |
-| `lib/backend-prompt.md` | Phase 2 prompt: tells Claude how to build a planned slice |
-| `lib/AGENT.md` | Agent instructions included in Claude's context |
-
-## How it works
-
-**Phase 1** — triggered when `tasks.json` has entries:
-- The realtime agent writes a task to `tasks.json` each time a `slice:changed` event arrives from the board
-- The loop picks it up and runs Claude (or Ollama) with `prompt.md`
-- Claude loads the slice data and updates `.slices/`
-
-**Phase 2** — triggered when any file in `.slices/` contains `"status": "Planned"`:
-- The loop runs Claude with `backend-prompt.md`
-- Claude implements the slice in the project
-- Phase 2 is Claude-only; Ollama mode skips it (ollama-agent handles its own queue)
-
-Both phases run in a continuous loop with a 3-second idle sleep. The realtime agent runs concurrently in the same process.
-
-## Running the realtime agent separately
-
-If you want the board subscription in one terminal and the Claude loop in another:
-
-```bash
-# Terminal 1 — realtime agent only
-node .build-kit/realtime-agent.js
-
-# Terminal 2 — loop only (poll tasks.json without the realtime subscription)
-.build-kit/ralph.sh
-```
-
-## Ollama configuration
-
-```bash
-OLLAMA_MODEL=qwen3:8b          # model to use (default: qwen3:8b)
-OLLAMA_URL=http://host:11434   # Ollama server URL (default: http://localhost:11434)
-```
-
-## Config
-
-Credentials are stored in `.build-kit/.eventmodelers/config.json` (written by `ralph-li install`):
-
-```json
-{
-  "organizationId": "...",
-  "boardId": "...",
-  "token": "...",
-  "baseUrl": "https://api.eventmodelers.ai"
-}
-```
-
-Claude skills live in `.build-kit/.claude/skills/` and are available inside any Claude Code session started from `.build-kit/`.

package/stacks/supabase/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/supabase/templates/build-kit/lib/ralph.js

@@ -1,369 +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, dirname } 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 ────────────────────────────────────────────────────────────────────
-
-// Config is resolved by walking from the kit dir up through every ancestor
-// directory's .eventmodelers/config.json, merging fields as we go — a value
-// set by a closer (more specific) directory always wins over a farther one.
-// The walk stops as soon as the merged config has full connection credentials
-// (see hasCredentials); anthropicBaseUrl/model are picked up opportunistically
-// along the way but never force the walk to continue further up.
-function* configCandidates(kitDir) {
-  yield join(kitDir, '.eventmodelers', 'config.json');
-  let dir = dirname(kitDir);
-  while (true) {
-    yield join(dir, '.eventmodelers', 'config.json');
-    const parent = dirname(dir);
-    if (parent === dir) return;
-    dir = parent;
-  }
-}
-
-function loadLocalConfig(kitDir) {
-  const merged = {};
-  const sources = [];
-
-  for (const candidate of configCandidates(kitDir)) {
-    if (!existsSync(candidate)) continue;
-    let cfg;
-    try {
-      cfg = JSON.parse(readFileSync(candidate, 'utf-8'));
-    } catch {
-      console.warn(`[ralph] Skipping invalid config at ${candidate}`);
-      continue;
-    }
-    for (const [key, value] of Object.entries(cfg)) {
-      if (merged[key] === undefined) merged[key] = value;
-    }
-    sources.push(candidate);
-    if (hasCredentials(merged)) break;
-  }
-
-  if (process.env.BASE_URL) merged.baseUrl = process.env.BASE_URL;
-
-  if (sources.length > 1) {
-    console.log(`[ralph] Merged config from: ${sources.join(', ')}`);
-  } else if (sources.length === 1 && sources[0] !== join(kitDir, '.eventmodelers', 'config.json')) {
-    console.log(`[ralph] Using credentials from ${sources[0]}`);
-  } else if (sources.length === 0) {
-    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-supabase`);
-    console.warn(`        Code generation from local slice definitions will still run.`);
-  }
-
-  return merged;
-}
-
-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);
-  }
-
-  // current_context.json is STICKY. We work within ONE context at a time and must
-  // not auto-jump to another context just because it happens to have planned work.
-  // Keep the existing context if it still exists; only seed it when absent or stale.
-  const ctxPath = join(slicesDir, 'current_context.json');
-  let activeCtx = null;
-  if (existsSync(ctxPath)) {
-    try { activeCtx = JSON.parse(readFileSync(ctxPath, 'utf-8')).name; } catch {}
-  }
-  if (!activeCtx || !contexts[activeCtx]) {
-    // First run (or the current context disappeared): seed with a context that
-    // has planned work, else the first one. This is the ONLY place we choose it.
-    const plannedCtx = Object.keys(contexts).find(c => contexts[c].slices.some(s => (s.status || '').toLowerCase() === 'planned'));
-    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 readCurrentContext(kitDir) {
-  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; }
-}
-
-// Returns the first Planned slice IN THE CURRENT CONTEXT ONLY. If the current
-// context has no planned work, returns null so the loop waits — it must NEVER
-// cross into another context to find something to build.
-function getFirstPlannedSliceTitle(kitDir) {
-  const currentCtx = readCurrentContext(kitDir);
-  if (!currentCtx) return null;
-  const indexPath = join(kitDir, '.slices', currentCtx, 'index.json');
-  if (!existsSync(indexPath)) return null;
-  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);
-  let lastIdleCtx;
-
-  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) {
-      // No planned work in the current context — wait, do NOT switch contexts.
-      const ctx = readCurrentContext(kitDir);
-      if (ctx !== lastIdleCtx) {
-        console.log(`[ralph] No planned slices in current context "${ctx}" — waiting. Switch context on the board to continue.`);
-        lastIdleCtx = ctx;
-      }
-      await new Promise((r) => setTimeout(r, 10_000));
-    } else {
-      lastIdleCtx = undefined;
-    }
-  }
-}
-
-// ── 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/supabase/templates/build-kit/ralph-claude.js

@@ -1,44 +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`
-  : '';
-
-const claudeArgs = ['--dangerously-skip-permissions'];
-if (cfg.model) claudeArgs.push('--model', cfg.model);
-const claudeEnv = cfg.anthropicBaseUrl
-  ? { ...process.env, ANTHROPIC_BASE_URL: cfg.anthropicBaseUrl }
-  : process.env;
-
-function runClaude(prompt) {
-  return new Promise((resolve, reject) => {
-    const proc = spawn('claude', [...claudeArgs, '-p', inlineHeader + prompt], {
-      cwd: projectDir,
-      stdio: 'inherit',
-      env: claudeEnv,
-    });
-    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);
-});