@vibedx/vibekit 0.6.4 → 0.7.0

package/assets/config.yml

@@ -24,6 +24,9 @@ tickets:
 team:
   path: .vibe/team.yml
 
+agent:
+  timeout: 900
+
 ai:
   enabled: false
 

package/index.js

@@ -23,7 +23,8 @@ const __dirname = dirname(__filename);
 // Available commands in VibeKit
 const AVAILABLE_COMMANDS = [
   'init', 'new', 'close', 'list', 'get-started',
-  'start', 'link', 'unlink', 'refine', 'lint', 'review', 'team', 'skills'
+  'start', 'link', 'unlink', 'refine', 'lint', 'review', 'team', 'skills',
+  'status', 'pr'
 ];
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibedx/vibekit",
-  "version": "0.6.4",
+  "version": "0.7.0",
   "description": "A powerful CLI tool for managing development tickets and project workflows",
   "main": "index.js",
   "type": "module",

package/src/commands/pr/index.js

@@ -0,0 +1,259 @@
+import fs from 'fs';
+import path from 'path';
+import yaml from 'js-yaml';
+import { execSync } from 'child_process';
+import { getTicketsDir, getConfig } from '../../utils/index.js';
+import {
+  isGitRepository,
+  getCurrentBranch,
+  getDefaultBaseBranch,
+  listWorktrees,
+  getRepoRoot
+} from '../../utils/git.js';
+
+function parseArgs(args) {
+  const flags = {};
+  const ids = [];
+
+  let i = 0;
+  while (i < args.length) {
+    const arg = args[i];
+    if (arg === '--all' || arg === '-a') {
+      flags.all = true;
+      i++;
+    } else if (arg === '--base' && i + 1 < args.length) {
+      flags.baseBranch = args[i + 1];
+      i += 2;
+    } else if (arg === '--draft' || arg === '-d') {
+      flags.draft = true;
+      i++;
+    } else if (arg === '--dry-run') {
+      flags.dryRun = true;
+      i++;
+    } else if (!arg.startsWith('-')) {
+      ids.push(arg);
+      i++;
+    } else {
+      i++;
+    }
+  }
+  return { ids, flags };
+}
+
+function normalizeTicketId(input) {
+  if (input.startsWith('TKT-')) return input;
+  if (/^\d+$/.test(input)) return `TKT-${input.padStart(3, '0')}`;
+  return null;
+}
+
+function findTicketForBranch(ticketsDir, branch) {
+  const files = fs.readdirSync(ticketsDir).filter(f => f.endsWith('.md'));
+  for (const file of files) {
+    const filePath = path.join(ticketsDir, file);
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const match = content.match(/^---\n([\s\S]*?)\n---/);
+    if (match) {
+      const fm = yaml.load(match[1]);
+      const slug = fm.slug || '';
+      if (branch.includes(fm.id) || branch.includes(slug)) {
+        const body = content.split('---').slice(2).join('---').trim();
+        return { frontmatter: fm, body, filePath };
+      }
+    }
+  }
+  return null;
+}
+
+function loadTicket(ticketsDir, ticketId) {
+  const files = fs.readdirSync(ticketsDir).filter(f => f.startsWith(`${ticketId}-`));
+  if (files.length === 0) return null;
+  const filePath = path.join(ticketsDir, files[0]);
+  const content = fs.readFileSync(filePath, 'utf-8');
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return null;
+  const fm = yaml.load(match[1]);
+  const body = content.split('---').slice(2).join('---').trim();
+  return { frontmatter: fm, body, filePath };
+}
+
+function hasRemote() {
+  try {
+    execSync('git remote get-url origin', { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function pushBranch(branch, cwd) {
+  try {
+    execSync(`git push -u origin ${branch}`, { cwd, stdio: 'pipe' });
+    return true;
+  } catch (error) {
+    console.error(`  ❌ Failed to push ${branch}: ${error.message}`);
+    return false;
+  }
+}
+
+function createPR(branch, baseBranch, title, body, draft, cwd) {
+  const draftFlag = draft ? ' --draft' : '';
+  const safeTitle = title.replace(/"/g, '\\"');
+  const safeBody = body.replace(/'/g, "'\\''");
+  try {
+    const result = execSync(
+      `gh pr create --head "${branch}" --base "${baseBranch}" --title "${safeTitle}"${draftFlag} --body '${safeBody}'`,
+      { cwd, encoding: 'utf-8' }
+    );
+    return result.trim();
+  } catch (error) {
+    if (error.message.includes('already exists')) {
+      try {
+        const existing = execSync(`gh pr view "${branch}" --json url -q .url`, { cwd, encoding: 'utf-8' });
+        return existing.trim() + ' (already existed)';
+      } catch {
+        return null;
+      }
+    }
+    console.error(`  ❌ Failed to create PR: ${error.message}`);
+    return null;
+  }
+}
+
+function buildPRBody(ticket) {
+  if (!ticket) return 'No ticket context found.';
+
+  const fm = ticket.frontmatter;
+  const sections = [];
+  sections.push(`## ${fm.id}: ${fm.title}`);
+  if (fm.priority) sections.push(`**Priority:** ${fm.priority}`);
+  if (fm.assignee) sections.push(`**Assignee:** ${fm.assignee}`);
+  sections.push('');
+  sections.push(ticket.body);
+  return sections.join('\n');
+}
+
+function getBranchCwd(worktrees, branch) {
+  const wt = worktrees.find(w => w.branch === branch);
+  return wt ? wt.path : null;
+}
+
+async function prCommand(args) {
+  if (!isGitRepository()) {
+    console.error('❌ Not in a git repository.');
+    process.exit(1);
+  }
+
+  if (!hasRemote()) {
+    console.error('❌ No git remote "origin" found. Push your repo to GitHub first.');
+    process.exit(1);
+  }
+
+  try {
+    execSync('gh --version', { stdio: 'ignore' });
+  } catch {
+    console.error('❌ GitHub CLI (gh) is required. Install it: https://cli.github.com');
+    process.exit(1);
+  }
+
+  const { ids, flags } = parseArgs(args);
+  const config = getConfig();
+  const ticketsDir = getTicketsDir();
+  const baseBranch = flags.baseBranch || config.git?.default_base || getDefaultBaseBranch();
+  const worktrees = listWorktrees();
+  const repoRoot = getRepoRoot();
+
+  let branches = [];
+
+  if (flags.all) {
+    // Gather all worktree branches (excluding the main worktree)
+    const mainRoot = repoRoot;
+    branches = worktrees
+      .filter(wt => wt.branch && wt.path !== mainRoot && wt.branch !== baseBranch)
+      .map(wt => ({ branch: wt.branch, cwd: wt.path }));
+
+    if (branches.length === 0) {
+      console.error('❌ No worktree branches found. Use `vibe plan` to create them.');
+      process.exit(1);
+    }
+  } else if (ids.length > 0) {
+    // Look up branches for specific ticket IDs
+    for (const id of ids) {
+      const ticketId = normalizeTicketId(id);
+      if (!ticketId) {
+        console.error(`❌ Invalid ticket ID: ${id}`);
+        process.exit(1);
+      }
+      const ticket = loadTicket(ticketsDir, ticketId);
+      if (!ticket) {
+        console.error(`❌ Ticket ${ticketId} not found.`);
+        process.exit(1);
+      }
+      const branchPrefix = config.git?.branch_prefix || '';
+      const slug = ticket.frontmatter.slug || ticket.frontmatter.id;
+      const branchName = slug.includes(ticket.frontmatter.id)
+        ? `${branchPrefix}${slug}`
+        : `${branchPrefix}${ticket.frontmatter.id}-${slug}`;
+
+      const wtCwd = getBranchCwd(worktrees, branchName);
+      branches.push({ branch: branchName, cwd: wtCwd || repoRoot, ticketId });
+    }
+  } else {
+    // Current branch
+    const currentBranch = getCurrentBranch();
+    if (!currentBranch || currentBranch === baseBranch) {
+      console.error(`❌ You're on ${currentBranch || 'a detached HEAD'}. Switch to a feature branch or specify ticket IDs.`);
+      console.error('');
+      console.error('Usage: vibe pr [TKT-001 ...] [--all] [--draft] [--base main]');
+      process.exit(1);
+    }
+    branches.push({ branch: currentBranch, cwd: repoRoot });
+  }
+
+  console.log(`\n📝 Opening ${branches.length} PR(s) against ${baseBranch}:\n`);
+
+  if (flags.dryRun) {
+    for (const { branch } of branches) {
+      const ticket = findTicketForBranch(ticketsDir, branch);
+      const title = ticket ? `${ticket.frontmatter.id}: ${ticket.frontmatter.title}` : branch;
+      console.log(`  ${branch} → "${title}"`);
+    }
+    console.log('\n🏁 Dry run complete. No PRs created.');
+    return;
+  }
+
+  const results = [];
+  for (const { branch, cwd } of branches) {
+    const ticket = findTicketForBranch(ticketsDir, branch);
+    const title = ticket ? `${ticket.frontmatter.id}: ${ticket.frontmatter.title}` : branch;
+    const body = buildPRBody(ticket);
+
+    console.log(`  📤 ${branch}`);
+
+    if (!pushBranch(branch, cwd)) continue;
+
+    const prUrl = createPR(branch, baseBranch, title, body, flags.draft, cwd);
+    if (prUrl) {
+      console.log(`  ✅ ${prUrl}`);
+      results.push({ branch, url: prUrl });
+
+      // Update ticket status to review
+      if (ticket) {
+        try {
+          const currentContent = fs.readFileSync(ticket.filePath, 'utf-8');
+          const now = new Date().toISOString();
+          const updatedContent = currentContent
+            .replace(/^status: (.+)$/m, 'status: review')
+            .replace(/^updated_at: (.+)$/m, `updated_at: "${now}"`);
+          fs.writeFileSync(ticket.filePath, updatedContent, 'utf-8');
+        } catch {
+          // Non-critical — skip
+        }
+      }
+    }
+    console.log('');
+  }
+
+  console.log(`🏁 Done! ${results.length}/${branches.length} PR(s) opened.`);
+}
+
+export default prCommand;

package/src/commands/pr/index.test.js

@@ -0,0 +1,139 @@
+import { jest } from '@jest/globals';
+import fs from 'fs';
+import path from 'path';
+
+jest.unstable_mockModule('child_process', () => ({
+  execSync: jest.fn()
+}));
+
+jest.unstable_mockModule('../../utils/index.js', () => ({
+  getTicketsDir: jest.fn(),
+  getConfig: jest.fn(() => ({ git: { branch_prefix: 'feature/', default_base: 'main' } }))
+}));
+
+jest.unstable_mockModule('../../utils/git.js', () => ({
+  isGitRepository: jest.fn(() => true),
+  getCurrentBranch: jest.fn(() => 'feature/TKT-001-add-login'),
+  getDefaultBaseBranch: jest.fn(() => 'main'),
+  listWorktrees: jest.fn(() => []),
+  getRepoRoot: jest.fn(() => '/tmp/test-repo')
+}));
+
+const { default: prCommand } = await import('./index.js');
+const { getTicketsDir } = await import('../../utils/index.js');
+const { isGitRepository, getCurrentBranch, listWorktrees, getRepoRoot } = await import('../../utils/git.js');
+const childProcess = await import('child_process');
+
+const TICKET_CONTENT = `---
+id: TKT-001
+title: Add login page
+slug: TKT-001-add-login-page
+status: in_progress
+priority: high
+assignee: dev1
+author: pm
+created_at: "2026-01-01T00:00:00Z"
+updated_at: "2026-01-01T00:00:00Z"
+---
+
+## Description
+Add a login page.
+`;
+
+describe('pr command', () => {
+  let tempDir;
+  let mockExit;
+  let mockConsoleLog;
+  let mockConsoleError;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join('/tmp', 'vibe-pr-test-'));
+    const ticketsDir = path.join(tempDir, '.vibe', 'tickets');
+    fs.mkdirSync(ticketsDir, { recursive: true });
+    fs.writeFileSync(path.join(ticketsDir, 'TKT-001-add-login-page.md'), TICKET_CONTENT);
+
+    getTicketsDir.mockReturnValue(ticketsDir);
+    mockExit = jest.spyOn(process, 'exit').mockImplementation(() => { throw new Error('process.exit'); });
+    mockConsoleLog = jest.spyOn(console, 'log').mockImplementation(() => {});
+    mockConsoleError = jest.spyOn(console, 'error').mockImplementation(() => {});
+
+    // Default: gh is installed, origin exists
+    childProcess.execSync.mockImplementation((cmd) => {
+      if (cmd === 'gh --version') return 'gh version 2.0.0';
+      if (cmd.includes('remote get-url')) return 'git@github.com:org/repo.git';
+      if (cmd.includes('git push')) return '';
+      if (cmd.includes('gh pr create')) return 'https://github.com/org/repo/pull/1';
+      return '';
+    });
+  });
+
+  afterEach(() => {
+    mockExit.mockRestore();
+    mockConsoleLog.mockRestore();
+    mockConsoleError.mockRestore();
+    fs.rmSync(tempDir, { recursive: true, force: true });
+    jest.clearAllMocks();
+  });
+
+  test('exits if not in git repo', async () => {
+    isGitRepository.mockReturnValueOnce(false);
+    await expect(prCommand([])).rejects.toThrow('process.exit');
+    expect(mockConsoleError).toHaveBeenCalledWith('❌ Not in a git repository.');
+  });
+
+  test('exits if no remote', async () => {
+    childProcess.execSync.mockImplementation((cmd) => {
+      if (cmd.includes('remote get-url')) throw new Error('no remote');
+      return '';
+    });
+    await expect(prCommand([])).rejects.toThrow('process.exit');
+    expect(mockConsoleError).toHaveBeenCalledWith(expect.stringContaining('No git remote'));
+  });
+
+  test('exits if gh not installed', async () => {
+    childProcess.execSync.mockImplementation((cmd) => {
+      if (cmd === 'gh --version') throw new Error('not found');
+      if (cmd.includes('remote get-url')) return 'git@github.com:org/repo.git';
+      return '';
+    });
+    await expect(prCommand([])).rejects.toThrow('process.exit');
+    expect(mockConsoleError).toHaveBeenCalledWith(expect.stringContaining('GitHub CLI'));
+  });
+
+  test('creates PR for current branch', async () => {
+    await prCommand([]);
+    expect(childProcess.execSync).toHaveBeenCalledWith(
+      expect.stringContaining('gh pr create'),
+      expect.any(Object)
+    );
+    expect(mockConsoleLog).toHaveBeenCalledWith(expect.stringContaining('https://github.com'));
+  });
+
+  test('dry run shows branches without creating PRs', async () => {
+    await prCommand(['--dry-run']);
+    expect(mockConsoleLog).toHaveBeenCalledWith(expect.stringContaining('Dry run complete'));
+    const prCreateCalls = childProcess.execSync.mock.calls.filter(([cmd]) =>
+      typeof cmd === 'string' && cmd.includes('gh pr create')
+    );
+    expect(prCreateCalls.length).toBe(0);
+  });
+
+  test('errors when on base branch with no args', async () => {
+    getCurrentBranch.mockReturnValueOnce('main');
+    await expect(prCommand([])).rejects.toThrow('process.exit');
+    expect(mockConsoleError).toHaveBeenCalledWith(expect.stringContaining("You're on main"));
+  });
+
+  test('--all collects worktree branches', async () => {
+    listWorktrees.mockReturnValueOnce([
+      { path: '/tmp/test-repo', branch: 'main' },
+      { path: '/tmp/wt-1', branch: 'feature/TKT-001-login' },
+      { path: '/tmp/wt-2', branch: 'feature/TKT-002-signup' }
+    ]);
+    getRepoRoot.mockReturnValueOnce('/tmp/test-repo');
+
+    await prCommand(['--all']);
+    const prCalls = childProcess.execSync.mock.calls.filter(([cmd]) => cmd.includes('gh pr create'));
+    expect(prCalls.length).toBe(2);
+  });
+});

package/src/commands/start/index.js

@@ -1,6 +1,7 @@
 import fs from 'fs';
 import path from 'path';
 import yaml from 'js-yaml';
+import { execSync, spawn } from 'child_process';
 import { getTicketsDir, getConfig, createSlug } from '../../utils/index.js';
 import {
   isGitRepository,
@@ -13,230 +14,341 @@ import {
   getRepoName,
   getWorktreePath,
   createWorktree,
-  createWorktreeExistingBranch
+  createWorktreeExistingBranch,
+  getRepoRoot,
+  getDefaultBaseBranch
 } from '../../utils/git.js';
 
+function parseTicketIds(args) {
+  const ids = [];
+  const flags = {};
+  let i = 0;
+  while (i < args.length) {
+    const arg = args[i];
+    if (arg === '--base' && i + 1 < args.length) {
+      flags.baseBranch = args[i + 1];
+      i += 2;
+    } else if (arg === '--dry-run') {
+      flags.dryRun = true;
+      i++;
+    } else if (arg === '--no-install') {
+      flags.noInstall = true;
+      i++;
+    } else if (arg === '--agent') {
+      flags.agent = true;
+      i++;
+    } else if (arg === '--worktree' || arg === '-w') {
+      flags.worktree = true;
+      i++;
+    } else if (arg === '--update-status' || arg === '-u') {
+      flags.updateStatus = true;
+      i++;
+    } else if (arg === '--prompt' && i + 1 < args.length) {
+      flags.prompt = args[i + 1];
+      i += 2;
+    } else if (arg.startsWith('--status=')) {
+      flags.statusFilter = arg.split('=')[1];
+      i++;
+    } else if (!arg.startsWith('-')) {
+      ids.push(arg);
+      i++;
+    } else {
+      i++;
+    }
+  }
+  return { ids, flags };
+}
+
+function normalizeTicketId(input) {
+  if (input.startsWith('TKT-')) return input;
+  if (/^\d+$/.test(input)) return `TKT-${input.padStart(3, '0')}`;
+  return null;
+}
+
+function loadTicket(ticketsDir, ticketId) {
+  const files = fs.readdirSync(ticketsDir).filter(f => f.startsWith(`${ticketId}-`));
+  if (files.length === 0) return null;
+  const filePath = path.join(ticketsDir, files[0]);
+  const content = fs.readFileSync(filePath, 'utf-8');
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return null;
+  const frontmatter = yaml.load(match[1]);
+  return { frontmatter, content, filePath, fileName: files[0] };
+}
+
+function loadTicketsByStatus(ticketsDir, status) {
+  const files = fs.readdirSync(ticketsDir).filter(f => f.endsWith('.md'));
+  const tickets = [];
+  for (const file of files) {
+    const filePath = path.join(ticketsDir, file);
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const match = content.match(/^---\n([\s\S]*?)\n---/);
+    if (match) {
+      const frontmatter = yaml.load(match[1]);
+      if (frontmatter.status === status) {
+        tickets.push({ frontmatter, content, filePath, fileName: file });
+      }
+    }
+  }
+  return tickets;
+}
+
+function getBranchName(ticket, config) {
+  const branchPrefix = config.git?.branch_prefix || '';
+  const slug = String(ticket.frontmatter.slug || ticket.frontmatter.id);
+  return slug.includes(ticket.frontmatter.id)
+    ? `${branchPrefix}${slug}`
+    : `${branchPrefix}${ticket.frontmatter.id}-${slug}`;
+}
+
+function updateTicketStatus(ticket, worktreePath) {
+  const now = new Date().toISOString();
+  let updatedContent = ticket.content;
+
+  if (updatedContent.match(/^worktree_path: .+$/m)) {
+    updatedContent = updatedContent.replace(/^worktree_path: .+$/m, `worktree_path: "${worktreePath}"`);
+  } else {
+    updatedContent = updatedContent.replace(/^(updated_at: .+)$/m, `$1\nworktree_path: "${worktreePath}"`);
+  }
+
+  updatedContent = updatedContent
+    .replace(/^status: (.+)$/m, 'status: in_progress')
+    .replace(/^updated_at: (.+)$/m, `updated_at: "${now}"`);
+
+  fs.writeFileSync(ticket.filePath, updatedContent, 'utf-8');
+}
+
 /**
- * Start working on a ticket by checking out its branch
+ * Start working on ticket(s) by checking out branches or creating worktrees
  * @param {string[]} args Command arguments
  */
 function startCommand(args) {
-  // Check if we're in a git repository
   if (!isGitRepository()) {
-    console.error('❌ Not in a git repository. Please run this command from within a git repository.');
+    console.error('❌ Not in a git repository.');
     process.exit(1);
   }
-  
-  // Parse arguments
-  if (args.length === 0) {
-    console.error('❌ Please provide a ticket ID (e.g., vibe start TKT-006)');
+
+  const { ids, flags } = parseTicketIds(args);
+
+  if (ids.length === 0 && !flags.statusFilter) {
+    console.error('❌ Usage: vibe start <TKT-001> [<TKT-002> ...] [-w] [--agent] [--base main] [--dry-run]');
+    console.error('');
+    console.error('Start working on tickets. Without -w, checks out branch locally. With -w, creates worktrees.');
+    console.error('');
+    console.error('Options:');
+    console.error('  -w, --worktree     Create worktrees for tickets');
+    console.error('  --agent            Spawn Claude agents to work on tickets');
+    console.error('  --status=<status>  Start all tickets with this status (e.g. --status=open)');
+    console.error('  --base <branch>    Base branch for new branches/worktrees (default: main)');
+    console.error('  --dry-run          Show what would happen without doing it');
+    console.error('  --no-install       Skip npm install in worktrees');
     process.exit(1);
   }
-  
-  // Extract ticket ID and options
-  let ticketId = args[0];
-  let baseBranch = null;
-  let updateStatus = true;
-  let useWorktree = false;
-
-  // Process additional arguments
-  for (let i = 1; i < args.length; i++) {
-    if (args[i] === '--base' && i + 1 < args.length) {
-      baseBranch = args[i + 1];
-      i++;
-    } else if (args[i] === '--update-status' || args[i] === '-u') {
-      updateStatus = true;
-    } else if (args[i] === '--worktree' || args[i] === '-w') {
-      useWorktree = true;
+
+  const config = getConfig();
+  const ticketsDir = getTicketsDir();
+  const repoName = getRepoName();
+  const repoRoot = getRepoRoot();
+
+  let tickets = [];
+
+  if (flags.statusFilter) {
+    tickets = loadTicketsByStatus(ticketsDir, flags.statusFilter);
+    if (tickets.length === 0) {
+      console.error(`❌ No tickets found with status: ${flags.statusFilter}`);
+      process.exit(1);
     }
+    console.log(`📋 Found ${tickets.length} ticket(s) with status "${flags.statusFilter}"`);
   }
-  
-  // Normalize ticket ID format (add TKT- prefix if not present)
-  if (!ticketId.startsWith('TKT-')) {
-    // Check if it's just a number
-    if (/^\d+$/.test(ticketId)) {
-      ticketId = `TKT-${ticketId.padStart(3, '0')}`;
-    } else {
-      console.error('❌ Invalid ticket ID format. Expected TKT-XXX or just the number.');
+
+  for (const id of ids) {
+    const ticketId = normalizeTicketId(id);
+    if (!ticketId) {
+      console.error(`❌ Invalid ticket ID: ${id}`);
+      process.exit(1);
+    }
+    const ticket = loadTicket(ticketsDir, ticketId);
+    if (!ticket) {
+      console.error(`❌ Ticket ${ticketId} not found.`);
       process.exit(1);
     }
+    if (!tickets.find(t => t.frontmatter.id === ticket.frontmatter.id)) {
+      tickets.push(ticket);
+    }
   }
-  
-  // Get configuration
-  const config = getConfig();
-  const ticketsDir = getTicketsDir();
-  
-  // Check if the ticket exists
-  const ticketFiles = fs.readdirSync(ticketsDir).filter(file => file.startsWith(`${ticketId}-`));
-  
-  if (ticketFiles.length === 0) {
-    console.error(`❌ Ticket ${ticketId} not found.`);
+
+  if (tickets.length === 0) {
+    console.error('❌ No tickets to start.');
     process.exit(1);
   }
-  
-  const ticketFile = ticketFiles[0];
-  const ticketPath = path.join(ticketsDir, ticketFile);
-  
-  // Read the ticket content to get the title and slug
-  const ticketContent = fs.readFileSync(ticketPath, 'utf-8');
-  const titleMatch = ticketContent.match(/title: (.+)/);
-  const title = titleMatch ? titleMatch[1].trim() : '';
-  
-  // Look for the slug in the frontmatter
-  const slugMatch = ticketContent.match(/slug: (.+)/);
-  let slug;
-  
-  if (slugMatch && slugMatch[1].trim()) {
-    // Use the slug from the ticket file
-    slug = slugMatch[1].trim();
-  } else {
-    // Generate a slug from the title as fallback
-    slug = `${ticketId}-${createSlug(title)}`;
-    console.log(`⚠️  No slug found in ticket. Generated slug: ${slug}`);
-    
-    // Update the ticket with the generated slug
-    try {
-      let updatedContent = ticketContent;
-      if (updatedContent.includes('slug:')) {
-        updatedContent = updatedContent.replace(/slug:.*/, `slug: ${slug}`);
-      } else {
-        updatedContent = updatedContent.replace(/---/, `---\nslug: ${slug}`);
-      }
-      
-      fs.writeFileSync(ticketPath, updatedContent, 'utf-8');
-      console.log(`✅ Updated ticket with slug: ${slug}`);
-    } catch (error) {
-      console.error(`❌ Failed to update ticket with slug: ${error.message}`);
-    }
+
+  const useWorktree = flags.worktree;
+  const spawnAgent = flags.agent;
+
+  if (spawnAgent && !useWorktree && tickets.length > 1) {
+    console.error('❌ --agent without -w only supports a single ticket. Use -w for multiple tickets.');
+    process.exit(1);
   }
-  
-  // Get branch prefix from config or use default (empty)
-  const branchPrefix = config.git?.branch_prefix || '';
-  
-  // Create branch name - if slug already contains the ticket ID, don't add it again
-  const branchName = slug.includes(ticketId) 
-    ? `${branchPrefix}${slug}` 
-    : `${branchPrefix}${ticketId}-${slug}`;
-  
-  if (useWorktree) {
-    const repoName = getRepoName();
-    const worktreePath = getWorktreePath(repoName, branchName);
 
-    if (fs.existsSync(worktreePath)) {
-      console.log(`🔍 Worktree already exists at: ${worktreePath}`);
-      console.log(`✅ Ready to work in: ${worktreePath}`);
+  console.log('');
+  console.log(`🚀 Starting ${tickets.length} ticket(s):\n`);
+
+  const worktreeInfos = [];
+
+  for (const ticket of tickets) {
+    const branchName = getBranchName(ticket, config);
+    const title = ticket.frontmatter.title || 'Untitled';
+
+    if (useWorktree) {
+      const worktreePath = getWorktreePath(repoName, branchName);
+      worktreeInfos.push({
+        ticket,
+        branchName,
+        worktreePath,
+        title,
+        alreadyExists: fs.existsSync(worktreePath)
+      });
+      const status = fs.existsSync(worktreePath) ? '(exists)' : '(new)';
+      console.log(`  ${ticket.frontmatter.id} — ${title}`);
+      console.log(`    🌿 ${branchName} ${status}`);
+      console.log(`    📂 ${worktreePath}`);
     } else {
-      const branchExistsLocal = branchExistsLocally(branchName);
-      const branchExistsRemote = branchExistsRemotely(branchName);
+      console.log(`  ${ticket.frontmatter.id} — ${title}`);
+      console.log(`    🌿 ${branchName}`);
+    }
+    console.log('');
+  }
+
+  if (flags.dryRun) {
+    console.log('🏁 Dry run complete. No changes made.');
+    return;
+  }
+
+  if (useWorktree) {
+    for (const info of worktreeInfos) {
+      if (info.alreadyExists) {
+        console.log(`✅ ${info.ticket.frontmatter.id}: Worktree already exists`);
+        continue;
+      }
 
       try {
-        if (branchExistsLocal || branchExistsRemote) {
-          console.log(`🔍 Creating worktree for existing branch: ${branchName}`);
-          createWorktreeExistingBranch(worktreePath, branchName);
+        const branchExists = branchExistsLocally(info.branchName) || branchExistsRemotely(info.branchName);
+        if (branchExists) {
+          createWorktreeExistingBranch(info.worktreePath, info.branchName);
         } else {
-          console.log(`🔍 Creating worktree with new branch: ${branchName}`);
-          createWorktree(worktreePath, branchName, baseBranch);
+          createWorktree(info.worktreePath, info.branchName, flags.baseBranch);
         }
-        console.log(`✅ Worktree created at: ${worktreePath}`);
+        console.log(`✅ ${info.ticket.frontmatter.id}: Worktree created`);
       } catch (error) {
-        console.error(`❌ Failed to create worktree: ${error.message}`);
-        process.exit(1);
+        console.error(`❌ ${info.ticket.frontmatter.id}: Failed to create worktree — ${error.message}`);
+        continue;
       }
-    }
 
-    // Store worktree_path in ticket frontmatter
-    try {
-      const currentContent = fs.readFileSync(ticketPath, 'utf-8');
-      const now = new Date().toISOString();
-      let updatedContent = currentContent;
+      updateTicketStatus(info.ticket, info.worktreePath);
+    }
 
-      if (updatedContent.match(/^worktree_path: .+$/m)) {
-        updatedContent = updatedContent.replace(/^worktree_path: .+$/m, `worktree_path: "${worktreePath}"`);
-      } else {
-        updatedContent = updatedContent.replace(/^(updated_at: .+)$/m, `$1\nworktree_path: "${worktreePath}"`);
+    if (!flags.noInstall) {
+      const pkgExists = fs.existsSync(path.join(repoRoot, 'package.json'));
+      if (pkgExists) {
+        console.log('\n📦 Installing dependencies in worktrees...');
+        for (const info of worktreeInfos) {
+          if (fs.existsSync(path.join(info.worktreePath, 'package.json'))) {
+            try {
+              execSync('npm install --silent', { cwd: info.worktreePath, stdio: 'ignore' });
+              console.log(`  ✅ ${info.ticket.frontmatter.id}: npm install done`);
+            } catch (error) {
+              console.warn(`  ⚠️  ${info.ticket.frontmatter.id}: npm install failed — ${error.message}`);
+            }
+          }
+        }
       }
+    }
 
-      if (updateStatus) {
-        updatedContent = updatedContent
-          .replace(/^status: (.+)$/m, 'status: in_progress')
-          .replace(/^updated_at: (.+)$/m, `updated_at: "${now}"`);
-      }
+    if (spawnAgent) {
+      const agentTimeout = config.worktree?.agent?.timeout || 900;
+      console.log('\n🤖 Spawning Claude agents...\n');
+      for (const info of worktreeInfos) {
+        const ticketContent = fs.readFileSync(info.ticket.filePath, 'utf-8');
+        const prompt = flags.prompt
+          ? flags.prompt
+          : `You are working on ticket ${info.ticket.frontmatter.id}: ${info.title}\n\nHere is the full ticket:\n\n${ticketContent}\n\nImplement the ticket requirements. Follow the acceptance criteria. Commit your work when done. Update the ticket status to done when complete.`;
+
+        try {
+          const agentProcess = spawn('claude', ['-p', prompt, '--timeout', String(agentTimeout * 1000)], {
+            cwd: info.worktreePath,
+            stdio: 'ignore',
+            detached: true
+          });
 
-      fs.writeFileSync(ticketPath, updatedContent, 'utf-8');
-      if (updateStatus) {
-        console.log(`✅ Updated ticket status to: in_progress`);
+          agentProcess.unref();
+          console.log(`  🤖 ${info.ticket.frontmatter.id}: Agent spawned in ${info.worktreePath} (timeout: ${agentTimeout}s)`);
+        } catch (error) {
+          console.error(`  ❌ ${info.ticket.frontmatter.id}: Failed to spawn agent — ${error.message}`);
+        }
       }
-    } catch (error) {
-      console.error(`❌ Failed to update ticket: ${error.message}`);
-    }
 
-    console.log('');
-    console.log(`🎯 Now working on: ${ticketId} - ${title}`);
-    console.log(`🌿 Branch: ${branchName}`);
-    console.log(`📂 Worktree: ${worktreePath}`);
-    console.log('');
-    console.log('To start working in the worktree:');
-    console.log(`  cd ${worktreePath}`);
-    console.log('');
-    console.log('💡 Run `npm install` in the worktree to install dependencies.');
-  } else {
-    // Check if there are uncommitted changes
-    const gitStatus = getGitStatus();
-    if (gitStatus) {
-      console.warn('⚠️  You have uncommitted changes. Stash or commit them before switching branches.');
+      console.log('\n🏁 All agents launched!\n');
+      console.log('Monitor progress:');
+      console.log('  vibe status          # see active worktree work');
+      console.log('  vibe list --status=in_progress # see in-progress tickets');
+    } else {
+      console.log('\n🏁 Worktrees created!\n');
+      console.log('To work in a worktree:');
+      console.log(`  cd ${worktreeInfos[0]?.worktreePath || '<worktree-path>'}`);
       console.log('');
+      console.log('When done:');
+      console.log('  vibe pr --all        # open PRs for all worktree branches');
     }
+  } else {
+    for (const ticket of tickets) {
+      const branchName = getBranchName(ticket, config);
+      const branchExistsLocal = branchExistsLocally(branchName);
+      const branchExistsRemote = branchExistsRemotely(branchName);
 
-    // Check if the branch already exists
-    const branchExistsLocal = branchExistsLocally(branchName);
-    const branchExistsRemote = branchExistsRemotely(branchName);
-
-    if (branchExistsLocal || branchExistsRemote) {
-      console.log(`🔍 Branch ${branchName} already exists.`);
-
-      if (checkoutBranch(branchName)) {
-        console.log(`✅ Switched to branch: ${branchName}`);
+      if (branchExistsLocal || branchExistsRemote) {
+        console.log(`🔍 ${ticket.frontmatter.id}: Branch exists`);
       } else {
-        console.error(`❌ Failed to switch to branch: ${branchName}`);
-        process.exit(1);
+        try {
+          createAndCheckoutBranch(branchName, flags.baseBranch);
+          console.log(`✅ ${ticket.frontmatter.id}: Created branch ${branchName}`);
+        } catch (error) {
+          console.error(`❌ ${ticket.frontmatter.id}: Failed to create branch — ${error.message}`);
+        }
       }
-    } else {
-      console.log(`🔍 Creating new branch: ${branchName}`);
 
-      if (createAndCheckoutBranch(branchName, baseBranch)) {
-        console.log(`✅ Created and switched to branch: ${branchName}`);
-      } else {
-        console.error(`❌ Failed to create branch: ${branchName}`);
-        process.exit(1);
-      }
+      updateTicketStatus(ticket, null);
     }
 
-    // Update ticket status if requested
-    if (updateStatus) {
-      try {
-        const currentContent = fs.readFileSync(ticketPath, 'utf-8');
-        const now = new Date().toISOString();
-
-        let updatedContent = currentContent
-          .replace(/^status: (.+)$/m, 'status: in_progress')
-          .replace(/^updated_at: (.+)$/m, `updated_at: ${now}`);
+    if (spawnAgent) {
+      const ticket = tickets[0];
+      const agentTimeout = config.worktree?.agent?.timeout || 900;
+      const ticketContent = fs.readFileSync(ticket.filePath, 'utf-8');
+      const prompt = flags.prompt
+        ? flags.prompt
+        : `You are working on ticket ${ticket.frontmatter.id}: ${ticket.frontmatter.title}\n\nHere is the full ticket:\n\n${ticketContent}\n\nImplement the ticket requirements. Follow the acceptance criteria. Commit your work when done. Update the ticket status to done when complete.`;
 
-        fs.writeFileSync(ticketPath, updatedContent, 'utf-8');
+      console.log('\n🤖 Spawning Claude agent...\n');
+      try {
+        const agentProcess = spawn('claude', ['-p', prompt, '--timeout', String(agentTimeout * 1000)], {
+          cwd: process.cwd(),
+          stdio: 'ignore',
+          detached: true
+        });
 
-        console.log(`✅ Updated ticket status to: in_progress`);
-        console.log(`✅ Updated timestamp to: ${now}`);
+        agentProcess.unref();
+        console.log(`  🤖 ${ticket.frontmatter.id}: Agent spawned (timeout: ${agentTimeout}s)`);
+        console.log('\n🏁 Agent launched!\n');
+        console.log('Monitor progress:');
+        console.log('  vibe status          # see ticket status');
+        console.log('  vibe list --status=in_progress # see in-progress tickets');
       } catch (error) {
-        console.error(`❌ Failed to update ticket status: ${error.message}`);
+        console.error(`  ❌ ${ticket.frontmatter.id}: Failed to spawn agent — ${error.message}`);
       }
+    } else {
+      console.log('\n🏁 Branches ready!\n');
+      console.log('To switch to a branch:');
+      console.log(`  git checkout ${getBranchName(tickets[0], config)}`);
     }
-
-    // Summary
-    console.log('');
-    console.log(`🎯 Now working on: ${ticketId} - ${title}`);
-    console.log(`🌿 Branch: ${branchName}`);
-    console.log('');
-    console.log('To push this branch to remote:');
-    console.log(`  git push -u origin ${branchName}`);
   }
 }
 

package/src/commands/start/index.test.js

@@ -49,7 +49,7 @@ describe('start command', () => {
 
       // Assert
       expect(exitMock.exitCalls).toContain(1);
-      expect(consoleMock.logs.error).toContain('❌ Please provide a ticket ID (e.g., vibe start TKT-006)');
+      expect(consoleMock.logs.error[0]).toContain('Usage: vibe start');
     });
 
     it('should show error for invalid ticket ID format', () => {
@@ -61,7 +61,7 @@ describe('start command', () => {
 
       // Assert
       expect(exitMock.exitCalls).toContain(1);
-      expect(consoleMock.logs.error).toContain('❌ Invalid ticket ID format. Expected TKT-XXX or just the number.');
+      expect(consoleMock.logs.error).toContain('❌ Invalid ticket ID: invalid-format');
     });
   });
 
@@ -79,10 +79,21 @@ describe('start command', () => {
     });
   });
 
-  // Note: Full git integration testing would require:
-  // - Proper git repository setup
-  // - Mocking all git utility functions
-  // - Testing branch creation and checkout
-  // - Testing ticket status updates
-  // This is better handled in integration tests with proper git mocking
+  describe('--agent flag validation', () => {
+    it('should error when --agent used without -w for multiple tickets', () => {
+      // Arrange
+      createMockVibeProject(tempDir, {
+        withTickets: [
+          { id: 'TKT-001', title: 'First', status: 'open' },
+          { id: 'TKT-002', title: 'Second', status: 'open' }
+        ]
+      });
+
+      // Act
+      expect(() => startCommand(['TKT-001', 'TKT-002', '--agent'])).toThrow('process.exit(1)');
+
+      // Assert
+      expect(consoleMock.logs.error[0]).toContain('--agent without -w only supports a single ticket');
+    });
+  });
 });

package/src/commands/status/index.js

@@ -0,0 +1,80 @@
+import fs from 'fs';
+import path from 'path';
+import yaml from 'js-yaml';
+import { execSync } from 'child_process';
+import { getTicketsDir, getConfig } from '../../utils/index.js';
+import { isGitRepository, getRepoName } from '../../utils/git.js';
+
+function getWorktreesStatus() {
+  try {
+    const output = execSync('git worktree list --porcelain', { encoding: 'utf-8' });
+    const lines = output.trim().split('\n').filter(l => l);
+    const worktrees = [];
+    for (const line of lines) {
+      const [path_, branch_] = line.split(' ');
+      if (path_ && path_ !== '.') {
+        const branch = branch_.replace('branch ', '').replace(/^refs\/heads\//, '');
+        worktrees.push({ path: path_, branch });
+      }
+    }
+    return worktrees;
+  } catch (error) {
+    return [];
+  }
+}
+
+function loadTicketFromPath(ticketsDir, worktreePath) {
+  const files = fs.readdirSync(ticketsDir).filter(f => f.endsWith('.md'));
+  for (const file of files) {
+    const filePath = path.join(ticketsDir, file);
+    const content = fs.readFileSync(filePath, 'utf-8');
+    if (content.includes(`worktree_path: "${worktreePath}"`)) {
+      const match = content.match(/^---\n([\s\S]*?)\n---/);
+      if (match) {
+        const frontmatter = yaml.load(match[1]);
+        return { id: frontmatter.id, title: frontmatter.title, status: frontmatter.status, filePath };
+      }
+    }
+  }
+  return null;
+}
+
+function statusCommand(args) {
+  if (!isGitRepository()) {
+    console.error('❌ Not in a git repository.');
+    process.exit(1);
+  }
+
+  const ticketsDir = getTicketsDir();
+  const worktrees = getWorktreesStatus();
+
+  if (worktrees.length === 0) {
+    console.log('📭 No active worktrees.\n');
+    console.log('Start a ticket with worktrees:');
+    console.log('  vibe start <TKT-001> -w');
+    return;
+  }
+
+  console.log('\n🌳 Active Worktrees\n');
+
+  for (const wt of worktrees) {
+    const ticket = loadTicketFromPath(ticketsDir, wt.path);
+    if (ticket) {
+      console.log(`  ${ticket.id} — ${ticket.title}`);
+      console.log(`    📂 ${wt.path}`);
+      console.log(`    🌿 ${wt.branch}`);
+      console.log(`    ✓ ${ticket.status}`);
+    } else {
+      console.log(`  ${wt.branch}`);
+      console.log(`    📂 ${wt.path}`);
+    }
+    console.log('');
+  }
+
+  console.log('Commands:');
+  console.log('  cd <path>            # Enter a worktree');
+  console.log('  vibe pr --all        # Open PRs for all branches');
+  console.log('  git worktree remove  # Remove a worktree when done');
+}
+
+export default statusCommand;

package/src/commands/status/index.test.js

@@ -0,0 +1,49 @@
+import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';
+import {
+  createTempDir,
+  cleanupTempDir,
+  mockConsole,
+  mockProcessCwd,
+  createMockVibeProject
+} from '../../utils/test-helpers.js';
+import statusCommand from './index.js';
+
+describe('status command', () => {
+  let tempDir;
+  let consoleMock;
+  let restoreCwd;
+
+  beforeEach(() => {
+    tempDir = createTempDir('status-test');
+    consoleMock = mockConsole();
+    restoreCwd = mockProcessCwd(tempDir);
+  });
+
+  afterEach(() => {
+    consoleMock.restore();
+    restoreCwd();
+    cleanupTempDir(tempDir);
+  });
+
+  describe('basic validation', () => {
+    it('should validate that status command exists and is callable', () => {
+      expect(typeof statusCommand).toBe('function');
+    });
+
+    it('should accept arguments parameter', () => {
+      expect(statusCommand.length).toBe(1);
+    });
+
+    it('should show message when no active worktrees', () => {
+      // Arrange
+      createMockVibeProject(tempDir);
+
+      // Act
+      statusCommand([]);
+
+      // Assert
+      const output = consoleMock.logs.log[0];
+      expect(output.includes('No active worktrees') || output.includes('Active Worktrees')).toBe(true);
+    });
+  });
+});