framedeck-mcp 2.0.0

package/README.md

@@ -0,0 +1,108 @@
+# framedeck-mcp
+
+MCP server for [Framedeck](https://framedeck.app) — connect any AI assistant to your content production pipeline.
+
+Works with **Claude**, **ChatGPT**, **Gemini**, **Copilot**, and any MCP-compatible client.
+
+## Quick Start
+
+1. Get your API key at [framedeck.app](https://framedeck.app) > Settings > API Keys
+2. Add to your AI assistant config (see below)
+
+## Setup
+
+### Claude Code
+
+```bash
+claude mcp add framedeck -e FRAMEDECK_API_KEY=your_key_here -- npx -y framedeck-mcp
+```
+
+### Claude Desktop
+
+Add to your `claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "framedeck": {
+      "command": "npx",
+      "args": ["-y", "framedeck-mcp"],
+      "env": {
+        "FRAMEDECK_API_KEY": "your_key_here"
+      }
+    }
+  }
+}
+```
+
+### Other MCP Clients
+
+Set the environment variable `FRAMEDECK_API_KEY` and run:
+
+```bash
+npx framedeck-mcp
+```
+
+## What You Can Do
+
+Talk to your AI assistant naturally:
+
+- *"I had 3 video ideas: cooking tutorial, camera review, day in the life"* — creates ideas in your Idea Pool
+- *"The cooking tutorial is a go!"* — graduates it to a full production with stages
+- *"Add tasks: write intro, record B-roll, find music"* — creates frames in your production
+- *"Move the intro to Editing"* — updates your board in real-time
+- *"How's my channel looking?"* — get a full overview with overdue items
+
+## Tools (33)
+
+| Tool | Description |
+|------|-------------|
+| `set_active_board` | Set the active production context |
+| `get_active_board` | Show current active production |
+| `list_boards` | List all productions/projects |
+| `create_board` | Create a new production or project |
+| `list_columns` | List stages in a board |
+| `create_column` | Create a new stage |
+| `delete_column` | Delete a stage |
+| `list_cards` | List cards/frames with filters |
+| `create_card` | Create a card/frame |
+| `create_multiple_cards` | Batch create (up to 50) |
+| `update_card` | Update title, description, priority, due date |
+| `move_card` | Move to a different stage |
+| `delete_card` | Permanently delete |
+| `archive_card` | Soft delete (restorable) |
+| `duplicate_card` | Copy with checklist and labels |
+| `set_card_color` | Color-code a card |
+| `add_comment` | Add a comment |
+| `add_checklist_item` | Add a subtask |
+| `toggle_checklist_item` | Check/uncheck a subtask |
+| `add_labels_to_card` | Add labels to a card |
+| `remove_label_from_card` | Remove a label |
+| `get_card_details` | Full card info |
+| `search_cards` | Search by keyword |
+| `assign_card` | Assign a team member |
+| `get_my_cards` | Cards grouped by status |
+| `get_board_overview` | Board summary with overdue items |
+| `list_labels` | List all labels |
+| `create_label` | Create a label |
+| `link_commit` | Link a git commit to a card |
+| `log_work` | Log time spent |
+| `get_sprint_summary` | Activity summary |
+| `graduate_to_production` | Promote idea to full production |
+
+## Dual Mode
+
+Framedeck supports two board modes:
+
+- **Creator mode**: Productions, Stages, Frames — for content pipelines
+- **Classic mode**: Projects, Stages, Cards — for standard project management
+
+The MCP server automatically uses the correct terminology based on each board's mode.
+
+## Idea Pool
+
+When you add ideas without specifying a board, they automatically land in your **Idea Pool**. When an idea is ready, use `graduate_to_production` to create a dedicated production with full stages (Idea > Scripting > Filming > Editing > Published).
+
+## License
+
+MIT

package/index.js

@@ -0,0 +1,1118 @@
+#!/usr/bin/env node
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+
+// ── Config ──────────────────────────────────────────────
+const API_KEY = process.env.FRAMEDECK_API_KEY || process.env.COMMAND_CENTER_API_KEY;
+const PROXY_URL = process.env.FRAMEDECK_PROXY_URL || process.env.COMMAND_CENTER_PROXY_URL || 'https://iecdacsegqginojacpca.supabase.co/functions/v1/mcp-proxy';
+
+// Legacy: direct Supabase connection for local dev
+const SUPABASE_URL = process.env.SUPABASE_URL;
+const SUPABASE_SERVICE_ROLE_KEY = process.env.SUPABASE_SERVICE_ROLE_KEY;
+const LEGACY_USER_ID = process.env.MCP_USER_ID;
+
+const USE_PROXY = !!API_KEY && !SUPABASE_SERVICE_ROLE_KEY;
+
+let supabase, USER_ID, USER_PLAN = 'free';
+
+if (USE_PROXY) {
+  if (!API_KEY) { console.error('Missing: FRAMEDECK_API_KEY. Get your key at https://framedeck.app → Settings → API Keys'); process.exit(1); }
+} else {
+  // Legacy direct mode
+  if (!SUPABASE_URL || !SUPABASE_SERVICE_ROLE_KEY) {
+    console.error('Missing: SUPABASE_URL + SUPABASE_SERVICE_ROLE_KEY, or set FRAMEDECK_API_KEY for proxy mode');
+    process.exit(1);
+  }
+  const { createClient } = await import('@supabase/supabase-js');
+  const { createHash } = await import('node:crypto');
+  supabase = createClient(SUPABASE_URL, SUPABASE_SERVICE_ROLE_KEY);
+
+  if (API_KEY) {
+    const keyHash = createHash('sha256').update(API_KEY).digest('hex');
+    const { data, error } = await supabase.rpc('validate_api_key', { key_hash: keyHash });
+    if (error || !data?.length) { console.error('Invalid API key'); process.exit(1); }
+    USER_ID = data[0].user_id;
+    USER_PLAN = data[0].plan;
+  } else if (LEGACY_USER_ID) {
+    USER_ID = LEGACY_USER_ID;
+  } else {
+    console.error('Missing: FRAMEDECK_API_KEY or MCP_USER_ID');
+    process.exit(1);
+  }
+}
+
+// ── Proxy call helper ───────────────────────────────────
+async function proxyCall(action, params = {}) {
+  const res = await fetch(PROXY_URL, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'Authorization': `Bearer ${API_KEY}`,
+    },
+    body: JSON.stringify({ action, params }),
+  });
+  return await res.json();
+}
+
+// ── Direct mode helpers (legacy) ────────────────────────
+async function resolveColumn(nameOrId, boardId = null) {
+  let query = supabase.from('columns').select('id, name').eq('id', nameOrId).eq('user_id', USER_ID);
+  if (boardId) query = query.eq('board_id', boardId);
+  let { data } = await query.maybeSingle();
+  if (data) return data;
+  // Use limit(1) instead of maybeSingle() to handle duplicate column names gracefully
+  let nameQuery = supabase.from('columns').select('id, name').eq('user_id', USER_ID).ilike('name', nameOrId).order('position').limit(1);
+  if (boardId) nameQuery = nameQuery.eq('board_id', boardId);
+  const { data: byName } = await nameQuery;
+  return byName?.[0] || null;
+}
+async function resolveBoard(nameOrId) {
+  let { data } = await supabase.from('boards').select('id, name').eq('id', nameOrId).eq('user_id', USER_ID).maybeSingle();
+  if (data) return data;
+  const { data: byName } = await supabase.from('boards').select('id, name').eq('user_id', USER_ID).ilike('name', nameOrId).order('position').limit(1);
+  return byName?.[0] || null;
+}
+async function resolveLabel(nameOrId) {
+  let { data } = await supabase.from('tags').select('id, name').eq('id', nameOrId).eq('user_id', USER_ID).maybeSingle();
+  if (data) return data;
+  const { data: byName } = await supabase.from('tags').select('id, name').eq('user_id', USER_ID).ilike('name', nameOrId).order('position').limit(1);
+  return byName?.[0] || null;
+}
+async function resolveCard(nameOrId) {
+  // Get user's board IDs to scope card resolution (service role bypasses RLS)
+  const { data: userBoards } = await supabase.from('boards').select('id').eq('user_id', USER_ID);
+  const boardIds = userBoards?.map(b => b.id) || [];
+  if (!boardIds.length) return null;
+
+  let { data } = await supabase.from('cards').select('id, title').eq('id', nameOrId).in('board_id', boardIds).maybeSingle();
+  if (data) return data;
+  const { data: byName } = await supabase.from('cards').select('id, title').in('board_id', boardIds).ilike('title', `%${nameOrId}%`).limit(1).maybeSingle();
+  return byName;
+}
+async function getMaxPosition(table, filter = {}) {
+  let query = supabase.from(table).select('position').order('position', { ascending: false }).limit(1);
+  for (const [k, v] of Object.entries(filter)) query = query.eq(k, v);
+  const { data } = await query;
+  return data?.[0]?.position ?? -1;
+}
+
+// ── Broadcast helper — notify browser clients of MCP mutations ──
+// Keep a persistent channel so we don't have to reconnect every time
+let mcpBroadcastChannel = null;
+let mcpChannelReady = false;
+
+function initBroadcastChannel() {
+  if (!supabase || mcpBroadcastChannel) return;
+  mcpBroadcastChannel = supabase.channel('mcp-changes');
+  mcpBroadcastChannel.subscribe((status) => {
+    mcpChannelReady = status === 'SUBSCRIBED';
+  });
+}
+
+async function broadcastChange(table) {
+  if (!mcpBroadcastChannel || !mcpChannelReady) return;
+  try {
+    await mcpBroadcastChannel.send({ type: 'broadcast', event: 'mutation', payload: { table } });
+  } catch (_) { /* best-effort */ }
+}
+
+// Initialize the channel at startup (only in direct/legacy mode)
+if (supabase) initBroadcastChannel();
+
+// ── Terminology helper ─────────────────────────────────
+// Returns mode-aware labels based on board mode (creator vs classic)
+function terms(mode) {
+  if (mode === 'creator') return { board: 'production', Board: 'Production', card: 'frame', Card: 'Frame', cards: 'frames', Cards: 'Frames', stage: 'stage', Stage: 'Stage' };
+  return { board: 'project', Board: 'Project', card: 'card', Card: 'Card', cards: 'cards', Cards: 'Cards', stage: 'stage', Stage: 'Stage' };
+}
+
+// Look up a board's mode and return its terms
+async function boardTerms(boardId) {
+  if (!boardId) return terms('classic');
+  const { data } = await supabase.from('boards').select('mode').eq('id', boardId).eq('user_id', USER_ID).single();
+  return terms(data?.mode);
+}
+
+// ── Active board context ───────────────────────────────
+// Stores the "current" board so users don't have to specify it every time.
+// Set via set_active_board, used as fallback when board param is omitted.
+let activeBoardId = null;
+let activeBoardName = null;
+let activeBoardMode = 'classic';
+
+function activeTerms() { return terms(activeBoardMode); }
+
+async function requireBoard(boardParam) {
+  if (boardParam) {
+    const brd = await resolveBoard(boardParam);
+    return brd;
+  }
+  if (activeBoardId) {
+    return { id: activeBoardId, name: activeBoardName };
+  }
+  return null;
+}
+
+// ── Idea Pool auto-creation ────────────────────────────
+// When no board specified and no active board, find or create "Idea Pool"
+const IDEA_POOL_NAME = 'Idea Pool';
+const IDEA_POOL_ICON = '💡';
+const IDEA_POOL_COLUMN = 'Ideas';
+
+async function ensureIdeaPool() {
+  // Check if Idea Pool already exists
+  const { data: existing } = await supabase.from('boards')
+    .select('id, name').eq('user_id', USER_ID).ilike('name', IDEA_POOL_NAME).limit(1);
+  if (existing?.length) return existing[0];
+
+  // Create it — handle race condition (concurrent calls may both pass the check above)
+  const maxPos = await getMaxPosition('boards', { user_id: USER_ID });
+  const { data: pool, error } = await supabase.from('boards').insert({
+    name: IDEA_POOL_NAME, icon: IDEA_POOL_ICON, color: '#f59e0b',
+    position: maxPos + 1, user_id: USER_ID, mode: 'creator',
+  }).select().single();
+  if (error) {
+    // Race condition: another call created it first — find and return it
+    const { data: raceResult } = await supabase.from('boards')
+      .select('id, name').eq('user_id', USER_ID).ilike('name', IDEA_POOL_NAME).limit(1);
+    return raceResult?.[0] || null;
+  }
+
+  // Add the owner as member
+  const { data: user } = await supabase.auth.admin.getUserById(USER_ID);
+  await supabase.from('project_members').upsert({
+    board_id: pool.id, user_id: USER_ID,
+    user_email: user?.user?.email || '', user_avatar: user?.user?.user_metadata?.avatar_url || '',
+    role: 'owner',
+  }, { onConflict: 'board_id,user_id' });
+
+  // Create the two stages: Ideas + In Production
+  await supabase.from('columns').insert({
+    name: 'Ideas', color: '#6b7280', position: 0, board_id: pool.id, user_id: USER_ID,
+  });
+  await supabase.from('columns').insert({
+    name: 'In Production', color: '#10b981', position: 1, board_id: pool.id, user_id: USER_ID,
+  });
+
+  await broadcastChange('boards');
+  await broadcastChange('columns');
+  return pool;
+}
+
+// ── Generic tool handler ────────────────────────────────
+function handleTool(action, directHandler) {
+  return async (params) => {
+    if (USE_PROXY) {
+      const result = await proxyCall(action, params);
+      const text = result.ok ? (result.data || 'Done.') : `Error: ${result.error}`;
+      return { content: [{ type: 'text', text }] };
+    }
+    return directHandler(params);
+  };
+}
+
+// ── MCP Server ──────────────────────────────────────────
+const server = new McpServer({ name: 'framedeck', version: '2.0.0' });
+
+// ── list_boards ─────────────────────────────────────────
+server.tool('list_boards', 'List all projects/productions in Framedeck', {},
+  handleTool('list_boards', async () => {
+    const { data, error } = await supabase.from('boards').select('id, name, icon, color, position, mode').eq('user_id', USER_ID).order('position');
+    if (error) return { content: [{ type: 'text', text: `Error: ${error.message}` }] };
+    const text = data.map(b => `${b.icon || '📋'} ${b.name} [${b.mode || 'classic'}] (${b.id})`).join('\n') || 'No boards found.';
+    return { content: [{ type: 'text', text }] };
+  })
+);
+
+// ── create_board ────────────────────────────────────────
+server.tool('create_board', 'Create a new project/board in Framedeck', {
+  name: z.string().describe('Board name'),
+  icon: z.string().optional().describe('Emoji icon for the board (default: 📋)'),
+  color: z.string().regex(/^#[0-9a-fA-F]{3,8}$/).optional().describe('Hex color for the board (default: #3b82f6)'),
+  mode: z.enum(['creator', 'classic']).optional().describe('Board mode: creator (Productions/Stages/Frames) or classic (Projects/Stages/Cards). Default: classic'),
+}, handleTool('create_board', async ({ name, icon, color, mode }) => {
+  if (USER_PLAN === 'free') {
+    const { count } = await supabase.from('boards').select('*', { count: 'exact', head: true }).eq('user_id', USER_ID);
+    if (count >= 2) return { content: [{ type: 'text', text: 'Free plan limit reached (2 boards). Upgrade to create more.' }] };
+  }
+  const maxPos = await getMaxPosition('boards', { user_id: USER_ID });
+  const { data, error } = await supabase.from('boards').insert({
+    name, icon: icon || '📋', color: color || '#3b82f6', position: maxPos + 1, user_id: USER_ID, mode: mode || 'classic',
+  }).select().single();
+  if (error) return { content: [{ type: 'text', text: `Error: ${error.message}` }] };
+  const { data: user } = await supabase.auth.admin.getUserById(USER_ID);
+  await supabase.from('project_members').upsert({
+    board_id: data.id, user_id: USER_ID,
+    user_email: user?.user?.email || '', user_avatar: user?.user?.user_metadata?.avatar_url || '',
+    role: 'owner',
+  }, { onConflict: 'board_id,user_id' });
+  return { content: [{ type: 'text', text: `Created board: ${data.icon} ${data.name} (${data.id})` }] };
+}));
+
+// ── set_active_board ───────────────────────────────────
+server.tool('set_active_board', 'Set the active board/production context. Once set, other tools will use this board by default when no board is specified.', {
+  board: z.string().describe('Board/production name or ID to set as active'),
+}, handleTool('set_active_board', async ({ board }) => {
+  const brd = await resolveBoard(board);
+  if (!brd) return { content: [{ type: 'text', text: `Board "${board}" not found.` }] };
+  activeBoardId = brd.id;
+  activeBoardName = brd.name;
+  // Fetch full board info for richer response
+  const { data: fullBoard } = await supabase.from('boards').select('icon, mode').eq('id', brd.id).single();
+  activeBoardMode = fullBoard?.mode || 'classic';
+  const t = activeTerms();
+  const { data: cols } = await supabase.from('columns').select('name').eq('board_id', brd.id).order('position');
+  const stages = (cols || []).map(c => c.name).join(' → ');
+  return { content: [{ type: 'text', text: `Active ${t.board} set to: ${fullBoard?.icon || '📋'} ${brd.name}\nStages: ${stages || 'none'}` }] };
+}));
+
+// ── get_active_board ───────────────────────────────────
+server.tool('get_active_board', 'Show which board/production is currently set as the active context.', {},
+  handleTool('get_active_board', async () => {
+    if (!activeBoardId) return { content: [{ type: 'text', text: 'No active board set. Use set_active_board to set one.' }] };
+    const { data: brd } = await supabase.from('boards').select('name, icon, mode').eq('id', activeBoardId).single();
+    if (!brd) { activeBoardId = null; activeBoardName = null; activeBoardMode = 'classic'; return { content: [{ type: 'text', text: 'Active board no longer exists.' }] }; }
+    const t = terms(brd.mode);
+    const { data: cols } = await supabase.from('columns').select('name').eq('board_id', activeBoardId).order('position');
+    const { data: cards } = await supabase.from('cards').select('id').eq('board_id', activeBoardId).eq('archived', false);
+    const stages = (cols || []).map(c => c.name).join(' → ');
+    return { content: [{ type: 'text', text: `Active ${t.board}: ${brd.icon || '📋'} ${brd.name}\nStages: ${stages}\n${t.Cards}: ${(cards || []).length}` }] };
+  })
+);
+
+// ── list_columns ────────────────────────────────────────
+server.tool('list_columns', 'List stages in a board. Uses active board if set and no board specified.', {
+  board: z.string().optional().describe('Board/production name or ID (uses active board if omitted and set)'),
+}, handleTool('list_columns', async ({ board }) => {
+    let query = supabase.from('columns').select('id, name, color, position, board_id').eq('user_id', USER_ID).order('position');
+    if (board) {
+      const brd = await resolveBoard(board);
+      if (!brd) return { content: [{ type: 'text', text: `Board "${board}" not found.` }] };
+      query = query.eq('board_id', brd.id);
+    } else if (activeBoardId) {
+      query = query.eq('board_id', activeBoardId);
+    }
+    const { data, error } = await query;
+    if (error) return { content: [{ type: 'text', text: `Error: ${error.message}` }] };
+    return { content: [{ type: 'text', text: data.map(c => `${c.name} (${c.id})`).join('\n') || 'No columns found.' }] };
+  })
+);
+
+// ── list_labels ─────────────────────────────────────────
+server.tool('list_labels', 'List all labels/tags', {},
+  handleTool('list_labels', async () => {
+    const { data, error } = await supabase.from('tags').select('id, name, color, position').eq('user_id', USER_ID).order('position');
+    if (error) return { content: [{ type: 'text', text: `Error: ${error.message}` }] };
+    return { content: [{ type: 'text', text: data.map(t => `${t.name} (${t.id})`).join('\n') || 'No labels found.' }] };
+  })
+);
+
+// ── create_label ────────────────────────────────────────
+server.tool('create_label', 'Create a new label/tag', {
+  name: z.string().describe('Label name'),
+  color: z.string().regex(/^#[0-9a-fA-F]{3,8}$/).optional().describe('Hex color for the label (default: #6b7280)'),
+}, handleTool('create_label', async ({ name, color }) => {
+  const maxPos = await getMaxPosition('tags', { user_id: USER_ID });
+  const { data, error } = await supabase.from('tags').insert({
+    name, color: color || '#6b7280', position: maxPos + 1, user_id: USER_ID,
+  }).select().single();
+  if (error) return { content: [{ type: 'text', text: `Error: ${error.message}` }] };
+  return { content: [{ type: 'text', text: `Created label: ${data.name} (${data.id})` }] };
+}));
+
+// ── list_cards ──────────────────────────────────────────
+server.tool('list_cards', 'List cards/frames with optional filters. Uses active board if set and no board specified.', {
+  board: z.string().optional().describe('Board/production name or ID (uses active board if omitted and set)'),
+  column: z.string().optional().describe('Stage name or ID to filter by'),
+  priority: z.string().optional().describe('Priority to filter by: urgent, high, medium, low'),
+  limit: z.number().optional().describe('Max number of cards to return (default 50)'),
+}, handleTool('list_cards', async ({ board, column, priority, limit }) => {
+  let query = supabase.from('cards').select('id, title, description, column_name, board_id, priority, due_date, position').order('position');
+  if (board) {
+    const b = await resolveBoard(board);
+    if (!b) return { content: [{ type: 'text', text: `Board "${board}" not found.` }] };
+    query = query.eq('board_id', b.id);
+  } else if (activeBoardId) {
+    query = query.eq('board_id', activeBoardId);
+  } else {
+    const { data: userBoards } = await supabase.from('boards').select('id').eq('user_id', USER_ID);
+    if (userBoards?.length) query = query.in('board_id', userBoards.map(b => b.id));
+  }
+  if (column) {
+    const c = await resolveColumn(column);
+    if (!c) return { content: [{ type: 'text', text: `Column "${column}" not found.` }] };
+    query = query.eq('column_name', c.id);
+  }
+  if (priority) query = query.eq('priority', priority);
+  query = query.limit(limit || 50);
+  const { data, error } = await query;
+  if (error) return { content: [{ type: 'text', text: `Error: ${error.message}` }] };
+  const { data: cols } = await supabase.from('columns').select('id, name').eq('user_id', USER_ID);
+  const { data: boards } = await supabase.from('boards').select('id, name, icon').eq('user_id', USER_ID);
+  const colMap = Object.fromEntries((cols || []).map(c => [c.id, c.name]));
+  const boardMap = Object.fromEntries((boards || []).map(b => [b.id, `${b.icon || ''} ${b.name}`]));
+  const text = data.map(card => {
+    const parts = [`• ${card.title}`];
+    if (card.priority) parts.push(`[${card.priority.toUpperCase()}]`);
+    parts.push(`| ${colMap[card.column_name] || 'Unknown'}`);
+    parts.push(`| ${boardMap[card.board_id] || 'Unknown'}`);
+    if (card.due_date) parts.push(`| Due: ${card.due_date}`);
+    return parts.join(' ');
+  }).join('\n') || 'No cards found.';
+  const scopedBoardId = board ? (await resolveBoard(board))?.id : activeBoardId;
+  const t = await boardTerms(scopedBoardId);
+  const boardContext = board ? `in "${board}"` : activeBoardId ? `in "${activeBoardName}"` : `across all ${t.board}s`;
+  return { content: [{ type: 'text', text: `📋 ${data.length} ${t.card}(s) ${boardContext}:\n${text}` }] };
+}));
+
+// ── create_card ─────────────────────────────────────────
+server.tool('create_card', 'Create a new card/frame. Uses active board if set, or Idea Pool as fallback for quick idea capture.', {
+  title: z.string().describe('Card title'),
+  description: z.string().optional().describe('Card description'),
+  column: z.string().optional().describe('Stage name or ID (e.g. "Idea", "Scripting", "To Do"). Defaults to first stage.'),
+  board: z.string().optional().describe('Board/production name or ID (uses active board or Idea Pool if omitted)'),
+  priority: z.string().optional().describe('Priority: urgent, high, medium, low'),
+  labels: z.array(z.string()).optional().describe('Label names or IDs to attach'),
+  due_date: z.string().optional().describe('Due date (YYYY-MM-DD)'),
+}, handleTool('create_card', async ({ title, description, column, board, priority, labels, due_date }) => {
+  let brd = await requireBoard(board);
+  let usedIdeaPool = false;
+  if (!brd) {
+    // No board specified, no active board → use Idea Pool
+    brd = await ensureIdeaPool();
+    usedIdeaPool = true;
+    if (!brd) return { content: [{ type: 'text', text: 'Could not find or create Idea Pool.' }] };
+  }
+  let col;
+  if (column) {
+    col = await resolveColumn(column, brd.id);
+    if (!col) return { content: [{ type: 'text', text: `Stage "${column}" not found in ${brd.name}.` }] };
+  } else {
+    // Default to first column in the board
+    const { data: firstCol } = await supabase.from('columns').select('id, name').eq('board_id', brd.id).order('position').limit(1);
+    col = firstCol?.[0];
+    if (!col) return { content: [{ type: 'text', text: `No stages found in ${brd.name}. Create a stage first.` }] };
+  }
+  const maxPos = await getMaxPosition('cards', { column_name: col.id });
+  const { data: card, error } = await supabase.from('cards').insert({
+    title, description: description || '', column_name: col.id, board_id: brd.id,
+    priority: priority || '', due_date: due_date || '', position: maxPos + 1, color: '', cover_image: '',
+  }).select().single();
+  if (error) return { content: [{ type: 'text', text: `Error: ${error.message}` }] };
+  if (labels?.length && card) {
+    for (const labelName of labels) {
+      const label = await resolveLabel(labelName);
+      if (label) await supabase.from('card_tags').insert({ card_id: card.id, tag_id: label.id });
+    }
+  }
+  await supabase.from('activity_log').insert({
+    user_id: USER_ID, user_email: 'Claude Code', action: 'created',
+    entity_type: 'card', entity_name: title, details: `in ${col.name} (${brd.name})`,
+  });
+  await broadcastChange('cards');
+  const t = await boardTerms(brd.id);
+  const poolNote = usedIdeaPool ? ' 💡 Added to Idea Pool.' : '';
+  return { content: [{ type: 'text', text: `Created ${t.card} "${title}" in ${col.name} (${brd.name})${priority ? ` [${priority.toUpperCase()}]` : ''}.${poolNote} ID: ${card.id}` }] };
+}));
+
+// ── update_card ─────────────────────────────────────────
+server.tool('update_card', 'Update an existing card/frame', {
+  id: z.string().describe('Card ID or title (partial match supported)'),
+  title: z.string().optional().describe('New title'),
+  description: z.string().optional().describe('New description'),
+  column: z.string().optional().describe('Move to stage (name or ID)'),
+  priority: z.string().optional().describe('New priority: urgent, high, medium, low, or empty to clear'),
+  due_date: z.string().optional().describe('New due date (YYYY-MM-DD) or empty to clear'),
+}, handleTool('update_card', async ({ id, title, description, column, priority, due_date }) => {
+  const card = await resolveCard(id);
+  if (!card) return { content: [{ type: 'text', text: `Card "${id}" not found.` }] };
+  const updates = {};
+  if (title !== undefined) updates.title = title;
+  if (description !== undefined) updates.description = description;
+  if (priority !== undefined) updates.priority = priority;
+  if (due_date !== undefined) updates.due_date = due_date;
+  if (column) {
+    const col = await resolveColumn(column);
+    if (!col) return { content: [{ type: 'text', text: `Column "${column}" not found.` }] };
+    updates.column_name = col.id;
+  }
+  const { data, error } = await supabase.from('cards').update(updates).eq('id', card.id).select('title').single();
+  if (error) return { content: [{ type: 'text', text: `Error: ${error.message}` }] };
+  await broadcastChange('cards');
+  return { content: [{ type: 'text', text: `Updated card "${data.title}".` }] };
+}));
+
+// ── move_card ───────────────────────────────────────────
+server.tool('move_card', 'Move a card/frame to a different stage', {
+  id: z.string().describe('Card ID or title (partial match supported)'),
+  column: z.string().describe('Target stage name or ID'),
+}, handleTool('move_card', async ({ id, column }) => {
+  const card = await resolveCard(id);
+  if (!card) return { content: [{ type: 'text', text: `Card "${id}" not found.` }] };
+  const { data: fullCard } = await supabase.from('cards').select('board_id').eq('id', card.id).single();
+  const col = await resolveColumn(column, fullCard?.board_id);
+  if (!col) return { content: [{ type: 'text', text: `Column "${column}" not found.` }] };
+  const maxPos = await getMaxPosition('cards', { column_name: col.id });
+  const { error } = await supabase.from('cards').update({ column_name: col.id, position: maxPos + 1 }).eq('id', card.id);
+  if (error) return { content: [{ type: 'text', text: `Error: ${error.message}` }] };
+  await supabase.from('activity_log').insert({
+    user_id: USER_ID, user_email: 'Claude Code', action: 'moved',
+    entity_type: 'card', entity_name: card.title, details: `to ${col.name}`,
+  });
+  await broadcastChange('cards');
+  return { content: [{ type: 'text', text: `Moved "${card.title}" to ${col.name}.` }] };
+}));
+
+// ── delete_card ─────────────────────────────────────────
+server.tool('delete_card', 'Permanently delete a card/frame', {
+  id: z.string().describe('Card ID or title (partial match supported)'),
+}, handleTool('delete_card', async ({ id }) => {
+  const card = await resolveCard(id);
+  if (!card) return { content: [{ type: 'text', text: `Card "${id}" not found.` }] };
+  const { data: cardInfo } = await supabase.from('cards').select('board_id').eq('id', card.id).single();
+  const t = await boardTerms(cardInfo?.board_id);
+  const { error } = await supabase.from('cards').delete().eq('id', card.id);
+  if (error) return { content: [{ type: 'text', text: `Error: ${error.message}` }] };
+  await broadcastChange('cards');
+  return { content: [{ type: 'text', text: `Deleted ${t.card} "${card.title}".` }] };
+}));
+
+// ── add_comment ─────────────────────────────────────────
+server.tool('add_comment', 'Add a comment to a card', {
+  card_id: z.string().describe('Card ID or title (partial match supported)'),
+  text: z.string().describe('Comment text'),
+}, handleTool('add_comment', async ({ card_id, text }) => {
+  const card = await resolveCard(card_id);
+  if (!card) return { content: [{ type: 'text', text: 'Card not found or access denied.' }] };
+  const { error } = await supabase.from('comments').insert({
+    card_id: card.id, text, user_id: USER_ID, user_email: 'Claude Code', user_avatar: '',
+  });
+  if (error) return { content: [{ type: 'text', text: 'Failed to add comment.' }] };
+  await broadcastChange('cards');
+  return { content: [{ type: 'text', text: 'Comment added to card.' }] };
+}));
+
+// ── add_checklist_item ──────────────────────────────────
+server.tool('add_checklist_item', 'Add a subtask/checklist item to a card', {
+  card_id: z.string().describe('Card ID or title (partial match supported)'),
+  text: z.string().describe('Subtask text'),
+}, handleTool('add_checklist_item', async ({ card_id, text }) => {
+  const card = await resolveCard(card_id);
+  if (!card) return { content: [{ type: 'text', text: 'Card not found or access denied.' }] };
+  const maxPos = await getMaxPosition('checklist_items', { card_id: card.id });
+  const { error } = await supabase.from('checklist_items').insert({
+    card_id: card.id, text, checked: false, position: maxPos + 1,
+  });
+  if (error) return { content: [{ type: 'text', text: 'Failed to add checklist item.' }] };
+  await broadcastChange('cards');
+  return { content: [{ type: 'text', text: `Checklist item "${text}" added.` }] };
+}));
+
+// ── get_card_details ────────────────────────────────────
+server.tool('get_card_details', 'Get full details of a card including comments, checklists, attachments, and labels', {
+  id: z.string().describe('Card ID or title (partial match supported)'),
+}, handleTool('get_card_details', async ({ id }) => {
+  const card = await resolveCard(id);
+  if (!card) return { content: [{ type: 'text', text: `Card "${id}" not found.` }] };
+  const { data: fullCard } = await supabase.from('cards').select('*').eq('id', card.id).single();
+  const { data: comments } = await supabase.from('comments').select('text, user_email, created_at').eq('card_id', card.id).order('created_at');
+  const { data: checklist } = await supabase.from('checklist_items').select('text, checked, position').eq('card_id', card.id).order('position');
+  const { data: attachments } = await supabase.from('attachments').select('file_name, file_url, file_type, created_at').eq('card_id', card.id).order('created_at');
+  const { data: cardTags } = await supabase.from('card_tags').select('tag_id').eq('card_id', card.id);
+  let labels = [];
+  if (cardTags?.length) {
+    const tagIds = cardTags.map(ct => ct.tag_id);
+    const { data: tags } = await supabase.from('tags').select('name').in('id', tagIds);
+    labels = (tags || []).map(t => t.name);
+  }
+  let output = `# ${fullCard.title}\n`;
+  if (fullCard.description) output += `\n${fullCard.description}\n`;
+  if (fullCard.priority) output += `\nPriority: ${fullCard.priority.toUpperCase()}`;
+  if (fullCard.due_date) output += `\nDue: ${fullCard.due_date}`;
+  if (labels.length) output += `\nLabels: ${labels.join(', ')}`;
+  if (fullCard.assignee_email) output += `\nAssigned to: ${fullCard.assignee_email}`;
+  output += `\nID: ${fullCard.id}`;
+  if (checklist?.length) {
+    const done = checklist.filter(i => i.checked).length;
+    output += `\n\nChecklist (${done}/${checklist.length}):\n`;
+    output += checklist.map(i => `  ${i.checked ? '[x]' : '[ ]'} ${i.text}`).join('\n');
+  }
+  if (comments?.length) {
+    output += `\n\nComments (${comments.length}):\n`;
+    output += comments.map(c => `  ${c.user_email} (${new Date(c.created_at).toLocaleDateString()}): ${c.text}`).join('\n');
+  }
+  if (attachments?.length) {
+    output += `\n\nAttachments (${attachments.length}):\n`;
+    output += attachments.map(a => `  ${a.file_name} (${a.file_type})`).join('\n');
+  }
+  return { content: [{ type: 'text', text: output }] };
+}));
+
+// ── search_cards ────────────────────────────────────────
+server.tool('search_cards', 'Search for cards by keyword across all boards', {
+  query: z.string().describe('Search keyword to match against card titles and descriptions'),
+  limit: z.number().optional().describe('Max results (default 20)'),
+}, handleTool('search_cards', async ({ query, limit }) => {
+  const { data: userBoards } = await supabase.from('boards').select('id, name, icon').eq('user_id', USER_ID);
+  if (!userBoards?.length) return { content: [{ type: 'text', text: 'No boards found.' }] };
+  const boardIds = userBoards.map(b => b.id);
+  const boardMap = Object.fromEntries(userBoards.map(b => [b.id, b]));
+  const { data: cards, error } = await supabase.from('cards')
+    .select('id, title, description, column_name, board_id, priority, due_date')
+    .in('board_id', boardIds)
+    .or(`title.ilike.%${query.replace(/[%_,()]/g, '')}%,description.ilike.%${query.replace(/[%_,()]/g, '')}%`)
+    .limit(limit || 20);
+  if (error) return { content: [{ type: 'text', text: `Error: ${error.message}` }] };
+  if (!cards?.length) return { content: [{ type: 'text', text: `No cards matching "${query}".` }] };
+  const { data: cols } = await supabase.from('columns').select('id, name').eq('user_id', USER_ID);
+  const colMap = Object.fromEntries((cols || []).map(c => [c.id, c.name]));
+  const text = cards.map(card => {
+    const brd = boardMap[card.board_id];
+    const parts = [`• ${card.title}`];
+    if (card.priority) parts.push(`[${card.priority.toUpperCase()}]`);
+    parts.push(`| ${colMap[card.column_name] || 'Unknown'}`);
+    if (brd) parts.push(`| ${brd.icon || ''} ${brd.name}`);
+    return parts.join(' ');
+  }).join('\n');
+  return { content: [{ type: 'text', text: `🔍 ${cards.length} result(s) for "${query}" across all boards:\n${text}` }] };
+}));
+
+// ── assign_card ─────────────────────────────────────────
+server.tool('assign_card', 'Assign or unassign a user to a card', {
+  id: z.string().describe('Card ID or title (partial match supported)'),
+  email: z.string().email().optional().describe('Email of the user to assign'),
+  unassign: z.boolean().optional().describe('Set to true to unassign the current assignee'),
+}, handleTool('assign_card', async ({ id, email, unassign }) => {
+  const card = await resolveCard(id);
+  if (!card) return { content: [{ type: 'text', text: `Card "${id}" not found.` }] };
+  if (unassign) {
+    const { error } = await supabase.from('cards').update({ assignee_id: null, assignee_email: null, assignee_avatar: null }).eq('id', card.id);
+    if (error) return { content: [{ type: 'text', text: `Error: ${error.message}` }] };
+    await broadcastChange('cards');
+    return { content: [{ type: 'text', text: `Unassigned "${card.title}".` }] };
+  }
+  if (!email) return { content: [{ type: 'text', text: 'Email is required to assign a card.' }] };
+  const { data: fullCard } = await supabase.from('cards').select('board_id').eq('id', card.id).single();
+  const { data: member } = await supabase.from('project_members')
+    .select('user_id, user_email, user_avatar')
+    .eq('board_id', fullCard.board_id).ilike('user_email', email).maybeSingle();
+  const { error } = await supabase.from('cards').update({
+    assignee_id: member?.user_id || null,
+    assignee_email: member?.user_email || email,
+    assignee_avatar: member?.user_avatar || '',
+  }).eq('id', card.id);
+  if (error) return { content: [{ type: 'text', text: `Error: ${error.message}` }] };
+  await supabase.from('activity_log').insert({
+    user_id: USER_ID, user_email: 'Claude Code', action: 'assigned',
+    entity_type: 'card', entity_name: card.title, details: `to ${member?.user_email || email}`,
+  });
+  await broadcastChange('cards');
+  return { content: [{ type: 'text', text: `Assigned "${card.title}" to ${member?.user_email || email}.` }] };
+}));
+
+// ── get_my_cards ────────────────────────────────────────
+server.tool('get_my_cards', 'Get cards assigned to the current user, grouped by status.', {
+  board: z.string().optional().describe('Board/production name or ID (uses active board if omitted and set)'),
+  include_done: z.boolean().optional().describe('Include completed cards (default: false)'),
+}, handleTool('get_my_cards', async ({ board, include_done }) => {
+  const { data: userBoards } = await supabase.from('boards').select('id, name, icon').eq('user_id', USER_ID);
+  if (!userBoards?.length) return { content: [{ type: 'text', text: 'No boards found.' }] };
+  const boardMap = Object.fromEntries(userBoards.map(b => [b.id, b]));
+  let boardIds = userBoards.map(b => b.id);
+  if (board) {
+    const b = await resolveBoard(board);
+    if (!b) return { content: [{ type: 'text', text: `Board "${board}" not found.` }] };
+    boardIds = [b.id];
+  } else if (activeBoardId) {
+    boardIds = [activeBoardId];
+  }
+  const { data: cols } = await supabase.from('columns').select('id, name, position').eq('user_id', USER_ID).order('position');
+  const colMap = Object.fromEntries((cols || []).map(c => [c.id, c]));
+  const { data: cards, error } = await supabase.from('cards')
+    .select('id, title, description, column_name, board_id, priority, due_date, position')
+    .in('board_id', boardIds).order('position');
+  if (error) return { content: [{ type: 'text', text: `Error: ${error.message}` }] };
+  const groups = {};
+  for (const card of cards) {
+    const colName = colMap[card.column_name]?.name || 'Unknown';
+    const colPos = colMap[card.column_name]?.position ?? 999;
+    if (!include_done && (colName.toLowerCase() === 'done' || colName.toLowerCase() === 'archive')) continue;
+    if (!groups[colName]) groups[colName] = { position: colPos, cards: [] };
+    groups[colName].cards.push(card);
+  }
+  const sortedGroups = Object.entries(groups).sort((a, b) => a[1].position - b[1].position);
+  if (sortedGroups.length === 0) return { content: [{ type: 'text', text: 'No active cards found.' }] };
+  const cardIds = cards.map(c => c.id);
+  const { data: checklistItems } = await supabase.from('checklist_items').select('card_id, checked').in('card_id', cardIds);
+  const checklistMap = {};
+  for (const item of (checklistItems || [])) {
+    if (!checklistMap[item.card_id]) checklistMap[item.card_id] = { total: 0, done: 0 };
+    checklistMap[item.card_id].total++;
+    if (item.checked) checklistMap[item.card_id].done++;
+  }
+  let output = '';
+  let totalCards = 0;
+  for (const [colName, group] of sortedGroups) {
+    output += `\n── ${colName} (${group.cards.length}) ──\n`;
+    for (const card of group.cards) {
+      totalCards++;
+      const brd = boardMap[card.board_id];
+      const parts = [`  • ${card.title}`];
+      if (card.priority) parts.push(`[${card.priority.toUpperCase()}]`);
+      if (brd) parts.push(`| ${brd.icon || ''} ${brd.name}`);
+      if (card.due_date) {
+        const due = new Date(card.due_date);
+        const now = new Date();
+        const diffDays = Math.ceil((due - now) / (1000 * 60 * 60 * 24));
+        if (diffDays < 0) parts.push(`| ⚠️ OVERDUE by ${Math.abs(diffDays)}d`);
+        else if (diffDays === 0) parts.push(`| 📅 Due TODAY`);
+        else if (diffDays <= 3) parts.push(`| 📅 Due in ${diffDays}d`);
+        else parts.push(`| 📅 ${card.due_date}`);
+      }
+      const cl = checklistMap[card.id];
+      if (cl) parts.push(`| ✅ ${cl.done}/${cl.total}`);
+      output += parts.join(' ') + '\n';
+    }
+  }
+  const t = boardIds.length === 1 ? await boardTerms(boardIds[0]) : terms('classic');
+  const boardContext = board ? board : (boardIds.length === 1 ? boardMap[boardIds[0]]?.name : `${boardIds.length} ${t.board}s`);
+  return { content: [{ type: 'text', text: `📋 ${totalCards} active ${t.card}(s) in ${boardContext} across ${sortedGroups.length} stage(s)\n${output}` }] };
+}));
+
+// ── link_commit ─────────────────────────────────────────
+server.tool('link_commit', 'Link a git commit to a card. Automatically adds commit info as a comment.', {
+  card_id: z.string().describe('Card ID or title (partial match supported)'),
+  sha: z.string().describe('Git commit SHA (short or full)'),
+  message: z.string().describe('Commit message'),
+  branch: z.string().optional().describe('Branch name'),
+  repo: z.string().optional().describe('Repository name or URL'),
+}, handleTool('link_commit', async ({ card_id, sha, message, branch, repo }) => {
+  const card = await resolveCard(card_id);
+  if (!card) return { content: [{ type: 'text', text: `Card "${card_id}" not found.` }] };
+  const shortSha = sha.substring(0, 7);
+  let commentText = `🔗 Commit \`${shortSha}\`: ${message}`;
+  if (branch) commentText += `\nBranch: ${branch}`;
+  if (repo) commentText += `\nRepo: ${repo}`;
+  const { error } = await supabase.from('comments').insert({
+    card_id: card.id, text: commentText, user_id: USER_ID, user_email: 'Claude Code', user_avatar: '',
+  });
+  if (error) return { content: [{ type: 'text', text: `Error: ${error.message}` }] };
+  await supabase.from('activity_log').insert({
+    user_id: USER_ID, user_email: 'Claude Code', action: 'linked_commit',
+    entity_type: 'card', entity_name: card.title, details: `commit ${shortSha}`,
+  });
+  return { content: [{ type: 'text', text: `Linked commit ${shortSha} to "${card.title}".` }] };
+}));
+
+// ── log_work ────────────────────────────────────────────
+server.tool('log_work', 'Logs time spent on a card', {
+  card_id: z.string().describe('Card ID'),
+  hours: z.number().describe('Number of hours worked'),
+  description: z.string().optional().describe('Description of work done'),
+}, handleTool('log_work', async ({ card_id, hours, description }) => {
+  const card = await resolveCard(card_id);
+  if (!card) return { content: [{ type: 'text', text: `Card "${card_id}" not found.` }] };
+  const commentText = `⏱️ Logged ${hours}h${description ? `: ${description}` : ''}`;
+  const { error } = await supabase.from('comments').insert({
+    card_id: card.id, text: commentText, user_id: USER_ID, user_email: 'Claude Code', user_avatar: '',
+  });
+  if (error) return { content: [{ type: 'text', text: `Error: ${error.message}` }] };
+  await supabase.from('activity_log').insert({
+    user_id: USER_ID, user_email: 'Claude Code', action: 'logged_work',
+    entity_type: 'card', entity_name: card.title, details: `${hours}h${description ? ` - ${description}` : ''}`,
+  });
+  return { content: [{ type: 'text', text: `Logged ${hours}h on "${card.title}".` }] };
+}));
+
+// ── get_sprint_summary ──────────────────────────────────
+server.tool('get_sprint_summary', 'Shows a summary of activity across all boards for the past N days', {
+  days: z.number().optional().describe('How many days to look back (default 7)'),
+}, handleTool('get_sprint_summary', async ({ days }) => {
+  const lookback = days || 7;
+  const since = new Date();
+  since.setDate(since.getDate() - lookback);
+  const sinceISO = since.toISOString();
+
+  const { data: userBoards } = await supabase.from('boards').select('id').eq('user_id', USER_ID);
+  if (!userBoards?.length) return { content: [{ type: 'text', text: 'No boards found.' }] };
+
+  const { data: logs, error } = await supabase.from('activity_log')
+    .select('action, entity_type, entity_name, details, created_at')
+    .eq('user_id', USER_ID)
+    .gte('created_at', sinceISO)
+    .order('created_at', { ascending: false });
+
+  if (error) return { content: [{ type: 'text', text: `Error: ${error.message}` }] };
+  if (!logs?.length) return { content: [{ type: 'text', text: `No activity in the past ${lookback} day(s).` }] };
+
+  // Group by action
+  const groups = {};
+  for (const log of logs) {
+    if (!groups[log.action]) groups[log.action] = [];
+    groups[log.action].push(log);
+  }
+
+  // Find cards moved to Done
+  const completed = (groups['moved'] || []).filter(l => l.details?.toLowerCase().includes('to done'));
+
+  let output = `📊 Sprint summary (past ${lookback} day(s))\n`;
+  output += `Total activity entries: ${logs.length}\n\n`;
+
+  for (const [action, items] of Object.entries(groups)) {
+    output += `── ${action} (${items.length}) ──\n`;
+    for (const item of items.slice(0, 10)) {
+      output += `  • ${item.entity_name}${item.details ? ` — ${item.details}` : ''}\n`;
+    }
+    if (items.length > 10) output += `  ... and ${items.length - 10} more\n`;
+    output += '\n';
+  }
+
+  if (completed.length) {
+    output += `✅ Completed (moved to Done): ${completed.length}\n`;
+    for (const c of completed) {
+      output += `  • ${c.entity_name}\n`;
+    }
+  }
+
+  return { content: [{ type: 'text', text: output }] };
+}));
+
+// ── create_multiple_cards ───────────────────────────────
+server.tool('create_multiple_cards', 'Create multiple cards/frames at once. Ideal for batch idea capture via voice. Uses active board if board is not specified.', {
+  board: z.string().optional().describe('Board/production name or ID (uses active board or Idea Pool if omitted)'),
+  column: z.string().optional().describe('Stage name or ID. Defaults to first stage.'),
+  cards: z.array(z.object({
+    title: z.string().describe('Card title'),
+    description: z.string().optional().describe('Card description'),
+    priority: z.string().optional().describe('Priority: urgent, high, medium, low'),
+    due_date: z.string().optional().describe('Due date (YYYY-MM-DD)'),
+  })).max(50).describe('Array of cards to create (max 50)'),
+  labels: z.array(z.string()).optional().describe('Label names to attach to ALL cards'),
+}, handleTool('create_multiple_cards', async ({ board, column, cards, labels }) => {
+  let brd = await requireBoard(board);
+  let usedIdeaPool = false;
+  if (!brd) {
+    brd = await ensureIdeaPool();
+    usedIdeaPool = true;
+    if (!brd) return { content: [{ type: 'text', text: 'Could not find or create Idea Pool.' }] };
+  }
+  let col;
+  if (column) {
+    col = await resolveColumn(column, brd.id);
+    if (!col) return { content: [{ type: 'text', text: `Stage "${column}" not found in ${brd.name}.` }] };
+  } else {
+    const { data: firstCol } = await supabase.from('columns').select('id, name').eq('board_id', brd.id).order('position').limit(1);
+    col = firstCol?.[0];
+    if (!col) return { content: [{ type: 'text', text: `No stages found in ${brd.name}.` }] };
+  }
+  let maxPos = await getMaxPosition('cards', { column_name: col.id });
+  const resolvedLabels = [];
+  if (labels?.length) {
+    for (const l of labels) {
+      const label = await resolveLabel(l);
+      if (label) resolvedLabels.push(label);
+    }
+  }
+  const created = [];
+  for (const c of cards) {
+    maxPos++;
+    const { data: card, error } = await supabase.from('cards').insert({
+      title: c.title, description: c.description || '', column_name: col.id, board_id: brd.id,
+      priority: c.priority || '', due_date: c.due_date || '', position: maxPos, color: '', cover_image: '',
+    }).select().single();
+    if (error) { created.push(`✗ ${c.title}: ${error.message}`); continue; }
+    for (const label of resolvedLabels) {
+      await supabase.from('card_tags').insert({ card_id: card.id, tag_id: label.id });
+    }
+    created.push(`✓ ${c.title}`);
+  }
+  await supabase.from('activity_log').insert({
+    user_id: USER_ID, user_email: 'Claude Code', action: 'batch_created',
+    entity_type: 'card', entity_name: `${cards.length} cards`, details: `in ${col.name} (${brd.name})`,
+  });
+  await broadcastChange('cards');
+  const t = await boardTerms(brd.id);
+  const poolNote = usedIdeaPool ? ' 💡 Added to Idea Pool.' : '';
+  return { content: [{ type: 'text', text: `Created ${created.filter(c => c.startsWith('✓')).length}/${cards.length} ${t.cards} in ${col.name} (${brd.name}):${poolNote}\n${created.join('\n')}` }] };
+}));
+
+// ── toggle_checklist_item ──────────────────────────────
+server.tool('toggle_checklist_item', 'Check or uncheck a subtask/checklist item', {
+  card_id: z.string().describe('Card ID or title (partial match supported)'),
+  item_text: z.string().describe('Text of the checklist item to toggle (partial match)'),
+  checked: z.boolean().optional().describe('Set to true to check, false to uncheck. Omit to toggle.'),
+}, handleTool('toggle_checklist_item', async ({ card_id, item_text, checked }) => {
+  const card = await resolveCard(card_id);
+  if (!card) return { content: [{ type: 'text', text: `Card "${card_id}" not found.` }] };
+  const { data: items } = await supabase.from('checklist_items').select('id, text, checked').eq('card_id', card.id);
+  const item = (items || []).find(i => i.text.toLowerCase().includes(item_text.toLowerCase()));
+  if (!item) return { content: [{ type: 'text', text: `Checklist item matching "${item_text}" not found.` }] };
+  const newChecked = checked !== undefined ? checked : !item.checked;
+  const { error } = await supabase.from('checklist_items').update({ checked: newChecked }).eq('id', item.id);
+  if (error) return { content: [{ type: 'text', text: `Error: ${error.message}` }] };
+  await broadcastChange('cards');
+  return { content: [{ type: 'text', text: `${newChecked ? '☑' : '☐'} "${item.text}" on "${card.title}".` }] };
+}));
+
+// ── get_board_overview ─────────────────────────────────
+server.tool('get_board_overview', 'Get a quick overview of a board: stages with card counts, overdue items. Uses active board if not specified.', {
+  board: z.string().optional().describe('Board/production name or ID (uses active board if omitted)'),
+}, handleTool('get_board_overview', async ({ board }) => {
+  const brd = await requireBoard(board);
+  if (!brd) return { content: [{ type: 'text', text: board ? `Board "${board}" not found.` : 'No board specified and no active board set. Use set_active_board first.' }] };
+  const { data: cols } = await supabase.from('columns').select('id, name, position').eq('board_id', brd.id).order('position');
+  const { data: cards } = await supabase.from('cards').select('id, title, column_name, priority, due_date, updated_at').eq('board_id', brd.id).eq('archived', false);
+  const colMap = Object.fromEntries((cols || []).map(c => [c.id, c.name]));
+  const now = new Date();
+  let overdue = [];
+  let dueToday = [];
+  let dueSoon = [];
+  const stageCounts = {};
+  for (const col of (cols || [])) stageCounts[col.name] = 0;
+  for (const card of (cards || [])) {
+    const colName = colMap[card.column_name] || 'Unknown';
+    if (stageCounts[colName] !== undefined) stageCounts[colName]++;
+    if (card.due_date) {
+      const due = new Date(card.due_date);
+      const diffDays = Math.ceil((due - now) / (1000 * 60 * 60 * 24));
+      if (diffDays < 0) overdue.push({ ...card, days: Math.abs(diffDays) });
+      else if (diffDays === 0) dueToday.push(card);
+      else if (diffDays <= 3) dueSoon.push({ ...card, days: diffDays });
+    }
+  }
+  const t = terms(brd.mode);
+  let output = `${brd.icon || '📋'} ${brd.name} (${t.Board})\n`;
+  output += `Total: ${(cards || []).length} ${t.cards}\n\n`;
+  output += `Stages:\n`;
+  for (const col of (cols || [])) {
+    output += `  ${col.name}: ${stageCounts[col.name]} ${t.cards}\n`;
+  }
+  if (overdue.length) {
+    output += `\n⚠️ Overdue (${overdue.length}):\n`;
+    for (const c of overdue) output += `  • ${c.title} — ${c.days}d overdue\n`;
+  }
+  if (dueToday.length) {
+    output += `\n📅 Due today (${dueToday.length}):\n`;
+    for (const c of dueToday) output += `  • ${c.title}\n`;
+  }
+  if (dueSoon.length) {
+    output += `\n🔜 Due soon (${dueSoon.length}):\n`;
+    for (const c of dueSoon) output += `  • ${c.title} — in ${c.days}d\n`;
+  }
+  return { content: [{ type: 'text', text: output }] };
+}));
+
+// ── add_labels_to_card ─────────────────────────────────
+server.tool('add_labels_to_card', 'Add one or more labels to an existing card', {
+  card_id: z.string().describe('Card ID or title (partial match supported)'),
+  labels: z.array(z.string()).describe('Label names or IDs to add'),
+}, handleTool('add_labels_to_card', async ({ card_id, labels }) => {
+  const card = await resolveCard(card_id);
+  if (!card) return { content: [{ type: 'text', text: `Card "${card_id}" not found.` }] };
+  const added = [];
+  for (const labelName of labels) {
+    const label = await resolveLabel(labelName);
+    if (!label) { added.push(`✗ "${labelName}" not found`); continue; }
+    const { data: existing } = await supabase.from('card_tags').select('id').eq('card_id', card.id).eq('tag_id', label.id).maybeSingle();
+    if (existing) { added.push(`⊘ "${label.name}" already on card`); continue; }
+    const { error } = await supabase.from('card_tags').insert({ card_id: card.id, tag_id: label.id });
+    if (error) { added.push(`✗ "${label.name}": ${error.message}`); continue; }
+    added.push(`✓ ${label.name}`);
+  }
+  await broadcastChange('cards');
+  return { content: [{ type: 'text', text: `Labels on "${card.title}":\n${added.join('\n')}` }] };
+}));
+
+// ── remove_label_from_card ─────────────────────────────
+server.tool('remove_label_from_card', 'Remove a label from a card', {
+  card_id: z.string().describe('Card ID or title (partial match supported)'),
+  label: z.string().describe('Label name or ID to remove'),
+}, handleTool('remove_label_from_card', async ({ card_id, label }) => {
+  const card = await resolveCard(card_id);
+  if (!card) return { content: [{ type: 'text', text: `Card "${card_id}" not found.` }] };
+  const lbl = await resolveLabel(label);
+  if (!lbl) return { content: [{ type: 'text', text: `Label "${label}" not found.` }] };
+  const { error } = await supabase.from('card_tags').delete().eq('card_id', card.id).eq('tag_id', lbl.id);
+  if (error) return { content: [{ type: 'text', text: `Error: ${error.message}` }] };
+  await broadcastChange('cards');
+  return { content: [{ type: 'text', text: `Removed label "${lbl.name}" from "${card.title}".` }] };
+}));
+
+// ── archive_card ───────────────────────────────────────
+server.tool('archive_card', 'Archive a card (soft delete — can be restored in the UI)', {
+  id: z.string().describe('Card ID or title (partial match supported)'),
+}, handleTool('archive_card', async ({ id }) => {
+  const card = await resolveCard(id);
+  if (!card) return { content: [{ type: 'text', text: `Card "${id}" not found.` }] };
+  const { data: cardInfo } = await supabase.from('cards').select('board_id').eq('id', card.id).single();
+  const t = await boardTerms(cardInfo?.board_id);
+  const { error } = await supabase.from('cards').update({ archived: true }).eq('id', card.id);
+  if (error) return { content: [{ type: 'text', text: `Error: ${error.message}` }] };
+  await supabase.from('activity_log').insert({
+    user_id: USER_ID, user_email: 'Claude Code', action: 'archived',
+    entity_type: t.card, entity_name: card.title, details: '',
+  });
+  await broadcastChange('cards');
+  return { content: [{ type: 'text', text: `Archived ${t.card} "${card.title}".` }] };
+}));
+
+// ── duplicate_card ─────────────────────────────────────
+server.tool('duplicate_card', 'Duplicate a card including its checklist items', {
+  id: z.string().describe('Card ID or title (partial match supported)'),
+  new_title: z.string().optional().describe('Title for the copy (default: "Copy of <original>")'),
+}, handleTool('duplicate_card', async ({ id, new_title }) => {
+  const card = await resolveCard(id);
+  if (!card) return { content: [{ type: 'text', text: `Card "${id}" not found.` }] };
+  const { data: original } = await supabase.from('cards').select('*').eq('id', card.id).single();
+  if (!original) return { content: [{ type: 'text', text: 'Could not fetch card details.' }] };
+  const maxPos = await getMaxPosition('cards', { column_name: original.column_name });
+  const { data: copy, error } = await supabase.from('cards').insert({
+    title: new_title || `Copy of ${original.title}`,
+    description: original.description, column_name: original.column_name, board_id: original.board_id,
+    priority: original.priority, due_date: original.due_date, color: original.color,
+    cover_image: original.cover_image, position: maxPos + 1,
+  }).select().single();
+  if (error) return { content: [{ type: 'text', text: `Error: ${error.message}` }] };
+  // Copy checklist items
+  const { data: checklist } = await supabase.from('checklist_items').select('text, position').eq('card_id', card.id).order('position');
+  if (checklist?.length) {
+    for (const item of checklist) {
+      await supabase.from('checklist_items').insert({ card_id: copy.id, text: item.text, checked: false, position: item.position });
+    }
+  }
+  // Copy labels
+  const { data: cardTags } = await supabase.from('card_tags').select('tag_id').eq('card_id', card.id);
+  if (cardTags?.length) {
+    for (const ct of cardTags) {
+      await supabase.from('card_tags').insert({ card_id: copy.id, tag_id: ct.tag_id });
+    }
+  }
+  await broadcastChange('cards');
+  const t = await boardTerms(original.board_id);
+  return { content: [{ type: 'text', text: `Duplicated ${t.card} "${original.title}" → "${copy.title}" (${copy.id})` }] };
+}));
+
+// ── set_card_color ─────────────────────────────────────
+server.tool('set_card_color', 'Set or clear the color of a card for visual categorization', {
+  id: z.string().describe('Card ID or title (partial match supported)'),
+  color: z.string().regex(/^(#[0-9a-fA-F]{3,8})?$/).describe('Hex color (e.g. "#ef4444") or empty string to clear'),
+}, handleTool('set_card_color', async ({ id, color }) => {
+  const card = await resolveCard(id);
+  if (!card) return { content: [{ type: 'text', text: `Card "${id}" not found.` }] };
+  const { error } = await supabase.from('cards').update({ color: color || '' }).eq('id', card.id);
+  if (error) return { content: [{ type: 'text', text: `Error: ${error.message}` }] };
+  await broadcastChange('cards');
+  return { content: [{ type: 'text', text: color ? `Set color ${color} on "${card.title}".` : `Cleared color on "${card.title}".` }] };
+}));
+
+// ── create_column ──────────────────────────────────────
+server.tool('create_column', 'Create a new stage in a board. Uses active board if not specified.', {
+  name: z.string().describe('Stage name'),
+  board: z.string().optional().describe('Board/production name or ID (uses active board if omitted)'),
+  color: z.string().regex(/^#[0-9a-fA-F]{3,8}$/).optional().describe('Hex color (default: #6b7280)'),
+}, handleTool('create_column', async ({ name, board, color }) => {
+  const brd = await requireBoard(board);
+  if (!brd) return { content: [{ type: 'text', text: board ? `Board "${board}" not found.` : 'No board specified and no active board set. Use set_active_board first.' }] };
+  const maxPos = await getMaxPosition('columns', { board_id: brd.id });
+  const { data, error } = await supabase.from('columns').insert({
+    name, color: color || '#6b7280', position: maxPos + 1, board_id: brd.id, user_id: USER_ID,
+  }).select().single();
+  if (error) return { content: [{ type: 'text', text: `Error: ${error.message}` }] };
+  await broadcastChange('columns');
+  return { content: [{ type: 'text', text: `Created stage "${data.name}" in ${brd.name} (${data.id})` }] };
+}));
+
+// ── delete_column ──────────────────────────────────────
+server.tool('delete_column', 'Delete a stage/column from a board. Cards in this stage will be moved to the first remaining stage.', {
+  id: z.string().describe('Column/stage name or ID'),
+  board: z.string().optional().describe('Board name or ID (helps resolve ambiguous stage names)'),
+}, handleTool('delete_column', async ({ id, board }) => {
+  const boardId = board ? (await resolveBoard(board))?.id : null;
+  const col = await resolveColumn(id, boardId);
+  if (!col) return { content: [{ type: 'text', text: `Stage "${id}" not found.` }] };
+  // Find the column's board_id
+  const { data: colFull } = await supabase.from('columns').select('board_id').eq('id', col.id).single();
+  // Find replacement column in same board
+  const { data: siblings } = await supabase.from('columns').select('id, name').eq('board_id', colFull.board_id).neq('id', col.id).order('position').limit(1);
+  if (siblings?.length) {
+    // Move orphan cards to first sibling
+    await supabase.from('cards').update({ column_name: siblings[0].id }).eq('column_name', col.id);
+  }
+  const { error } = await supabase.from('columns').delete().eq('id', col.id);
+  if (error) return { content: [{ type: 'text', text: `Error: ${error.message}` }] };
+  await broadcastChange('columns');
+  const movedTo = siblings?.length ? ` Cards moved to "${siblings[0].name}".` : '';
+  return { content: [{ type: 'text', text: `Deleted stage "${col.name}".${movedTo}` }] };
+}));
+
+// ── graduate_to_production ──────────────────────────────
+server.tool('graduate_to_production', 'Promote an idea from the Idea Pool into its own dedicated production with full stages (Idea → Scripting → Filming → Editing → Published). Moves the idea card to "In Production" stage in the Idea Pool (auto-archived after the configured days).', {
+  idea: z.string().describe('Card title or ID from the Idea Pool to graduate'),
+  name: z.string().optional().describe('Production name (defaults to the idea title)'),
+  icon: z.string().optional().describe('Emoji icon (default: 🎬)'),
+  color: z.string().regex(/^#[0-9a-fA-F]{3,8}$/).optional().describe('Hex color (default: #3b82f6)'),
+  stages: z.array(z.string()).optional().describe('Custom stage names (default: Idea, Scripting, Filming, Editing, Published)'),
+}, handleTool('graduate_to_production', async ({ idea, name, icon, color, stages }) => {
+  // Find the idea card
+  const card = await resolveCard(idea);
+  if (!card) return { content: [{ type: 'text', text: `Idea "${idea}" not found.` }] };
+  const { data: fullCard } = await supabase.from('cards').select('title, description, board_id').eq('id', card.id).single();
+
+  const productionName = name || fullCard.title;
+  const stageNames = stages || ['Idea', 'Scripting', 'Filming', 'Editing', 'Published'];
+  const stageColors = ['#6b7280', '#3b82f6', '#f59e0b', '#8b5cf6', '#10b981'];
+
+  // Create the production board
+  const maxPos = await getMaxPosition('boards', { user_id: USER_ID });
+  const { data: production, error } = await supabase.from('boards').insert({
+    name: productionName, icon: icon || '🎬', color: color || '#3b82f6',
+    position: maxPos + 1, user_id: USER_ID, mode: 'creator',
+  }).select().single();
+  if (error) return { content: [{ type: 'text', text: `Error creating production: ${error.message}` }] };
+
+  // Add owner
+  const { data: user } = await supabase.auth.admin.getUserById(USER_ID);
+  await supabase.from('project_members').upsert({
+    board_id: production.id, user_id: USER_ID,
+    user_email: user?.user?.email || '', user_avatar: user?.user?.user_metadata?.avatar_url || '',
+    role: 'owner',
+  }, { onConflict: 'board_id,user_id' });
+
+  // Create stages
+  for (let i = 0; i < stageNames.length; i++) {
+    await supabase.from('columns').insert({
+      name: stageNames[i], color: stageColors[i % stageColors.length],
+      position: i, board_id: production.id, user_id: USER_ID,
+    });
+  }
+
+  // Move the original idea card to "In Production" stage (instead of archiving)
+  // Verify the card's board belongs to this user before touching columns
+  if (fullCard.board_id) {
+    const { data: ownerCheck } = await supabase.from('boards').select('id').eq('id', fullCard.board_id).eq('user_id', USER_ID).single();
+    if (!ownerCheck) return { content: [{ type: 'text', text: 'Access denied: idea card belongs to another board.' }] };
+    const { data: inProdCol } = await supabase.from('columns')
+      .select('id').eq('board_id', fullCard.board_id).ilike('name', 'In Production').limit(1);
+    if (inProdCol?.length) {
+      const inProdMaxPos = await getMaxPosition('cards', { column_name: inProdCol[0].id });
+      await supabase.from('cards').update({ column_name: inProdCol[0].id, position: inProdMaxPos + 1 }).eq('id', card.id);
+    }
+  }
+
+  // Log activity
+  await supabase.from('activity_log').insert({
+    user_id: USER_ID, user_email: 'Claude Code', action: 'graduated',
+    entity_type: 'production', entity_name: productionName, details: `from Idea Pool`,
+  });
+
+  await broadcastChange('boards');
+  await broadcastChange('columns');
+  await broadcastChange('cards');
+
+  return { content: [{ type: 'text', text: `🎬 Graduated "${fullCard.title}" to production!\n\nProduction: ${icon || '🎬'} ${productionName}\nStages: ${stageNames.join(' → ')}\n\nIdea moved to "In Production" in Idea Pool. Production ID: ${production.id}` }] };
+}));
+
+// ── Start server ────────────────────────────────────────
+const transport = new StdioServerTransport();
+await server.connect(transport);

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "framedeck-mcp",
+  "version": "2.0.0",
+  "type": "module",
+  "description": "MCP server for Framedeck — connect any AI assistant to your content production pipeline",
+  "main": "index.js",
+  "bin": {
+    "framedeck-mcp": "./index.js"
+  },
+  "keywords": [
+    "mcp",
+    "framedeck",
+    "kanban",
+    "content-creator",
+    "video-production",
+    "claude",
+    "ai-assistant",
+    "model-context-protocol"
+  ],
+  "author": "Framedeck",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Lukaris/framedeck"
+  },
+  "homepage": "https://framedeck.app",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "@supabase/supabase-js": "^2.49.0",
+    "zod": "^3.22.0"
+  }
+}