@magic-ingredients/tiny-brain-local 0.3.10

package/dist/prompts/planning/planning.prompt.js

@@ -0,0 +1,1016 @@
+/**
+ * Planning Prompt Handler
+ *
+ * Thin dispatcher for planning-related prompt executions
+ * Validates args with Zod, dispatches to PlanningService, formats responses
+ */
+import { z } from 'zod';
+import { PlanningService } from '@magic-ingredients/tiny-brain-core';
+// Zod schemas for each prompt handler
+const CreatePlanArgsSchema = z.object({
+    title: z.string(),
+    overview: z.string(),
+    phases: z.string().optional(),
+});
+const UpdatePlanArgsSchema = z.object({
+    planId: z.string().optional(),
+    operation: z.enum(['add-phase', 'update-phase-status', 'add-todo', 'complete-todo']),
+    phaseNumber: z.number().optional(),
+    content: z.string().optional(),
+    status: z.enum(['pending', 'in_progress', 'completed']).optional(),
+});
+const PlanStatusArgsSchema = z.object({
+    planId: z.string().optional(),
+    verbose: z.boolean().optional(),
+});
+const ListPlansArgsSchema = z.object({
+    status: z.enum(['active', 'completed', 'archived', 'all']).optional().default('active'),
+});
+const PlanReportArgsSchema = z.object({
+    planId: z.string().optional(),
+    format: z.enum(['summary', 'detailed', 'markdown']).optional().default('detailed'),
+});
+const ArchivePlanArgsSchema = z.object({
+    planId: z.string().optional(),
+    reason: z.string().optional().default('Completed'),
+});
+const SwitchPlanArgsSchema = z.object({
+    planId: z.string(),
+    // Note: switchToPlan automatically unarchives if needed
+});
+const StartWatchArgsSchema = z.object({
+    port: z.number().optional().default(8765),
+    autoOpen: z.boolean().optional().default(true),
+});
+const StopWatchArgsSchema = z.object({});
+// Singleton instance tracking for plan watcher
+let watcherInstance = null;
+export class PlanningPrompt {
+    /**
+     * Get all planning-related prompt definitions
+     */
+    static getPromptDefinitions() {
+        return [
+            {
+                name: 'create-plan',
+                description: '📋 Create a new structured plan with automatic phase extraction',
+                arguments: [
+                    {
+                        name: 'title',
+                        description: 'Title for the new plan',
+                        required: true,
+                    },
+                    {
+                        name: 'overview',
+                        description: 'Overview or description of the plan',
+                        required: true,
+                    },
+                    {
+                        name: 'phases',
+                        description: 'Optional comma-separated list of initial phases',
+                        required: false,
+                    },
+                ],
+            },
+            {
+                name: 'update-plan',
+                description: '✏️ Update an existing plan with new phases, todos, or status changes',
+                arguments: [
+                    {
+                        name: 'planId',
+                        description: 'ID of the plan to update (optional, uses active plan if not provided)',
+                        required: false,
+                    },
+                    {
+                        name: 'operation',
+                        description: 'Operation to perform: add-phase, update-phase-status, add-todo, complete-todo',
+                        required: true,
+                    },
+                    {
+                        name: 'phaseNumber',
+                        description: 'Phase number for phase-specific operations',
+                        required: false,
+                    },
+                    {
+                        name: 'content',
+                        description: 'Content for the operation (phase title, todo content, etc.)',
+                        required: false,
+                    },
+                    {
+                        name: 'status',
+                        description: 'New status for phase updates: pending, in_progress, completed',
+                        required: false,
+                    },
+                ],
+            },
+            {
+                name: 'plan-status',
+                description: '📊 Get current status and progress of a plan',
+                arguments: [
+                    {
+                        name: 'planId',
+                        description: 'Plan ID (optional, uses active plan if not provided)',
+                        required: false,
+                    },
+                    {
+                        name: 'verbose',
+                        description: 'Show detailed breakdown including all phases and todos',
+                        required: false,
+                    },
+                ],
+            },
+            {
+                name: 'list-plans',
+                description: '📋 List all plans for the current persona',
+                arguments: [
+                    {
+                        name: 'status',
+                        description: 'Filter by status: active, completed, archived, all',
+                        required: false,
+                    },
+                ],
+            },
+            {
+                name: 'plan-report',
+                description: '📄 Generate a comprehensive markdown report for a plan',
+                arguments: [
+                    {
+                        name: 'planId',
+                        description: 'Plan ID (optional, uses active plan if not provided)',
+                        required: false,
+                    },
+                    {
+                        name: 'format',
+                        description: 'Report format: summary, detailed, markdown',
+                        required: false,
+                    },
+                ],
+            },
+            {
+                name: 'archive-plan',
+                description: '📦 Archive a completed plan',
+                arguments: [
+                    {
+                        name: 'planId',
+                        description: 'Plan ID (optional, uses active plan if not provided)',
+                        required: false,
+                    },
+                    {
+                        name: 'reason',
+                        description: 'Reason for archiving the plan',
+                        required: false,
+                    },
+                ],
+            },
+            {
+                name: 'switch-plan',
+                description: '🔄 Switch to a different plan as the active plan',
+                arguments: [
+                    {
+                        name: 'planId',
+                        description: 'ID of the plan to switch to',
+                        required: true,
+                    },
+                    {
+                        name: 'force',
+                        description: 'Allow switching to archived plans',
+                        required: false,
+                    },
+                ],
+            },
+            {
+                name: 'start-watch',
+                description: '🚀 Launch web dashboard to monitor plans in real-time',
+                arguments: [
+                    {
+                        name: 'port',
+                        description: 'Port number for the dashboard (default: 8765)',
+                        required: false,
+                    },
+                    {
+                        name: 'autoOpen',
+                        description: 'Automatically open browser when dashboard starts',
+                        required: false,
+                    },
+                ],
+            },
+            {
+                name: 'stop-watch',
+                description: '🛑 Stop the running plan watcher dashboard',
+                arguments: [],
+            },
+        ];
+    }
+    /**
+     * Main handler that routes to specific prompt handlers
+     */
+    static async handle(name, args, context) {
+        switch (name) {
+            case 'create-plan':
+                return await PlanningPrompt.handleCreatePlan(args, context);
+            case 'update-plan':
+                return await PlanningPrompt.handleUpdatePlan(args, context);
+            case 'plan-status':
+                return await PlanningPrompt.handlePlanStatus(args, context);
+            case 'list-plans':
+                return await PlanningPrompt.handleListPlans(args, context);
+            case 'plan-report':
+                return await PlanningPrompt.handlePlanReport(args, context);
+            case 'archive-plan':
+                return await PlanningPrompt.handleArchivePlan(args, context);
+            case 'switch-plan':
+                return await PlanningPrompt.handleSwitchPlan(args, context);
+            case 'start-watch':
+                return await PlanningPrompt.handleStartWatch(args, context);
+            case 'stop-watch':
+                return await PlanningPrompt.handleStopWatch(args, context);
+            default:
+                throw new Error(`Unknown planning prompt: ${name}`);
+        }
+    }
+    /**
+     * Handle create-plan prompt
+     */
+    static async handleCreatePlan(args, context) {
+        try {
+            // Validate args with Zod
+            const validatedArgs = CreatePlanArgsSchema.parse(args);
+            const { title, overview, phases: phasesArg } = validatedArgs;
+            if (!context.activePersona?.id) {
+                throw new Error('No active persona found. Use "as" tool to switch to a persona first.');
+            }
+            // Parse initial phases if provided
+            const initialPhases = phasesArg
+                ? phasesArg
+                    .split(',')
+                    .map((p) => p.trim())
+                    .filter((p) => p.length > 0)
+                : undefined;
+            // Create service with RequestContext
+            const planningService = new PlanningService(context);
+            // Call service method with validated args
+            const plan = await planningService.createPlan({
+                title,
+                overview,
+                initialPhases,
+            });
+            const resultText = [
+                `✅ Created plan: "${plan.title}"`,
+                `Plan ID: ${plan.id}`,
+                `Persona: ${context.activePersona.id}`,
+                '',
+                `Phases: ${plan.phases.length}`,
+                ...plan.phases.map((phase, i) => `${i + 1}. ${phase.title}`),
+                '',
+                'Use "plan-status" to see the current progress.',
+            ].join('\n');
+            return {
+                description: 'Create a new structured plan',
+                messages: [
+                    {
+                        role: 'user',
+                        content: {
+                            type: 'text',
+                            text: `Create plan: ${title}${initialPhases ? ` with phases: ${initialPhases.join(', ')}` : ''}`,
+                        },
+                    },
+                    {
+                        role: 'assistant',
+                        content: {
+                            type: 'text',
+                            text: resultText,
+                        },
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            if (error instanceof z.ZodError) {
+                const errorText = `Invalid arguments: ${error.errors.map(e => e.message).join(', ')}`;
+                return {
+                    description: 'Error creating plan',
+                    messages: [
+                        {
+                            role: 'user',
+                            content: {
+                                type: 'text',
+                                text: `Create plan: ${args.title}`,
+                            },
+                        },
+                        {
+                            role: 'assistant',
+                            content: {
+                                type: 'text',
+                                text: errorText,
+                            },
+                        },
+                    ],
+                };
+            }
+            const errorText = `Failed to create plan: ${error instanceof Error ? error.message : 'Unknown error'}`;
+            return {
+                description: 'Error creating plan',
+                messages: [
+                    {
+                        role: 'user',
+                        content: {
+                            type: 'text',
+                            text: `Create plan: ${args.title}`,
+                        },
+                    },
+                    {
+                        role: 'assistant',
+                        content: {
+                            type: 'text',
+                            text: errorText,
+                        },
+                    },
+                ],
+            };
+        }
+    }
+    /**
+     * Handle update-plan prompt
+     */
+    static async handleUpdatePlan(args, context) {
+        try {
+            // Validate args with Zod
+            const validatedArgs = UpdatePlanArgsSchema.parse(args);
+            const { planId, operation, phaseNumber, content, status } = validatedArgs;
+            if (!context.activePersona?.id) {
+                throw new Error('No active persona found. Use "as" tool to switch to a persona first.');
+            }
+            // Create service with RequestContext
+            const planningService = new PlanningService(context);
+            // Get the plan to update
+            let plan;
+            if (planId) {
+                plan = await planningService.loadPlan({ planId });
+                if (!plan) {
+                    throw new Error(`Plan not found: ${planId}`);
+                }
+            }
+            else {
+                plan = await planningService.getActivePlan();
+                if (!plan) {
+                    throw new Error('No active plan found. Specify a planId or create a new plan.');
+                }
+            }
+            // Build updates based on operation
+            const updates = {};
+            switch (operation) {
+                case 'add-phase':
+                    if (!content) {
+                        throw new Error('Content (phase title) is required for add-phase operation');
+                    }
+                    updates.addPhase = { title: content };
+                    break;
+                case 'update-phase-status':
+                    if (phaseNumber === undefined) {
+                        throw new Error('Phase number is required for update-phase-status operation');
+                    }
+                    if (!status) {
+                        throw new Error('Status is required for update-phase-status operation');
+                    }
+                    updates.updatePhase = { phaseNumber, status };
+                    break;
+                case 'add-todo':
+                    if (phaseNumber === undefined) {
+                        throw new Error('Phase number is required for add-todo operation');
+                    }
+                    if (!content) {
+                        throw new Error('Content (todo text) is required for add-todo operation');
+                    }
+                    updates.updatePhase = { phaseNumber, addTodo: content };
+                    break;
+                case 'complete-todo':
+                    if (phaseNumber === undefined) {
+                        throw new Error('Phase number is required for complete-todo operation');
+                    }
+                    if (!content) {
+                        throw new Error('Content (todo text) is required for complete-todo operation');
+                    }
+                    updates.updatePhase = { phaseNumber, completeTodo: content };
+                    break;
+                default:
+                    throw new Error(`Unknown operation: ${operation}`);
+            }
+            // Call service method with validated args
+            const updatedPlan = await planningService.updatePlan({
+                planId: plan.id,
+                updates,
+            });
+            // Format response
+            const statusReport = await planningService.generateStatusReport(updatedPlan);
+            const resultText = [
+                `✅ Updated plan: "${updatedPlan.title}"`,
+                '',
+                'Plan updated successfully.',
+                '',
+                statusReport,
+            ].join('\n');
+            return {
+                description: 'Update plan with new information',
+                messages: [
+                    {
+                        role: 'user',
+                        content: {
+                            type: 'text',
+                            text: `Update plan: ${operation}${content ? ` - ${content}` : ''}`,
+                        },
+                    },
+                    {
+                        role: 'assistant',
+                        content: {
+                            type: 'text',
+                            text: resultText,
+                        },
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            if (error instanceof z.ZodError) {
+                const errorText = `Invalid arguments: ${error.errors.map(e => e.message).join(', ')}`;
+                return {
+                    description: 'Error updating plan',
+                    messages: [
+                        {
+                            role: 'user',
+                            content: {
+                                type: 'text',
+                                text: `Update plan: ${args.operation}`,
+                            },
+                        },
+                        {
+                            role: 'assistant',
+                            content: {
+                                type: 'text',
+                                text: errorText,
+                            },
+                        },
+                    ],
+                };
+            }
+            const errorText = `Failed to update plan: ${error instanceof Error ? error.message : 'Unknown error'}`;
+            return {
+                description: 'Error updating plan',
+                messages: [
+                    {
+                        role: 'user',
+                        content: {
+                            type: 'text',
+                            text: `Update plan: ${args.operation}`,
+                        },
+                    },
+                    {
+                        role: 'assistant',
+                        content: {
+                            type: 'text',
+                            text: errorText,
+                        },
+                    },
+                ],
+            };
+        }
+    }
+    /**
+     * Handle plan-status prompt
+     */
+    static async handlePlanStatus(args, context) {
+        try {
+            // Validate args with Zod
+            const validatedArgs = PlanStatusArgsSchema.parse(args);
+            const { planId, verbose } = validatedArgs;
+            if (!context.activePersona?.id) {
+                throw new Error('No active persona found. Use "as" tool to switch to a persona first.');
+            }
+            // Create service with RequestContext
+            const planningService = new PlanningService(context);
+            // Get the plan
+            let plan;
+            if (planId) {
+                plan = await planningService.loadPlan({ planId });
+                if (!plan) {
+                    throw new Error(`Plan not found: ${planId}`);
+                }
+            }
+            else {
+                plan = await planningService.getActivePlan();
+                if (!plan) {
+                    throw new Error(`No active plan found for persona "${context.activePersona.id}". Use "list-plans" to see all plans.`);
+                }
+            }
+            // Format response
+            const resultText = verbose
+                ? await planningService.formatPlan(plan)
+                : await planningService.generateStatusReport(plan);
+            return {
+                description: 'Show current plan status and progress',
+                messages: [
+                    {
+                        role: 'user',
+                        content: {
+                            type: 'text',
+                            text: `Show plan status${verbose ? ' (detailed)' : ''}`,
+                        },
+                    },
+                    {
+                        role: 'assistant',
+                        content: {
+                            type: 'text',
+                            text: resultText,
+                        },
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            if (error instanceof z.ZodError) {
+                throw new Error(`Invalid arguments: ${error.errors.map(e => e.message).join(', ')}`);
+            }
+            const errorText = `Failed to get plan status: ${error instanceof Error ? error.message : 'Unknown error'}`;
+            return {
+                description: 'Error getting plan status',
+                messages: [
+                    {
+                        role: 'user',
+                        content: {
+                            type: 'text',
+                            text: 'Show plan status',
+                        },
+                    },
+                    {
+                        role: 'assistant',
+                        content: {
+                            type: 'text',
+                            text: errorText,
+                        },
+                    },
+                ],
+            };
+        }
+    }
+    /**
+     * Handle list-plans prompt
+     */
+    static async handleListPlans(args, context) {
+        try {
+            // Validate args with Zod
+            const validatedArgs = ListPlansArgsSchema.parse(args);
+            const statusFilter = validatedArgs.status;
+            if (!context.activePersona?.id) {
+                throw new Error('No active persona found. Use "as" tool to switch to a persona first.');
+            }
+            // Create service with RequestContext
+            const planningService = new PlanningService(context);
+            // Call service method with validated args
+            const plans = await planningService.listPlans({
+                type: statusFilter === 'all' ? undefined : statusFilter === 'completed' ? 'active' : statusFilter,
+            });
+            if (plans.length === 0) {
+                const resultText = `No ${statusFilter} plans found for persona "${context.activePersona.id}".`;
+                return {
+                    description: 'List available plans',
+                    messages: [
+                        {
+                            role: 'user',
+                            content: {
+                                type: 'text',
+                                text: `List ${statusFilter} plans`,
+                            },
+                        },
+                        {
+                            role: 'assistant',
+                            content: {
+                                type: 'text',
+                                text: resultText,
+                            },
+                        },
+                    ],
+                };
+            }
+            // Format response
+            const formattedList = await planningService.formatPlan(plans[0]);
+            const resultText = [
+                `📋 Plans for persona "${context.activePersona.id}":`,
+                '',
+                formattedList,
+            ].join('\n');
+            return {
+                description: 'List available plans',
+                messages: [
+                    {
+                        role: 'user',
+                        content: {
+                            type: 'text',
+                            text: `List ${statusFilter} plans`,
+                        },
+                    },
+                    {
+                        role: 'assistant',
+                        content: {
+                            type: 'text',
+                            text: resultText,
+                        },
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            if (error instanceof z.ZodError) {
+                throw new Error(`Invalid arguments: ${error.errors.map(e => e.message).join(', ')}`);
+            }
+            const errorText = `Failed to list plans: ${error instanceof Error ? error.message : 'Unknown error'}`;
+            return {
+                description: 'Error listing plans',
+                messages: [
+                    {
+                        role: 'user',
+                        content: {
+                            type: 'text',
+                            text: 'List plans',
+                        },
+                    },
+                    {
+                        role: 'assistant',
+                        content: {
+                            type: 'text',
+                            text: errorText,
+                        },
+                    },
+                ],
+            };
+        }
+    }
+    /**
+     * Handle plan-report prompt
+     */
+    static async handlePlanReport(args, context) {
+        try {
+            // Validate args with Zod
+            const validatedArgs = PlanReportArgsSchema.parse(args);
+            const { planId, format } = validatedArgs;
+            if (!context.activePersona?.id) {
+                throw new Error('No active persona found. Use "as" tool to switch to a persona first.');
+            }
+            // Create service with RequestContext
+            const planningService = new PlanningService(context);
+            // Get the plan
+            let plan;
+            if (planId) {
+                plan = await planningService.loadPlan({ planId });
+                if (!plan) {
+                    throw new Error(`Plan not found: ${planId}`);
+                }
+            }
+            else {
+                plan = await planningService.getActivePlan();
+                if (!plan) {
+                    throw new Error('No active plan found.');
+                }
+            }
+            // Format response based on format option
+            const report = format === 'summary'
+                ? await planningService.generateStatusReport(plan)
+                : await planningService.formatPlan(plan, format === 'markdown');
+            return {
+                description: 'Generate comprehensive plan report',
+                messages: [
+                    {
+                        role: 'user',
+                        content: {
+                            type: 'text',
+                            text: `Generate ${format} report for plan`,
+                        },
+                    },
+                    {
+                        role: 'assistant',
+                        content: {
+                            type: 'text',
+                            text: report,
+                        },
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            if (error instanceof z.ZodError) {
+                throw new Error(`Invalid arguments: ${error.errors.map(e => e.message).join(', ')}`);
+            }
+            const errorText = `Failed to generate plan report: ${error instanceof Error ? error.message : 'Unknown error'}`;
+            return {
+                description: 'Error generating plan report',
+                messages: [
+                    {
+                        role: 'user',
+                        content: {
+                            type: 'text',
+                            text: 'Generate plan report',
+                        },
+                    },
+                    {
+                        role: 'assistant',
+                        content: {
+                            type: 'text',
+                            text: errorText,
+                        },
+                    },
+                ],
+            };
+        }
+    }
+    /**
+     * Handle archive-plan prompt
+     */
+    static async handleArchivePlan(args, context) {
+        try {
+            // Validate args with Zod
+            const validatedArgs = ArchivePlanArgsSchema.parse(args);
+            const { planId, reason } = validatedArgs;
+            if (!context.activePersona?.id) {
+                throw new Error('No active persona found. Use "as" tool to switch to a persona first.');
+            }
+            // Create service with RequestContext
+            const planningService = new PlanningService(context);
+            // Get the plan to archive
+            let plan;
+            if (planId) {
+                plan = await planningService.loadPlan({ planId });
+                if (!plan) {
+                    throw new Error(`Plan not found: ${planId}`);
+                }
+            }
+            else {
+                plan = await planningService.getActivePlan();
+                if (!plan) {
+                    throw new Error('No active plan found to archive.');
+                }
+            }
+            // Call service method with validated args
+            const archived = await planningService.archivePlan({
+                planId: plan.id,
+                reason,
+            });
+            if (!archived) {
+                throw new Error('Failed to archive plan.');
+            }
+            const resultText = `✅ Archived plan: "${plan.title}"\nReason: ${reason}`;
+            return {
+                description: 'Archive a completed plan',
+                messages: [
+                    {
+                        role: 'user',
+                        content: {
+                            type: 'text',
+                            text: `Archive plan: ${reason}`,
+                        },
+                    },
+                    {
+                        role: 'assistant',
+                        content: {
+                            type: 'text',
+                            text: resultText,
+                        },
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            if (error instanceof z.ZodError) {
+                throw new Error(`Invalid arguments: ${error.errors.map(e => e.message).join(', ')}`);
+            }
+            const errorText = `Failed to archive plan: ${error instanceof Error ? error.message : 'Unknown error'}`;
+            return {
+                description: 'Error archiving plan',
+                messages: [
+                    {
+                        role: 'user',
+                        content: {
+                            type: 'text',
+                            text: 'Archive plan',
+                        },
+                    },
+                    {
+                        role: 'assistant',
+                        content: {
+                            type: 'text',
+                            text: errorText,
+                        },
+                    },
+                ],
+            };
+        }
+    }
+    /**
+     * Handle switch-plan prompt
+     */
+    static async handleSwitchPlan(args, context) {
+        try {
+            // Validate args with Zod
+            const validatedArgs = SwitchPlanArgsSchema.parse(args);
+            const { planId } = validatedArgs;
+            if (!context.activePersona?.id) {
+                throw new Error('No active persona found. Use "as" tool to switch to a persona first.');
+            }
+            // Create service with RequestContext
+            const planningService = new PlanningService(context);
+            // Use the new switchToPlan method which handles both active and archived plans
+            // It will automatically unarchive if needed
+            const switchedPlan = await planningService.switchToPlan(planId);
+            const state = switchedPlan.currentState;
+            const resultText = `✅ Switched active plan to: "${switchedPlan.title}"
+Plan ID: ${switchedPlan.id}
+Status: ${switchedPlan.status}
+Progress: ${state.overallProgress.percentComplete}% (${state.overallProgress.completedPhases}/${state.overallProgress.totalPhases} phases, ${state.overallProgress.completedTodos}/${state.overallProgress.totalTodos} tasks)`;
+            return {
+                description: 'Switch to a different plan',
+                messages: [
+                    {
+                        role: 'user',
+                        content: {
+                            type: 'text',
+                            text: `Switch to plan: ${planId}`,
+                        },
+                    },
+                    {
+                        role: 'assistant',
+                        content: {
+                            type: 'text',
+                            text: resultText,
+                        },
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            if (error instanceof z.ZodError) {
+                throw new Error(`Invalid arguments: ${error.errors.map(e => e.message).join(', ')}`);
+            }
+            const errorText = `Failed to switch plan: ${error instanceof Error ? error.message : 'Unknown error'}`;
+            return {
+                description: 'Error switching plan',
+                messages: [
+                    {
+                        role: 'user',
+                        content: {
+                            type: 'text',
+                            text: 'Switch plan',
+                        },
+                    },
+                    {
+                        role: 'assistant',
+                        content: {
+                            type: 'text',
+                            text: errorText,
+                        },
+                    },
+                ],
+            };
+        }
+    }
+    /**
+     * Handle start-watch prompt
+     */
+    static async handleStartWatch(args, context) {
+        try {
+            // Validate args with Zod
+            const validatedArgs = StartWatchArgsSchema.parse(args);
+            const { port, autoOpen } = validatedArgs;
+            if (!context.activePersona?.id) {
+                throw new Error('No active persona found. Use "as" tool to switch to a persona first.');
+            }
+            // Check if we have an existing watcher
+            if (watcherInstance) {
+                const isRunning = watcherInstance.isRunning();
+                if (isRunning) {
+                    // Stop the old watcher before creating a new one
+                    await watcherInstance.stop();
+                }
+            }
+            // Import PlanWatcherService dynamically to avoid circular dependencies
+            const { PlanWatcherService } = await import('../../services/plan-watcher.service.js');
+            // Create new watcher instance and store it
+            watcherInstance = new PlanWatcherService(context);
+            // Start the dashboard
+            const result = await watcherInstance.start({ port, autoOpen });
+            if (!result.success) {
+                watcherInstance = null;
+                throw new Error(result.error?.message || 'Failed to start plan watcher');
+            }
+            const resultText = `🚀 Plan watcher dashboard started successfully!
+
+📊 Dashboard URL: ${result.data?.url}
+Port: ${port}
+
+The dashboard is now running and will monitor your plans in real-time.
+Use "stop-watch" to stop the dashboard when done.`;
+            return {
+                description: 'Start plan watcher dashboard',
+                messages: [
+                    {
+                        role: 'user',
+                        content: {
+                            type: 'text',
+                            text: `Start plan watcher on port ${port}`,
+                        },
+                    },
+                    {
+                        role: 'assistant',
+                        content: {
+                            type: 'text',
+                            text: resultText,
+                        },
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            if (error instanceof z.ZodError) {
+                throw new Error(`Invalid arguments: ${error.errors.map(e => e.message).join(', ')}`);
+            }
+            const errorText = `Failed to start plan watcher: ${error instanceof Error ? error.message : 'Unknown error'}`;
+            return {
+                description: 'Error starting plan watcher',
+                messages: [
+                    {
+                        role: 'user',
+                        content: {
+                            type: 'text',
+                            text: 'Start plan watcher',
+                        },
+                    },
+                    {
+                        role: 'assistant',
+                        content: {
+                            type: 'text',
+                            text: errorText,
+                        },
+                    },
+                ],
+            };
+        }
+    }
+    /**
+     * Handle stop-watch prompt
+     */
+    static async handleStopWatch(args, _context) {
+        try {
+            // Validate args with Zod (even though there are no args, for consistency)
+            StopWatchArgsSchema.parse(args);
+            if (!watcherInstance) {
+                throw new Error('Plan watcher is not running');
+            }
+            // Stop the dashboard
+            const result = await watcherInstance.stop();
+            if (!result.success) {
+                throw new Error(result.error?.message || 'Failed to stop plan watcher');
+            }
+            // Clear the singleton instance
+            watcherInstance = null;
+            const resultText = `🛑 Plan watcher dashboard stopped successfully.`;
+            return {
+                description: 'Stop plan watcher dashboard',
+                messages: [
+                    {
+                        role: 'user',
+                        content: {
+                            type: 'text',
+                            text: 'Stop plan watcher',
+                        },
+                    },
+                    {
+                        role: 'assistant',
+                        content: {
+                            type: 'text',
+                            text: resultText,
+                        },
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            const errorText = `Failed to stop plan watcher: ${error instanceof Error ? error.message : 'Unknown error'}`;
+            return {
+                description: 'Error stopping plan watcher',
+                messages: [
+                    {
+                        role: 'user',
+                        content: {
+                            type: 'text',
+                            text: 'Stop plan watcher',
+                        },
+                    },
+                    {
+                        role: 'assistant',
+                        content: {
+                            type: 'text',
+                            text: errorText,
+                        },
+                    },
+                ],
+            };
+        }
+    }
+}
+//# sourceMappingURL=planning.prompt.js.map