Does the definition of "Execution State" equals "Bad" change between developmen​t environmen​t and run-time?

Question

My basic question is:
If the execution state of vi is "bad" under the development environment, shouldn't it also be "bad" under the run-time environment?
So here is the background:
So I use SVN and I ran into this problem where I would be working on one piece of code without having my top-level vi open and would inadvertantly break the top-level vi.  And being in hurry or whatever I would not open the top-level vi to check the run arrow and I would check in my code, which of course breaks the top-level vi for everyone else and causes lots of problems. 
So to solve this I wanted to create a Tortoise SVN client side hook to check the check the top-level vi(s) to see if the run arrow was broken before I commit my changes.  I'm trying to use the Execution State to check this.  I am using an Equals primitive to compare it to a "Bad" constant. (as a side question is checking the execution state the best way to do this?  or is this even a valid way to do this?  It's the only way I've found so far to check the run arrow.).  
So the way I'm going about this is:
1.  I create a executable (written in LabVIEW) which is run by TSVN
2.  When TSVN calls it  (I set it up as a start-commit hook) I pass it a parameter which is text file which lists all the top level vi(s)
I do these first 2 steps in order to make it as generic as possible.  I can use it on any project with any number of top-level vis (or dynamically called vis) all I do is point it to a different text file.
3.  Inside the executable I just read the list of vis, open a reference to each one and check the execution state.  I do this inside a for loop, but keep the references open and close them after the for loop in case they share some subvis or libraries, so they stay in memory (could this be the cause of some of my problems??)
4.  Then after the for loop executes and the references are closed I simply fire off a popup if any of them are broken.
5. Then I simply exit LabVIEW to return control to TSVN.
So my problem is this:
In the development environment everything works as expected.  But when I try the exact  same thing in the executable it tells me the run arrow is broken.
Why the difference?  I'm checking the same list of vis and the runs arrows have not changed, they are still all good.
So it appears that checking the execution state to see if it is bad behaves differently in the run-time versus the development environment.
Can anyone confirm or deny that?
It seems to me that it should behave the same.
The help for the Vi.Exec.State property says that it works in the run-time (Read-only), so why am I getting different results?
On a side question if anyone knows of an easier way to accomplish what I want to do, please let me know. I went this route because I had some experience with writing TSVN hooks and I thought it would be pretty simple and it is if I can get this comparison to behave.
edited to fix a typo and to remove the duplicate attachment
Attachments:
Check Run Arrow_BD.png ‏6 KB

Answer 1

I believe that plugins rely on the libraries being located in a specific location. The installer can place these libraries in the specific location or some other installer can do that. You can create code that scans the library directly to "learn" what packages/libraries are available. Then you would build the path to that VI and open the reference to it.
Mark Yedinak
"Does anyone know where the love of God goes when the waves turn the minutes to hours?"
Wreck of the Edmund Fitzgerald - Gordon Lightfoot