@kosuke-ai/cli 0.0.38 → 0.0.39

package/dist/kosuke/commands/tickets.js

@@ -2,10 +2,21 @@
  * 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)
+ * structured tickets with test coverage:
+ *
+ * SCAFFOLD BATCH:
+ *   1. Schema scaffold (database infrastructure)
+ *   2. DB test (validate scaffold schema)
+ *   3. Backend scaffold (API infrastructure)
+ *   4. Frontend scaffold (UI infrastructure)
+ *   5. Web tests (validate scaffold E2E)
+ *
+ * LOGIC BATCHES (1..N):
+ *   1. Schema logic (business entities)
+ *   2. DB test (validate logic schema)
+ *   3. Backend logic (business API)
+ *   4. Frontend logic (business UI)
+ *   5. Web tests (validate logic E2E)
  *
  * Claude Code Agent explores the specified directory (default: current directory)
  * to understand the existing codebase and generate contextual tickets.
@@ -23,10 +34,244 @@ 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';
+/**
+ * Analyze requirements to determine which layers are needed
+ */
+async function analyzeRequiredLayers(requirementsContent, projectPath) {
+    console.log('🔍 Analyzing requirements to determine needed layers...\n');
+    const systemPrompt = `You are an expert software architect analyzing requirements to determine which layers need changes.
+
+**Your Task:**
+Analyze the requirements and determine which layers (schema/backend/frontend) need changes.
+
+**Requirements:**
+${requirementsContent}
+
+**Context:**
+You have access to the project directory at: ${projectPath}
+Explore the codebase to understand the existing architecture and tech stack.
+
+**Analysis Criteria:**
+
+**Schema (Database):**
+- New tables, columns, or relationships
+- Changes to existing database structure
+- Data model modifications
+- Examples: "Add comments to posts", "Track user preferences", "Store session data"
+
+**Backend (API):**
+- New API endpoints or business logic
+- Changes to existing endpoints
+- Server-side processing or validation
+- Integration with external services
+- Examples: "Export data to CSV", "Send email notifications", "Process payments"
+
+**Frontend (UI):**
+- New pages, components, or user interactions
+- Changes to existing UI
+- User-facing features
+- Examples: "Add dark mode toggle", "Create dashboard", "Build user profile page"
+
+**Important:**
+- Simple UI changes (styling, layout) typically DON'T need backend or schema changes
+- Features involving data persistence ALWAYS need schema + backend + frontend
+- API-only features (webhooks, cron jobs) may not need frontend changes
+- Be precise - only include layers that are actually needed
+
+**Output Format:**
+Return ONLY a valid JSON object with this structure:
+{
+  "needsSchema": boolean,
+  "needsBackend": boolean,
+  "needsFrontend": boolean,
+  "reasoning": "Brief explanation of why each layer is or isn't needed"
+}
+
+No markdown, no code blocks, just raw JSON.`;
+    const agentResult = await runAgent('Analyze requirements and determine needed layers', {
+        systemPrompt,
+        cwd: projectPath,
+        maxTurns: 15,
+        verbosity: 'minimal',
+    });
+    // Parse response
+    try {
+        const jsonMatch = agentResult.response.match(/\{[\s\S]*\}/);
+        if (!jsonMatch) {
+            throw new Error('No JSON found in analysis response');
+        }
+        const analysis = JSON.parse(jsonMatch[0]);
+        // Validate structure
+        if (typeof analysis.needsSchema !== 'boolean' ||
+            typeof analysis.needsBackend !== 'boolean' ||
+            typeof analysis.needsFrontend !== 'boolean' ||
+            typeof analysis.reasoning !== 'string') {
+            throw new Error('Invalid analysis structure');
+        }
+        return analysis;
+    }
+    catch (error) {
+        console.error('❌ Failed to parse layer analysis:', error);
+        console.error('Raw response:', agentResult.response.substring(0, 500));
+        throw new Error(`Failed to analyze required layers: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Build system prompt for DB test ticket generation
+ */
+function buildDBTestPrompt(batchType, requirementsContent, projectPath, previousSchemaTickets) {
+    const ticketId = batchType === 'scaffold' ? 'DB-TEST-1' : 'DB-TEST-2';
+    const schemaTicketsContext = previousSchemaTickets
+        .map((t) => `**${t.id}: ${t.title}**\n${t.description}`)
+        .join('\n\n');
+    return `You are an expert QA engineer generating database validation test tickets.
+
+**Your Task:**
+Generate ONE database test ticket to validate the schema implementation from the tickets below.
+
+**Schema Tickets to Validate:**
+${schemaTicketsContext}
+
+**Database Test Ticket Goal:**
+Based on the schema tickets above, create a test that validates those tables were correctly created:
+1. Extract all table names mentioned in the schema tickets
+2. List all tables that need to be validated
+3. Create a test ticket that checks those tables exist
+
+**IMPORTANT:**
+- Do NOT explore the codebase
+- Do NOT look at existing schema files
+- ONLY use the schema tickets above to determine what tables to validate
+- The test should verify that the tables described in those tickets exist
+
+**Ticket Structure:**
+- id: "${ticketId}"
+- title: Clear description of what schema is being validated
+- description: Detailed test plan with:
+  * List of tables to validate (extracted from schema tickets above)
+  * What to check: verify all tables exist
+  * Success criteria: all tables from schema tickets exist in database
+- type: "db-test"
+- estimatedEffort: 1-3 (these are simple validation tests)
+- status: "Todo"
+- category: "database-validation"
+
+**Output Format:**
+Return ONLY a valid JSON array with ONE ticket. No markdown, no code blocks, just raw JSON.
+
+Example:
+[
+  {
+    "id": "DB-TEST-1",
+    "title": "Validate scaffold database schema",
+    "description": "Verify that the scaffold schema has been correctly implemented based on SCHEMA-SCAFFOLD-1:\\n\\nTables to validate:\\n- users\\n- user_subscriptions\\n- notifications\\n\\nValidation checks:\\n- Verify all tables exist\\n- Check table names are correct\\n\\nAcceptance Criteria:\\n- All tables from SCHEMA-SCAFFOLD-1 exist in database\\n- No schema errors",
+    "type": "db-test",
+    "estimatedEffort": 2,
+    "status": "Todo",
+    "category": "database-validation"
+  }
+]
+
+**Critical Instructions:**
+1. Analyze the schema tickets above to extract table names
+2. Generate a focused test ticket that validates those specific tables exist
+3. Reference the schema ticket IDs in the description
+4. Keep descriptions clear and actionable
+5. Return ONLY valid JSON - no explanations, no markdown formatting`;
+}
+/**
+ * Build system prompt for Web test ticket generation
+ */
+function buildWebTestPrompt(batchType, requirementsContent, projectPath, previousImplementationTickets, startingNumber) {
+    const backendTicketsContext = previousImplementationTickets.backend
+        .map((t) => `**${t.id}: ${t.title}**\n${t.description}`)
+        .join('\n\n');
+    const frontendTicketsContext = previousImplementationTickets.frontend
+        .map((t) => `**${t.id}: ${t.title}**\n${t.description}`)
+        .join('\n\n');
+    return `You are an expert QA engineer generating end-to-end web test tickets.
+
+**Your Task:**
+Generate web test tickets to validate the implementation from the backend and frontend tickets below.
+
+**Backend Tickets to Validate:**
+${backendTicketsContext || 'No backend tickets for this batch'}
+
+**Frontend Tickets to Validate:**
+${frontendTicketsContext || 'No frontend tickets for this batch'}
+
+**Web Test Ticket Goals:**
+Based on the implementation tickets above, create tests that validate those features work end-to-end:
+1. Analyze the backend and frontend tickets to understand what features were implemented
+2. Create test tickets that verify those features work correctly in the browser
+3. Focus on user-facing functionality and complete user flows
+
+**IMPORTANT:**
+- Do NOT explore the codebase
+- Do NOT look at existing frontend implementation
+- ONLY use the implementation tickets above to determine what to test
+- The tests should verify that the features described in those tickets work end-to-end
+
+Let Claude decide granularity based on complexity - could be:
+- One test per major user flow
+- One test covering multiple related features
+- Multiple tests for complex features
+
+**Ticket Structure:**
+Each ticket must have:
+- id: "WEB-TEST-${startingNumber}", "WEB-TEST-${startingNumber + 1}", etc. (sequential)
+- title: Clear description of what is being tested
+- description: Detailed test plan with:
+  * Reference to implementation tickets being tested
+  * User flow to test
+  * Steps to execute
+  * Expected outcomes (based on implementation tickets)
+  * Success criteria
+- type: "web-test"
+- estimatedEffort: number (1-10 based on test complexity)
+- status: "Todo"
+- category: feature name being tested
+
+**Output Format:**
+Return ONLY a valid JSON array of tickets. No markdown, no code blocks, just raw JSON.
+
+Example:
+[
+  {
+    "id": "WEB-TEST-1",
+    "title": "Test authentication flow (validates BACKEND-SCAFFOLD-1, FRONTEND-SCAFFOLD-1)",
+    "description": "Validate that the authentication implementation from BACKEND-SCAFFOLD-1 and FRONTEND-SCAFFOLD-1 works end-to-end:\\n\\nTest Flow:\\n1. Navigate to sign-in page\\n2. Enter credentials\\n3. Submit form\\n4. Verify redirect to dashboard\\n5. Check user session is active\\n\\nExpected Results (from implementation tickets):\\n- Sign-in successful\\n- User redirected to dashboard\\n- Protected content visible\\n\\nAcceptance Criteria:\\n- Authentication works as described in BACKEND-SCAFFOLD-1\\n- UI matches FRONTEND-SCAFFOLD-1 requirements\\n- No console errors\\n- Session persists correctly",
+    "type": "web-test",
+    "estimatedEffort": 5,
+    "status": "Todo",
+    "category": "authentication"
+  }
+]
+
+**Critical Instructions:**
+1. Analyze the implementation tickets above to extract features to test
+2. Generate test tickets that validate those specific features
+3. Reference the implementation ticket IDs in test descriptions
+4. Focus on end-to-end user flows that span backend + frontend
+5. Make descriptions detailed with clear steps
+6. Return ONLY valid JSON - no explanations, no markdown formatting
+7. Ensure ticket IDs are sequential starting from WEB-TEST-${startingNumber}`;
+}
 /**
  * Build system prompt for ticket generation with integrated analysis
  */
-function buildTicketGenerationPrompt(phase, ticketType, requirementsContent, projectPath) {
+function buildTicketGenerationPrompt(phase, ticketType, requirementsContent, projectPath, isScaffoldMode, previousTickets) {
+    // Handle test tickets differently
+    if (phase === 'db-test') {
+        return buildDBTestPrompt(ticketType, requirementsContent, projectPath, previousTickets?.schema || []);
+    }
+    if (phase === 'web-test') {
+        const startingNumber = previousTickets?.webTestStartNumber || 1;
+        return buildWebTestPrompt(ticketType, requirementsContent, projectPath, {
+            backend: previousTickets?.backend || [],
+            frontend: previousTickets?.frontend || [],
+        }, startingNumber);
+    }
     const phaseTypeKey = `${phase}_${ticketType}`;
     const phaseInstructions = {
         schema_scaffold: `
@@ -147,7 +392,8 @@ Assign appropriate category based on business domain:
 - Or use feature name (e.g., "user-management", "notifications", "analytics")
 - Keep categories consistent across related tickets
 `;
-    const templateBaseline = `
+    const contextualGuidance = isScaffoldMode
+        ? `
 **Kosuke Template Baseline (what the template already includes):**
 - **Authentication**: Better Auth with Email OTP
 - **User Model**: Individual users (no organizations/multi-tenancy by default)
@@ -174,8 +420,28 @@ For LOGIC tickets:
 - Focus on core business functionality
 - Implement application-specific features
 - Build domain models and workflows
+`
+        : `
+**Project Context:**
+Explore the codebase to understand:
+- Tech stack and framework versions (Next.js, React, etc.)
+- Existing architecture patterns (App Router, API routes, etc.)
+- Database schema structure and ORM (Drizzle, Prisma, etc.)
+- API route patterns and conventions
+- UI component library and styling approach
+- Testing framework and patterns
+- Authentication system (if any)
+- State management approach
+
+**Critical Instructions:**
+- Generate tickets that follow existing patterns in the codebase
+- Use the same naming conventions, file structure, and code style
+- Leverage existing utilities and components where possible
+- Match the existing tech stack (don't introduce new frameworks)
+- Follow the project's architectural decisions
+- Maintain consistency with existing code quality standards
 `;
-    return `You are an expert software architect generating implementation tickets for a Kosuke Template project.
+    return `You are an expert software architect generating implementation tickets for ${isScaffoldMode ? 'a Kosuke Template project' : 'an existing project'}.
 
 **Your Task:**
 ${phaseInstructions[phaseTypeKey]}
@@ -183,11 +449,11 @@ ${phaseInstructions[phaseTypeKey]}
 **Requirements Document:**
 ${requirementsContent}
 
-${templateBaseline}
+${contextualGuidance}
 
 **Context:**
 You have access to the project directory at: ${projectPath}
-The template baseline is documented in CLAUDE.md.
+${isScaffoldMode ? 'The template baseline is documented in CLAUDE.md.' : ''}
 Explore the codebase to understand the tech stack, architecture patterns, and coding conventions.
 
 **Ticket Structure:**
@@ -246,11 +512,12 @@ function parseTicketsFromResponse(response, phase, ticketType) {
         if (!Array.isArray(tickets)) {
             throw new Error(`Expected array of tickets, got ${typeof tickets}`);
         }
+        const validTypes = ['scaffold', 'logic', 'db-test', 'web-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' ||
@@ -284,29 +551,37 @@ function writeTicketsToFile(outputPath, tickets) {
 /**
  * Generate tickets for a specific phase and type
  */
-async function generatePhaseTickets(phase, ticketType, requirementsContent, projectPath, outputPath, existingTickets) {
+async function generatePhaseTickets(phase, ticketType, requirementsContent, projectPath, outputPath, existingTickets, isScaffoldMode, previousTickets) {
     const phaseEmoji = {
         schema: '🗄️',
         backend: '⚙️',
         frontend: '🎨',
+        'db-test': '🧪',
+        'web-test': '🌐',
     };
     const typeEmoji = {
         scaffold: '🏗️',
         logic: '💡',
+        'db-test': '🧪',
+        'web-test': '🌐',
     };
     const phaseName = {
         schema: 'Schema',
         backend: 'Backend',
         frontend: 'Frontend',
+        'db-test': 'DB Test',
+        'web-test': 'Web Test',
     };
     const typeName = {
         scaffold: 'Scaffold',
         logic: 'Logic',
+        'db-test': 'DB Test',
+        'web-test': 'Web Test',
     };
     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 systemPrompt = buildTicketGenerationPrompt(phase, ticketType, requirementsContent, projectPath, isScaffoldMode, previousTickets);
     const agentResult = await runAgent(`Generate ${phaseName[phase]} ${typeName[ticketType]} tickets from the requirements.`, {
         systemPrompt,
         cwd: projectPath,
@@ -335,7 +610,8 @@ async function generatePhaseTickets(phase, ticketType, requirementsContent, proj
  * Core tickets logic
  */
 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,21 +623,56 @@ 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 (infrastructure + logic)' : 'Logic-only (smart layer detection)'}\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');
+    }
+    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`);
     }
-    const requirementsContent = readFileSync(requirementsPath, 'utf-8');
-    console.log(`   ✅ Loaded ${path} (${requirementsContent.length} characters)\n`);
     // 3. Determine output path for incremental writes
     const outputFilename = options.output || 'tickets.json';
     const outputPath = join(projectPath, outputFilename);
-    // 4. Generate tickets in six phases (scaffold + logic for each)
+    // 4. Analyze required layers (only in logic-only mode)
+    let layerAnalysis = null;
+    if (!isScaffoldMode) {
+        layerAnalysis = await analyzeRequiredLayers(requirementsContent, projectPath);
+        console.log(`\n📊 Layer Analysis:`);
+        console.log(`   Schema (DB):   ${layerAnalysis.needsSchema ? '✅ Required' : '⏭️  Skip'}`);
+        console.log(`   Backend (API): ${layerAnalysis.needsBackend ? '✅ Required' : '⏭️  Skip'}`);
+        console.log(`   Frontend (UI): ${layerAnalysis.needsFrontend ? '✅ Required' : '⏭️  Skip'}`);
+        console.log(`\n💭 Reasoning: ${layerAnalysis.reasoning}\n`);
+    }
+    // 5. Generate tickets in the new structure with tests
     let totalInputTokens = 0;
     let totalOutputTokens = 0;
     let totalCacheCreationTokens = 0;
@@ -371,70 +682,125 @@ export async function ticketsCore(options) {
     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);
+    // Helper to add metrics from a phase result
+    const addMetrics = (result) => {
+        allTickets = [...allTickets, ...result.tickets];
+        totalInputTokens += result.tokensUsed.input;
+        totalOutputTokens += result.tokensUsed.output;
+        totalCacheCreationTokens += result.tokensUsed.cacheCreation;
+        totalCacheReadTokens += result.tokensUsed.cacheRead;
+        totalCost += result.cost;
+        allConversationMessages.push(...result.conversationMessages);
+    };
+    // ==================== SCAFFOLD MODE ====================
+    if (isScaffoldMode) {
+        console.log('\n' + '='.repeat(80));
+        console.log('🏗️  SCAFFOLD BATCH - Infrastructure Setup');
+        console.log('='.repeat(80));
+        // Track batch tickets for test generation
+        let batchSchemaTickets = [];
+        let batchBackendTickets = [];
+        let batchFrontendTickets = [];
+        // 1. Schema Scaffold
+        const schemaScaffoldResult = await generatePhaseTickets('schema', 'scaffold', requirementsContent, projectPath, outputPath, allTickets, isScaffoldMode);
+        addMetrics(schemaScaffoldResult);
+        batchSchemaTickets = schemaScaffoldResult.tickets;
+        // 2. DB Test (validate scaffold schema)
+        addMetrics(await generatePhaseTickets('db-test', 'scaffold', requirementsContent, projectPath, outputPath, allTickets, isScaffoldMode, { schema: batchSchemaTickets }));
+        // 3. Backend Scaffold
+        const backendScaffoldResult = await generatePhaseTickets('backend', 'scaffold', requirementsContent, projectPath, outputPath, allTickets, isScaffoldMode);
+        addMetrics(backendScaffoldResult);
+        batchBackendTickets = backendScaffoldResult.tickets;
+        // 4. Frontend Scaffold
+        const frontendScaffoldResult = await generatePhaseTickets('frontend', 'scaffold', requirementsContent, projectPath, outputPath, allTickets, isScaffoldMode);
+        addMetrics(frontendScaffoldResult);
+        batchFrontendTickets = frontendScaffoldResult.tickets;
+        // 5. Web Tests (validate scaffold E2E)
+        addMetrics(await generatePhaseTickets('web-test', 'scaffold', requirementsContent, projectPath, outputPath, allTickets, isScaffoldMode, {
+            backend: batchBackendTickets,
+            frontend: batchFrontendTickets,
+            webTestStartNumber: 1,
+        }));
+        // ==================== LOGIC BATCH ====================
+        console.log('\n' + '='.repeat(80));
+        console.log('💡 LOGIC BATCH - Business Functionality');
+        console.log('='.repeat(80));
+        // Reset batch tracking for logic
+        batchSchemaTickets = [];
+        batchBackendTickets = [];
+        batchFrontendTickets = [];
+        // 1. Schema Logic
+        const schemaLogicResult = await generatePhaseTickets('schema', 'logic', requirementsContent, projectPath, outputPath, allTickets, isScaffoldMode);
+        addMetrics(schemaLogicResult);
+        batchSchemaTickets = schemaLogicResult.tickets;
+        // 2. DB Test (validate logic schema)
+        addMetrics(await generatePhaseTickets('db-test', 'logic', requirementsContent, projectPath, outputPath, allTickets, isScaffoldMode, { schema: batchSchemaTickets }));
+        // 3. Backend Logic
+        const backendLogicResult = await generatePhaseTickets('backend', 'logic', requirementsContent, projectPath, outputPath, allTickets, isScaffoldMode);
+        addMetrics(backendLogicResult);
+        batchBackendTickets = backendLogicResult.tickets;
+        // 4. Frontend Logic
+        const frontendLogicResult = await generatePhaseTickets('frontend', 'logic', requirementsContent, projectPath, outputPath, allTickets, isScaffoldMode);
+        addMetrics(frontendLogicResult);
+        batchFrontendTickets = frontendLogicResult.tickets;
+        // 5. Web Tests (validate logic E2E)
+        const currentWebTestCount = allTickets.filter((t) => t.id.startsWith('WEB-TEST-')).length;
+        addMetrics(await generatePhaseTickets('web-test', 'logic', requirementsContent, projectPath, outputPath, allTickets, isScaffoldMode, {
+            backend: batchBackendTickets,
+            frontend: batchFrontendTickets,
+            webTestStartNumber: currentWebTestCount + 1,
+        }));
+    }
+    else {
+        // ==================== LOGIC-ONLY MODE ====================
+        console.log('\n' + '='.repeat(80));
+        console.log('💡 LOGIC-ONLY MODE - Smart Layer Detection');
+        console.log('='.repeat(80));
+        // Track tickets for test generation
+        let schemaTickets = [];
+        let backendTickets = [];
+        let frontendTickets = [];
+        // 1. Schema Logic (if needed)
+        if (layerAnalysis?.needsSchema) {
+            const schemaLogicResult = await generatePhaseTickets('schema', 'logic', requirementsContent, projectPath, outputPath, allTickets, isScaffoldMode);
+            addMetrics(schemaLogicResult);
+            schemaTickets = schemaLogicResult.tickets;
+            // DB Test (validate schema)
+            if (schemaTickets.length > 0) {
+                addMetrics(await generatePhaseTickets('db-test', 'logic', requirementsContent, projectPath, outputPath, allTickets, isScaffoldMode, { schema: schemaTickets }));
+            }
+        }
+        // 2. Backend Logic (if needed)
+        if (layerAnalysis?.needsBackend) {
+            const backendLogicResult = await generatePhaseTickets('backend', 'logic', requirementsContent, projectPath, outputPath, allTickets, isScaffoldMode);
+            addMetrics(backendLogicResult);
+            backendTickets = backendLogicResult.tickets;
+        }
+        // 3. Frontend Logic (if needed)
+        if (layerAnalysis?.needsFrontend) {
+            const frontendLogicResult = await generatePhaseTickets('frontend', 'logic', requirementsContent, projectPath, outputPath, allTickets, isScaffoldMode);
+            addMetrics(frontendLogicResult);
+            frontendTickets = frontendLogicResult.tickets;
+        }
+        // 4. Web Tests (if backend or frontend tickets generated)
+        if (backendTickets.length > 0 || frontendTickets.length > 0) {
+            addMetrics(await generatePhaseTickets('web-test', 'logic', requirementsContent, projectPath, outputPath, allTickets, isScaffoldMode, {
+                backend: backendTickets,
+                frontend: frontendTickets,
+                webTestStartNumber: 1,
+            }));
+        }
+    }
     // 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-'));
+    const testTickets = allTickets.filter((t) => t.id.startsWith('DB-TEST-') || t.id.startsWith('WEB-TEST-'));
     return {
         schemaTickets,
         backendTickets,
         frontendTickets,
+        testTickets,
         totalTickets: allTickets.length,
         projectPath,
         tokensUsed: {
@@ -477,6 +843,8 @@ export async function ticketsCommand(options) {
             ...result.backendTickets,
             ...result.frontendTickets,
         ].filter((t) => t.type === 'logic');
+        const dbTestTickets = result.testTickets.filter((t) => t.type === 'db-test');
+        const webTestTickets = result.testTickets.filter((t) => t.type === 'web-test');
         console.log(`\n${'='.repeat(60)}`);
         console.log('📊 Ticket Generation Summary');
         console.log(`${'='.repeat(60)}`);
@@ -488,6 +856,9 @@ export async function ticketsCommand(options) {
         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(`\n🧪 Test Tickets: ${result.testTickets.length}`);
+        console.log(`   🧪 Database Tests: ${dbTestTickets.length}`);
+        console.log(`   🌐 Web Tests: ${webTestTickets.length}`);
         console.log(`\n📝 Total Tickets: ${result.totalTickets}`);
         console.log(`${'='.repeat(60)}\n`);
         // Display cost breakdown