@the-bearded-bear/claude-craft 7.35.0 → 8.1.0

package/cli/kanban/server/services/repository.js

@@ -0,0 +1,173 @@
+import path from 'node:path';
+import { readFile } from 'node:fs/promises';
+import { scan, groupByCategory } from './file-scanner.js';
+import { parseAndValidate } from './frontmatter.js';
+import { StoryFrontmatterSchema, EpicFrontmatterSchema, TaskFrontmatterSchema } from '../../shared/schemas.js';
+
+/**
+ * In-memory cache of parsed project-management/ entities.
+ * Rebuilt via refresh() ; individual files can be reloaded via reloadFile(path).
+ */
+export class Repository {
+  constructor(rootDir) {
+    this.rootDir = path.resolve(rootDir);
+    this.stories = new Map(); // id -> { data, body, path, mtime, valid, errors? }
+    this.epics = new Map();
+    this.tasks = new Map();
+    this.docs = new Map(); // category -> [{ path, rel }]
+    this.sprints = new Map(); // sprintId -> { goal?, tasks: string[], files: [] }
+    this.filesByPath = new Map();
+  }
+
+  async refresh() {
+    const { files } = await scan(this.rootDir);
+    this.stories.clear();
+    this.epics.clear();
+    this.tasks.clear();
+    this.docs.clear();
+    this.sprints.clear();
+    this.filesByPath.clear();
+
+    const groups = groupByCategory(files);
+
+    for (const f of groups.story ?? []) {
+      const res = await parseAndValidate(f.path, StoryFrontmatterSchema);
+      const entry = { path: f.path, mtime: f.mtime, ...res };
+      if (res.ok) {
+        this.stories.set(res.data.id, entry);
+      } else {
+        const idMatch = path.basename(f.path).match(/US-\d+/);
+        if (idMatch) this.stories.set(idMatch[0], entry);
+      }
+      this.filesByPath.set(f.path, { kind: 'story', id: entry.ok ? entry.data.id : null });
+    }
+
+    for (const f of groups.epic ?? []) {
+      const res = await parseAndValidate(f.path, EpicFrontmatterSchema);
+      const entry = { path: f.path, mtime: f.mtime, ...res };
+      if (res.ok) this.epics.set(res.data.id, entry);
+      this.filesByPath.set(f.path, { kind: 'epic', id: res.ok ? res.data.id : null });
+    }
+
+    for (const f of groups.task ?? []) {
+      const res = await parseAndValidate(f.path, TaskFrontmatterSchema);
+      const entry = { path: f.path, mtime: f.mtime, sprintId: f.sprintId, ...res };
+      if (res.ok) this.tasks.set(res.data.id, entry);
+      this.filesByPath.set(f.path, { kind: 'task', id: res.ok ? res.data.id : null });
+    }
+
+    // Docs (root + architecture)
+    for (const category of ['doc', 'architecture']) {
+      for (const f of groups[category] ?? []) {
+        const rel = path.relative(this.rootDir, f.path).split(path.sep).join('/');
+        const arr = this.docs.get(category) ?? [];
+        arr.push({ path: f.path, rel });
+        this.docs.set(category, arr);
+      }
+    }
+
+    // Sprints aggregation
+    for (const f of files) {
+      if (!f.sprintId) continue;
+      const s = this.sprints.get(f.sprintId) ?? { id: f.sprintId, files: [], tasks: [] };
+      s.files.push(f);
+      if (f.category === 'task') s.tasks.push(f.path);
+      if (f.category === 'sprint-goal') s.goalPath = f.path;
+      this.sprints.set(f.sprintId, s);
+    }
+  }
+
+  listStories({ sprintId, status, epicId } = {}) {
+    const out = [];
+    for (const [, entry] of this.stories) {
+      if (!entry.ok) continue;
+      const d = entry.data;
+      if (sprintId && d.sprint_id !== sprintId) continue;
+      if (status && d.status !== status) continue;
+      if (epicId && d.epic_id !== epicId) continue;
+      out.push({ ...d, _mtime: entry.mtime });
+    }
+    return out.sort((a, b) => a.id.localeCompare(b.id));
+  }
+
+  listEpics() {
+    return [...this.epics.values()].filter((e) => e.ok).map((e) => ({ ...e.data, _mtime: e.mtime }));
+  }
+
+  getStory(id) {
+    const entry = this.stories.get(id);
+    if (!entry || !entry.ok) return null;
+    return { ...entry.data, _mtime: entry.mtime };
+  }
+
+  getStoryFile(id) {
+    const entry = this.stories.get(id);
+    return entry ? entry.path : null;
+  }
+
+  listTasksForStory(usId) {
+    return [...this.tasks.values()].filter((t) => t.ok && t.data.us_id === usId).map((t) => t.data);
+  }
+
+  listDocs() {
+    const out = [];
+    for (const [, arr] of this.docs) {
+      for (const d of arr) out.push(d);
+    }
+    return out.sort((a, b) => a.rel.localeCompare(b.rel));
+  }
+
+  async readDoc(rel) {
+    // Caller is responsible for resolving safely
+    const known = this.listDocs().find((d) => d.rel === rel);
+    if (!known) return null;
+    return await readFile(known.path, 'utf8');
+  }
+
+  buildDependenciesGraph() {
+    const nodes = [];
+    const edges = [];
+    for (const s of this.listStories()) {
+      nodes.push({ id: s.id, title: s.title, status: s.status, epic_id: s.epic_id ?? null });
+      for (const dep of s.dependencies ?? []) {
+        edges.push({ from: dep, to: s.id });
+      }
+    }
+    return { nodes, edges, cycles: detectCycles(nodes, edges) };
+  }
+}
+
+export function detectCycles(nodes, edges) {
+  const adj = new Map();
+  for (const n of nodes) adj.set(n.id, []);
+  for (const e of edges) {
+    if (!adj.has(e.from)) adj.set(e.from, []);
+    adj.get(e.from).push(e.to);
+  }
+  const cycles = [];
+  const WHITE = 0,
+    GRAY = 1,
+    BLACK = 2;
+  const color = new Map();
+  const stack = [];
+
+  function dfs(u) {
+    color.set(u, GRAY);
+    stack.push(u);
+    for (const v of adj.get(u) ?? []) {
+      const c = color.get(v) ?? WHITE;
+      if (c === WHITE) {
+        dfs(v);
+      } else if (c === GRAY) {
+        const idx = stack.indexOf(v);
+        cycles.push(stack.slice(idx).concat(v));
+      }
+    }
+    stack.pop();
+    color.set(u, BLACK);
+  }
+  for (const n of nodes) {
+    if ((color.get(n.id) ?? WHITE) === WHITE) dfs(n.id);
+  }
+  return cycles;
+}

package/cli/kanban/server/services/sprint-cache.js

@@ -0,0 +1,208 @@
+import path from 'node:path';
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import yaml from 'js-yaml';
+import { SprintStatusSchema } from '../../shared/schemas.js';
+
+/**
+ * Load sprint status from .bmad/sprint-status.yaml
+ * @param {string} projectRoot - Parent of project-management/ directory
+ * @returns {Promise<object|null>} Parsed sprint status or null if not found
+ */
+export async function loadSprintStatus(projectRoot) {
+  const yamlPath = path.join(projectRoot, '.bmad', 'sprint-status.yaml');
+  try {
+    const content = await readFile(yamlPath, 'utf8');
+    const parsed = yaml.load(content);
+    const result = SprintStatusSchema.safeParse(parsed);
+    if (!result.success) {
+      return { ...parsed, _invalid: true };
+    }
+    return result.data;
+  } catch (err) {
+    if (err.code === 'ENOENT') return null;
+    throw err;
+  }
+}
+
+/**
+ * Rebuild sprint-status.yaml from current repository state
+ * @param {string} projectRoot - Parent of project-management/ directory
+ * @param {import('./repository.js').Repository} repository
+ * @returns {Promise<object|null>} Built sprint status object or null if no active sprint
+ */
+export async function rebuildSprintStatus(projectRoot, repository) {
+  const currentStatus = await loadSprintStatus(projectRoot);
+  const existingHistory = currentStatus?._invalid ? {} : (currentStatus?.stories ?? {});
+
+  const activeSprint = findActiveSprint(repository);
+  if (!activeSprint) return null;
+
+  const sprintGoal = await readSprintGoal(repository, activeSprint);
+  const stories = repository.listStories({ sprintId: activeSprint });
+
+  const storyMap = {};
+  for (const story of stories) {
+    const historyFromYaml = existingHistory[story.id]?.history ?? [];
+    storyMap[story.id] = {
+      title: story.title,
+      status: story.status,
+      previous_status: story.previous_status ?? '',
+      assigned_to: story.assigned_to ?? '',
+      tdd_phase: story.tdd_phase ?? '',
+      story_points: story.story_points,
+      epic_id: story.epic_id ?? '',
+      tasks: story.tasks ?? { total: 0, completed: 0, list: [] },
+      history: historyFromYaml,
+    };
+  }
+
+  const sprintStatus = {
+    version: '1.0',
+    metadata: {
+      sprint_id: activeSprint,
+      name: activeSprint,
+      start_date: '',
+      end_date: '',
+      goal: sprintGoal,
+    },
+    stories: storyMap,
+  };
+
+  const yamlPath = path.join(projectRoot, '.bmad', 'sprint-status.yaml');
+  await mkdir(path.dirname(yamlPath), { recursive: true });
+  await writeFile(yamlPath, yaml.dump(sprintStatus, { lineWidth: -1 }), 'utf8');
+
+  return sprintStatus;
+}
+
+/**
+ * Compute burndown chart data from sprint status and current stories
+ * @param {object} sprintStatus - Sprint status object
+ * @param {Array} storiesBySprint - Current stories in the sprint
+ * @returns {object} Burndown chart with ideal/actual lines and on_track indicator
+ */
+export function computeBurndown(sprintStatus, storiesBySprint) {
+  const totalPoints = storiesBySprint.reduce((sum, s) => sum + (s.story_points ?? 0), 0);
+
+  if (!sprintStatus.metadata.start_date || !sprintStatus.metadata.end_date) {
+    return {
+      ideal: [],
+      actual: [],
+      total_points: totalPoints,
+      on_track: null,
+    };
+  }
+
+  const startDate = new Date(sprintStatus.metadata.start_date);
+  const endDate = new Date(sprintStatus.metadata.end_date);
+  const totalDays = Math.ceil((endDate - startDate) / (1000 * 60 * 60 * 24));
+
+  const ideal = [];
+  for (let day = 0; day <= totalDays; day++) {
+    const date = new Date(startDate);
+    date.setDate(date.getDate() + day);
+    const remaining = totalPoints - (totalPoints / totalDays) * day;
+    ideal.push({
+      date: date.toISOString().split('T')[0],
+      points: Math.max(0, Math.round(remaining * 10) / 10),
+    });
+  }
+
+  const actual = buildActualBurndown(sprintStatus, storiesBySprint, startDate, endDate);
+
+  let onTrack = null;
+  if (actual.length > 0 && totalPoints > 0) {
+    const lastActual = actual[actual.length - 1];
+    const sameDay = ideal.find((i) => i.date === lastActual.date);
+    if (sameDay) {
+      const diff = lastActual.points - sameDay.points;
+      const variance = diff / totalPoints;
+      if (variance <= 0.1) onTrack = 'on-track';
+      else if (variance <= 0.25) onTrack = 'at-risk';
+      else onTrack = 'behind';
+    }
+  }
+
+  return {
+    ideal,
+    actual,
+    total_points: totalPoints,
+    on_track: onTrack,
+  };
+}
+
+function findActiveSprint(repository) {
+  const allStories = repository.listStories();
+  const sprintCounts = {};
+
+  for (const story of allStories) {
+    if (!story.sprint_id) continue;
+    if (!sprintCounts[story.sprint_id]) {
+      sprintCounts[story.sprint_id] = { active: 0, all: 0 };
+    }
+    sprintCounts[story.sprint_id].all++;
+    if (['in-progress', 'review', 'ready-for-dev'].includes(story.status)) {
+      sprintCounts[story.sprint_id].active++;
+    }
+  }
+
+  const sprints = Object.entries(sprintCounts).sort((a, b) => {
+    if (a[1].active !== b[1].active) return b[1].active - a[1].active;
+    return b[0].localeCompare(a[0]);
+  });
+
+  return sprints.length > 0 ? sprints[0][0] : null;
+}
+
+async function readSprintGoal(repository, sprintId) {
+  const sprint = repository.sprints.get(sprintId);
+  if (!sprint?.goalPath) return '';
+  try {
+    const content = await readFile(sprint.goalPath, 'utf8');
+    const firstLine = content.split('\n').find((l) => l.trim() && !l.startsWith('#'));
+    return firstLine?.trim() ?? '';
+  } catch {
+    return '';
+  }
+}
+
+function buildActualBurndown(sprintStatus, storiesBySprint, startDate, endDate) {
+  const doneEvents = [];
+
+  for (const story of storiesBySprint) {
+    const storyData = sprintStatus.stories[story.id];
+    if (!storyData?.history) continue;
+
+    for (const entry of storyData.history) {
+      if (entry.to === 'done') {
+        const eventDate = new Date(entry.timestamp);
+        if (eventDate >= startDate && eventDate <= endDate) {
+          doneEvents.push({
+            date: entry.timestamp.split('T')[0],
+            points: story.story_points ?? 0,
+          });
+        }
+      }
+    }
+  }
+
+  doneEvents.sort((a, b) => a.date.localeCompare(b.date));
+
+  const actual = [];
+  let remaining = storiesBySprint.reduce((sum, s) => sum + (s.story_points ?? 0), 0);
+
+  actual.push({
+    date: startDate.toISOString().split('T')[0],
+    points: remaining,
+  });
+
+  for (const event of doneEvents) {
+    remaining -= event.points;
+    actual.push({
+      date: event.date,
+      points: Math.max(0, remaining),
+    });
+  }
+
+  return actual;
+}

package/cli/kanban/server/services/state-machine.js

@@ -0,0 +1,156 @@
+/**
+ * BMAD v6 state machine for User Story status transitions.
+ * Authoritative server-side validator. UI proposes, this disposes.
+ *
+ * Allowed transitions (deny by default) :
+ *   backlog       -> ready-for-dev | blocked
+ *   ready-for-dev -> in-progress   | blocked | backlog
+ *   in-progress   -> review        | blocked
+ *   review        -> done          | in-progress | blocked
+ *   done          -> (terminal, no outgoing)
+ *   blocked       -> previous_status (via unblock)
+ *
+ * Gates (must pass before transition is allowed) :
+ *   backlog       -> ready-for-dev : invest_score === 6
+ *   in-progress   -> review        : tasks.completed === tasks.total && tasks.total > 0
+ *   review        -> done          : tasks.completed === tasks.total && tdd_phase in green|refactor|done
+ */
+
+export const STATUSES = Object.freeze(['backlog', 'ready-for-dev', 'in-progress', 'review', 'done', 'blocked']);
+
+const TRANSITIONS = Object.freeze({
+  backlog: ['ready-for-dev', 'blocked'],
+  'ready-for-dev': ['in-progress', 'blocked', 'backlog'],
+  'in-progress': ['review', 'blocked'],
+  review: ['done', 'in-progress', 'blocked'],
+  done: [],
+  blocked: [],
+});
+
+const GATES = Object.freeze({
+  'backlog->ready-for-dev': {
+    name: 'invest_gate',
+    check: (story) => {
+      const score = Number(story.invest_score ?? 0);
+      return {
+        passed: score >= 6,
+        missing: score >= 6 ? [] : [`invest_score must be 6/6 (got ${score})`],
+      };
+    },
+  },
+  'in-progress->review': {
+    name: 'tasks_complete_gate',
+    check: (story) => {
+      const total = Number(story.tasks?.total ?? 0);
+      const done = Number(story.tasks?.completed ?? 0);
+      const missing = [];
+      if (total <= 0) missing.push('no tasks defined (tasks.total must be > 0)');
+      if (done < total) missing.push(`${total - done} task(s) not completed`);
+      return { passed: missing.length === 0, missing };
+    },
+  },
+  'review->done': {
+    name: 'dod_gate',
+    check: (story) => {
+      const total = Number(story.tasks?.total ?? 0);
+      const done = Number(story.tasks?.completed ?? 0);
+      const tddOk = ['green', 'refactor', 'done'].includes(story.tdd_phase ?? '');
+      const missing = [];
+      if (total <= 0 || done < total) missing.push('not all tasks completed');
+      if (!tddOk) missing.push(`tdd_phase must be green|refactor|done (got "${story.tdd_phase ?? ''}")`);
+      return { passed: missing.length === 0, missing };
+    },
+  },
+});
+
+/**
+ * @param {string} from - current status
+ * @param {string} to - target status
+ * @returns {boolean} true if the transition is structurally allowed (gates NOT evaluated).
+ */
+export function isTransitionAllowed(from, to) {
+  if (!STATUSES.includes(from) || !STATUSES.includes(to)) return false;
+  if (from === to) return false;
+  if (to === 'blocked') return from !== 'blocked' && from !== 'done';
+  if (from === 'blocked') return false;
+  return (TRANSITIONS[from] ?? []).includes(to);
+}
+
+/**
+ * Validate a transition request against structure + gates.
+ * @param {object} story - story frontmatter
+ * @param {string} to - target status
+ * @param {object} [opts]
+ * @param {string} [opts.blocked_reason] - required when to === 'blocked'
+ * @returns {{ allowed: boolean, reason?: string, gate?: string, missing?: string[] }}
+ */
+export function validateTransition(story, to, opts = {}) {
+  const from = story.status;
+
+  if (to === 'blocked') {
+    if (from === 'blocked') return { allowed: false, reason: 'already blocked' };
+    if (!opts.blocked_reason || !opts.blocked_reason.trim()) {
+      return { allowed: false, reason: 'blocked_reason is required' };
+    }
+    return { allowed: true };
+  }
+
+  if (!isTransitionAllowed(from, to)) {
+    return { allowed: false, reason: `transition ${from} -> ${to} not allowed` };
+  }
+
+  const gate = GATES[`${from}->${to}`];
+  if (gate) {
+    const result = gate.check(story);
+    if (!result.passed) {
+      return { allowed: false, gate: gate.name, missing: result.missing, reason: 'gate failed' };
+    }
+  }
+  return { allowed: true };
+}
+
+/**
+ * Unblock a story : restore previous_status. Does NOT evaluate gates
+ * (the story was valid before being blocked).
+ * @param {object} story
+ * @returns {{ allowed: boolean, status?: string, reason?: string }}
+ */
+export function validateUnblock(story) {
+  if (story.status !== 'blocked') {
+    return { allowed: false, reason: 'story is not blocked' };
+  }
+  const prev = story.previous_status;
+  if (!prev || !STATUSES.includes(prev) || prev === 'blocked') {
+    return { allowed: false, reason: 'no valid previous_status to restore' };
+  }
+  return { allowed: true, status: prev };
+}
+
+/**
+ * Compute the frontmatter patch to apply for a given transition.
+ * @param {object} story
+ * @param {string} to
+ * @param {object} [opts]
+ * @returns {object} partial frontmatter to merge
+ */
+export function computeTransitionPatch(story, to, opts = {}) {
+  if (to === 'blocked') {
+    return {
+      status: 'blocked',
+      previous_status: story.status,
+      blocked_reason: opts.blocked_reason ?? '',
+      blocked_at: opts.now ?? new Date().toISOString(),
+    };
+  }
+  const patch = { status: to };
+  if (story.status === 'blocked') {
+    patch.previous_status = '';
+    patch.blocked_reason = '';
+    patch.blocked_at = '';
+  } else {
+    patch.previous_status = story.status;
+  }
+  return patch;
+}
+
+export const _internal = { TRANSITIONS, GATES };

package/cli/kanban/shared/schemas.js

@@ -0,0 +1,127 @@
+import { z } from 'zod';
+
+export const STATUSES = ['backlog', 'ready-for-dev', 'in-progress', 'review', 'done', 'blocked'];
+export const PRIORITIES = ['must', 'should', 'could', 'wont'];
+export const TDD_PHASES = ['', 'red', 'green', 'refactor', 'done'];
+export const TASK_TYPES = ['DB', 'BE', 'FE-WEB', 'FE-MOB', 'TEST', 'DOC', 'OPS', 'REV'];
+export const TASK_STATUSES = ['to-do', 'in-progress', 'done', 'blocked'];
+
+const idPattern = (prefix) => z.string().regex(new RegExp(`^${prefix}-\\d{3,}$`), `Expected ${prefix}-XXX`);
+
+export const StoryStatusSchema = z.enum(STATUSES);
+export const PrioritySchema = z.enum(PRIORITIES);
+export const TddPhaseSchema = z.enum(TDD_PHASES);
+
+export const HistoryEntrySchema = z.object({
+  timestamp: z.string(),
+  from: z.string(),
+  to: z.string(),
+  by: z.string().default('auto'),
+  reason: z.string().default(''),
+});
+
+export const StoryFrontmatterSchema = z
+  .object({
+    id: idPattern('US'),
+    title: z.string().min(1),
+    epic_id: idPattern('EPIC').nullable().optional(),
+    persona: z.string().optional().default(''),
+    status: StoryStatusSchema.default('backlog'),
+    previous_status: z.string().optional().default(''),
+    story_points: z.number().int().min(0).max(21).default(0),
+    priority: PrioritySchema.optional().default('should'),
+    sprint_id: z.string().nullable().optional(),
+    assigned_to: z.string().optional().default(''),
+    tdd_phase: TddPhaseSchema.optional().default(''),
+    invest_score: z.number().int().min(0).max(6).optional().default(0),
+    blocked_reason: z.string().optional().default(''),
+    blocked_at: z.string().optional().default(''),
+    traceability: z
+      .object({
+        implements: z.array(z.string()).default([]),
+        tests: z.array(z.string()).default([]),
+      })
+      .optional()
+      .default({ implements: [], tests: [] }),
+    tasks: z
+      .object({
+        total: z.number().int().min(0).default(0),
+        completed: z.number().int().min(0).default(0),
+        list: z.array(idPattern('TASK')).default([]),
+      })
+      .optional()
+      .default({ total: 0, completed: 0, list: [] }),
+    dependencies: z.array(idPattern('US')).optional().default([]),
+  })
+  .passthrough();
+
+export const EpicFrontmatterSchema = z
+  .object({
+    id: idPattern('EPIC'),
+    title: z.string().min(1),
+    status: z.enum(['draft', 'ready', 'in-progress', 'done']).default('draft'),
+    business_value: z.enum(['high', 'medium', 'low']).optional().default('medium'),
+    estimated_sprints: z.number().int().min(0).optional().default(0),
+  })
+  .passthrough();
+
+export const TaskFrontmatterSchema = z
+  .object({
+    id: idPattern('TASK'),
+    us_id: idPattern('US'),
+    type: z.enum(TASK_TYPES),
+    status: z.enum(TASK_STATUSES).default('to-do'),
+    estimation_hours: z.number().min(0).default(0),
+    actual_hours: z.number().min(0).optional().default(0),
+    assigned_to: z.string().optional().default(''),
+  })
+  .passthrough();
+
+export const SprintStatusSchema = z
+  .object({
+    version: z.string().default('1.0'),
+    metadata: z.object({
+      sprint_id: z.string(),
+      name: z.string(),
+      start_date: z.string(),
+      end_date: z.string(),
+      goal: z.string().default(''),
+    }),
+    stories: z
+      .record(
+        z.object({
+          title: z.string(),
+          status: StoryStatusSchema,
+          previous_status: z.string().optional().default(''),
+          assigned_to: z.string().optional().default(''),
+          tdd_phase: TddPhaseSchema.optional().default(''),
+          story_points: z.number().int().min(0).default(0),
+          epic_id: z.string().optional().default(''),
+          tasks: z
+            .object({
+              total: z.number().int().min(0).default(0),
+              completed: z.number().int().min(0).default(0),
+              list: z.array(z.string()).default([]),
+            })
+            .optional(),
+          history: z.array(HistoryEntrySchema).optional().default([]),
+        })
+      )
+      .default({}),
+  })
+  .passthrough();
+
+export const TransitionRequestSchema = z.object({
+  status: StoryStatusSchema,
+  blocked_reason: z.string().max(500).optional(),
+  reason: z.string().max(500).optional(),
+});
+
+export const StoryPatchSchema = z
+  .object({
+    story_points: z.number().int().min(0).max(21).optional(),
+    assigned_to: z.string().max(100).optional(),
+    priority: PrioritySchema.optional(),
+    tdd_phase: TddPhaseSchema.optional(),
+  })
+  .strict();

package/cli/lib/help.js

@@ -47,6 +47,7 @@ ${c.bold}Commands:${c.reset}
   ${c.green}update${c.reset}               Refresh existing installation
   ${c.green}flatten${c.reset}              Generate flattened codebase summary
   ${c.green}ralph${c.reset}                Run Ralph Wiggum continuous loop
+  ${c.green}kanban${c.reset}               Launch local Kanban UI for project-management/
   ${c.green}help${c.reset}                 Show this help message
 
 ${c.bold}Options:${c.reset}
@@ -79,6 +80,9 @@ ${c.bold}Examples:${c.reset}
   ${c.dim}# Run Ralph continuous loop${c.reset}
   npx @the-bearded-bear/claude-craft ralph "Implement user authentication"
 
+  ${c.dim}# Launch Kanban UI for the current BMAD project${c.reset}
+  npx @the-bearded-bear/claude-craft kanban --open
+
 ${c.bold}Technologies:${c.reset}
 ${Object.entries(TECHNOLOGIES)
   .map(([key, val]) => `  ${c.cyan}${key.padEnd(12)}${c.reset} ${val.desc}`)