@kosuke-ai/cli 0.0.38 → 0.0.40

package/dist/kosuke/commands/tickets.js

@@ -1,256 +1,271 @@
 /**
  * Tickets command - Generate tickets from requirements document
  *
- * This command analyzes a requirements document (default: docs.md) and generates
- * structured tickets in three phases:
- * 1. Schema tickets (database design)
- * 2. Backend tickets (API, services, business logic)
- * 3. Frontend tickets (pages, components, UI)
+ * This command analyzes a requirements document and generates structured tickets:
  *
- * Claude Code Agent explores the specified directory (default: current directory)
- * to understand the existing codebase and generate contextual tickets.
+ * SCAFFOLD MODE (--scaffold flag):
+ *   SCAFFOLD BATCH (template adaptation):
+ *     1. SCAFFOLD-SCHEMA-1 (database infrastructure changes, auto-validated)
+ *     2. SCAFFOLD-BACKEND-X (API infrastructure changes)
+ *     3. SCAFFOLD-FRONTEND-X (UI infrastructure changes)
+ *     4. SCAFFOLD-WEB-TEST-X (validate scaffold E2E)
  *
- * All paths (--path and --output) are relative to the project directory.
+ *   LOGIC BATCH (business functionality):
+ *     1. LOGIC-SCHEMA-1 (business entities, auto-validated)
+ *     2. LOGIC-BACKEND-1 (business API)
+ *     3. LOGIC-FRONTEND-1 (business UI)
+ *     4. LOGIC-WEB-TEST-1 (validate logic E2E)
+ *     ... (multiple logic batches per feature)
+ *
+ * LOGIC-ONLY MODE (default):
+ *   Only generates LOGIC tickets for new features
+ *
+ * Claude Code Agent explores the codebase to understand the tech stack and
+ * generates contextual tickets in a single comprehensive analysis.
  *
  * Usage:
- *   kosuke tickets                                    # Use docs.md in current directory
+ *   kosuke tickets                                    # Logic-only mode, use docs.md
+ *   kosuke tickets --scaffold                         # Scaffold + logic mode
  *   kosuke tickets --path=custom.md                   # Custom requirements file
- *   kosuke tickets --output=my-tickets.json           # Custom output file
- *   kosuke tickets --directory=./projects/my-app      # Analyze specific directory
- *   kosuke tickets --dir=./my-app --path=docs/spec.md # Custom directory and requirements path
+ *   kosuke tickets --prompt="Add dark mode"           # Inline requirements
+ *   kosuke tickets --directory=./my-app               # Analyze specific directory
  */
 import { existsSync, readFileSync, statSync, writeFileSync } from 'fs';
 import { join, resolve } from 'path';
 import { formatCostBreakdown, runAgent } from '../utils/claude-agent.js';
 import { logger, setupCancellationHandler } from '../utils/logger.js';
 /**
- * Build system prompt for ticket generation with integrated analysis
+ * Build unified system prompt for comprehensive ticket generation
  */
-function buildTicketGenerationPrompt(phase, ticketType, requirementsContent, projectPath) {
-    const phaseTypeKey = `${phase}_${ticketType}`;
-    const phaseInstructions = {
-        schema_scaffold: `
-**GENERATE: ONE DATABASE SCHEMA SCAFFOLD TICKET**
-
-This ticket should handle infrastructure/setup database changes based on the analysis:
-- Modifications to auth tables (if organizations needed or removed)
-- Billing/subscription tables (if changed or removed)
-- Email verification/notification tables
-- Any template baseline schema adjustments
-
-**Key Focus:**
-- What needs to be REMOVED from template (e.g., organization tables if not needed)
-- What needs to be ADDED for infrastructure (e.g., organization support if needed)
-- Updates to existing template tables for new requirements
-
-Ticket ID: SCHEMA-SCAFFOLD-1
-`,
-        schema_logic: `
-**GENERATE: ONE DATABASE SCHEMA BUSINESS LOGIC TICKET**
-
-This ticket should handle core business domain tables based on the analysis:
-- Main application entities (e.g., tasks, projects, posts, campaigns)
-- Business-specific relationships
-- Domain-specific fields and constraints
-- Application data models
-
-**Key Focus:**
-- Core business entities unique to this application
-- Relationships between business entities
-- NOT infrastructure tables (auth, billing, etc.)
-
-Ticket ID: SCHEMA-LOGIC-1
-`,
-        backend_scaffold: `
-**GENERATE: BACKEND SCAFFOLD TICKETS**
-
-Generate tickets for infrastructure/setup backend changes:
-- Auth modifications (add/remove organization support, change providers)
-- Billing API changes (remove Stripe, add different tiers, etc.)
-- Email template setup (create transactional email templates)
-- Landing page API routes (if needed)
-- Third-party integrations setup
-
-**Granularity:**
-- ONE ticket per infrastructure area (auth, billing, email, landing)
-- Let Claude decide granularity based on complexity
-- Each ticket should be independently implementable
-
-Ticket IDs: BACKEND-SCAFFOLD-1, BACKEND-SCAFFOLD-2, etc. (sequential)
-`,
-        backend_logic: `
-**GENERATE: BACKEND BUSINESS LOGIC TICKETS**
-
-Generate tickets for core application backend features:
-- API endpoints for business entities
-- Service layer logic
-- Business rules and validation
-- Application-specific data processing
-- Feature-specific integrations
-
-**Granularity:**
-- ONE ticket per feature/module
-- Let Claude decide granularity based on complexity
-- Each ticket should be independently implementable
-
-Ticket IDs: BACKEND-LOGIC-1, BACKEND-LOGIC-2, etc. (sequential)
-`,
-        frontend_scaffold: `
-**GENERATE: FRONTEND SCAFFOLD TICKETS**
-
-Generate tickets for infrastructure/setup frontend changes:
-- Auth UI modifications (add/remove organization switcher, change auth flow)
-- Billing UI changes (subscription management, pricing page updates)
-- Landing page customization
-- Email template previews
-- Navigation/layout updates for infrastructure changes
-
-**Granularity:**
-- ONE ticket per infrastructure area
-- Let Claude decide granularity based on complexity
-- Each ticket should be independently implementable
-
-Ticket IDs: FRONTEND-SCAFFOLD-1, FRONTEND-SCAFFOLD-2, etc. (sequential)
-`,
-        frontend_logic: `
-**GENERATE: FRONTEND BUSINESS LOGIC TICKETS**
-
-Generate tickets for core application frontend features:
-- Application-specific pages
-- Feature-specific UI components
-- Business logic forms
-- User workflows
-- Application state management
-
-**Granularity:**
-- ONE ticket per PAGE or major feature
-- Let Claude decide granularity based on complexity
-- Each ticket should cover all components and functionality for that area
-
-Ticket IDs: FRONTEND-LOGIC-1, FRONTEND-LOGIC-2, etc. (sequential)
-`,
-    };
-    const categoryGuidance = ticketType === 'scaffold'
+function buildTicketPrompt(requirementsContent, projectPath, isScaffoldMode) {
+    const scaffoldGuidance = isScaffoldMode
         ? `
-**Category Assignment:**
-Assign appropriate category to each ticket:
-- "auth" - Authentication and authorization changes
-- "billing" - Payment and subscription changes
-- "email" - Transactional email setup
-- "landing" - Public marketing pages
-- "infrastructure" - General setup/configuration
+**SCAFFOLD TICKETS - Template Adaptation ONLY:**
+
+These tickets focus on removing, changing, or customizing the Kosuke Template baseline.
+DO NOT add new business logic or features from requirements here.
+
+Scaffold tickets should:
+- ❌ REMOVE unused template features (e.g., organizations, billing, multi-tenancy)
+- 🔄 CHANGE existing features (e.g., swap Better Auth for Clerk, simplify billing)
+- 🎨 CUSTOMIZE infrastructure (landing page, email templates, branding, navigation)
+
+Examples of SCAFFOLD tickets:
+- "Remove organization/multi-tenancy support from auth"
+- "Simplify billing to single tier (remove pro/business tiers)"
+- "Customize landing page for [specific use case]"
+- "Remove landing page entirely (internal tool)"
+- "Update email templates for [brand name]"
+
+**SCAFFOLD Ticket Ordering:**
+1. SCAFFOLD-SCHEMA-1 (one ticket for all database infrastructure changes, auto-validated)
+2. SCAFFOLD-BACKEND-1, SCAFFOLD-BACKEND-2, ... (backend infrastructure tickets)
+3. SCAFFOLD-FRONTEND-1, SCAFFOLD-FRONTEND-2, ... (frontend infrastructure tickets)
+4. SCAFFOLD-WEB-TEST-1, SCAFFOLD-WEB-TEST-2, ... (E2E tests for scaffold)
 `
-        : `
-**Category Assignment:**
-Assign appropriate category based on business domain:
-- Use the main entity name (e.g., "tasks", "projects", "campaigns")
-- Or use feature name (e.g., "user-management", "notifications", "analytics")
-- Keep categories consistent across related tickets
-`;
-    const templateBaseline = `
-**Kosuke Template Baseline (what the template already includes):**
-- **Authentication**: Better Auth with Email OTP
-- **User Model**: Individual users (no organizations/multi-tenancy by default)
-- **Billing**: Stripe with subscription tiers (free, pro, business)
-- **Email**: Resend for transactional emails
-- **Landing Page**: Basic marketing site with pricing
-- **Database**: PostgreSQL with Drizzle ORM
-- **Stack**: Next.js 15, React 19, TypeScript, Tailwind, Shadcn UI
-
-**Analysis Instructions:**
-Before generating tickets, analyze the requirements to understand:
-1. **Auth**: Does it need organizations/multi-tenancy? Different auth provider?
-2. **Billing**: Keep Stripe? Remove billing entirely? Different tiers?
-3. **Email**: What transactional emails are needed? Custom templates?
-4. **Landing**: Customize marketing pages? Remove landing page?
-5. **Core Domain**: What are the main business entities and workflows?
-
-For SCAFFOLD tickets:
-- Identify what needs to be REMOVED from template (if not needed)
-- Identify what needs to be ADDED to template (if needed)
-- Identify what needs to be CUSTOMIZED (landing page, email templates, etc.)
-
-For LOGIC tickets:
-- Focus on core business functionality
-- Implement application-specific features
-- Build domain models and workflows
-`;
-    return `You are an expert software architect generating implementation tickets for a Kosuke Template project.
+        : '';
+    const webTestGuidance = `
+**WEB TEST TICKETS - Stagehand Agent E2E Tests:**
 
-**Your Task:**
-${phaseInstructions[phaseTypeKey]}
+Web test tickets are executed by Stagehand agent and must follow these guidelines:
+
+**Test User Discovery:**
+1. **ALWAYS read seed files** to find test user credentials:
+   - Look for files: lib/db/seed.ts, src/lib/db/seed.ts
+   - Pattern: Any email ending with "+kosuke_test@example.com" uses OTP code "424242"
+   - Example: john+kosuke_test@example.com → OTP: 424242
+   - Include all discovered test users in ticket description
+
+**Ticket Structure Requirements:**
+Each web test ticket MUST include:
+
+1. **Test User Credentials** (at the top)
+   - List all test users with their emails
+   - Document OTP code (424242)
+   - Specify user roles if applicable (admin, regular user, etc.)
+
+2. **Test Steps** (numbered, detailed natural language)
+   - Navigation instructions ("Navigate to /sign-in")
+   - User interactions ("Click button labeled 'New Task'")
+   - Input actions ("Enter 'Test Task' in title field")
+   - Expected outcomes after each step ("Expected: Task appears in list")
+   - Use CLEAR element descriptions (button text, labels, placeholders)
+   - Use relative paths only (e.g., /sign-in, /tasks) - base URL provided as test argument
+
+3. **Acceptance Criteria**
+   - Final expected state
+   - Data validation points
+   - User feedback confirmation
+
+**Stagehand Best Practices:**
+- Use natural language, NOT code
+- Be SPECIFIC about element identification (button text, input labels, exact URLs)
+- Include EXPECTED OUTCOMES after each major action
+- Combine related flows into ONE ticket (signup → create → invite = 1 ticket)
+- Authentication steps MUST be explicit:
+  1. Navigate to /sign-in
+  2. Enter email: {test_user}+kosuke_test@example.com
+  3. Click "Send Code" button
+  4. Enter OTP: 424242
+  5. Click "Verify" button
+  6. Expected: Redirected to dashboard/main app
+
+**Example Web Test Ticket:**
+
+{
+  "id": "LOGIC-WEB-TEST-1",
+  "title": "E2E: User signup and create first task",
+  "description": "**Test User Credentials:**\\n- Email: john+kosuke_test@example.com\\n- OTP Code: 424242\\n\\n**Test Steps:**\\n\\n1. **Sign in with test user**\\n   - Navigate to /sign-in\\n   - Enter email: john+kosuke_test@example.com\\n   - Click button labeled 'Send Code'\\n   - Enter OTP code: 424242\\n   - Click button labeled 'Verify'\\n   - Expected: Redirected to /tasks\\n\\n2. **Create new task**\\n   - Click button with text 'New Task'\\n   - Enter 'My First Task' in the Title field\\n   - Select 'High' from Priority dropdown\\n   - Click 'Create Task' button\\n   - Expected: Task appears in task list\\n   - Expected: Success message shown\\n\\n3. **Verify task persistence**\\n   - Refresh the page\\n   - Expected: Task 'My First Task' still visible\\n   - Expected: Priority shows 'High'\\n\\n**Acceptance Criteria:**\\n- User successfully authenticates with OTP\\n- Task is created and visible\\n- Task persists after page refresh\\n- UI shows appropriate feedback",
+  "type": "test",
+  "estimatedEffort": 4,
+  "status": "Todo",
+  "category": "tasks"
+}`;
+    return `You are an expert software architect generating implementation tickets.
 
 **Requirements Document:**
 ${requirementsContent}
 
-${templateBaseline}
-
-**Context:**
+**Project Context:**
 You have access to the project directory at: ${projectPath}
-The template baseline is documented in CLAUDE.md.
-Explore the codebase to understand the tech stack, architecture patterns, and coding conventions.
+
+${scaffoldGuidance}
+${webTestGuidance}
+
+**LOGIC TICKETS - Business Functionality:**
+
+These tickets implement the actual features and requirements from the document.
+
+Logic tickets should:
+- 🗄️ Create schema for business entities (tasks, projects, posts, etc.)
+- ⚙️ Build backend APIs for business features
+- 🎨 Create frontend UI for business features
+
+**LOGIC Ticket Ordering:**
+Each feature can have its own batch of tickets:
+
+Feature 1:
+1. LOGIC-SCHEMA-1 (schema for feature 1, auto-validated)
+2. LOGIC-BACKEND-1 (backend for feature 1)
+3. LOGIC-FRONTEND-1 (frontend for feature 1)
+4. LOGIC-WEB-TEST-1 (E2E test for feature 1)
+
+Feature 2:
+5. LOGIC-BACKEND-2 (backend for feature 2, if no schema needed)
+6. LOGIC-FRONTEND-2 (frontend for feature 2)
+7. LOGIC-WEB-TEST-2 (E2E test for feature 2)
+
+**Ticket Granularity:**
+- Schema: Usually ONE ticket per batch (scaffold or logic), automatically validated during build
+- Backend: Let complexity decide (could be 1-5 tickets per batch)
+- Frontend: Let complexity decide (could be 1-5 tickets per batch)
+- Web Tests: Let complexity decide (1 test per major user flow)
+
+**Your Task:**
+1. **Explore the codebase** using read_file, grep, codebase_search to understand:
+   - Current tech stack and framework versions
+   - Existing architecture patterns
+   - Database schema structure
+   - API route patterns
+   - UI component library and styling
+   ${isScaffoldMode ? '   - What template features are currently present\n   - What needs to be removed, changed, or customized' : ''}
+
+2. **Discover test users** for web testing:
+   - Read seed files: lib/db/seed.ts, src/lib/db/seed.ts (use read_file or grep)
+   - Look for test user pattern: {name}+kosuke_test@example.com
+   - Document all test users found (email addresses)
+   - Note: All test users use OTP code 424242 for Better Auth
+   - Include test user credentials in ALL web test tickets
+
+3. **Analyze requirements** to determine:
+   - Which layers are needed (schema/backend/frontend)
+   - How to break down features into logical batches
+   - What user flows need E2E web tests
+
+4. **Generate ALL tickets** in the correct order:
+   ${isScaffoldMode ? '   - SCAFFOLD batch first (template adaptation)\n   - LOGIC batches second (business features)' : '   - LOGIC batches only (business features)'}
+   - Follow the ticket ordering structure above
+   - Schema tickets are automatically validated during build (no separate test tickets needed)
+   - For web tests: Include test user credentials, detailed steps, and expected outcomes
 
 **Ticket Structure:**
 Each ticket must be a JSON object with:
-- id: string (e.g., "SCHEMA-SCAFFOLD-1", "BACKEND-LOGIC-2")
+- id: string (e.g., "SCAFFOLD-SCHEMA-1", "LOGIC-BACKEND-2", "SCAFFOLD-WEB-TEST-1")
 - title: string (clear, concise title)
 - description: string (detailed description with acceptance criteria)
-- type: "${ticketType}" (scaffold or logic)
+- type: "schema" | "backend" | "frontend" | "test"
 - estimatedEffort: number (1-10, where 1=very easy, 10=very complex)
-- status: "Todo" (all tickets start as Todo)
-- category: string (see guidance below)
-${categoryGuidance}
+- status: "Todo"
+- category: string (e.g., "auth", "billing", "user-management", "tasks")
 
 **Output Format:**
-Return ONLY a valid JSON array of tickets. No markdown, no code blocks, just raw JSON.
+Return ONLY a valid JSON array of ALL tickets in the correct order. No markdown, no code blocks, just raw JSON.
 
 Example:
 [
   {
-    "id": "BACKEND-SCAFFOLD-1",
-    "title": "Remove organization support from authentication",
-    "description": "Remove multi-tenancy/organization features from the template:\\n- Remove organization tables from schema\\n- Update user model to remove org references\\n- Simplify auth middleware (no org context)\\n- Remove org switcher from UI\\n\\nAcceptance Criteria:\\n- All organization references removed from codebase\\n- Auth flow works for individual users only\\n- Database migrations remove org tables\\n- No compilation errors",
-    "type": "scaffold",
-    "estimatedEffort": 6,
+    "id": "SCAFFOLD-SCHEMA-1",
+    "title": "Remove organizations and simplify auth schema",
+    "description": "Remove multi-tenancy/organization features from database:\\n- Drop organization tables\\n- Remove org foreign keys from users table\\n- Simplify schema to individual users only\\n\\nAcceptance Criteria:\\n- Organization tables removed\\n- User table simplified\\n- Migrations created and validated automatically\\n- No schema errors",
+    "type": "schema",
+    "estimatedEffort": 5,
     "status": "Todo",
     "category": "auth"
+  },
+  {
+    "id": "LOGIC-WEB-TEST-1",
+    "title": "E2E: User creates and manages a task",
+    "description": "**Test User Credentials:**\\n- Email: john+kosuke_test@example.com\\n- OTP Code: 424242\\n\\n**Test Steps:**\\n\\n1. **Authenticate as test user**\\n   - Navigate to /sign-in\\n   - Enter email: john+kosuke_test@example.com\\n   - Click 'Send Code' button\\n   - Enter OTP: 424242\\n   - Click 'Verify' button\\n   - Expected: Redirected to /tasks dashboard\\n\\n2. **Create new task**\\n   - Click 'New Task' button\\n   - Enter title: 'Test Task'\\n   - Select priority: 'High'\\n   - Click 'Create' button\\n   - Expected: Task appears in task list\\n   - Expected: Success toast notification shown\\n\\n3. **Edit task**\\n   - Click on the created task\\n   - Change title to: 'Updated Task'\\n   - Expected: Task title updates immediately\\n\\n4. **Delete task**\\n   - Click delete icon on task\\n   - Confirm deletion in dialog\\n   - Expected: Task removed from list\\n\\n**Acceptance Criteria:**\\n- User successfully authenticates\\n- Task creation, editing, and deletion work\\n- UI provides appropriate feedback\\n- Changes persist correctly",
+    "type": "test",
+    "estimatedEffort": 5,
+    "status": "Todo",
+    "category": "tasks"
   }
 ]
 
 **Critical Instructions:**
-1. Analyze requirements against template baseline
-2. Explore the project directory to understand existing patterns (use read_file, grep, codebase_search)
-3. Generate tickets that are actionable and specific
-4. Return ONLY valid JSON - no explanations, no markdown formatting
-5. Ensure ticket IDs follow the naming convention (${phase.toUpperCase()}-${ticketType.toUpperCase()}-N)
-6. Make descriptions detailed with clear acceptance criteria
-7. Estimate effort realistically (consider complexity, dependencies, testing)
-8. Assign appropriate categories for organization and filtering
-9. For scaffold tickets: focus on infrastructure changes (add/remove/customize template features)
-10. For logic tickets: focus on business domain implementation
-
-Begin by exploring the project directory, analyzing requirements, then generate the tickets.`;
+1. Explore the project directory thoroughly before generating tickets
+2. ${isScaffoldMode ? 'For SCAFFOLD: Focus on template adaptation ONLY (remove/change/customize)' : ''}
+3. For LOGIC: Focus on business features from requirements
+4. **IMPORTANT**: Read seed files (lib/db/seed.ts or src/lib/db/seed.ts) to discover test users
+5. **SCHEMA TICKETS**: No separate test tickets needed - validation happens automatically during build
+6. **WEB TESTS MUST INCLUDE**:
+   - Test user credentials at the top
+   - Clear numbered steps with natural language
+   - Expected outcomes after each step
+   - Specific element descriptions (button text, labels, URLs)
+   - Complete user flows in one ticket (signup → create → invite = 1 ticket)
+7. Follow the exact ticket ordering structure
+8. Make descriptions detailed with clear acceptance criteria
+9. Return ONLY valid JSON - no explanations, no markdown
+10. Ensure sequential ticket IDs match the ordering structure
+
+Begin by:
+1. Reading seed files to discover test users
+2. Exploring the project directory structure
+3. Generating ALL tickets in the correct order with test user info in web tests.`;
 }
 /**
- * Parse tickets from Claude's response
+ * Parse all tickets from Claude's response
  */
-function parseTicketsFromResponse(response, phase, ticketType) {
+function parseAllTickets(response) {
     try {
         // Extract JSON from response (in case Claude includes extra text)
         const jsonMatch = response.match(/\[[\s\S]*\]/);
         if (!jsonMatch) {
-            throw new Error(`No JSON array found in ${phase} ${ticketType} response`);
+            throw new Error('No JSON array found in response');
         }
         const tickets = JSON.parse(jsonMatch[0]);
         // Validate tickets
         if (!Array.isArray(tickets)) {
             throw new Error(`Expected array of tickets, got ${typeof tickets}`);
         }
+        const validTypes = ['schema', 'backend', 'frontend', 'test'];
         for (const ticket of tickets) {
             if (!ticket.id || !ticket.title || !ticket.description) {
                 throw new Error(`Invalid ticket structure: ${JSON.stringify(ticket)}`);
             }
-            if (!ticket.type || (ticket.type !== 'scaffold' && ticket.type !== 'logic')) {
+            if (!ticket.type || !validTypes.includes(ticket.type)) {
                 throw new Error(`Invalid or missing type for ticket ${ticket.id}: ${ticket.type}`);
             }
             if (typeof ticket.estimatedEffort !== 'number' ||
@@ -265,13 +280,13 @@ function parseTicketsFromResponse(response, phase, ticketType) {
         return tickets;
     }
     catch (error) {
-        console.error(`\n❌ Failed to parse tickets from ${phase} ${ticketType} phase:`);
+        console.error('\n❌ Failed to parse tickets from response:');
         console.error(`Raw response:\n${response.substring(0, 500)}...\n`);
-        throw new Error(`Failed to parse ${phase} ${ticketType} tickets: ${error instanceof Error ? error.message : String(error)}`);
+        throw new Error(`Failed to parse tickets: ${error instanceof Error ? error.message : String(error)}`);
     }
 }
 /**
- * Write tickets to file incrementally
+ * Write tickets to output file
  */
 function writeTicketsToFile(outputPath, tickets) {
     const outputData = {
@@ -282,60 +297,11 @@ function writeTicketsToFile(outputPath, tickets) {
     writeFileSync(outputPath, JSON.stringify(outputData, null, 2), 'utf-8');
 }
 /**
- * Generate tickets for a specific phase and type
- */
-async function generatePhaseTickets(phase, ticketType, requirementsContent, projectPath, outputPath, existingTickets) {
-    const phaseEmoji = {
-        schema: '🗄️',
-        backend: '⚙️',
-        frontend: '🎨',
-    };
-    const typeEmoji = {
-        scaffold: '🏗️',
-        logic: '💡',
-    };
-    const phaseName = {
-        schema: 'Schema',
-        backend: 'Backend',
-        frontend: 'Frontend',
-    };
-    const typeName = {
-        scaffold: 'Scaffold',
-        logic: 'Logic',
-    };
-    console.log(`\n${'='.repeat(60)}`);
-    console.log(`${phaseEmoji[phase]} ${typeEmoji[ticketType]}  ${phaseName[phase]} ${typeName[ticketType]} Tickets`);
-    console.log(`${'='.repeat(60)}\n`);
-    const systemPrompt = buildTicketGenerationPrompt(phase, ticketType, requirementsContent, projectPath);
-    const agentResult = await runAgent(`Generate ${phaseName[phase]} ${typeName[ticketType]} tickets from the requirements.`, {
-        systemPrompt,
-        cwd: projectPath,
-        maxTurns: 25,
-        verbosity: 'normal',
-        captureConversation: true,
-    });
-    // Parse tickets from response
-    const tickets = parseTicketsFromResponse(agentResult.response, phase, ticketType);
-    console.log(`\n✅ Generated ${tickets.length} ${phaseName[phase]} ${typeName[ticketType]} ticket${tickets.length === 1 ? '' : 's'}`);
-    tickets.forEach((ticket) => {
-        console.log(`   ${phaseEmoji[phase]} ${ticket.id}: ${ticket.title} (Effort: ${ticket.estimatedEffort}/10${ticket.category ? `, Category: ${ticket.category}` : ''})`);
-    });
-    // Write tickets incrementally after each phase
-    const allTickets = [...existingTickets, ...tickets];
-    writeTicketsToFile(outputPath, allTickets);
-    console.log(`   💾 Progress saved to: ${outputPath}\n`);
-    return {
-        tickets,
-        tokensUsed: agentResult.tokensUsed,
-        cost: agentResult.cost,
-        conversationMessages: agentResult.conversationMessages || [],
-    };
-}
-/**
- * Core tickets logic
+ * Core tickets logic - Simplified to single agent call
  */
 export async function ticketsCore(options) {
-    const { path = 'docs.md', directory } = options;
+    const { directory, scaffold = false } = options;
+    const isScaffoldMode = scaffold;
     // 1. Validate and resolve project directory
     const projectPath = directory ? resolve(directory) : process.cwd();
     if (!existsSync(projectPath)) {
@@ -347,104 +313,117 @@ export async function ticketsCore(options) {
     if (!stats.isDirectory()) {
         throw new Error(`Path is not a directory: ${projectPath}\n` + `Please provide a valid directory path.`);
     }
-    console.log(`📁 Using project directory: ${projectPath}\n`);
-    // 2. Read requirements document (relative to project directory)
-    console.log('📄 Reading requirements document...');
-    const requirementsPath = join(projectPath, path);
-    if (!existsSync(requirementsPath)) {
-        throw new Error(`Requirements document not found: ${path}\n` +
-            `Please provide a valid path using --path=<file>\n` +
-            `Example: kosuke tickets --path=requirements.md`);
+    console.log(`📁 Using project directory: ${projectPath}`);
+    console.log(`🏗️  Mode: ${isScaffoldMode ? 'Scaffold (template adaptation + business logic)' : 'Logic-only (business features)'}\n`);
+    // 2. Get requirements content (from prompt or file)
+    let requirementsContent;
+    if (options.prompt && options.path) {
+        throw new Error('Cannot use both --prompt and --path. Please provide only one:\n' +
+            '  kosuke tickets --prompt="Add dark mode"\n' +
+            '  kosuke tickets --path=docs.md');
     }
-    const requirementsContent = readFileSync(requirementsPath, 'utf-8');
-    console.log(`   ✅ Loaded ${path} (${requirementsContent.length} characters)\n`);
-    // 3. Determine output path for incremental writes
+    if (options.prompt) {
+        requirementsContent = options.prompt;
+        console.log(`📝 Using inline prompt (${requirementsContent.length} characters)\n`);
+    }
+    else if (options.path) {
+        const requirementsPath = join(projectPath, options.path);
+        if (!existsSync(requirementsPath)) {
+            throw new Error(`Requirements document not found: ${options.path}\n` +
+                `Please provide a valid path using --path=<file>\n` +
+                `Example: kosuke tickets --path=requirements.md`);
+        }
+        requirementsContent = readFileSync(requirementsPath, 'utf-8');
+        console.log(`📄 Loaded ${options.path} (${requirementsContent.length} characters)\n`);
+    }
+    else {
+        // Default to docs.md if neither prompt nor path provided
+        const defaultPath = 'docs.md';
+        const requirementsPath = join(projectPath, defaultPath);
+        if (!existsSync(requirementsPath)) {
+            throw new Error('Requirements not provided. Use either:\n' +
+                '  --prompt="Your requirements here"\n' +
+                '  --path=requirements.md\n' +
+                '  Or create a docs.md file in the project directory');
+        }
+        requirementsContent = readFileSync(requirementsPath, 'utf-8');
+        console.log(`📄 Loaded ${defaultPath} (${requirementsContent.length} characters)\n`);
+    }
+    // 3. Determine output path
     const outputFilename = options.output || 'tickets.json';
     const outputPath = join(projectPath, outputFilename);
-    // 4. Generate tickets in six phases (scaffold + logic for each)
-    let totalInputTokens = 0;
-    let totalOutputTokens = 0;
-    let totalCacheCreationTokens = 0;
-    let totalCacheReadTokens = 0;
-    let totalCost = 0;
-    // Collect all conversation messages from all phases
-    const allConversationMessages = [];
-    // Track all tickets
-    let allTickets = [];
-    // SCAFFOLD TICKETS (Infrastructure changes)
-    // Phase 1: Schema Scaffold
-    const schemaScaffoldResult = await generatePhaseTickets('schema', 'scaffold', requirementsContent, projectPath, outputPath, allTickets);
-    allTickets = [...allTickets, ...schemaScaffoldResult.tickets];
-    totalInputTokens += schemaScaffoldResult.tokensUsed.input;
-    totalOutputTokens += schemaScaffoldResult.tokensUsed.output;
-    totalCacheCreationTokens += schemaScaffoldResult.tokensUsed.cacheCreation;
-    totalCacheReadTokens += schemaScaffoldResult.tokensUsed.cacheRead;
-    totalCost += schemaScaffoldResult.cost;
-    allConversationMessages.push(...schemaScaffoldResult.conversationMessages);
-    // Phase 2: Backend Scaffold
-    const backendScaffoldResult = await generatePhaseTickets('backend', 'scaffold', requirementsContent, projectPath, outputPath, allTickets);
-    allTickets = [...allTickets, ...backendScaffoldResult.tickets];
-    totalInputTokens += backendScaffoldResult.tokensUsed.input;
-    totalOutputTokens += backendScaffoldResult.tokensUsed.output;
-    totalCacheCreationTokens += backendScaffoldResult.tokensUsed.cacheCreation;
-    totalCacheReadTokens += backendScaffoldResult.tokensUsed.cacheRead;
-    totalCost += backendScaffoldResult.cost;
-    allConversationMessages.push(...backendScaffoldResult.conversationMessages);
-    // Phase 3: Frontend Scaffold
-    const frontendScaffoldResult = await generatePhaseTickets('frontend', 'scaffold', requirementsContent, projectPath, outputPath, allTickets);
-    allTickets = [...allTickets, ...frontendScaffoldResult.tickets];
-    totalInputTokens += frontendScaffoldResult.tokensUsed.input;
-    totalOutputTokens += frontendScaffoldResult.tokensUsed.output;
-    totalCacheCreationTokens += frontendScaffoldResult.tokensUsed.cacheCreation;
-    totalCacheReadTokens += frontendScaffoldResult.tokensUsed.cacheRead;
-    totalCost += frontendScaffoldResult.cost;
-    allConversationMessages.push(...frontendScaffoldResult.conversationMessages);
-    // LOGIC TICKETS (Business functionality)
-    // Phase 4: Schema Logic
-    const schemaLogicResult = await generatePhaseTickets('schema', 'logic', requirementsContent, projectPath, outputPath, allTickets);
-    allTickets = [...allTickets, ...schemaLogicResult.tickets];
-    totalInputTokens += schemaLogicResult.tokensUsed.input;
-    totalOutputTokens += schemaLogicResult.tokensUsed.output;
-    totalCacheCreationTokens += schemaLogicResult.tokensUsed.cacheCreation;
-    totalCacheReadTokens += schemaLogicResult.tokensUsed.cacheRead;
-    totalCost += schemaLogicResult.cost;
-    allConversationMessages.push(...schemaLogicResult.conversationMessages);
-    // Phase 5: Backend Logic
-    const backendLogicResult = await generatePhaseTickets('backend', 'logic', requirementsContent, projectPath, outputPath, allTickets);
-    allTickets = [...allTickets, ...backendLogicResult.tickets];
-    totalInputTokens += backendLogicResult.tokensUsed.input;
-    totalOutputTokens += backendLogicResult.tokensUsed.output;
-    totalCacheCreationTokens += backendLogicResult.tokensUsed.cacheCreation;
-    totalCacheReadTokens += backendLogicResult.tokensUsed.cacheRead;
-    totalCost += backendLogicResult.cost;
-    allConversationMessages.push(...backendLogicResult.conversationMessages);
-    // Phase 6: Frontend Logic
-    const frontendLogicResult = await generatePhaseTickets('frontend', 'logic', requirementsContent, projectPath, outputPath, allTickets);
-    allTickets = [...allTickets, ...frontendLogicResult.tickets];
-    totalInputTokens += frontendLogicResult.tokensUsed.input;
-    totalOutputTokens += frontendLogicResult.tokensUsed.output;
-    totalCacheCreationTokens += frontendLogicResult.tokensUsed.cacheCreation;
-    totalCacheReadTokens += frontendLogicResult.tokensUsed.cacheRead;
-    totalCost += frontendLogicResult.cost;
-    allConversationMessages.push(...frontendLogicResult.conversationMessages);
-    // Separate tickets by phase for result
-    const schemaTickets = allTickets.filter((t) => t.id.startsWith('SCHEMA-'));
-    const backendTickets = allTickets.filter((t) => t.id.startsWith('BACKEND-'));
-    const frontendTickets = allTickets.filter((t) => t.id.startsWith('FRONTEND-'));
+    // 4. Generate ALL tickets in a single comprehensive agent call
+    console.log(`\n${'='.repeat(80)}`);
+    console.log('🎯 Generating Tickets with Claude Code Agent');
+    console.log(`${'='.repeat(80)}\n`);
+    const systemPrompt = buildTicketPrompt(requirementsContent, projectPath, isScaffoldMode);
+    const agentResult = await runAgent('Generate all tickets from requirements', {
+        systemPrompt,
+        cwd: projectPath,
+        maxTurns: 40, // Give Claude enough turns to explore codebase and generate all tickets
+        verbosity: 'normal',
+        captureConversation: true,
+    });
+    // 5. Parse all tickets from single response
+    const allTickets = parseAllTickets(agentResult.response);
+    // 6. Display tickets by batch (scaffold vs logic based on ID) and by type
+    const scaffoldTickets = allTickets.filter((t) => t.id.toUpperCase().startsWith('SCAFFOLD-'));
+    const logicTickets = allTickets.filter((t) => t.id.toUpperCase().startsWith('LOGIC-'));
+    const testTickets = allTickets.filter((t) => t.type === 'test');
+    if (scaffoldTickets.length > 0) {
+        console.log(`\n${'='.repeat(60)}`);
+        console.log('🏗️  SCAFFOLD Tickets (Template Adaptation)');
+        console.log(`${'='.repeat(60)}`);
+        scaffoldTickets.forEach((ticket) => {
+            const emoji = ticket.id.includes('SCHEMA')
+                ? '🗄️'
+                : ticket.id.includes('BACKEND')
+                    ? '⚙️'
+                    : ticket.id.includes('FRONTEND')
+                        ? '🎨'
+                        : '🌐';
+            console.log(`   ${emoji} ${ticket.id}: ${ticket.title} (Effort: ${ticket.estimatedEffort}/10${ticket.category ? `, Category: ${ticket.category}` : ''})`);
+        });
+    }
+    if (logicTickets.length > 0) {
+        console.log(`\n${'='.repeat(60)}`);
+        console.log('💡 LOGIC Tickets (Business Functionality)');
+        console.log(`${'='.repeat(60)}`);
+        logicTickets.forEach((ticket) => {
+            const emoji = ticket.id.includes('SCHEMA')
+                ? '🗄️'
+                : ticket.id.includes('BACKEND')
+                    ? '⚙️'
+                    : '🎨';
+            console.log(`   ${emoji} ${ticket.id}: ${ticket.title} (Effort: ${ticket.estimatedEffort}/10${ticket.category ? `, Category: ${ticket.category}` : ''})`);
+        });
+    }
+    if (testTickets.length > 0) {
+        console.log(`\n${'='.repeat(60)}`);
+        console.log('🧪 TEST Tickets (E2E Validation)');
+        console.log(`${'='.repeat(60)}`);
+        testTickets.forEach((ticket) => {
+            console.log(`   🌐 ${ticket.id}: ${ticket.title} (Effort: ${ticket.estimatedEffort}/10)`);
+        });
+    }
+    // 7. Write tickets to file
+    writeTicketsToFile(outputPath, allTickets);
+    console.log(`\n💾 Tickets saved to: ${outputPath}`);
+    // 8. Separate tickets by phase for compatibility with existing result structure
+    const schemaTickets = allTickets.filter((t) => t.type === 'schema');
+    const backendTickets = allTickets.filter((t) => t.type === 'backend');
+    const frontendTickets = allTickets.filter((t) => t.type === 'frontend');
+    // testTickets already declared above for display
     return {
         schemaTickets,
         backendTickets,
         frontendTickets,
+        testTickets,
         totalTickets: allTickets.length,
         projectPath,
-        tokensUsed: {
-            input: totalInputTokens,
-            output: totalOutputTokens,
-            cacheCreation: totalCacheCreationTokens,
-            cacheRead: totalCacheReadTokens,
-        },
-        cost: totalCost,
-        conversationMessages: allConversationMessages,
+        tokensUsed: agentResult.tokensUsed,
+        cost: agentResult.cost,
+        conversationMessages: agentResult.conversationMessages || [],
     };
 }
 /**
@@ -466,30 +445,37 @@ export async function ticketsCommand(options) {
         // Track metrics
         logger.trackTokens(logContext, result.tokensUsed);
         logContext.conversationMessages = result.conversationMessages;
-        // Display summary
+        // Get all tickets by batch (scaffold vs logic)
         const scaffoldTickets = [
             ...result.schemaTickets,
             ...result.backendTickets,
             ...result.frontendTickets,
-        ].filter((t) => t.type === 'scaffold');
+            ...result.testTickets,
+        ].filter((t) => t.id.toUpperCase().startsWith('SCAFFOLD-'));
         const logicTickets = [
             ...result.schemaTickets,
             ...result.backendTickets,
             ...result.frontendTickets,
-        ].filter((t) => t.type === 'logic');
-        console.log(`\n${'='.repeat(60)}`);
+            ...result.testTickets,
+        ].filter((t) => t.id.toUpperCase().startsWith('LOGIC-'));
+        // Display summary
+        console.log(`\n${'='.repeat(80)}`);
         console.log('📊 Ticket Generation Summary');
-        console.log(`${'='.repeat(60)}`);
-        console.log(`\n🏗️  Scaffold Tickets (Infrastructure): ${scaffoldTickets.length}`);
-        console.log(`   🗄️  Schema: ${result.schemaTickets.filter((t) => t.type === 'scaffold').length}`);
-        console.log(`   ⚙️  Backend: ${result.backendTickets.filter((t) => t.type === 'scaffold').length}`);
-        console.log(`   🎨 Frontend: ${result.frontendTickets.filter((t) => t.type === 'scaffold').length}`);
+        console.log(`${'='.repeat(80)}`);
+        if (scaffoldTickets.length > 0) {
+            console.log(`\n🏗️  Scaffold Tickets (Template Adaptation): ${scaffoldTickets.length}`);
+            console.log(`   🗄️  Schema: ${result.schemaTickets.filter((t) => t.id.toUpperCase().startsWith('SCAFFOLD-')).length} (auto-validated)`);
+            console.log(`   ⚙️  Backend: ${result.backendTickets.filter((t) => t.id.toUpperCase().startsWith('SCAFFOLD-')).length}`);
+            console.log(`   🎨 Frontend: ${result.frontendTickets.filter((t) => t.id.toUpperCase().startsWith('SCAFFOLD-')).length}`);
+            console.log(`   🧪 Tests: ${result.testTickets.filter((t) => t.id.toUpperCase().startsWith('SCAFFOLD-')).length}`);
+        }
         console.log(`\n💡 Logic Tickets (Business Functionality): ${logicTickets.length}`);
-        console.log(`   🗄️  Schema: ${result.schemaTickets.filter((t) => t.type === 'logic').length}`);
-        console.log(`   ⚙️  Backend: ${result.backendTickets.filter((t) => t.type === 'logic').length}`);
-        console.log(`   🎨 Frontend: ${result.frontendTickets.filter((t) => t.type === 'logic').length}`);
+        console.log(`   🗄️  Schema: ${result.schemaTickets.filter((t) => t.id.toUpperCase().startsWith('LOGIC-')).length} (auto-validated)`);
+        console.log(`   ⚙️  Backend: ${result.backendTickets.filter((t) => t.id.toUpperCase().startsWith('LOGIC-')).length}`);
+        console.log(`   🎨 Frontend: ${result.frontendTickets.filter((t) => t.id.toUpperCase().startsWith('LOGIC-')).length}`);
+        console.log(`   🧪 Tests: ${result.testTickets.filter((t) => t.id.toUpperCase().startsWith('LOGIC-')).length}`);
         console.log(`\n📝 Total Tickets: ${result.totalTickets}`);
-        console.log(`${'='.repeat(60)}\n`);
+        console.log(`${'='.repeat(80)}\n`);
         // Display cost breakdown
         const costBreakdown = formatCostBreakdown({
             cost: result.cost,
@@ -499,7 +485,7 @@ export async function ticketsCommand(options) {
             filesReferenced: new Set(),
         });
         console.log(`💰 Total Cost: ${costBreakdown}\n`);
-        // Final confirmation (file already written incrementally)
+        // Final confirmation
         const outputFilename = options.output || 'tickets.json';
         const outputPath = join(result.projectPath, outputFilename);
         console.log(`✅ All tickets saved to: ${outputPath}\n`);