@autocode-cli/autocode 0.8.37 → 0.22.0

package/bin/autocode

@@ -1,2 +1,2338 @@
 #!/usr/bin/env node
-import('../dist/index.js');
+
+import { spawn, execSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { dirname, resolve, join } from 'node:path';
+import { existsSync, mkdirSync, writeFileSync, readFileSync } from 'node:fs';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const root = resolve(__dirname, '..');
+
+// Parse arguments
+const args = process.argv.slice(2);
+const command = args[0] || 'serve';
+const commandArgs = args.slice(1);
+
+// API base URL for CLI commands (required for API calls)
+function getApiBase() {
+  const url = process.env.AUTOCODE_API_URL;
+  if (!url) {
+    console.error('Error: AUTOCODE_API_URL environment variable is required');
+    console.error('Example: export AUTOCODE_API_URL=http://localhost:3000');
+    process.exit(1);
+  }
+  return url;
+}
+
+// Help message
+function showHelp() {
+  console.log(`
+AutoCode CLI - Issue tracking dashboard
+
+Usage:
+  autocode [command] [options]
+
+Commands:
+  serve [options]           Start the dashboard server (default)
+  show <key>                Show issue details
+  history <key>             Show full issue history
+  list [options]            List issues
+  comment <key> <text>      Add comment to an issue
+  start <key>               Start issue (move from backlog only)
+  next <key>                Advance issue to next column
+  move <key> <column>       Move issue to a different column
+  new <title> [desc]        Create a new issue
+  parent <key> [parent]     Manage parent relationships
+  health                    Check workflow health
+  stats                     Show usage statistics
+  init                      Initialize project structure
+  catalog [action]          List or manage column catalog
+  pipeline <action>         Manage pipelines
+  help                      Show this help message
+
+Pipeline Commands:
+  pipeline list             List all pipelines
+  pipeline show <name>      Show pipeline with columns
+  pipeline create <name>    Create new pipeline
+  pipeline delete <name>    Delete pipeline version
+  pipeline activate <name>  Activate pipeline version
+  pipeline versions <name>  List all versions
+  pipeline draft <name>     Create draft from latest
+  pipeline finalize <name>  Finalize draft (--activate)
+  pipeline add-column       Add column to pipeline
+  pipeline remove-column    Remove column from pipeline
+  pipeline move-column      Move column between segments
+
+Catalog Commands:
+  catalog                   List available columns
+  catalog add <slug>        Add new column to catalog
+
+Serve Options:
+  -p, --port <port>         Server port (default: 3000)
+  -e, --expose              Expose via Cloudflare tunnel
+  --debug                   Enable debug logging to autocode/debug.log
+
+Show Options:
+  --json                    Output as JSON
+
+History Options:
+  --json                    Output as JSON (includes all data)
+  --full                    Show complete prompt and terminal content
+  --limit <N>               Show only last N entries
+
+List Options:
+  -c, --column <slug>       Filter by column
+  -p, --priority <P0-P3>    Filter by priority
+  -l, --label <label>       Filter by label
+  --parent <key>            Filter by parent
+  --tree                    Display as tree
+  --json                    Output as JSON
+
+New Issue Options:
+  -p, --priority <P0-P3>    Priority (default: P2)
+  -l, --labels <labels>     Comma-separated labels
+  -a, --acceptance <crit>   Acceptance criteria
+  -c, --column <slug>       Target column (default: backlog)
+  --parent <key>            Parent issue key
+
+Move Options:
+  -f, --force               Force move (skip validation)
+
+Health Options:
+  --json                    Output as JSON
+  -v, --verbose             Show detailed information
+
+Stats Options:
+  --json                    Output as JSON
+  --session                 Show only session stats
+  --totals                  Show only total stats
+
+Pipeline Options:
+  --version <N>             Specific version
+  --json                    Output as JSON
+  --description "..."       Pipeline description
+  --segment <segment>       Segment (definition|action|finish)
+  --position <N>            Position in segment
+  --name "Display Name"     Column display name
+  --activate                Activate after finalizing
+
+Examples:
+  autocode                                    Start server
+  autocode serve -p 8080                      Start on port 8080
+  autocode show AC-000001                     Show issue details
+  autocode history AC-000001                  Show full issue history
+  autocode list -c 07_in-progress             List issues in column
+  autocode list --tree                        Show issue hierarchy
+  autocode comment AC-000001 "Done"           Add comment
+  autocode start AC-000001                    Start issue from backlog
+  autocode next AC-000001                     Advance issue
+  autocode move AC-000001 07_in-progress      Move issue
+  autocode new "Fix bug" -p P1 -l bug         Create issue
+  autocode parent AC-000001                   Show parent/children
+  autocode parent AC-000001 AC-000002         Set parent
+  autocode health                             Check for stuck issues
+  autocode stats                              Show Claude usage stats
+  autocode pipeline list                      List all pipelines
+  autocode pipeline show default              Show pipeline details
+  autocode pipeline add-column default review --segment action
+  autocode catalog add my-col --segment action --name "My Column"
+`);
+}
+
+// Parse port from arguments
+function getPort() {
+  const portIndex = args.findIndex(a => a === '-p' || a === '--port');
+  if (portIndex !== -1 && args[portIndex + 1]) {
+    return parseInt(args[portIndex + 1], 10);
+  }
+  return 3000;
+}
+
+// Check if --expose flag is present
+function hasExposeFlag() {
+  return args.includes('-e') || args.includes('--expose');
+}
+
+// Check if --debug flag is present
+function hasDebugFlag() {
+  return args.includes('--debug');
+}
+
+// Check if cloudflared is installed
+function isCloudflaredInstalled() {
+  try {
+    execSync('which cloudflared', { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// Start cloudflare tunnel
+function startTunnel(port) {
+  return new Promise((resolve, reject) => {
+    console.log('Starting Cloudflare tunnel...');
+
+    const tunnel = spawn('cloudflared', ['tunnel', '--url', `http://localhost:${port}`], {
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+
+    if (!tunnel.pid) {
+      reject(new Error('Failed to start cloudflared process'));
+      return;
+    }
+
+    let url = null;
+    let resolved = false;
+    const urlRegex = /https:\/\/[a-zA-Z0-9-]+\.trycloudflare\.com/;
+
+    // Timeout for URL extraction
+    const timeout = setTimeout(() => {
+      if (!resolved) {
+        resolved = true;
+        if (url) {
+          resolve({ tunnel, url });
+        } else {
+          reject(new Error('Timeout waiting for tunnel URL'));
+        }
+      }
+    }, 30000);
+
+    // Parse URL from stderr (cloudflared outputs to stderr)
+    tunnel.stderr.on('data', (data) => {
+      const output = data.toString();
+      const match = output.match(urlRegex);
+      if (match && !resolved) {
+        url = match[0];
+        resolved = true;
+        clearTimeout(timeout);
+        resolve({ tunnel, url });
+      }
+    });
+
+    tunnel.on('exit', (code) => {
+      if (!resolved) {
+        resolved = true;
+        clearTimeout(timeout);
+        reject(new Error(`cloudflared exited with code ${code}`));
+      }
+    });
+
+    tunnel.on('error', (err) => {
+      if (!resolved) {
+        resolved = true;
+        clearTimeout(timeout);
+        reject(err);
+      }
+    });
+  });
+}
+
+// Start the Nitro server
+async function startServer() {
+  const serverPath = resolve(root, '.output/server/index.mjs');
+
+  if (!existsSync(serverPath)) {
+    console.error('Error: .output/server/index.mjs not found');
+    console.error('Please run "npm run build" first');
+    process.exit(1);
+  }
+
+  const port = getPort();
+  const expose = hasExposeFlag();
+
+  // Check cloudflared if expose is requested
+  if (expose && !isCloudflaredInstalled()) {
+    console.error('Error: cloudflared is not installed');
+    console.error('Install: https://developers.cloudflare.com/cloudflare-one/connections/connect-networks/downloads/');
+    process.exit(1);
+  }
+
+  const debugMode = hasDebugFlag();
+
+  const env = {
+    ...process.env,
+    PORT: String(port),
+    NITRO_PORT: String(port),
+    AUTOCODE_DEBUG: String(debugMode),
+  };
+
+  console.log(`Starting AutoCode dashboard on port ${port}...`);
+
+  const server = spawn('node', [serverPath], {
+    stdio: 'inherit',
+    env,
+  });
+
+  let tunnelProcess = null;
+
+  // Start tunnel if requested
+  if (expose) {
+    try {
+      const { tunnel, url } = await startTunnel(port);
+      tunnelProcess = tunnel;
+      console.log(`\n🌐 Public URL: ${url}\n`);
+    } catch (err) {
+      console.error('Failed to start tunnel:', err.message);
+    }
+  }
+
+  server.on('error', (err) => {
+    console.error('Failed to start server:', err);
+    if (tunnelProcess) tunnelProcess.kill();
+    process.exit(1);
+  });
+
+  server.on('exit', (code) => {
+    if (tunnelProcess) tunnelProcess.kill();
+    process.exit(code || 0);
+  });
+
+  // Handle Ctrl+C
+  process.on('SIGINT', () => {
+    console.log('\nShutting down...');
+    server.kill('SIGTERM');
+    if (tunnelProcess) tunnelProcess.kill();
+    process.exit(0);
+  });
+}
+
+// ============================================
+// CLI Commands (use API)
+// ============================================
+
+async function commentCmd() {
+  const key = commandArgs[0];
+  const text = commandArgs.slice(1).join(' ');
+
+  if (!key || !text) {
+    console.error('Usage: autocode comment <issue-key> "<text>"');
+    process.exit(1);
+  }
+
+  if (!key.match(/^AC-\d{6}$/)) {
+    console.error(`Invalid issue key: ${key}`);
+    process.exit(1);
+  }
+
+  try {
+    const res = await fetch(`${getApiBase()}/api/issues/${key}/comments`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ content: text, author: 'Claude' })
+    });
+
+    if (!res.ok) {
+      const err = await res.json().catch(() => ({}));
+      console.error(`Failed: ${err.message || res.statusText}`);
+      process.exit(1);
+    }
+
+    console.log(`✓ Added comment to ${key}`);
+  } catch (e) {
+    console.error(`Error: ${e.message}`);
+    console.error('Make sure autocode server is running');
+    process.exit(1);
+  }
+}
+
+async function startCmd() {
+  const key = commandArgs[0];
+
+  if (!key) {
+    console.error('Usage: autocode start <issue-key>');
+    process.exit(1);
+  }
+
+  if (!key.match(/^AC-\d{6}$/)) {
+    console.error(`Invalid issue key: ${key}`);
+    process.exit(1);
+  }
+
+  try {
+    // Get current column
+    const issueRes = await fetch(`${getApiBase()}/api/issues/${key}`);
+    if (!issueRes.ok) {
+      console.error(`Issue '${key}' not found`);
+      process.exit(1);
+    }
+    const issue = await issueRes.json();
+    const fromCol = issue.column_slug;
+
+    // Check if already started (not in backlog)
+    if (!fromCol.includes('backlog')) {
+      console.log(`✓ Issue ${key} already started`);
+      console.log(`  Current column: ${fromCol}`);
+      console.log(`  (start only works from backlog)`);
+      return;
+    }
+
+    // Advance from backlog
+    const res = await fetch(`${getApiBase()}/api/issues/${key}/next`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({})
+    });
+
+    if (!res.ok) {
+      const err = await res.json().catch(() => ({}));
+      console.error(`Failed: ${err.message || err.error || res.statusText}`);
+      process.exit(1);
+    }
+
+    const result = await res.json();
+    console.log(`✓ Started ${key}`);
+    console.log(`  From: ${fromCol}`);
+    console.log(`  To: ${result.data?.column_slug || 'next'}`);
+  } catch (e) {
+    console.error(`Error: ${e.message}`);
+    console.error('Make sure autocode server is running');
+    process.exit(1);
+  }
+}
+
+async function nextCmd() {
+  const key = commandArgs[0];
+
+  if (!key) {
+    console.error('Usage: autocode next <issue-key>');
+    process.exit(1);
+  }
+
+  if (!key.match(/^AC-\d{6}$/)) {
+    console.error(`Invalid issue key: ${key}`);
+    process.exit(1);
+  }
+
+  try {
+    // Get current column
+    const issueRes = await fetch(`${getApiBase()}/api/issues/${key}`);
+    if (!issueRes.ok) {
+      console.error(`Issue '${key}' not found`);
+      process.exit(1);
+    }
+    const issue = await issueRes.json();
+    const fromCol = issue.column_slug;
+
+    // Advance
+    const res = await fetch(`${getApiBase()}/api/issues/${key}/next`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({})
+    });
+
+    if (!res.ok) {
+      const err = await res.json().catch(() => ({}));
+      console.error(`Failed: ${err.message || err.error || res.statusText}`);
+      process.exit(1);
+    }
+
+    const result = await res.json();
+    console.log(`✓ Advanced ${key}`);
+    console.log(`  From: ${fromCol}`);
+    console.log(`  To: ${result.data?.column_slug || 'next'}`);
+  } catch (e) {
+    console.error(`Error: ${e.message}`);
+    console.error('Make sure autocode server is running');
+    process.exit(1);
+  }
+}
+
+async function moveCmd() {
+  const key = commandArgs[0];
+  const column = commandArgs[1];
+  const force = commandArgs.includes('--force') || commandArgs.includes('-f');
+
+  if (!key || !column) {
+    console.error('Usage: autocode move <issue-key> <column-slug> [--force]');
+    process.exit(1);
+  }
+
+  if (!key.match(/^AC-\d{6}$/)) {
+    console.error(`Invalid issue key: ${key}`);
+    process.exit(1);
+  }
+
+  try {
+    const issueRes = await fetch(`${getApiBase()}/api/issues/${key}`);
+    if (!issueRes.ok) {
+      console.error(`Issue '${key}' not found`);
+      process.exit(1);
+    }
+    const issue = await issueRes.json();
+    const fromCol = issue.column_slug;
+
+    const res = await fetch(`${getApiBase()}/api/issues/${key}/move`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ column, force })
+    });
+
+    if (!res.ok) {
+      const err = await res.json().catch(() => ({}));
+      console.error(`Failed: ${err.message || err.error || res.statusText}`);
+      if (!force) console.error('Use --force to override');
+      process.exit(1);
+    }
+
+    const result = await res.json();
+    console.log(`✓ Moved ${key}`);
+    console.log(`  From: ${fromCol}`);
+    console.log(`  To: ${result.data?.column_slug || column}`);
+  } catch (e) {
+    console.error(`Error: ${e.message}`);
+    console.error('Make sure autocode server is running');
+    process.exit(1);
+  }
+}
+
+async function newCmd() {
+  // Parse options
+  const opts = {};
+  let title = '';
+  let desc = '';
+  let i = 0;
+
+  while (i < commandArgs.length) {
+    const arg = commandArgs[i];
+    if (arg === '-p' || arg === '--priority') opts.priority = commandArgs[++i];
+    else if (arg === '-l' || arg === '--labels') opts.labels = commandArgs[++i];
+    else if (arg === '-a' || arg === '--acceptance') opts.acceptance = commandArgs[++i];
+    else if (arg === '-s' || arg === '--semver') opts.semver = commandArgs[++i];
+    else if (arg === '-c' || arg === '--column') opts.column = commandArgs[++i];
+    else if (arg === '--parent') opts.parent = commandArgs[++i];
+    else if (arg === '--autocomplete') opts.autocomplete = true;
+    else if (arg === '--lang') opts.lang = commandArgs[++i];
+    else if (!title) title = arg;
+    else if (!desc) desc = arg;
+    i++;
+  }
+
+  if (!title) {
+    console.error('Usage: autocode new "<title>" ["<description>"] [options]');
+    console.error('Options: -p <priority> -l <labels> -a <acceptance> -c <column> --parent <key> --autocomplete --lang <en|fr>');
+    process.exit(1);
+  }
+
+  try {
+    const body = {
+      title,
+      description: desc || '',
+      priority: opts.priority || 'P2',
+    };
+
+    if (opts.labels) body.labels = opts.labels.split(',').map(l => l.trim());
+    if (opts.acceptance) body.acceptance_criteria = opts.acceptance.split(',').map(c => c.trim());
+    if (opts.semver) body.semver = opts.semver;
+    if (opts.parent) body.parent_key = opts.parent;
+
+    const res = await fetch(`${getApiBase()}/api/issues`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(body)
+    });
+
+    if (!res.ok) {
+      const err = await res.json().catch(() => ({}));
+      console.error(`Failed: ${err.message || err.error || res.statusText}`);
+      process.exit(1);
+    }
+
+    const result = await res.json();
+    const issue = result.data || result;
+
+    // Autocomplete if requested (generates acceptance criteria, description, etc.)
+    if (opts.autocomplete) {
+      console.log(`  Generating acceptance criteria...`);
+      const autoRes = await fetch(`${getApiBase()}/api/issues/autocomplete`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          title: issue.title,
+          description: issue.description,
+          priority: issue.priority,
+          lang: opts.lang || 'fr'
+        })
+      });
+
+      if (autoRes.ok) {
+        const autoData = await autoRes.json();
+        // Update issue with generated fields
+        const patchRes = await fetch(`${getApiBase()}/api/issues/${issue.key}`, {
+          method: 'PATCH',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({
+            description: autoData.description || issue.description,
+            priority: autoData.priority || issue.priority,
+            labels: autoData.labels || [],
+            acceptance_criteria: autoData.acceptance_criteria || [],
+            semver: autoData.semver || 'patch'
+          })
+        });
+
+        if (patchRes.ok) {
+          const updated = await patchRes.json();
+          console.log(`  ✓ Autocomplete: ${(updated.acceptance_criteria || []).length} criteria generated`);
+        } else {
+          console.error(`  ⚠ Autocomplete update failed`);
+        }
+      } else {
+        console.error(`  ⚠ Autocomplete generation failed`);
+      }
+    }
+
+    // Move to column if specified
+    if (opts.column && opts.column !== '00_backlog') {
+      await fetch(`${getApiBase()}/api/issues/${issue.key}/move`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ column: opts.column, force: true })
+      });
+    }
+
+    console.log(`✓ Created ${issue.key}`);
+    console.log(`  Title: ${issue.title}`);
+    console.log(`  Priority: ${issue.priority || 'P2'}`);
+    console.log(`  Column: ${opts.column || '00_backlog'}`);
+  } catch (e) {
+    console.error(`Error: ${e.message}`);
+    console.error('Make sure autocode server is running');
+    process.exit(1);
+  }
+}
+
+// ============================================
+// show - Show issue details
+// ============================================
+async function showCmd() {
+  const key = commandArgs[0];
+  const jsonOutput = commandArgs.includes('--json');
+
+  if (!key) {
+    console.error('Usage: autocode show <issue-key> [--json]');
+    process.exit(1);
+  }
+
+  if (!key.match(/^AC-\d{6}$/)) {
+    console.error(`Invalid issue key: ${key}`);
+    process.exit(1);
+  }
+
+  try {
+    const API = getApiBase();
+    const [issueRes, childrenRes, ancestorsRes] = await Promise.all([
+      fetch(`${API}/api/issues/${key}`),
+      fetch(`${API}/api/issues/${key}/children`),
+      fetch(`${API}/api/issues/${key}/ancestors`)
+    ]);
+
+    if (!issueRes.ok) {
+      console.error(`Issue '${key}' not found`);
+      process.exit(1);
+    }
+
+    const issue = await issueRes.json();
+    const children = childrenRes.ok ? await childrenRes.json() : [];
+    const ancestors = ancestorsRes.ok ? await ancestorsRes.json() : [];
+
+    if (jsonOutput) {
+      console.log(JSON.stringify({ ...issue, children, ancestors }, null, 2));
+      return;
+    }
+
+    // Pretty print
+    console.log();
+    console.log(`\x1b[1m${issue.key}: ${issue.title}\x1b[0m`);
+    console.log('─'.repeat(60));
+
+    console.log(`  Status:   ${issue.column_slug}`);
+    console.log(`  Priority: ${issue.priority}`);
+    console.log(`  Semver:   ${issue.semver || '-'}`);
+
+    if (issue.labels?.length > 0) {
+      console.log(`  Labels:   ${issue.labels.join(', ')}`);
+    }
+
+    if (issue.parent_key) {
+      console.log(`  Parent:   ${issue.parent_key}`);
+    }
+
+    if (children.length > 0) {
+      console.log(`  Children: ${children.length} issue(s)`);
+    }
+
+    console.log();
+    console.log(`  Created:  ${issue.created_at}`);
+    console.log(`  Updated:  ${issue.updated_at}`);
+
+    if (issue.description && issue.description !== '[Description]') {
+      console.log();
+      console.log('\x1b[1mDescription:\x1b[0m');
+      console.log(issue.description);
+    }
+
+    if (issue.acceptance_criteria?.length > 0) {
+      console.log();
+      console.log('\x1b[1mAcceptance Criteria:\x1b[0m');
+      for (const c of issue.acceptance_criteria) {
+        console.log(`  - ${c}`);
+      }
+    }
+
+    if (issue.comments?.length > 0) {
+      console.log();
+      console.log(`\x1b[1mComments (${issue.comments.length}):\x1b[0m`);
+      for (const c of issue.comments) {
+        console.log();
+        console.log(`  \x1b[2m[${c.column}] ${c.created_at}\x1b[0m`);
+        console.log(`  ${c.text}`);
+      }
+    }
+
+    if (children.length > 0) {
+      console.log();
+      console.log(`\x1b[1mChildren (${children.length}):\x1b[0m`);
+      for (const child of children) {
+        const status = child.column_slug?.substring(0, 15).padEnd(15) || '';
+        console.log(`  \x1b[36m${child.key}\x1b[0m [${status}] ${child.title.substring(0, 40)}`);
+      }
+    }
+
+    if (issue.history?.length > 0) {
+      console.log();
+      console.log('\x1b[1mHistory:\x1b[0m');
+      for (const h of issue.history) {
+        console.log(`  \x1b[2m${h.at}: ${h.action} ${h.from || '-'} → ${h.to}\x1b[0m`);
+      }
+    }
+
+    console.log();
+  } catch (e) {
+    console.error(`Error: ${e.message}`);
+    console.error('Make sure autocode server is running');
+    process.exit(1);
+  }
+}
+
+// ============================================
+// history - Show full issue history
+// ============================================
+async function historyCmd() {
+  const key = commandArgs[0];
+  const jsonOutput = commandArgs.includes('--json');
+  const fullOutput = commandArgs.includes('--full');
+  const limitIdx = commandArgs.findIndex(a => a === '--limit');
+  const limit = limitIdx !== -1 ? parseInt(commandArgs[limitIdx + 1], 10) : undefined;
+
+  if (!key) {
+    console.error('Usage: autocode history <issue-key> [--json] [--full] [--limit N]');
+    process.exit(1);
+  }
+
+  if (!key.match(/^AC-\d{6}$/)) {
+    console.error(`Invalid issue key: ${key}`);
+    process.exit(1);
+  }
+
+  try {
+    const API = getApiBase();
+
+    // Fetch full history (includes execution logs)
+    const res = await fetch(`${API}/api/issues/${key}/full-history`);
+
+    if (!res.ok) {
+      if (res.status === 404) {
+        console.error(`Issue '${key}' not found`);
+      } else {
+        console.error(`Failed to get history: ${res.statusText}`);
+      }
+      process.exit(1);
+    }
+
+    const data = await res.json();
+    let history = data.entries || [];
+
+    // Apply limit if specified
+    if (limit && limit > 0) {
+      history = history.slice(-limit);
+    }
+
+    if (jsonOutput) {
+      console.log(JSON.stringify(history, null, 2));
+      return;
+    }
+
+    if (history.length === 0) {
+      console.log(`No history found for ${key}`);
+      return;
+    }
+
+    console.log();
+    console.log(`\x1b[1mHistory for ${key}\x1b[0m`);
+    console.log('═'.repeat(80));
+
+    for (let i = 0; i < history.length; i++) {
+      const entry = history[i];
+      const timestamp = entry.at.substring(0, 19).replace('T', ' ');
+      const action = formatAction(entry.action);
+      const from = entry.fromColumn || entry.from || '-';
+      const to = entry.toColumn || entry.to;
+      const sessionId = entry.sessionId ? `[${entry.sessionId}]` : '';
+
+      // Entry header
+      console.log();
+      console.log(`\x1b[1m#${i + 1}\x1b[0m  ${timestamp}  ${action}`);
+
+      // Transition details
+      if (entry.action === 'moved' || entry.action === 'started') {
+        console.log(`    Transition: ${from} → ${to}`);
+      } else if (entry.action === 'created') {
+        console.log(`    Created in: ${to}`);
+      } else if (entry.action === 'edited') {
+        console.log(`    Edited in: ${to}`);
+      }
+
+      if (entry.sessionId) {
+        console.log(`    Session: ${sessionId}`);
+      }
+
+      // Show changes if present (for edited action)
+      if (entry.changes && entry.changes.length > 0) {
+        console.log();
+        console.log('    \x1b[35mChanges:\x1b[0m');
+        for (const change of entry.changes) {
+          const field = change.field;
+          console.log(`      \x1b[36m${field}:\x1b[0m`);
+          if (fullOutput || String(change.from || '').length < 100) {
+            console.log(`        \x1b[31m- ${formatValue(change.from)}\x1b[0m`);
+            console.log(`        \x1b[32m+ ${formatValue(change.to)}\x1b[0m`);
+          } else {
+            console.log(`        \x1b[31m- ${truncate(String(change.from || ''), 80)}\x1b[0m`);
+            console.log(`        \x1b[32m+ ${truncate(String(change.to || ''), 80)}\x1b[0m`);
+          }
+        }
+      }
+
+      // Show prompt if available
+      if (entry.prompt) {
+        console.log();
+        console.log('    \x1b[33mPrompt:\x1b[0m');
+        if (fullOutput) {
+          const lines = entry.prompt.split('\n');
+          for (const line of lines) {
+            console.log(`      ${line}`);
+          }
+        } else {
+          const preview = entry.prompt.substring(0, 200).replace(/\n/g, ' ');
+          console.log(`      ${preview}${entry.prompt.length > 200 ? '...' : ''}`);
+          console.log(`      \x1b[2m(${entry.prompt.length} chars, use --full to see all)\x1b[0m`);
+        }
+      }
+
+      // Show terminal output if available
+      const terminalLog = entry.terminalLog || entry.terminal;
+      if (terminalLog) {
+        console.log();
+        console.log('    \x1b[32mTerminal Output:\x1b[0m');
+        if (fullOutput) {
+          const lines = terminalLog.split('\n');
+          for (const line of lines) {
+            console.log(`      ${line}`);
+          }
+        } else {
+          const preview = terminalLog.substring(0, 300).replace(/\n/g, ' ');
+          console.log(`      ${preview}${terminalLog.length > 300 ? '...' : ''}`);
+          console.log(`      \x1b[2m(${terminalLog.length} chars, use --full to see all)\x1b[0m`);
+        }
+      }
+
+      // Separator between entries
+      if (i < history.length - 1) {
+        console.log();
+        console.log('─'.repeat(80));
+      }
+    }
+
+    console.log();
+    console.log('═'.repeat(80));
+    console.log(`Total: ${history.length} entries`);
+
+    // Summary of artifacts
+    const withPrompt = history.filter(h => h.prompt).length;
+    const withTerminal = history.filter(h => h.terminalLog || h.terminal).length;
+    if (withPrompt > 0 || withTerminal > 0) {
+      console.log(`Artifacts: ${withPrompt} prompts, ${withTerminal} terminal logs`);
+    }
+
+    if (!fullOutput && (withPrompt > 0 || withTerminal > 0)) {
+      console.log('\x1b[2mTip: Use --full to see complete prompt and terminal content\x1b[0m');
+    }
+  } catch (e) {
+    console.error(`Error: ${e.message}`);
+    console.error('Make sure autocode server is running');
+    process.exit(1);
+  }
+}
+
+function formatValue(val) {
+  if (val === null || val === undefined) return '(empty)';
+  if (typeof val === 'string') return val.replace(/\n/g, '\\n');
+  return JSON.stringify(val);
+}
+
+function formatAction(action) {
+  const width = 8;
+  switch (action) {
+    case 'created': return `\x1b[32m${'created'.padEnd(width)}\x1b[0m`;
+    case 'moved': return `\x1b[36m${'moved'.padEnd(width)}\x1b[0m`;
+    case 'started': return `\x1b[33m${'started'.padEnd(width)}\x1b[0m`;
+    case 'edited': return `\x1b[35m${'edited'.padEnd(width)}\x1b[0m`;
+    default: return action.padEnd(width);
+  }
+}
+
+function truncate(str, maxLen) {
+  if (str.length <= maxLen) return str;
+  return str.substring(0, maxLen - 3) + '...';
+}
+
+// ============================================
+// list - List issues
+// ============================================
+async function listCmd() {
+  const opts = {};
+  let i = 0;
+
+  while (i < commandArgs.length) {
+    const arg = commandArgs[i];
+    if (arg === '-c' || arg === '--column') opts.column = commandArgs[++i];
+    else if (arg === '-p' || arg === '--priority') opts.priority = commandArgs[++i];
+    else if (arg === '-l' || arg === '--label') opts.label = commandArgs[++i];
+    else if (arg === '--parent') opts.parent = commandArgs[++i];
+    else if (arg === '--tree') opts.tree = true;
+    else if (arg === '--json') opts.json = true;
+    i++;
+  }
+
+  try {
+    const API = getApiBase();
+    const params = new URLSearchParams();
+    if (opts.column) params.set('column', opts.column);
+    if (opts.priority) params.set('priority', opts.priority);
+    if (opts.label) params.set('label', opts.label);
+    if (opts.parent) params.set('parent', opts.parent);
+
+    const url = `${API}/api/issues${params.toString() ? '?' + params.toString() : ''}`;
+    const res = await fetch(url);
+
+    if (!res.ok) {
+      const err = await res.json().catch(() => ({}));
+      console.error(`Failed: ${err.message || res.statusText}`);
+      process.exit(1);
+    }
+
+    let issues = await res.json();
+
+    // Sort by priority then key
+    const priorityOrder = { P0: 0, P1: 1, P2: 2, P3: 3 };
+    issues.sort((a, b) => {
+      const pDiff = (priorityOrder[a.priority] || 2) - (priorityOrder[b.priority] || 2);
+      if (pDiff !== 0) return pDiff;
+      return a.key.localeCompare(b.key);
+    });
+
+    if (opts.json) {
+      console.log(JSON.stringify(issues, null, 2));
+      return;
+    }
+
+    if (issues.length === 0) {
+      console.log('No issues found');
+      return;
+    }
+
+    if (opts.tree) {
+      console.log(`Issue hierarchy:`);
+      console.log('─'.repeat(60));
+      printTree(issues, null, 0);
+      return;
+    }
+
+    console.log(`Found ${issues.length} issue(s)`);
+    console.log('─'.repeat(60));
+
+    for (const issue of issues) {
+      const key = `\x1b[36m${issue.key}\x1b[0m`;
+      const priority = colorPriority(issue.priority);
+      const title = issue.title.substring(0, 50) + (issue.title.length > 50 ? '...' : '');
+      const status = `\x1b[2m[${issue.column_slug}]\x1b[0m`;
+      console.log(`${key} ${priority} ${title} ${status}`);
+    }
+  } catch (e) {
+    console.error(`Error: ${e.message}`);
+    console.error('Make sure autocode server is running');
+    process.exit(1);
+  }
+}
+
+function printTree(issues, parentKey, indent) {
+  // Filter: null, undefined, or empty string all mean "root level"
+  const children = issues.filter(t => {
+    const parent = t.parent_key;
+    if (parentKey === null) {
+      return !parent || parent === '';
+    }
+    return parent === parentKey;
+  });
+
+  const priorityOrder = { P0: 0, P1: 1, P2: 2, P3: 3 };
+
+  children.sort((a, b) => {
+    const pDiff = (priorityOrder[a.priority] || 2) - (priorityOrder[b.priority] || 2);
+    if (pDiff !== 0) return pDiff;
+    return a.key.localeCompare(b.key);
+  });
+
+  for (const issue of children) {
+    const prefix = indent > 0 ? '  '.repeat(indent - 1) + '└─ ' : '';
+    const key = `\x1b[36m${issue.key}\x1b[0m`;
+    const priority = colorPriority(issue.priority);
+    const title = issue.title.substring(0, 40) + (issue.title.length > 40 ? '...' : '');
+    const status = `\x1b[2m[${(issue.column_slug || '').substring(0, 12)}]\x1b[0m`;
+    console.log(`${prefix}${key} ${priority} ${title} ${status}`);
+    printTree(issues, issue.key, indent + 1);
+  }
+}
+
+function colorPriority(p) {
+  switch (p) {
+    case 'P0': return '\x1b[31mP0\x1b[0m';
+    case 'P1': return '\x1b[33mP1\x1b[0m';
+    case 'P2': return '\x1b[32mP2\x1b[0m';
+    case 'P3': return '\x1b[2mP3\x1b[0m';
+    default: return p || 'P2';
+  }
+}
+
+// ============================================
+// health - Check workflow health
+// ============================================
+async function healthCmd() {
+  const jsonOutput = commandArgs.includes('--json');
+  const verbose = commandArgs.includes('-v') || commandArgs.includes('--verbose');
+
+  try {
+    const res = await fetch(`${getApiBase()}/api/workflow/health`);
+
+    if (!res.ok) {
+      console.error('Failed to get health status');
+      process.exit(1);
+    }
+
+    const report = await res.json();
+
+    if (jsonOutput) {
+      console.log(JSON.stringify(report, null, 2));
+      return;
+    }
+
+    if (report.healthy) {
+      console.log('\x1b[32m✓ All issues healthy\x1b[0m');
+      console.log(`  Total issues: ${report.issueCount || report.summary?.totalIssues || 0}`);
+      return;
+    }
+
+    // Simple format from API
+    if (report.message) {
+      console.log(`\x1b[33m⚠ ${report.message}\x1b[0m`);
+      console.log(`  Issues: ${report.issueCount || 0}`);
+      return;
+    }
+
+    // Extended format with stuckIssues
+    const stuckIssues = report.stuckIssues || [];
+    const errorCount = stuckIssues.filter(s => s.severity === 'error').length;
+    const warningCount = stuckIssues.filter(s => s.severity === 'warning').length;
+
+    if (errorCount > 0) {
+      console.log(`\x1b[31m✗ ${errorCount} issue(s) need attention\x1b[0m`);
+    }
+    if (warningCount > 0) {
+      console.log(`\x1b[33m⚠ ${warningCount} warning(s)\x1b[0m`);
+    }
+
+    if (stuckIssues.length === 0) {
+      return;
+    }
+
+    console.log('─'.repeat(60));
+
+    // Group by reason
+    const byReason = new Map();
+    for (const stuck of stuckIssues) {
+      const list = byReason.get(stuck.reason) || [];
+      list.push(stuck);
+      byReason.set(stuck.reason, list);
+    }
+
+    const reasonLabels = {
+      no_criteria: 'Missing Acceptance Criteria',
+      loop_detected: 'Loop Detected',
+      stale: 'Stale Issues',
+      hierarchy_conflict: 'Hierarchy Conflicts'
+    };
+
+    for (const [reason, issues] of byReason) {
+      console.log();
+      console.log(`${reasonLabels[reason] || reason} (${issues.length})`);
+
+      for (const stuck of issues) {
+        const severity = stuck.severity === 'error' ? '\x1b[31m!\x1b[0m' : '\x1b[33m?\x1b[0m';
+        const key = `\x1b[36m${stuck.key}\x1b[0m`;
+        const details = `\x1b[2m${stuck.details}\x1b[0m`;
+        console.log(`  ${severity} ${key} ${details}`);
+
+        if (verbose) {
+          console.log(`      Column: ${stuck.column}`);
+        }
+      }
+    }
+
+    if (report.recommendations?.length > 0) {
+      console.log();
+      console.log('Recommendations:');
+      for (const rec of report.recommendations) {
+        console.log(`  - ${rec}`);
+      }
+    }
+
+    if (verbose && report.summary) {
+      console.log();
+      console.log('Summary:');
+      console.log(`  Total issues:       ${report.summary.totalIssues}`);
+      console.log(`  Without criteria:   ${report.summary.issuesWithoutCriteria}`);
+      console.log(`  Looping:            ${report.summary.loopingIssues}`);
+      console.log(`  Hierarchy conflicts: ${report.summary.hierarchyConflicts}`);
+      console.log(`  Stale:              ${report.summary.staleIssues}`);
+    }
+  } catch (e) {
+    console.error(`Error: ${e.message}`);
+    console.error('Make sure autocode server is running');
+    process.exit(1);
+  }
+}
+
+// ============================================
+// parent - Manage parent relationships
+// ============================================
+async function parentCmd() {
+  const key = commandArgs[0];
+  const parentKey = commandArgs[1];
+
+  if (!key) {
+    console.error('Usage: autocode parent <issue-key> [parent-key|none]');
+    process.exit(1);
+  }
+
+  if (!key.match(/^AC-\d{6}$/)) {
+    console.error(`Invalid issue key: ${key}`);
+    process.exit(1);
+  }
+
+  try {
+    const API = getApiBase();
+
+    // Show current parent/children if no argument
+    if (!parentKey) {
+      const [issueRes, childrenRes, ancestorsRes] = await Promise.all([
+        fetch(`${API}/api/issues/${key}`),
+        fetch(`${API}/api/issues/${key}/children`),
+        fetch(`${API}/api/issues/${key}/ancestors`)
+      ]);
+
+      if (!issueRes.ok) {
+        console.error(`Issue '${key}' not found`);
+        process.exit(1);
+      }
+
+      const issue = await issueRes.json();
+      const children = childrenRes.ok ? await childrenRes.json() : [];
+      const ancestors = ancestorsRes.ok ? await ancestorsRes.json() : [];
+
+      console.log();
+      console.log(`\x1b[1m${issue.key}: ${issue.title}\x1b[0m`);
+      console.log('─'.repeat(60));
+
+      if (issue.parent_key) {
+        const parentRes = await fetch(`${API}/api/issues/${issue.parent_key}`);
+        const parent = parentRes.ok ? await parentRes.json() : null;
+        console.log(`  Parent: ${issue.parent_key}${parent ? ` (${parent.title.substring(0, 40)})` : ''}`);
+      } else {
+        console.log('  Parent: None (root issue)');
+      }
+
+      if (ancestors.length > 0) {
+        console.log();
+        console.log('\x1b[1mAncestors:\x1b[0m');
+        for (let i = ancestors.length - 1; i >= 0; i--) {
+          const a = ancestors[i];
+          const indent = '  '.repeat(ancestors.length - 1 - i);
+          console.log(`${indent}\x1b[36m${a.key}\x1b[0m ${a.title.substring(0, 40)}`);
+        }
+      }
+
+      if (children.length > 0) {
+        console.log();
+        console.log(`\x1b[1mChildren (${children.length}):\x1b[0m`);
+        for (const child of children) {
+          console.log(`  \x1b[36m${child.key}\x1b[0m [${(child.column_slug || '').substring(0, 12)}] ${child.title.substring(0, 40)}`);
+        }
+      }
+
+      console.log();
+      return;
+    }
+
+    // Set or remove parent
+    const newParentKey = parentKey.toLowerCase() === 'none' ? null : parentKey;
+
+    if (newParentKey && !newParentKey.match(/^AC-\d{6}$/)) {
+      console.error(`Invalid parent key: ${parentKey}`);
+      process.exit(1);
+    }
+
+    const res = await fetch(`${API}/api/issues/${key}`, {
+      method: 'PATCH',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ parent_key: newParentKey })
+    });
+
+    if (!res.ok) {
+      const err = await res.json().catch(() => ({}));
+      console.error(`Failed: ${err.message || err.error || res.statusText}`);
+      process.exit(1);
+    }
+
+    if (newParentKey) {
+      console.log(`✓ Set parent of ${key} to ${newParentKey}`);
+    } else {
+      console.log(`✓ Removed parent from ${key}`);
+    }
+  } catch (e) {
+    console.error(`Error: ${e.message}`);
+    console.error('Make sure autocode server is running');
+    process.exit(1);
+  }
+}
+
+// ============================================
+// stats - Show usage statistics
+// ============================================
+async function statsCmd() {
+  const jsonOutput = commandArgs.includes('--json');
+  const sessionOnly = commandArgs.includes('--session');
+  const totalsOnly = commandArgs.includes('--totals');
+
+  try {
+    const res = await fetch(`${getApiBase()}/api/stats`);
+
+    if (!res.ok) {
+      console.error('Failed to get stats');
+      process.exit(1);
+    }
+
+    const stats = await res.json();
+
+    if (jsonOutput) {
+      if (sessionOnly) console.log(JSON.stringify(stats.session, null, 2));
+      else if (totalsOnly) console.log(JSON.stringify(stats.totals, null, 2));
+      else console.log(JSON.stringify(stats, null, 2));
+      return;
+    }
+
+    console.log('Claude Usage Statistics');
+    console.log('─'.repeat(60));
+
+    console.log(`  Profile: \x1b[36m${stats.profile || 'default'}\x1b[0m`);
+    console.log(`  Model:   \x1b[2m${stats.model || 'N/A'}\x1b[0m`);
+    console.log();
+
+    if (!totalsOnly && stats.session) {
+      const sessionTotal = (stats.session.tokensInput || 0) + (stats.session.tokensOutput || 0);
+      console.log(`  \x1b[36mSession\x1b[0m (started: ${formatDate(stats.session.startedAt)})`);
+      console.log(`    Calls:         ${stats.session.callCount || 0}`);
+      console.log(`    Input tokens:  ${formatNumber(stats.session.tokensInput || 0)}`);
+      console.log(`    Output tokens: ${formatNumber(stats.session.tokensOutput || 0)}`);
+      console.log(`    Total tokens:  ${formatNumber(sessionTotal)}`);
+      console.log(`    Cost:          $${(stats.session.costUsd || 0).toFixed(2)}`);
+      console.log();
+    }
+
+    if (!sessionOnly && stats.totals) {
+      const total = (stats.totals.tokensInput || 0) + (stats.totals.tokensOutput || 0);
+      console.log(`  \x1b[36mAll Time\x1b[0m`);
+      console.log(`    Calls:         ${stats.totals.callCount || 0}`);
+      console.log(`    Input tokens:  ${formatNumber(stats.totals.tokensInput || 0)}`);
+      console.log(`    Output tokens: ${formatNumber(stats.totals.tokensOutput || 0)}`);
+      console.log(`    Total tokens:  ${formatNumber(total)}`);
+      console.log(`    Cost:          $${(stats.totals.costUsd || 0).toFixed(2)}`);
+      console.log();
+    }
+
+    if (!sessionOnly && !totalsOnly && stats.history?.length > 0) {
+      console.log(`  \x1b[36mRecent Calls\x1b[0m (last 5)`);
+      const recent = stats.history.slice(0, 5);
+      for (const call of recent) {
+        const issue = call.issue ? `\x1b[36m${call.issue}\x1b[0m` : '-';
+        const tokens = `${formatNumber(call.tokensInput || 0)}/${formatNumber(call.tokensOutput || 0)}`;
+        const cost = call.costUsd ? `$${call.costUsd.toFixed(2)}` : '';
+        const duration = formatDuration(call.duration || 0);
+        console.log(`    ${formatTime(call.timestamp)} ${issue} ${tokens} tokens ${cost} (${duration})`);
+      }
+    }
+  } catch (e) {
+    console.error(`Error: ${e.message}`);
+    console.error('Make sure autocode server is running');
+    process.exit(1);
+  }
+}
+
+function formatNumber(n) {
+  if (n >= 1000000) return (n / 1000000).toFixed(1) + 'M';
+  if (n >= 1000) return (n / 1000).toFixed(1) + 'K';
+  return n.toString();
+}
+
+function formatDate(iso) {
+  if (!iso) return 'N/A';
+  const d = new Date(iso);
+  return d.toLocaleDateString() + ' ' + d.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
+}
+
+function formatTime(iso) {
+  if (!iso) return 'N/A';
+  const d = new Date(iso);
+  return d.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit', second: '2-digit' });
+}
+
+function formatDuration(ms) {
+  if (ms < 1000) return ms + 'ms';
+  return (ms / 1000).toFixed(1) + 's';
+}
+
+// ============================================
+// init - Initialize project structure
+// ============================================
+function initCmd() {
+  const rootDir = commandArgs.find(a => !a.startsWith('-')) || 'autocode';
+
+  console.log(`Initializing autocode in ${rootDir}...`);
+
+  // Create directories
+  const columns = [
+    '00_backlog',
+    '01_ready',
+    '02_in-progress',
+    '03_review',
+    '04_done',
+    '_archive'
+  ];
+
+  try {
+    mkdirSync(rootDir, { recursive: true });
+    mkdirSync(join(rootDir, '.autocode'), { recursive: true });
+
+    for (const col of columns) {
+      mkdirSync(join(rootDir, col), { recursive: true });
+    }
+
+    // Create .seq file
+    const seqFile = join(rootDir, '.autocode', '.seq');
+    if (!existsSync(seqFile)) {
+      writeFileSync(seqFile, '0');
+    }
+
+    // Setup .gitignore
+    const gitignorePath = join(process.cwd(), '.gitignore');
+    const pattern = `/${rootDir}/*/.claude_prompt_*.md`;
+
+    let content = '';
+    if (existsSync(gitignorePath)) {
+      content = readFileSync(gitignorePath, 'utf-8');
+      if (!content.includes(pattern)) {
+        const newContent = content.trim()
+          ? `${content.trim()}\n\n# AutoCode temporary files\n${pattern}\n`
+          : `# AutoCode temporary files\n${pattern}\n`;
+        writeFileSync(gitignorePath, newContent);
+        console.log('Updated .gitignore with AutoCode patterns');
+      }
+    } else {
+      writeFileSync(gitignorePath, `# AutoCode temporary files\n${pattern}\n`);
+      console.log('Created .gitignore with AutoCode patterns');
+    }
+
+    console.log(`✓ Autocode initialized in ${rootDir}`);
+    console.log('');
+    console.log('Created columns:');
+    for (const col of columns) {
+      console.log(`  - ${col}`);
+    }
+    console.log('');
+    console.log('Next: Run `autocode new "Your first issue"` to create an issue');
+  } catch (e) {
+    console.error(`Error: ${e.message}`);
+    process.exit(1);
+  }
+}
+
+// ============================================
+// pipeline - Pipeline management commands
+// ============================================
+async function pipelineCmd() {
+  const subCommand = commandArgs[0];
+  const subArgs = commandArgs.slice(1);
+
+  switch (subCommand) {
+    case 'list':
+    case undefined:
+      await pipelineListCmd(subArgs);
+      break;
+    case 'show':
+      await pipelineShowCmd(subArgs);
+      break;
+    case 'create':
+      await pipelineCreateCmd(subArgs);
+      break;
+    case 'delete':
+      await pipelineDeleteCmd(subArgs);
+      break;
+    case 'activate':
+      await pipelineActivateCmd(subArgs);
+      break;
+    case 'versions':
+      await pipelineVersionsCmd(subArgs);
+      break;
+    case 'draft':
+      await pipelineDraftCmd(subArgs);
+      break;
+    case 'finalize':
+      await pipelineFinalizeCmd(subArgs);
+      break;
+    case 'add-column':
+      await pipelineAddColumnCmd(subArgs);
+      break;
+    case 'remove-column':
+      await pipelineRemoveColumnCmd(subArgs);
+      break;
+    case 'move-column':
+      await pipelineMoveColumnCmd(subArgs);
+      break;
+    default:
+      console.error(`Unknown pipeline command: ${subCommand}`);
+      showPipelineHelp();
+      process.exit(1);
+  }
+}
+
+function showPipelineHelp() {
+  console.log(`
+Pipeline Commands:
+  pipeline list             List all pipelines
+  pipeline show <name>      Show pipeline with columns
+  pipeline create <name>    Create new pipeline
+  pipeline delete <name>    Delete pipeline version
+  pipeline activate <name>  Activate pipeline version
+  pipeline versions <name>  List all versions
+  pipeline draft <name>     Create draft from latest
+  pipeline finalize <name>  Finalize draft
+
+Column Commands:
+  pipeline add-column <pipeline> <slug> --segment <seg>
+  pipeline remove-column <pipeline> <slug>
+  pipeline move-column <pipeline> <slug> --segment <seg>
+
+Options:
+  --version <N>             Specific version
+  --json                    Output as JSON
+  --description "..."       Pipeline description
+  --segment <segment>       Target segment (definition|action|finish)
+  --position <N>            Position within segment
+  --name "Display Name"     Column display name
+  --activate                Also activate after finalizing
+
+Examples:
+  autocode pipeline list
+  autocode pipeline show default
+  autocode pipeline create my-pipeline --description "Custom workflow"
+  autocode pipeline add-column default review-security --segment action
+  autocode pipeline finalize default --activate
+`);
+}
+
+// Helper: Get option value from args
+function getArgOption(args, flag) {
+  const idx = args.findIndex(a => a === flag);
+  if (idx !== -1 && args[idx + 1]) {
+    return args[idx + 1];
+  }
+  return undefined;
+}
+
+// Helper: Check if flag is present
+function hasArgFlag(args, flag) {
+  return args.includes(flag);
+}
+
+// Helper: Convert slug to display name
+function slugToName(slug) {
+  return slug
+    .split('-')
+    .map(w => w.charAt(0).toUpperCase() + w.slice(1))
+    .join(' ');
+}
+
+// Helper: Format pipeline status with color
+function formatPipelineStatus(pipeline) {
+  if (pipeline.active) return '\x1b[32mactive\x1b[0m';
+  if (pipeline.draft) return '\x1b[33mdraft\x1b[0m';
+  return 'locked';
+}
+
+// Helper: Get or create draft for a pipeline
+async function getOrCreateDraft(pipelineName) {
+  const API = getApiBase();
+
+  // Get versions
+  const versionsRes = await fetch(`${API}/api/pipelines/${pipelineName}/versions`);
+  if (!versionsRes.ok) {
+    throw new Error(`Pipeline '${pipelineName}' not found`);
+  }
+  const versionList = await versionsRes.json();
+
+  // Find existing draft
+  const draftInfo = versionList.find(v => v.draft);
+  if (draftInfo) {
+    // Get full draft data
+    const res = await fetch(`${API}/api/pipelines/${pipelineName}?version=${draftInfo.version}`);
+    if (!res.ok) throw new Error('Failed to get draft');
+    return res.json();
+  }
+
+  // Create new draft
+  console.log(`Creating draft from latest locked version...`);
+  const res = await fetch(`${API}/api/pipelines/${pipelineName}/versions`, { method: 'POST' });
+  if (!res.ok) {
+    const err = await res.json().catch(() => ({}));
+    throw new Error(err.message || 'Failed to create draft');
+  }
+  return res.json();
+}
+
+// pipeline list
+async function pipelineListCmd(args) {
+  const jsonOutput = hasArgFlag(args, '--json');
+
+  try {
+    const res = await fetch(`${getApiBase()}/api/pipelines`);
+    if (!res.ok) {
+      console.error('Failed to list pipelines');
+      process.exit(1);
+    }
+
+    const pipelines = await res.json();
+
+    if (jsonOutput) {
+      console.log(JSON.stringify(pipelines, null, 2));
+      return;
+    }
+
+    if (pipelines.length === 0) {
+      console.log('No pipelines found');
+      return;
+    }
+
+    console.log('Pipelines:');
+    console.log('─'.repeat(60));
+    console.log('  ' + 'NAME'.padEnd(20) + 'VERSION'.padEnd(10) + 'STATUS'.padEnd(12) + 'COLUMNS');
+
+    for (const p of pipelines) {
+      const name = p.name.substring(0, 19).padEnd(20);
+      const version = `v${p.version}`.padEnd(10);
+      const status = formatPipelineStatus(p).padEnd(20); // Extra padding for ANSI codes
+      const cols = (p.definition?.length || 0) + (p.action?.length || 0) + (p.finish?.length || 0);
+      console.log(`  ${name}${version}${status}${cols} columns`);
+    }
+
+    console.log();
+    console.log(`Total: ${pipelines.length} pipeline version(s)`);
+  } catch (e) {
+    console.error(`Error: ${e.message}`);
+    console.error('Make sure autocode server is running');
+    process.exit(1);
+  }
+}
+
+// pipeline show <name>
+async function pipelineShowCmd(args) {
+  const name = args.find(a => !a.startsWith('-'));
+  const version = getArgOption(args, '--version');
+  const jsonOutput = hasArgFlag(args, '--json');
+
+  if (!name) {
+    console.error('Usage: autocode pipeline show <name> [--version N] [--json]');
+    process.exit(1);
+  }
+
+  try {
+    const API = getApiBase();
+    const url = version
+      ? `${API}/api/pipelines/${name}?version=${version}`
+      : `${API}/api/pipelines/${name}`;
+
+    const res = await fetch(url);
+    if (!res.ok) {
+      console.error(`Pipeline '${name}' not found`);
+      process.exit(1);
+    }
+
+    const pipeline = await res.json();
+
+    if (jsonOutput) {
+      console.log(JSON.stringify(pipeline, null, 2));
+      return;
+    }
+
+    const status = pipeline.active ? '(active)' : pipeline.draft ? '(draft)' : '(locked)';
+    console.log();
+    console.log(`\x1b[1mPipeline: ${pipeline.name} v${pipeline.version} ${status}\x1b[0m`);
+    console.log('─'.repeat(60));
+
+    if (pipeline.description) {
+      console.log(`Description: ${pipeline.description}`);
+      console.log();
+    }
+
+    let index = 1;
+
+    // Definition segment
+    const defCols = pipeline.definition || [];
+    console.log(`\x1b[36mDEFINITION\x1b[0m (${defCols.length}):`);
+    for (const col of defCols) {
+      const num = String(index++).padStart(3);
+      const slug = col.slug.padEnd(20);
+      console.log(`  ${num}. ${slug} ${col.name}`);
+    }
+    console.log();
+
+    // Action segment
+    const actCols = pipeline.action || [];
+    console.log(`\x1b[33mACTION\x1b[0m (${actCols.length}):`);
+    for (const col of actCols) {
+      const num = String(index++).padStart(3);
+      const slug = col.slug.padEnd(20);
+      console.log(`  ${num}. ${slug} ${col.name}`);
+    }
+    console.log();
+
+    // Finish segment
+    const finCols = pipeline.finish || [];
+    console.log(`\x1b[32mFINISH\x1b[0m (${finCols.length}):`);
+    for (const col of finCols) {
+      const num = String(index++).padStart(3);
+      const slug = col.slug.padEnd(20);
+      console.log(`  ${num}. ${slug} ${col.name}`);
+    }
+    console.log();
+
+    const totalCols = defCols.length + actCols.length + finCols.length;
+    console.log(`Total: ${totalCols} columns`);
+
+    if (pipeline.createdAt) {
+      console.log(`Created: ${formatDate(pipeline.createdAt)}`);
+    }
+    if (pipeline.createdFromVersion) {
+      console.log(`Based on: v${pipeline.createdFromVersion}`);
+    }
+  } catch (e) {
+    console.error(`Error: ${e.message}`);
+    console.error('Make sure autocode server is running');
+    process.exit(1);
+  }
+}
+
+// pipeline versions <name>
+async function pipelineVersionsCmd(args) {
+  const name = args.find(a => !a.startsWith('-'));
+  const jsonOutput = hasArgFlag(args, '--json');
+
+  if (!name) {
+    console.error('Usage: autocode pipeline versions <name> [--json]');
+    process.exit(1);
+  }
+
+  try {
+    const res = await fetch(`${getApiBase()}/api/pipelines/${name}/versions`);
+    if (!res.ok) {
+      console.error(`Pipeline '${name}' not found`);
+      process.exit(1);
+    }
+
+    const versions = await res.json();
+
+    if (jsonOutput) {
+      console.log(JSON.stringify(versions, null, 2));
+      return;
+    }
+
+    console.log(`Versions of: ${name}`);
+    console.log('─'.repeat(60));
+    console.log('  ' + 'VERSION'.padEnd(10) + 'STATUS'.padEnd(12) + 'CREATED'.padEnd(22) + 'BASED ON'.padEnd(10) + 'COLUMNS');
+
+    for (const v of versions) {
+      const ver = `v${v.version}`.padEnd(10);
+      const status = (v.active ? '\x1b[32mactive\x1b[0m' : v.draft ? '\x1b[33mdraft\x1b[0m' : 'locked').padEnd(20);
+      const created = formatDate(v.createdAt).padEnd(22);
+      const basedOn = v.createdFromVersion ? `v${v.createdFromVersion}`.padEnd(10) : '-'.padEnd(10);
+      const cols = v.columnCount || 0;
+      console.log(`  ${ver}${status}${created}${basedOn}${cols}`);
+    }
+
+    console.log();
+    console.log(`Total: ${versions.length} version(s)`);
+  } catch (e) {
+    console.error(`Error: ${e.message}`);
+    console.error('Make sure autocode server is running');
+    process.exit(1);
+  }
+}
+
+// pipeline create <name>
+async function pipelineCreateCmd(args) {
+  const name = args.find(a => !a.startsWith('-'));
+  const description = getArgOption(args, '--description');
+
+  if (!name) {
+    console.error('Usage: autocode pipeline create <name> [--description "..."]');
+    process.exit(1);
+  }
+
+  try {
+    const body = { name };
+    if (description) body.description = description;
+
+    const res = await fetch(`${getApiBase()}/api/pipelines`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(body)
+    });
+
+    if (!res.ok) {
+      const err = await res.json().catch(() => ({}));
+      console.error(`Failed: ${err.message || res.statusText}`);
+      process.exit(1);
+    }
+
+    const pipeline = await res.json();
+
+    console.log(`✓ Created pipeline: ${pipeline.name} v${pipeline.version} (draft)`);
+    console.log();
+    console.log('Next steps:');
+    console.log(`  1. Add columns: autocode pipeline add-column ${name} <slug> --segment <definition|action|finish>`);
+    console.log(`  2. Finalize:    autocode pipeline finalize ${name}`);
+    console.log(`  3. Activate:    autocode pipeline activate ${name}`);
+  } catch (e) {
+    console.error(`Error: ${e.message}`);
+    console.error('Make sure autocode server is running');
+    process.exit(1);
+  }
+}
+
+// pipeline delete <name>
+async function pipelineDeleteCmd(args) {
+  const name = args.find(a => !a.startsWith('-'));
+  const version = getArgOption(args, '--version');
+  const force = hasArgFlag(args, '--force') || hasArgFlag(args, '-f');
+
+  if (!name) {
+    console.error('Usage: autocode pipeline delete <name> [--version N] [--force]');
+    process.exit(1);
+  }
+
+  try {
+    const API = getApiBase();
+
+    // If no version specified, find draft
+    let targetVersion = version;
+    if (!targetVersion) {
+      const versionsRes = await fetch(`${API}/api/pipelines/${name}/versions`);
+      if (!versionsRes.ok) {
+        console.error(`Pipeline '${name}' not found`);
+        process.exit(1);
+      }
+      const versions = await versionsRes.json();
+      const draft = versions.find(v => v.draft);
+      if (draft) {
+        targetVersion = draft.version;
+      } else {
+        console.error(`No draft found for '${name}'. Use --version to specify which version to delete.`);
+        process.exit(1);
+      }
+    }
+
+    const res = await fetch(`${API}/api/pipelines/${name}/versions/${targetVersion}`, {
+      method: 'DELETE'
+    });
+
+    if (!res.ok) {
+      const err = await res.json().catch(() => ({}));
+      console.error(`Failed: ${err.message || res.statusText}`);
+      process.exit(1);
+    }
+
+    console.log(`✓ Deleted: ${name} v${targetVersion}`);
+  } catch (e) {
+    console.error(`Error: ${e.message}`);
+    console.error('Make sure autocode server is running');
+    process.exit(1);
+  }
+}
+
+// pipeline activate <name>
+async function pipelineActivateCmd(args) {
+  const name = args.find(a => !a.startsWith('-'));
+  const version = getArgOption(args, '--version');
+
+  if (!name) {
+    console.error('Usage: autocode pipeline activate <name> [--version N]');
+    process.exit(1);
+  }
+
+  try {
+    const API = getApiBase();
+
+    // If no version specified, find latest locked
+    let targetVersion = version;
+    if (!targetVersion) {
+      const versionsRes = await fetch(`${API}/api/pipelines/${name}/versions`);
+      if (!versionsRes.ok) {
+        console.error(`Pipeline '${name}' not found`);
+        process.exit(1);
+      }
+      const versions = await versionsRes.json();
+      const locked = versions.filter(v => !v.draft).sort((a, b) => b.version - a.version);
+      if (locked.length === 0) {
+        console.error(`No locked version found for '${name}'. Finalize a draft first.`);
+        process.exit(1);
+      }
+      targetVersion = locked[0].version;
+    }
+
+    const res = await fetch(`${API}/api/pipelines/${name}/versions/${targetVersion}/activate`, {
+      method: 'PUT'
+    });
+
+    if (!res.ok) {
+      const err = await res.json().catch(() => ({}));
+      console.error(`Failed: ${err.message || res.statusText}`);
+      process.exit(1);
+    }
+
+    console.log(`✓ Activated: ${name} v${targetVersion}`);
+  } catch (e) {
+    console.error(`Error: ${e.message}`);
+    console.error('Make sure autocode server is running');
+    process.exit(1);
+  }
+}
+
+// pipeline draft <name>
+async function pipelineDraftCmd(args) {
+  const name = args.find(a => !a.startsWith('-'));
+
+  if (!name) {
+    console.error('Usage: autocode pipeline draft <name>');
+    process.exit(1);
+  }
+
+  try {
+    const res = await fetch(`${getApiBase()}/api/pipelines/${name}/versions`, {
+      method: 'POST'
+    });
+
+    if (!res.ok) {
+      const err = await res.json().catch(() => ({}));
+      console.error(`Failed: ${err.message || res.statusText}`);
+      process.exit(1);
+    }
+
+    const pipeline = await res.json();
+    const colCount = (pipeline.definition?.length || 0) + (pipeline.action?.length || 0) + (pipeline.finish?.length || 0);
+
+    console.log(`✓ Created draft: ${name} v${pipeline.version}`);
+    if (pipeline.createdFromVersion) {
+      console.log(`  Based on: v${pipeline.createdFromVersion} (${colCount} columns copied)`);
+    }
+    console.log();
+    console.log('Edit columns:');
+    console.log(`  autocode pipeline add-column ${name} <slug> --segment <segment>`);
+    console.log(`  autocode pipeline remove-column ${name} <slug>`);
+    console.log(`  autocode pipeline move-column ${name} <slug> --segment <segment>`);
+    console.log();
+    console.log('Finalize when ready:');
+    console.log(`  autocode pipeline finalize ${name}`);
+  } catch (e) {
+    console.error(`Error: ${e.message}`);
+    console.error('Make sure autocode server is running');
+    process.exit(1);
+  }
+}
+
+// pipeline finalize <name>
+async function pipelineFinalizeCmd(args) {
+  const name = args.find(a => !a.startsWith('-'));
+  const activate = hasArgFlag(args, '--activate');
+
+  if (!name) {
+    console.error('Usage: autocode pipeline finalize <name> [--activate]');
+    process.exit(1);
+  }
+
+  try {
+    const API = getApiBase();
+
+    // Find draft version
+    const versionsRes = await fetch(`${API}/api/pipelines/${name}/versions`);
+    if (!versionsRes.ok) {
+      console.error(`Pipeline '${name}' not found`);
+      process.exit(1);
+    }
+    const versions = await versionsRes.json();
+    const draft = versions.find(v => v.draft);
+    if (!draft) {
+      console.error(`No draft found for '${name}'`);
+      process.exit(1);
+    }
+
+    // Finalize
+    const finalizeRes = await fetch(`${API}/api/pipelines/${name}/versions/${draft.version}/finalize`, {
+      method: 'POST'
+    });
+
+    if (!finalizeRes.ok) {
+      const err = await finalizeRes.json().catch(() => ({}));
+      console.error(`Failed: ${err.message || finalizeRes.statusText}`);
+      process.exit(1);
+    }
+
+    if (activate) {
+      const activateRes = await fetch(`${API}/api/pipelines/${name}/versions/${draft.version}/activate`, {
+        method: 'PUT'
+      });
+
+      if (!activateRes.ok) {
+        console.error(`Finalized but failed to activate`);
+        process.exit(1);
+      }
+
+      console.log(`✓ Finalized and activated: ${name} v${draft.version}`);
+    } else {
+      console.log(`✓ Finalized: ${name} v${draft.version}`);
+      console.log(`  Status: locked (immutable)`);
+      console.log();
+      console.log(`To activate: autocode pipeline activate ${name} --version ${draft.version}`);
+    }
+  } catch (e) {
+    console.error(`Error: ${e.message}`);
+    console.error('Make sure autocode server is running');
+    process.exit(1);
+  }
+}
+
+// pipeline add-column <pipeline> <slug>
+async function pipelineAddColumnCmd(args) {
+  const pipeline = args[0];
+  const slug = args[1];
+  const segment = getArgOption(args, '--segment');
+  const position = getArgOption(args, '--position');
+  const name = getArgOption(args, '--name') || slugToName(slug || '');
+
+  if (!pipeline || !slug || !segment) {
+    console.error('Usage: autocode pipeline add-column <pipeline> <slug> --segment <definition|action|finish> [--position N] [--name "..."]');
+    process.exit(1);
+  }
+
+  if (!['definition', 'action', 'finish'].includes(segment)) {
+    console.error('Segment must be: definition, action, or finish');
+    process.exit(1);
+  }
+
+  try {
+    const API = getApiBase();
+
+    // Get or create draft
+    const draft = await getOrCreateDraft(pipeline);
+
+    // Get current columns for segment
+    const columns = [...(draft[segment] || [])];
+
+    // Check if column already exists
+    const allColumns = [...(draft.definition || []), ...(draft.action || []), ...(draft.finish || [])];
+    if (allColumns.some(c => c.slug === slug)) {
+      console.error(`Column '${slug}' already exists in pipeline`);
+      process.exit(1);
+    }
+
+    // Insert at position or end
+    const pos = position !== undefined ? parseInt(position, 10) : columns.length;
+    columns.splice(pos, 0, { slug, name });
+
+    // Update draft
+    const updateRes = await fetch(`${API}/api/pipelines/${pipeline}/versions/${draft.version}`, {
+      method: 'PUT',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ [segment]: columns })
+    });
+
+    if (!updateRes.ok) {
+      const err = await updateRes.json().catch(() => ({}));
+      console.error(`Failed: ${err.message || updateRes.statusText}`);
+      process.exit(1);
+    }
+
+    console.log(`✓ Added column: ${slug} to ${segment} segment (position ${pos})`);
+    console.log(`  Draft: ${pipeline} v${draft.version}`);
+    console.log();
+    console.log(`To finalize: autocode pipeline finalize ${pipeline}`);
+  } catch (e) {
+    console.error(`Error: ${e.message}`);
+    console.error('Make sure autocode server is running');
+    process.exit(1);
+  }
+}
+
+// pipeline remove-column <pipeline> <slug>
+async function pipelineRemoveColumnCmd(args) {
+  const pipeline = args[0];
+  const slug = args[1];
+
+  if (!pipeline || !slug) {
+    console.error('Usage: autocode pipeline remove-column <pipeline> <slug>');
+    process.exit(1);
+  }
+
+  // Cannot remove locked columns
+  if (slug === 'backlog' || slug === 'done') {
+    console.error(`Cannot remove locked column: ${slug}`);
+    process.exit(1);
+  }
+
+  try {
+    const API = getApiBase();
+
+    // Get or create draft
+    const draft = await getOrCreateDraft(pipeline);
+
+    // Find and remove column
+    let found = false;
+    let foundSegment = '';
+    const segments = ['definition', 'action', 'finish'];
+
+    for (const seg of segments) {
+      const columns = draft[seg] || [];
+      const idx = columns.findIndex(c => c.slug === slug);
+      if (idx !== -1) {
+        columns.splice(idx, 1);
+        found = true;
+        foundSegment = seg;
+
+        // Update draft
+        const updateRes = await fetch(`${API}/api/pipelines/${pipeline}/versions/${draft.version}`, {
+          method: 'PUT',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ [seg]: columns })
+        });
+
+        if (!updateRes.ok) {
+          const err = await updateRes.json().catch(() => ({}));
+          console.error(`Failed: ${err.message || updateRes.statusText}`);
+          process.exit(1);
+        }
+        break;
+      }
+    }
+
+    if (!found) {
+      console.error(`Column '${slug}' not found in pipeline`);
+      process.exit(1);
+    }
+
+    console.log(`✓ Removed column: ${slug} from ${foundSegment} segment`);
+    console.log(`  Draft: ${pipeline} v${draft.version}`);
+  } catch (e) {
+    console.error(`Error: ${e.message}`);
+    console.error('Make sure autocode server is running');
+    process.exit(1);
+  }
+}
+
+// pipeline move-column <pipeline> <slug>
+async function pipelineMoveColumnCmd(args) {
+  const pipeline = args[0];
+  const slug = args[1];
+  const targetSegment = getArgOption(args, '--segment');
+  const position = getArgOption(args, '--position');
+
+  if (!pipeline || !slug || !targetSegment) {
+    console.error('Usage: autocode pipeline move-column <pipeline> <slug> --segment <definition|action|finish> [--position N]');
+    process.exit(1);
+  }
+
+  if (!['definition', 'action', 'finish'].includes(targetSegment)) {
+    console.error('Segment must be: definition, action, or finish');
+    process.exit(1);
+  }
+
+  // Cannot move locked columns
+  if (slug === 'backlog' || slug === 'done') {
+    console.error(`Cannot move locked column: ${slug}`);
+    process.exit(1);
+  }
+
+  try {
+    const API = getApiBase();
+
+    // Get or create draft
+    const draft = await getOrCreateDraft(pipeline);
+
+    // Find column in current segment
+    let found = null;
+    let sourceSegment = '';
+    const segments = ['definition', 'action', 'finish'];
+
+    for (const seg of segments) {
+      const columns = draft[seg] || [];
+      const idx = columns.findIndex(c => c.slug === slug);
+      if (idx !== -1) {
+        found = columns[idx];
+        sourceSegment = seg;
+        columns.splice(idx, 1);
+        break;
+      }
+    }
+
+    if (!found) {
+      console.error(`Column '${slug}' not found in pipeline`);
+      process.exit(1);
+    }
+
+    // Insert at new position
+    const targetColumns = draft[targetSegment] || [];
+    const pos = position !== undefined ? parseInt(position, 10) : targetColumns.length;
+    targetColumns.splice(pos, 0, found);
+
+    // Update draft
+    const updateBody = {};
+    if (sourceSegment !== targetSegment) {
+      updateBody[sourceSegment] = draft[sourceSegment];
+    }
+    updateBody[targetSegment] = targetColumns;
+
+    const updateRes = await fetch(`${API}/api/pipelines/${pipeline}/versions/${draft.version}`, {
+      method: 'PUT',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(updateBody)
+    });
+
+    if (!updateRes.ok) {
+      const err = await updateRes.json().catch(() => ({}));
+      console.error(`Failed: ${err.message || updateRes.statusText}`);
+      process.exit(1);
+    }
+
+    console.log(`✓ Moved column: ${slug}`);
+    console.log(`  From: ${sourceSegment}`);
+    console.log(`  To: ${targetSegment} (position ${pos})`);
+    console.log(`  Draft: ${pipeline} v${draft.version}`);
+  } catch (e) {
+    console.error(`Error: ${e.message}`);
+    console.error('Make sure autocode server is running');
+    process.exit(1);
+  }
+}
+
+// ============================================
+// catalog - List available columns
+// ============================================
+async function catalogCmd() {
+  const subCmd = commandArgs[0];
+
+  // Handle 'catalog add' subcommand
+  if (subCmd === 'add') {
+    await catalogAddCmd(commandArgs.slice(1));
+    return;
+  }
+
+  const jsonOutput = commandArgs.includes('--json');
+
+  try {
+    const res = await fetch(`${getApiBase()}/api/catalog`);
+
+    if (!res.ok) {
+      console.error('Failed to get catalog');
+      process.exit(1);
+    }
+
+    const catalog = await res.json();
+
+    if (jsonOutput) {
+      console.log(JSON.stringify(catalog, null, 2));
+      return;
+    }
+
+    const segmentDescriptions = {
+      definition: 'Define what needs to be done',
+      action: 'Execute the work',
+      finish: 'Validate and complete'
+    };
+
+    let totalCount = 0;
+
+    // Handle both formats: array or { segments: {...} }
+    const segments = catalog.segments || catalog;
+    const segmentEntries = Array.isArray(segments)
+      ? segments.map(s => [s.segment, s])
+      : Object.entries(segments);
+
+    for (const [segmentName, segmentData] of segmentEntries) {
+      console.log();
+      console.log(`\x1b[1m${segmentName.toUpperCase()}\x1b[0m`);
+      console.log(`\x1b[2m${segmentDescriptions[segmentName] || segmentData.description || ''}\x1b[0m`);
+      console.log('─'.repeat(60));
+
+      const columns = segmentData.columns || [];
+      for (const column of columns) {
+        const slug = `\x1b[36m${column.slug.padEnd(25)}\x1b[0m`;
+        const name = (column.name || '').padEnd(30);
+        const desc = column.description?.substring(0, 40) + (column.description?.length > 40 ? '...' : '') || '';
+        console.log(`  ${slug} ${name} \x1b[2m${desc}\x1b[0m`);
+        totalCount++;
+      }
+    }
+
+    console.log();
+    console.log(`Total: ${totalCount} column(s) available`);
+  } catch (e) {
+    console.error(`Error: ${e.message}`);
+    console.error('Make sure autocode server is running');
+    process.exit(1);
+  }
+}
+
+// catalog add <slug>
+async function catalogAddCmd(args) {
+  const slug = args.find(a => !a.startsWith('-'));
+  const segment = getArgOption(args, '--segment');
+  const name = getArgOption(args, '--name') || slugToName(slug || '');
+  const description = getArgOption(args, '--description');
+
+  if (!slug || !segment) {
+    console.error('Usage: autocode catalog add <slug> --segment <definition|action|finish> [--name "..."] [--description "..."]');
+    process.exit(1);
+  }
+
+  if (!['definition', 'action', 'finish'].includes(segment)) {
+    console.error('Segment must be: definition, action, or finish');
+    process.exit(1);
+  }
+
+  try {
+    const body = { slug, name, segment };
+    if (description) body.description = description;
+
+    const res = await fetch(`${getApiBase()}/api/catalog`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(body)
+    });
+
+    if (!res.ok) {
+      const err = await res.json().catch(() => ({}));
+      console.error(`Failed: ${err.message || res.statusText}`);
+      process.exit(1);
+    }
+
+    console.log(`✓ Added to catalog: ${slug} (${segment} segment)`);
+    console.log(`  Name: ${name}`);
+    if (description) console.log(`  Description: ${description}`);
+  } catch (e) {
+    console.error(`Error: ${e.message}`);
+    console.error('Make sure autocode server is running');
+    process.exit(1);
+  }
+}
+
+// Main
+switch (command) {
+  case 'serve':
+  case undefined:
+    startServer();
+    break;
+  case 'show':
+    showCmd();
+    break;
+  case 'history':
+    historyCmd();
+    break;
+  case 'list':
+  case 'ls':
+    listCmd();
+    break;
+  case 'comment':
+    commentCmd();
+    break;
+  case 'start':
+    startCmd();
+    break;
+  case 'next':
+    nextCmd();
+    break;
+  case 'move':
+    moveCmd();
+    break;
+  case 'new':
+    newCmd();
+    break;
+  case 'parent':
+    parentCmd();
+    break;
+  case 'health':
+    healthCmd();
+    break;
+  case 'stats':
+    statsCmd();
+    break;
+  case 'init':
+    initCmd();
+    break;
+  case 'catalog':
+    catalogCmd();
+    break;
+  case 'pipeline':
+    pipelineCmd();
+    break;
+  case 'help':
+  case '--help':
+  case '-h':
+    showHelp();
+    break;
+  default:
+    // Check if it's an issue key shortcut - show issue details
+    if (command.match(/^AC-\d{6}$/)) {
+      commandArgs.unshift(command);
+      showCmd();
+    } else {
+      console.error(`Unknown command: ${command}`);
+      showHelp();
+      process.exit(1);
+    }
+}