@kosuke-ai/cli 0.0.44 → 0.0.45

package/dist/kosuke/commands/plan.js

@@ -16,14 +16,12 @@
  *   kosuke plan --prompt="Fix login timeout bug" --dir=./app
  *   kosuke plan --prompt="Add notes feature" --no-test  # Skip WEB-TEST tickets
  */
-import Anthropic from '@anthropic-ai/sdk';
-import { existsSync, mkdirSync, readFileSync, readdirSync, statSync } from 'fs';
+import { existsSync, mkdirSync, statSync } from 'fs';
 import { join, resolve } from 'path';
-import { glob } from 'glob';
-import { calculateCost } from '../utils/claude-agent.js';
+import { formatCostBreakdown, runAgent, runAgentStream } from '../utils/claude-agent.js';
 import { askQuestion } from '../utils/interactive-input.js';
 import { logger, setupCancellationHandler } from '../utils/logger.js';
-import { processAndWriteTickets, sortTicketsByOrder } from '../utils/tickets-manager.js';
+import { parseTickets, processAndWriteTickets } from '../utils/tickets-manager.js';
 /**
  * Generate timestamp-based tickets path in tickets/ folder
  * Creates the tickets/ folder if it doesn't exist
@@ -40,752 +38,431 @@ function generateTicketsPath(cwd) {
         .toISOString()
         .replace(/[T:]/g, '-')
         .replace(/\.\d{3}Z$/, '');
-    return join(ticketsDir, `${timestamp}.ticket.json`);
-}
-/**
- * Tool definitions for planning - includes file exploration and ticket generation
- */
-const PLAN_TOOLS = [
-    {
-        name: 'read_file',
-        description: 'Read the contents of a file. Use this to explore the codebase and understand existing patterns, conventions, and implementations.',
-        input_schema: {
-            type: 'object',
-            properties: {
-                path: {
-                    type: 'string',
-                    description: 'Path to the file to read (relative to project root)',
-                },
-            },
-            required: ['path'],
-        },
-    },
-    {
-        name: 'list_directory',
-        description: 'List files and directories in a given path. Use this to explore the project structure.',
-        input_schema: {
-            type: 'object',
-            properties: {
-                path: {
-                    type: 'string',
-                    description: 'Path to the directory to list (relative to project root, use "." for root)',
-                },
-            },
-            required: ['path'],
-        },
-    },
-    {
-        name: 'glob_search',
-        description: 'Find files matching a glob pattern. Use this to find specific file types or locate files by name pattern.',
-        input_schema: {
-            type: 'object',
-            properties: {
-                pattern: {
-                    type: 'string',
-                    description: 'Glob pattern to match (e.g., "**/*.ts", "lib/db/**/*.ts", "**/schema*.ts")',
-                },
-            },
-            required: ['pattern'],
-        },
-    },
-    {
-        name: 'write_tickets',
-        description: 'Create tickets.json file with implementation tickets. Use this when all clarification questions have been answered and you have enough information to create actionable tickets.',
-        input_schema: {
-            type: 'object',
-            properties: {
-                tickets: {
-                    type: 'array',
-                    description: 'Array of tickets to create',
-                    items: {
-                        type: 'object',
-                        properties: {
-                            id: {
-                                type: 'string',
-                                description: 'Ticket ID with prefix: PLAN-SCHEMA- for database, PLAN-ENGINE- for Python microservice, PLAN-BACKEND- for API, PLAN-FRONTEND- for UI, PLAN-WEB-TEST- for E2E tests',
-                            },
-                            title: {
-                                type: 'string',
-                                description: 'Short descriptive title',
-                            },
-                            description: {
-                                type: 'string',
-                                description: 'Detailed description with acceptance criteria, implementation notes, and technical requirements based on codebase analysis',
-                            },
-                            type: {
-                                type: 'string',
-                                enum: ['schema', 'engine', 'backend', 'frontend', 'test'],
-                                description: 'Ticket type: schema (database), engine (Python microservice), backend (API), frontend (UI), test (E2E)',
-                            },
-                            estimatedEffort: {
-                                type: 'number',
-                                description: 'Effort estimate 1-10',
-                            },
-                            category: {
-                                type: 'string',
-                                description: 'Feature category (e.g., auth, billing, tasks, ui)',
-                            },
-                        },
-                        required: ['id', 'title', 'description', 'type', 'estimatedEffort'],
-                    },
-                },
-            },
-            required: ['tickets'],
-        },
-    },
-];
-/**
- * Read CLAUDE.md from project directory if it exists
- */
-function readClaudeMd(cwd) {
-    const claudeMdPath = join(cwd, 'CLAUDE.md');
-    if (existsSync(claudeMdPath)) {
-        try {
-            return readFileSync(claudeMdPath, 'utf-8');
-        }
-        catch {
-            return null;
-        }
-    }
-    return null;
+    return join(ticketsDir, `${timestamp}.tickets.json`);
 }
 /**
  * Build system prompt for plan command
- * @param claudeMdContent - Content of CLAUDE.md file if it exists
+ *
+ * Two-phase workflow:
+ * - Phase 1: Ask clarification questions (non-technical, user-focused)
+ * - Phase 2: Generate tickets via write_tickets tool
+ *
  * @param noTest - If true, exclude WEB-TEST tickets from generation
  */
-function buildPlanSystemPrompt(claudeMdContent, noTest = false) {
-    const claudeSection = claudeMdContent
-        ? `
-
-**PROJECT CONTEXT (from CLAUDE.md):**
+function buildPlanSystemPrompt(noTest = false) {
+    const testGuidelines = noTest
+        ? ''
+        : `
 
-${claudeMdContent}
+**E2E Test Tickets:**
+- Find test users in seed files (\`lib/db/seed.ts\`)
+- Pattern: \`*+kosuke_test@example.com\` → OTP: \`424242\`
+- Required: Test credentials, numbered steps, clear element descriptions, acceptance criteria`;
+    return `# ROLE: TICKET PLANNER
 
----
-`
-        : '';
-    return `You are an expert software architect helping plan implementation tickets for a feature or bug fix.
+**YOUR PRIMARY OBJECTIVE:** Create implementation tickets that developers will use to build the feature. You analyze requirements and break them into structured, actionable tickets.
 
-**YOUR PRIMARY OBJECTIVE:** Gather enough information through clarification questions to create actionable implementation tickets that can be processed by an automated build system.
-${claudeSection}
 **Your Workflow:**
 
-1. **Explore Codebase**:
-   - Use list_directory to explore relevant parts of the codebase
-   - Read existing similar implementations to understand patterns
-   - Analyze what the user wants to achieve
-   - Identify what's unclear or needs user input
+**Phase 1:** Ask clarification questions (non-technical, user-focused)
+**Phase 2:** Output raw JSON tickets array
+
+**Critical Rules:**
+- NEVER start implementation - you only create tickets
+- NEVER create/edit files, install packages, or use Task tool
+- ALWAYS explore codebase (Read/Grep/Glob) to understand patterns before asking questions
+- YOU decide technical implementation details based on existing codebase
+
+## Phase 1: Ask Clarification Questions
 
-2. **Ask Clarification Questions**: Present questions in this format:
+When a user describes a feature request, analyze the codebase (Read/Grep/Glob) to understand existing patterns, then ask **ONLY business/UX questions** (not technical implementation questions).
+
+**Your first response MUST use this exact format:**
 
 ---
 ## Understanding Your Request
-
-[Brief summary of what you understood]
+[Brief business summary - what the user wants to achieve, NOT implementation details]
 
 ## Clarification Questions
 
-For each question, provide BOTH the question AND a recommended approach:
+For each clarification needed, provide BOTH a question AND a recommended approach:
 
 1. **[Topic]**
-   - Question: [User-focused question - NOT technical]
-   - 💡 Recommendation: [Simple, practical default choice]
+   - Question: [Non-technical user question]
+   - 💡 Recommendation: [Default choice that simplifies scope]
+
+2. **[Topic]**  
+   - Question: [Non-technical user question]
+   - 💡 Recommendation: [Default choice that simplifies scope]
 
-2. **[Topic]**
-   - Question: [User-focused question - NOT technical]
-   - 💡 Recommendation: [Simple, practical default choice]
+(Add as many questions as needed)
 
-**Quick Option:** Reply "go with recommendations" to accept all defaults.
+**Quick Response Option:** You can reply "go for recommendations" to accept all recommended approaches at once.
 ---
 
-3. **Iterative Refinement**: As the user answers:
-   - If user says "go with recommendations", accept all defaults
-   - If user provides specific answers, incorporate them
-   - Ask follow-up questions ONLY if critical information is still missing
-   - Bias towards simplicity - this is an MVP
+**ALLOWED QUESTIONS (User/Business Focus):**
+- What data to show/hide, empty state behavior
+- Error messages users see
+- Permission rules (who can do what)
+- User workflow and steps
 
-4. **Generate Tickets**: Once requirements are clear, use \`write_tickets\` tool to create tickets:
+**FORBIDDEN QUESTIONS (Technical - YOU decide these):**
+- Which library to use (jsPDF, PDFKit, etc.)
+- Backend vs client-side generation
+- API design (REST, tRPC, GraphQL)
+- Database queries or ORM choice
+- Component structure or styling
+- Performance optimization techniques
 
-**Ticket Types & Prefixes:**
-- \`PLAN-SCHEMA-N\`: Database schema changes (Drizzle ORM migrations)
-- \`PLAN-ENGINE-N\`: Python microservice (FastAPI endpoints)
-- \`PLAN-BACKEND-N\`: API/server-side logic (tRPC, server actions)
-- \`PLAN-FRONTEND-N\`: UI components and pages (React, Next.js)
+**YOU decide all technical choices** based on existing codebase patterns.
 
-**When to use ENGINE vs BACKEND:**
-- **Use BACKEND (Next.js)** for: CRUD operations, auth logic, business rules, anything TypeScript handles well (90% of features)
-- **Use ENGINE (Python)** for: ML/AI, data science (numpy/pandas), complex algorithms, PDF/document parsing, image processing, or when Python libraries are required${noTest
-        ? ''
-        : `
-- \`PLAN-WEB-TEST-N\`: E2E tests (Playwright, browser testing)`}
+**Language Reminders:**
+- ⚠️ NEVER say: "I'll implement", "Let me build", "Now I'll create the files"
+- ✅ INSTEAD say: "I'll create tickets for", "The tickets will include"
 
-**Ticket Order (build system processes in this order):**
-1. PLAN-SCHEMA tickets first (database changes)
-2. PLAN-ENGINE tickets (Python microservice - so backend can call it)
-3. PLAN-BACKEND tickets (API layer)
-4. PLAN-FRONTEND tickets (UI layer)${noTest
-        ? ''
-        : `
-5. PLAN-WEB-TEST tickets last (validate everything works)
-
-**WEB TEST TICKETS - Playwright MCP E2E Tests:**
-
-Web test tickets are executed by Playwright MCP with Claude AI. Follow these guidelines:
-
-**Test User Discovery:**
-- Read seed files (lib/db/seed.ts or src/lib/db/seed.ts) to find test users
-- Pattern: Any email ending with "+kosuke_test@example.com" uses OTP code "424242"
-- Example: john+kosuke_test@example.com → OTP: 424242
-
-**Each Web Test Ticket MUST Include:**
-1. **Test User Credentials** (at the top)
-   - Email addresses of test users
-   - OTP code: 424242
-   - User roles if applicable
-
-2. **Test Steps** (numbered, detailed natural language)
-   - Navigation: "Navigate to /sign-in"
-   - Interactions: "Click button labeled 'New Task'"
-   - Inputs: "Enter 'Test Task' in title field"
-   - Expected outcomes: "Expected: Task appears in list"
-   - Use CLEAR element descriptions (button text, labels)
-
-3. **Acceptance Criteria**
-   - Final expected state
-   - Data validation points
-
-**Authentication Steps Template:**
-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 main app`}
-
-**CRITICAL RULES FOR QUESTIONS:**
-- Questions must be NON-TECHNICAL and USER-FOCUSED
-- Focus ONLY on user experience, behavior, and business logic
-- YOU decide all technical/algorithmic details (libraries, caching, performance, architecture)
-- Never ask about: URLs, database design, APIs, algorithms, processing timing, or implementation approach
-- Include technical decisions in ticket DESCRIPTIONS, not in questions to users
+## Phase 2: Generate Tickets
 
-**Examples:**
-- ❌ BAD: "Should we cache results or process on-demand?"
-- ❌ BAD: "Should this use Python or TypeScript?"
-- ✅ GOOD: "Should invoices be per-user or shared per company?"
-- ✅ GOOD: "For empty descriptions, show neutral mood or hide it?"
+Once the user answers questions OR says "go for recommendations", immediately output a raw JSON array of tickets.
 
-**Ticket Generation Rules:**
-- Generate only the tickets actually needed
-- Ensure tickets are atomic and independently implementable
-- Include clear acceptance criteria in each ticket description
+**Critical:**
+- DO NOT say "Now I'll implement" or show "Implementation Plan" - you're creating TICKETS, not implementing
+- DO NOT read more files after Phase 1 completes
+- Your ENTIRE response = JSON array (no markdown wrapping, no explanations)
+- Output starts with "[" and ends with "]"
 
-**Example Tickets (Full JSON):**
+**Required JSON Format:**
 [
-  {
-    "id": "PLAN-SCHEMA-1",
-    "title": "Create tasks schema",
-    "description": "Create database schema for tasks feature:\\n- Create taskStatusEnum: 'todo', 'in_progress', 'done'\\n- Create tasks table with userId foreign key\\n- Export inferred types\\n\\n**Acceptance Criteria:**\\n- Tasks table created\\n- Enums defined at database level\\n- Migrations generated\\n\\n**Technical Notes:**\\n- Follow existing schema patterns in lib/db/schema/\\n- Use Drizzle ORM conventions",
-    "type": "schema",
-    "estimatedEffort": 4,
-    "category": "tasks"
-  },
   {
     "id": "PLAN-BACKEND-1",
-    "title": "Create tasks tRPC router",
-    "description": "Create backend API for tasks:\\n- Create lib/trpc/routers/tasks.ts\\n- Implement CRUD operations (list, create, update, delete)\\n- Server-side filtering by status\\n\\n**Acceptance Criteria:**\\n- All CRUD operations work\\n- Authorization enforced\\n- Type-safe implementation",
+    "title": "Add PDF export endpoint to orders router",
+    "description": "Create tRPC endpoint that generates PDF.\\n\\n**Acceptance Criteria:**\\n- Accepts filter parameters\\n- Returns PDF file\\n- Respects filters",
     "type": "backend",
     "estimatedEffort": 5,
-    "category": "tasks"
+    "status": "Todo",
+    "category": "orders"
   },
   {
     "id": "PLAN-FRONTEND-1",
-    "title": "Create tasks page with list and filters",
-    "description": "Create tasks management UI:\\n- Create app/(logged-in)/tasks/page.tsx\\n- Task list with status filters\\n- Add new task dialog\\n- Edit/delete actions\\n\\n**Acceptance Criteria:**\\n- Task list displays correctly\\n- Filters work\\n- CRUD operations functional\\n- Responsive design\\n\\n**Technical Notes:**\\n- Use existing UI components from components/ui/\\n- Follow page patterns from existing routes",
+    "title": "Add PDF export button to orders table",
+    "description": "Add button to toolbar.\\n\\n**Acceptance Criteria:**\\n- Button visible\\n- Downloads PDF\\n- Shows loading state",
     "type": "frontend",
-    "estimatedEffort": 6,
-    "category": "tasks"
-  },
+    "estimatedEffort": 4,
+    "status": "Todo",
+    "category": "orders"
+  }${noTest
+        ? ''
+        : `,
   {
     "id": "PLAN-WEB-TEST-1",
-    "title": "E2E: User creates and manages tasks",
-    "description": "**Test User Credentials:**\\n- Email: john+kosuke_test@example.com\\n- OTP Code: 424242\\n\\n**Test Steps:**\\n\\n1. **Sign in**\\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'\\n   - Expected: Redirected to /tasks\\n\\n2. **Create task**\\n   - Click 'New Task' button\\n   - Enter title: 'Test Task'\\n   - Click 'Create'\\n   - Expected: Task appears in list\\n\\n3. **Delete task**\\n   - Click delete button on task\\n   - Confirm deletion\\n   - Expected: Task removed\\n\\n**Acceptance Criteria:**\\n- User authenticates successfully\\n- Task CRUD operations work\\n- UI provides feedback",
+    "title": "E2E: Test PDF export with filters",
+    "description": "**Test User:** john+kosuke_test@example.com (OTP: 424242)\\n\\n**Steps:**\\n1. Sign in\\n2. Apply filters\\n3. Click PDF export\\n4. Verify download\\n\\n**Acceptance Criteria:**\\n- PDF downloads\\n- Contains filtered data",
     "type": "test",
-    "estimatedEffort": 4,
-    "category": "tasks"
-  }
-]`;
-}
-/**
- * Execute read_file tool
- */
-function executeReadFile(toolInput, cwd) {
-    try {
-        const filePath = toolInput.path;
-        const fullPath = join(cwd, filePath);
-        if (!existsSync(fullPath)) {
-            return { success: false, content: `File not found: ${filePath}` };
-        }
-        const stats = statSync(fullPath);
-        if (stats.isDirectory()) {
-            return { success: false, content: `Path is a directory, not a file: ${filePath}` };
-        }
-        const content = readFileSync(fullPath, 'utf-8');
-        console.log(`\n   📖 Reading: ${filePath}`);
-        return { success: true, content };
-    }
-    catch (error) {
-        const msg = error instanceof Error ? error.message : String(error);
-        return { success: false, content: `Error reading file: ${msg}` };
-    }
-}
-/**
- * Execute list_directory tool
- */
-function executeListDirectory(toolInput, cwd) {
-    try {
-        const dirPath = toolInput.path || '.';
-        const fullPath = join(cwd, dirPath);
-        if (!existsSync(fullPath)) {
-            return { success: false, content: `Directory not found: ${dirPath}` };
-        }
-        const stats = statSync(fullPath);
-        if (!stats.isDirectory()) {
-            return { success: false, content: `Path is not a directory: ${dirPath}` };
-        }
-        const entries = readdirSync(fullPath);
-        const items = [];
-        // Filter out common ignored directories
-        const ignoreDirs = ['node_modules', '.git', 'dist', 'build', '.next', '__pycache__', '.tmp'];
-        for (const entry of entries.sort()) {
-            if (entry.startsWith('.') && entry !== '.env.example')
-                continue;
-            if (ignoreDirs.includes(entry))
-                continue;
-            const entryPath = join(fullPath, entry);
-            try {
-                const entryStat = statSync(entryPath);
-                if (entryStat.isDirectory()) {
-                    items.push(`📁 ${entry}/`);
-                }
-                else {
-                    items.push(`📄 ${entry}`);
-                }
-            }
-            catch {
-                items.push(`❓ ${entry}`);
-            }
-        }
-        console.log(`\n   📂 Listing: ${dirPath}`);
-        return { success: true, content: items.join('\n') || '(empty directory)' };
-    }
-    catch (error) {
-        const msg = error instanceof Error ? error.message : String(error);
-        return { success: false, content: `Error listing directory: ${msg}` };
-    }
+    "estimatedEffort": 3,
+    "status": "Todo",
+    "category": "orders"
+  }`}
+]
+
+**CRITICAL - Exact Ticket ID Format (MUST MATCH):**
+- PLAN-SCHEMA-1, PLAN-SCHEMA-2, ... → type: "schema"
+- PLAN-ENGINE-1, PLAN-ENGINE-2, ... → type: "engine"
+- PLAN-BACKEND-1, PLAN-BACKEND-2, ... → type: "backend"
+- PLAN-FRONTEND-1, PLAN-FRONTEND-2, ... → type: "frontend"${noTest ? '' : '\n- PLAN-WEB-TEST-1, PLAN-WEB-TEST-2, ... → type: "test"'}
+
+**Required Fields (every ticket):**
+- id: Exact format above (NOT "PLAN-TEST-1", use "PLAN-WEB-TEST-1")
+- title: Short descriptive title
+- description: Details with **Acceptance Criteria:** section (use \\n for newlines)
+- type: MUST be one of: "schema", "engine", "backend", "frontend"${noTest ? '' : ', "test"'}
+- estimatedEffort: Integer from 1 to 10
+- status: ALWAYS "Todo"
+- category: Optional (e.g., "orders", "auth", "billing")
+
+**Dependency order:** SCHEMA → ENGINE → BACKEND → FRONTEND${noTest ? '' : ' → WEB-TEST'}
+${testGuidelines}
+
+🚨 **WHEN USER SAYS "go for recommendations" OR ANSWERS YOUR QUESTIONS:**
+
+YOU ARE NOW IN PHASE 2. EXPLORATION IS OVER.
+
+DO NOT:
+- Read more files
+- Search for packages  
+- Say "Now I'll implement" or "Let me create"
+- Use Task tool
+- Show "Implementation Plan"
+- Add any text before or after the JSON
+
+IMMEDIATELY OUTPUT THE JSON ARRAY. Your ENTIRE response = JSON array starting with "[" and ending with "]".
+
+**Examples:**
+
+❌ WRONG: \`Perfect! Now I'll implement... [shows implementation plan]\`
+❌ WRONG: \`Great! I'll create the tickets. \\\`\\\`\\\`json [...] \\\`\\\`\\\`\` (markdown wrapping)
+❌ WRONG: \`Now I'll update the files...\`
+
+✅ CORRECT: \`[{"id": "PLAN-BACKEND-1", "title": "Add PDF export endpoint", ...}]\`
+
+Just the raw JSON array. No explanatory text. No markdown code fences. No "Now I'll implement" language.`;
 }
 /**
- * Execute glob_search tool
+ * Shared setup for plan agent configuration
  */
-async function executeGlobSearch(toolInput, cwd) {
-    try {
-        const pattern = toolInput.pattern;
-        const files = await glob(pattern, {
-            cwd,
-            nodir: true,
-            ignore: ['node_modules/**', '.git/**', 'dist/**', 'build/**', '.next/**', '__pycache__/**'],
-        });
-        if (files.length === 0) {
-            return { success: true, content: `No files found matching: ${pattern}` };
-        }
-        // Limit results
-        const maxResults = 50;
-        const truncated = files.length > maxResults;
-        const displayFiles = files.slice(0, maxResults);
-        console.log(`\n   🔍 Found ${files.length} file(s) matching: ${pattern}`);
-        let content = displayFiles.join('\n');
-        if (truncated) {
-            content += `\n\n...[showing ${maxResults} of ${files.length} files]`;
-        }
-        return { success: true, content };
+function createPlanAgentConfig(options) {
+    const { prompt, directory, noTest = false, resume } = options;
+    // Validate directory
+    const cwd = directory ? resolve(directory) : process.cwd();
+    if (!existsSync(cwd)) {
+        return { error: `Directory not found: ${cwd}` };
     }
-    catch (error) {
-        const msg = error instanceof Error ? error.message : String(error);
-        return { success: false, content: `Error searching files: ${msg}` };
+    const stats = statSync(cwd);
+    if (!stats.isDirectory()) {
+        return { error: `Path is not a directory: ${cwd}` };
     }
+    const ticketsPath = generateTicketsPath(cwd);
+    const systemPrompt = buildPlanSystemPrompt(noTest);
+    const config = {
+        systemPrompt,
+        cwd,
+        maxTurns: 40, // Increased for complex planning sessions with multiple files to analyze
+        verbosity: 'verbose',
+        permissionMode: 'bypassPermissions',
+        // Restrict to read-only tools only
+        // Block all code editing, execution, task management, and agent control tools
+        disallowedTools: [
+            'Edit', // File editing
+            'Write', // File creation
+            'Delete', // File deletion
+            'NotebookEdit', // Notebook editing
+            'Bash', // Shell execution
+            'Task', // Sub-agent spawning (prevents implementation subtasks)
+            'TodoWrite', // Task management (implementation mode)
+            'ExitPlanMode', // Mode transitions
+        ],
+        ...(resume && { resume }),
+    };
+    return { config, ticketsPath, cwd, prompt };
 }
 /**
- * Execute write_tickets tool
- * Returns parsed tickets for later validation - does NOT write to file
+ * Plan core stream for server (async generator, no logging)
  */
-function executeWriteTickets(toolInput) {
-    try {
-        const inputTickets = toolInput.tickets;
-        // Transform to full Ticket objects
-        const tickets = inputTickets.map((t) => ({
-            id: t.id,
-            title: t.title,
-            description: t.description,
-            type: t.type,
-            estimatedEffort: t.estimatedEffort,
-            status: 'Todo',
-            category: t.category,
-        }));
-        // Sort tickets by processing order (using shared utility)
-        const sortedTickets = sortTicketsByOrder(tickets);
-        console.log(`\n📋 Generated ${sortedTickets.length} ticket(s) - validating...`);
-        return {
-            success: true,
-            message: `Generated ${sortedTickets.length} tickets - will validate and save after confirmation`,
-            tickets: sortedTickets,
-        };
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-        console.error(`\n❌ Failed to parse tickets: ${errorMessage}`);
-        return {
-            success: false,
-            message: `Error: ${errorMessage}`,
-            tickets: [],
+export async function* planCoreStream(options) {
+    const setup = createPlanAgentConfig(options);
+    if ('error' in setup) {
+        yield {
+            type: 'done',
+            data: {
+                status: 'error',
+                ticketsFile: null,
+                tokensUsed: { input: 0, output: 0, cacheCreation: 0, cacheRead: 0 },
+                cost: 0,
+                error: setup.error,
+            },
         };
+        return;
     }
-}
-/**
- * Format token usage for display
- */
-function formatTokenUsage(inputTokens, outputTokens, cacheCreationTokens, cacheReadTokens, cost) {
-    const breakdown = [];
-    if (inputTokens > 0)
-        breakdown.push(`${inputTokens.toLocaleString()} input`);
-    if (outputTokens > 0)
-        breakdown.push(`${outputTokens.toLocaleString()} output`);
-    if (cacheCreationTokens > 0)
-        breakdown.push(`${cacheCreationTokens.toLocaleString()} cache write`);
-    if (cacheReadTokens > 0)
-        breakdown.push(`${cacheReadTokens.toLocaleString()} cache read`);
-    return `💰 Cost: $${cost.toFixed(4)} (${breakdown.join(' + ')} tokens)`;
-}
-/**
- * Process a single Claude interaction with streaming
- * Handles multiple tool calls in a loop until Claude stops calling tools
- */
-async function processClaudeInteraction(messages, systemPrompt, cwd) {
-    const anthropic = new Anthropic({
-        apiKey: process.env.ANTHROPIC_API_KEY,
-    });
-    let responseText = '';
-    let tickets = [];
-    let ticketsCreated = false;
-    let totalInputTokens = 0;
-    let totalOutputTokens = 0;
-    let totalCacheCreationTokens = 0;
-    let totalCacheReadTokens = 0;
-    let isFirstOutput = true;
-    // Loop until Claude stops calling tools
-    const maxIterations = 20; // Safety limit
-    let iterations = 0;
-    while (iterations < maxIterations) {
-        iterations++;
-        // Stream the response
-        const stream = await anthropic.messages.stream({
-            model: 'claude-sonnet-4-20250514',
-            max_tokens: 8096,
-            system: systemPrompt,
-            tools: PLAN_TOOLS,
-            messages,
-        });
-        let currentText = '';
-        const toolUses = [];
-        // Process stream events
+    const { config, ticketsPath, cwd, prompt } = setup;
+    try {
+        const stream = runAgentStream(prompt, config);
+        let sessionId;
+        let fullResponse = '';
+        let tokensUsed = { input: 0, output: 0, cacheCreation: 0, cacheRead: 0 };
+        let cost = 0;
+        // Yield events from stream
         for await (const event of stream) {
-            if (event.type === 'content_block_start') {
-                if (event.content_block.type === 'text') {
-                    if (isFirstOutput) {
-                        process.stdout.write('\n> Claude:\n');
-                        isFirstOutput = false;
+            if (event.type === 'message') {
+                const claudeMessage = event.data;
+                yield { type: 'message', data: claudeMessage };
+                // Track session ID
+                if (claudeMessage.session_id) {
+                    sessionId = claudeMessage.session_id;
+                }
+                // Accumulate response text and extract tool calls from assistant messages
+                if (claudeMessage.type === 'assistant' && claudeMessage.message) {
+                    const msg = claudeMessage.message;
+                    if (msg.content && Array.isArray(msg.content)) {
+                        for (const block of msg.content) {
+                            if (block.type === 'text' && block.text) {
+                                fullResponse += block.text;
+                            }
+                            else if (block.type === 'tool_use' && block.name) {
+                                // Yield tool call event
+                                yield {
+                                    type: 'tool_call',
+                                    data: { name: block.name, input: block.input || {} },
+                                };
+                            }
+                        }
                     }
                 }
             }
-            else if (event.type === 'content_block_delta') {
-                if (event.delta.type === 'text_delta') {
-                    const delta = event.delta.text;
-                    currentText += delta;
-                    process.stdout.write(delta);
+            else if (event.type === 'agent_result') {
+                // Use metrics from final result
+                tokensUsed = event.data.tokensUsed;
+                cost = event.data.cost;
+                if (event.data.sessionId) {
+                    sessionId = event.data.sessionId;
                 }
             }
         }
-        responseText += currentText;
-        // Get final message
-        const finalMessage = await stream.finalMessage();
-        // Track token usage
-        const usage = finalMessage.usage;
-        totalInputTokens += usage.input_tokens;
-        totalOutputTokens += usage.output_tokens;
-        totalCacheCreationTokens += usage.cache_creation_input_tokens || 0;
-        totalCacheReadTokens += usage.cache_read_input_tokens || 0;
-        // Extract tool uses
-        for (const block of finalMessage.content) {
-            if (block.type === 'tool_use') {
-                toolUses.push({
-                    id: block.id,
-                    name: block.name,
-                    input: block.input,
-                });
-            }
-        }
-        // If no tools called, we're done
-        if (toolUses.length === 0) {
-            messages = [...messages, { role: 'assistant', content: finalMessage.content }];
-            break;
-        }
-        // Execute tools
-        messages = [...messages, { role: 'assistant', content: finalMessage.content }];
-        const toolResults = [];
-        for (const tool of toolUses) {
-            if (tool.name === 'read_file') {
-                const result = executeReadFile(tool.input, cwd);
-                toolResults.push({
-                    type: 'tool_result',
-                    tool_use_id: tool.id,
-                    content: result.content,
-                });
-            }
-            else if (tool.name === 'list_directory') {
-                const result = executeListDirectory(tool.input, cwd);
-                toolResults.push({
-                    type: 'tool_result',
-                    tool_use_id: tool.id,
-                    content: result.content,
-                });
-            }
-            else if (tool.name === 'glob_search') {
-                const result = await executeGlobSearch(tool.input, cwd);
-                toolResults.push({
-                    type: 'tool_result',
-                    tool_use_id: tool.id,
-                    content: result.content,
-                });
-            }
-            else if (tool.name === 'write_tickets') {
-                const result = executeWriteTickets(tool.input);
-                tickets = result.tickets;
-                ticketsCreated = result.success;
-                toolResults.push({
-                    type: 'tool_result',
-                    tool_use_id: tool.id,
-                    content: result.message,
-                });
+        // Try to parse tickets from response (Phase 2)
+        try {
+            const tickets = parseTickets(fullResponse);
+            // If no tickets were parsed, this is Phase 1 (clarification questions)
+            if (tickets.length === 0) {
+                yield {
+                    type: 'done',
+                    data: {
+                        status: 'input_required',
+                        ticketsFile: null,
+                        tokensUsed,
+                        cost,
+                        sessionId,
+                    },
+                };
+                return;
             }
-        }
-        messages = [...messages, { role: 'user', content: toolResults }];
-        // If tickets were created, get final response and stop
-        if (ticketsCreated) {
-            const followupStream = await anthropic.messages.stream({
-                model: 'claude-sonnet-4-20250514',
-                max_tokens: 8096,
-                system: systemPrompt,
-                tools: PLAN_TOOLS,
-                messages,
+            // Use full pipeline: validate, sort, write
+            await processAndWriteTickets(tickets, ticketsPath, cwd, {
+                skipValidation: false,
+                displaySummary: false, // Don't display in stream mode
             });
-            let followupText = '';
-            for await (const event of followupStream) {
-                if (event.type === 'content_block_delta') {
-                    if (event.delta.type === 'text_delta') {
-                        const delta = event.delta.text;
-                        followupText += delta;
-                        process.stdout.write(delta);
-                    }
-                }
-            }
-            const followupMessage = await followupStream.finalMessage();
-            responseText += '\n' + followupText;
-            messages = [...messages, { role: 'assistant', content: followupMessage.content }];
-            // Add followup token usage
-            const followupUsage = followupMessage.usage;
-            totalInputTokens += followupUsage.input_tokens;
-            totalOutputTokens += followupUsage.output_tokens;
-            totalCacheCreationTokens += followupUsage.cache_creation_input_tokens || 0;
-            totalCacheReadTokens += followupUsage.cache_read_input_tokens || 0;
-            break;
-        }
-    }
-    return {
-        response: responseText,
-        messages,
-        inputTokens: totalInputTokens,
-        outputTokens: totalOutputTokens,
-        cacheCreationTokens: totalCacheCreationTokens,
-        cacheReadTokens: totalCacheReadTokens,
-        tickets,
-        ticketsCreated,
-    };
-}
-/**
- * Interactive planning session
- */
-async function interactivePlanSession(initialPrompt, cwd, ticketsPath, logContext, noTest = false) {
-    console.log(`
-╔══════════════════════════════════════════════════════════════════════════════╗
-║                    Kosuke Plan - AI-Driven Ticket Planning                   ║
-╚══════════════════════════════════════════════════════════════════════════════╝
-  `);
-    console.log('💡 This tool will help you create implementation tickets from your feature/bug description.\n');
-    console.log('🤖 Claude will explore your codebase to understand patterns and conventions.\n');
-    // Read CLAUDE.md and inject into system prompt
-    const claudeMdContent = readClaudeMd(cwd);
-    if (claudeMdContent) {
-        console.log(`📖 Loaded CLAUDE.md (${Math.round(claudeMdContent.length / 1000)}k chars)\n`);
-    }
-    const systemPrompt = buildPlanSystemPrompt(claudeMdContent, noTest);
-    console.log(`${'─'.repeat(60)}`);
-    console.log('🤖 Using model: claude-sonnet-4-5');
-    console.log(`${'─'.repeat(60)}\n`);
-    console.log('✨ Tip: Enter to submit, Ctrl+J for new lines.\n');
-    // Set up Ctrl+C handler
-    const handleSigInt = async () => {
-        console.log('\n\n👋 Exiting planning session...\n');
-        if (logContext) {
-            await logger.complete(logContext, 'cancelled');
+            yield {
+                type: 'done',
+                data: {
+                    status: 'success',
+                    ticketsFile: ticketsPath,
+                    tokensUsed,
+                    cost,
+                    sessionId,
+                },
+            };
         }
-        process.exit(0);
-    };
-    process.on('SIGINT', handleSigInt);
-    const session = {
-        prompt: initialPrompt,
-        messages: [],
-    };
-    let totalInputTokens = 0;
-    let totalOutputTokens = 0;
-    let totalCacheCreationTokens = 0;
-    let totalCacheReadTokens = 0;
-    let totalCost = 0;
-    let finalTickets = [];
-    try {
-        // Start with initial prompt
-        session.messages.push({ role: 'user', content: initialPrompt });
-        let continueConversation = true;
-        while (continueConversation) {
-            console.log('\n🤔 Claude is analyzing...\n');
-            const result = await processClaudeInteraction(session.messages, systemPrompt, cwd);
-            session.messages = result.messages;
-            // Track costs
-            totalInputTokens += result.inputTokens;
-            totalOutputTokens += result.outputTokens;
-            totalCacheCreationTokens += result.cacheCreationTokens;
-            totalCacheReadTokens += result.cacheReadTokens;
-            const batchCost = calculateCost(result.inputTokens, result.outputTokens, result.cacheCreationTokens, result.cacheReadTokens);
-            totalCost += batchCost;
-            // Display cost
-            console.log('\n' + '─'.repeat(90));
-            console.log(formatTokenUsage(result.inputTokens, result.outputTokens, result.cacheCreationTokens, result.cacheReadTokens, batchCost));
-            console.log('─'.repeat(90) + '\n');
-            // Check if tickets were created
-            if (result.ticketsCreated) {
-                // Validate and write tickets using shared utility
-                const { tickets: validatedTickets } = await processAndWriteTickets(result.tickets, ticketsPath, cwd, { displaySummary: true });
-                finalTickets = validatedTickets;
-                console.log('═'.repeat(90));
-                console.log('📊 Total Session Cost:');
-                console.log(formatTokenUsage(totalInputTokens, totalOutputTokens, totalCacheCreationTokens, totalCacheReadTokens, totalCost));
-                console.log('═'.repeat(90));
-                // Get relative path for cleaner output
-                const relativeTicketsPath = ticketsPath.replace(cwd + '/', '');
-                console.log('\n🎉 Planning complete!\n');
-                console.log('💡 Next steps:');
-                console.log('   - Review tickets: cat "' + ticketsPath + '"');
-                console.log('   - Build tickets: kosuke build --directory="' +
-                    cwd +
-                    '" --tickets="' +
-                    relativeTicketsPath +
-                    '"');
-                console.log('   - List all tickets: ls ' + join(cwd, 'tickets'));
-                continueConversation = false;
-                break;
-            }
-            // Ask for user response
-            console.log('💬 Your response (type "exit" to quit):\n');
-            const userResponse = await askQuestion('You: ');
-            if (!userResponse) {
-                console.log('\n⚠️  Empty response. Please provide an answer or type "exit".');
-                continue;
+        catch (parseError) {
+            const errorMsg = parseError instanceof Error ? parseError.message : String(parseError);
+            // Check if this is a parse/validation error or just Phase 1
+            if (errorMsg.includes('No JSON array found')) {
+                // This is Phase 1 (clarification questions)
+                yield {
+                    type: 'done',
+                    data: {
+                        status: 'input_required',
+                        ticketsFile: null,
+                        tokensUsed,
+                        cost,
+                        sessionId,
+                    },
+                };
             }
-            if (userResponse.toLowerCase() === 'exit') {
-                console.log('\n👋 Exiting planning session.\n');
-                console.log('═'.repeat(90));
-                console.log('📊 Session Cost:');
-                console.log(formatTokenUsage(totalInputTokens, totalOutputTokens, totalCacheCreationTokens, totalCacheReadTokens, totalCost));
-                console.log('═'.repeat(90) + '\n');
-                continueConversation = false;
-                break;
+            else {
+                // Actual validation error
+                yield {
+                    type: 'done',
+                    data: {
+                        status: 'error',
+                        ticketsFile: null,
+                        tokensUsed,
+                        cost: 0,
+                        error: errorMsg,
+                    },
+                };
             }
-            // Add user response to messages
-            session.messages = [...session.messages, { role: 'user', content: userResponse }];
         }
     }
     catch (error) {
-        console.error('\n❌ Error during planning:', error);
-        throw error;
-    }
-    finally {
-        process.removeListener('SIGINT', handleSigInt);
+        yield {
+            type: 'done',
+            data: {
+                status: 'error',
+                ticketsFile: null,
+                tokensUsed: { input: 0, output: 0, cacheCreation: 0, cacheRead: 0 },
+                cost: 0,
+                error: error instanceof Error ? error.message : String(error),
+            },
+        };
     }
-    return {
-        messages: session.messages,
-        tickets: finalTickets,
-        tokensUsed: {
-            input: totalInputTokens,
-            output: totalOutputTokens,
-            cacheCreation: totalCacheCreationTokens,
-            cacheRead: totalCacheReadTokens,
-        },
-        cost: totalCost,
-    };
 }
 /**
- * Core plan function for programmatic use
+ * Plan interactive session for CLI (single turn with logging)
  */
-export async function planCore(options) {
-    const { prompt, directory, noTest = false } = options;
-    // Validate directory
-    const cwd = directory ? resolve(directory) : process.cwd();
-    if (!existsSync(cwd)) {
-        return {
-            success: false,
-            tickets: [],
-            ticketsFile: '',
-            tokensUsed: { input: 0, output: 0, cacheCreation: 0, cacheRead: 0 },
-            cost: 0,
-            error: `Directory not found: ${cwd}`,
-        };
-    }
-    const stats = statSync(cwd);
-    if (!stats.isDirectory()) {
+async function planInteractiveSession(options) {
+    const setup = createPlanAgentConfig(options);
+    if ('error' in setup) {
         return {
-            success: false,
-            tickets: [],
-            ticketsFile: '',
+            status: 'error',
+            ticketsFile: null,
             tokensUsed: { input: 0, output: 0, cacheCreation: 0, cacheRead: 0 },
             cost: 0,
-            error: `Path is not a directory: ${cwd}`,
+            error: setup.error,
         };
     }
-    const ticketsPath = generateTicketsPath(cwd);
+    const { config, ticketsPath, cwd, prompt } = setup;
     try {
-        const result = await interactivePlanSession(prompt, cwd, ticketsPath, undefined, noTest);
-        return {
-            success: result.tickets.length > 0,
-            tickets: result.tickets,
-            ticketsFile: ticketsPath,
-            tokensUsed: result.tokensUsed,
-            cost: result.cost,
-        };
+        console.log('\n🤔 Claude is analyzing...\n');
+        // Run agent with logging
+        const result = await runAgent(prompt, config);
+        // Display cost
+        console.log('\n' + '─'.repeat(90));
+        console.log(`💰 Cost: ${formatCostBreakdown(result)}`);
+        console.log('─'.repeat(90) + '\n');
+        // Try to parse tickets from response (Phase 2)
+        try {
+            const tickets = parseTickets(result.response);
+            // If no tickets were parsed, this is Phase 1 (clarification questions)
+            if (tickets.length === 0) {
+                return {
+                    status: 'input_required',
+                    ticketsFile: null,
+                    tokensUsed: result.tokensUsed,
+                    cost: result.cost,
+                    sessionId: result.sessionId,
+                    message: result.response,
+                };
+            }
+            // Use full pipeline: validate, sort, write
+            await processAndWriteTickets(tickets, ticketsPath, cwd, {
+                skipValidation: false,
+                displaySummary: true, // Display summary in interactive mode
+            });
+            console.log(`\n✅ Successfully created ${tickets.length} tickets: ${ticketsPath}\n`);
+            return {
+                status: 'success',
+                ticketsFile: ticketsPath,
+                tokensUsed: result.tokensUsed,
+                cost: result.cost,
+                sessionId: result.sessionId,
+                message: result.response,
+            };
+        }
+        catch (parseError) {
+            const errorMsg = parseError instanceof Error ? parseError.message : String(parseError);
+            // Check if this is a parse/validation error or just Phase 1
+            if (errorMsg.includes('No JSON array found')) {
+                // This is Phase 1 (clarification questions)
+                return {
+                    status: 'input_required',
+                    ticketsFile: null,
+                    tokensUsed: result.tokensUsed,
+                    cost: result.cost,
+                    sessionId: result.sessionId,
+                    message: result.response,
+                };
+            }
+            // Actual validation error - show it
+            console.error(`\n❌ Ticket validation failed: ${errorMsg}\n`);
+            return {
+                status: 'error',
+                ticketsFile: null,
+                tokensUsed: result.tokensUsed,
+                cost: result.cost,
+                error: errorMsg,
+            };
+        }
     }
     catch (error) {
         return {
-            success: false,
-            tickets: [],
-            ticketsFile: '',
+            status: 'error',
+            ticketsFile: null,
             tokensUsed: { input: 0, output: 0, cacheCreation: 0, cacheRead: 0 },
             cost: 0,
             error: error instanceof Error ? error.message : String(error),
@@ -793,7 +470,7 @@ export async function planCore(options) {
     }
 }
 /**
- * Main plan command
+ * Main plan command (interactive CLI wrapper)
  */
 export async function planCommand(options) {
     // Initialize logging
@@ -818,14 +495,129 @@ export async function planCommand(options) {
         if (!stats.isDirectory()) {
             throw new Error(`Path is not a directory: ${cwd}`);
         }
+        console.log(`
+╔══════════════════════════════════════════════════════════════════════════════╗
+║                    Kosuke Plan - AI-Driven Ticket Planning                   ║
+╚══════════════════════════════════════════════════════════════════════════════╝
+  `);
+        console.log('💡 This tool will help you create implementation tickets from your feature/bug description.\n');
+        console.log('🤖 Claude will explore your codebase to understand patterns and conventions.\n');
+        console.log('✨ Tip: Enter to submit, Ctrl+J for new lines.\n');
         console.log(`📁 Using project directory: ${cwd}\n`);
-        const ticketsPath = generateTicketsPath(cwd);
-        // Run interactive session
-        const sessionData = await interactivePlanSession(options.prompt, cwd, ticketsPath, logContext, options.noTest ?? false);
-        // Track metrics
-        logger.trackTokens(logContext, sessionData.tokensUsed);
-        // Log successful execution
-        await logger.complete(logContext, 'success');
+        // Set up Ctrl+C handler
+        const handleSigInt = async () => {
+            console.log('\n\n👋 Exiting planning session...\n');
+            await logger.complete(logContext, 'cancelled');
+            cleanupHandler();
+            process.exit(0);
+        };
+        process.on('SIGINT', handleSigInt);
+        let currentPrompt = options.prompt;
+        let sessionId = options.resume;
+        let totalInputTokens = 0;
+        let totalOutputTokens = 0;
+        let totalCacheCreationTokens = 0;
+        let totalCacheReadTokens = 0;
+        let totalCost = 0;
+        try {
+            // Interactive loop
+            while (true) {
+                const result = await planInteractiveSession({
+                    prompt: currentPrompt,
+                    directory: cwd,
+                    noTest: options.noTest,
+                    resume: sessionId,
+                });
+                // Track cumulative costs
+                totalInputTokens += result.tokensUsed.input;
+                totalOutputTokens += result.tokensUsed.output;
+                totalCacheCreationTokens += result.tokensUsed.cacheCreation;
+                totalCacheReadTokens += result.tokensUsed.cacheRead;
+                totalCost += result.cost;
+                sessionId = result.sessionId;
+                if (result.status === 'success') {
+                    // Planning complete
+                    console.log('═'.repeat(90));
+                    console.log('📊 Total Session Cost:');
+                    console.log(`💰 ${formatCostBreakdown({
+                        tokensUsed: {
+                            input: totalInputTokens,
+                            output: totalOutputTokens,
+                            cacheCreation: totalCacheCreationTokens,
+                            cacheRead: totalCacheReadTokens,
+                        },
+                        cost: totalCost,
+                        response: '',
+                        fixCount: 0,
+                        filesReferenced: new Set(),
+                    })}`);
+                    console.log('═'.repeat(90));
+                    const relativeTicketsPath = result.ticketsFile.replace(cwd + '/', '');
+                    console.log('\n🎉 Planning complete!\n');
+                    console.log('💡 Next steps:');
+                    console.log('   - Review tickets: cat "' + result.ticketsFile + '"');
+                    console.log('   - Build tickets: kosuke build --directory="' +
+                        cwd +
+                        '" --tickets="' +
+                        relativeTicketsPath +
+                        '"');
+                    console.log('   - List all tickets: ls ' + join(cwd, 'tickets'));
+                    if (sessionId) {
+                        console.log(`\n💾 Session ID: ${sessionId}`);
+                    }
+                    logger.trackTokens(logContext, {
+                        input: totalInputTokens,
+                        output: totalOutputTokens,
+                        cacheCreation: totalCacheCreationTokens,
+                        cacheRead: totalCacheReadTokens,
+                    });
+                    await logger.complete(logContext, 'success');
+                    break;
+                }
+                else if (result.status === 'input_required') {
+                    // Ask for user response
+                    console.log('💬 Your response (type "exit" to quit):\n');
+                    const userResponse = await askQuestion('You: ');
+                    if (!userResponse) {
+                        console.log('\n⚠️  Empty response. Please provide an answer or type "exit".');
+                        continue;
+                    }
+                    if (userResponse.toLowerCase() === 'exit') {
+                        console.log('\n👋 Exiting planning session.\n');
+                        if (sessionId) {
+                            console.log('💾 Session ID (to resume later):');
+                            console.log(`   ${sessionId}\n`);
+                            console.log('   Resume with: kosuke plan --prompt="continue" --resume=' + sessionId + '\n');
+                        }
+                        console.log('═'.repeat(90));
+                        console.log('📊 Session Cost:');
+                        console.log(`💰 ${formatCostBreakdown({
+                            tokensUsed: {
+                                input: totalInputTokens,
+                                output: totalOutputTokens,
+                                cacheCreation: totalCacheCreationTokens,
+                                cacheRead: totalCacheReadTokens,
+                            },
+                            cost: totalCost,
+                            response: '',
+                            fixCount: 0,
+                            filesReferenced: new Set(),
+                        })}`);
+                        console.log('═'.repeat(90) + '\n');
+                        await logger.complete(logContext, 'cancelled');
+                        break;
+                    }
+                    currentPrompt = userResponse;
+                }
+                else {
+                    // Error
+                    throw new Error(result.error || 'Unknown error during planning');
+                }
+            }
+        }
+        finally {
+            process.removeListener('SIGINT', handleSigInt);
+        }
         cleanupHandler();
     }
     catch (error) {