Debug infrastructure: managed mode, hit-count dedup, and comprehensive tests

 - Enable managed execution mode in CommandHelperPlugin so the debug
   session survives script completion on embedded (Minecraft) servers
 - Fix hit-count breakpoint deduplication: multiple AST nodes on the same
   source line no longer increment the hit counter more than once per
   visit. Uses column-based caching in ThreadDebugState to distinguish
   "same line, different node" from "new loop iteration, same first node"
 - Add evaluateBreakpointCondition() to DebugContext with per-thread
   cache-aware hit-count and condition evaluation
 - Add Breakpoint.getHitCount() getter
 - Add MSDebugServer managed mode support: setManagedExecution(),
   startedOnHostMainThread capture, resumeOnHostMainThread() for
   resuming on the server main thread, dynamic scripting mode flag
   in evaluate handler
 - Add 21 new DAP integration tests (39 total) covering: managed mode
   step-over, thread events, disconnect; variables/scopes; CArray
   expansion (indexed, associative, nested); evaluate expressions;
   exception breakpoints; conditional and hit-count breakpoints;
   step-in, step-out, step-in targets; disconnect resumes execution

Author: LadyCailin

src/main/java/com/laytonsmith/commandhelper/CommandHelperPlugin.java

@@ -729,6 +729,7 @@ private void startDebugServer() {
 				: null;
 
 		debugServer = new MSDebugServer();
+		debugServer.setManagedExecution(true);
 		try {
 			GlobalEnv gEnv = new GlobalEnv(
 					MethodScriptFileLocations.getDefault().getConfigDirectory(),

src/main/java/com/laytonsmith/core/environments/Breakpoint.java

@@ -159,6 +159,13 @@ public int incrementHitCount() {
 		return ++hitCount;
 	}
 
+	/**
+	 * Returns the current hit count without incrementing.
+	 */
+	public int getHitCount() {
+		return hitCount;
+	}
+
 	@Override
 	@SuppressWarnings("EqualsWhichDoesntCheckParameterClass")
 	public boolean equals(Object obj) {

src/main/java/com/laytonsmith/core/environments/DebugContext.java

@@ -385,7 +385,7 @@ public boolean shouldPause(Target source, int userCallDepth, Environment env) {
 		Breakpoint bp = getBreakpoint(source.file(), source.line());
 		if(bp != null) {
 			if(bp.isConditional()) {
-				shouldStop = evaluateBreakpointCondition(bp, env);
+				shouldStop = evaluateBreakpointCondition(bp, source, state, env);
 			} else {
 				shouldStop = true;
 			}
@@ -484,10 +484,22 @@ && sameSourceLine(source, state.getStepReferenceTarget())
 	 * Evaluates a conditional breakpoint's condition and hit count.
 	 * Returns true if the breakpoint should cause a pause.
 	 */
-	private boolean evaluateBreakpointCondition(Breakpoint bp, Environment env) {
-		// Check hit count first (cheap)
+	private boolean evaluateBreakpointCondition(Breakpoint bp, Target source,
+			ThreadDebugState state, Environment env) {
+		// Check hit count first (cheap). Deduplicate per source line visit:
+		// multiple AST nodes on the same line should only increment the hit
+		// count once. We use the column to distinguish "same visit, different
+		// node" (col differs → cache hit) from "new visit, same first node"
+		// (col matches → cache miss, re-evaluate).
 		if(bp.hitCountThreshold() > 0) {
-			if(bp.incrementHitCount() < bp.hitCountThreshold()) {
+			if(!state.hasCachedBreakpointResult(source.file(), source.line(), source.col())) {
+				int count = bp.incrementHitCount();
+				boolean hitReached = count >= bp.hitCountThreshold();
+				state.cacheBreakpointResult(source.file(), source.line(), source.col(), hitReached);
+				if(!hitReached) {
+					return false;
+				}
+			} else if(!state.getCachedBreakpointResult()) {
 				return false;
 			}
 		}

src/main/java/com/laytonsmith/core/environments/ThreadDebugState.java

@@ -2,6 +2,7 @@
 
 import com.laytonsmith.core.constructs.Target;
 
+import java.io.File;
 import java.util.concurrent.CountDownLatch;
 
 /**
@@ -20,6 +21,16 @@ public class ThreadDebugState {
 	private volatile boolean skippingResume = false;
 	private volatile CountDownLatch pauseLatch;
 
+	// Breakpoint hit-count deduplication: when shouldPause checks a
+	// hit-count breakpoint, we cache the file+line+col+result so that
+	// subsequent AST nodes on the same source line reuse the cached result
+	// (and don't re-increment the hit count). A "new visit" to the same
+	// line is detected when the same first-node column fires again.
+	private volatile File lastBpFile;
+	private volatile int lastBpLine = -1;
+	private volatile int lastBpCol = -1;
+	private volatile boolean lastBpResult;
+
 	public DebugContext.StepMode getStepMode() {
 		return stepMode;
 	}
@@ -95,4 +106,44 @@ public void resume() {
 			latch.countDown();
 		}
 	}
+
+	/**
+	 * Returns true if we already evaluated a hit-count breakpoint for this
+	 * file+line on this thread and can reuse the cached result. A cache hit
+	 * occurs when file+line match but col differs (a subsequent AST node on
+	 * the same source line). When file+line+col all match, it means the first
+	 * node is firing again (new loop iteration), so we return false to force
+	 * a fresh evaluation.
+	 */
+	public boolean hasCachedBreakpointResult(File file, int line, int col) {
+		return lastBpLine == line && file != null && file.equals(lastBpFile)
+				&& lastBpCol != col;
+	}
+
+	/**
+	 * Returns the cached breakpoint evaluation result.
+	 */
+	public boolean getCachedBreakpointResult() {
+		return lastBpResult;
+	}
+
+	/**
+	 * Caches the breakpoint evaluation result for the given file+line+col.
+	 */
+	public void cacheBreakpointResult(File file, int line, int col, boolean result) {
+		this.lastBpFile = file;
+		this.lastBpLine = line;
+		this.lastBpCol = col;
+		this.lastBpResult = result;
+	}
+
+	/**
+	 * Clears the breakpoint evaluation cache. Called when execution moves
+	 * to a different source line.
+	 */
+	public void clearBreakpointCache() {
+		this.lastBpFile = null;
+		this.lastBpLine = -1;
+		this.lastBpCol = -1;
+	}
 }

src/main/java/com/laytonsmith/tools/debugger/MSDebugServer.java

@@ -91,6 +91,8 @@
 import org.eclipse.lsp4j.debug.ThreadEventArguments;
 import org.eclipse.lsp4j.debug.ThreadEventArgumentsReason;
 
+import com.laytonsmith.abstraction.StaticLayer;
+
 /**
  * A Debug Adapter Protocol (DAP) server for MethodScript. This server can be started
  * alongside any MethodScript execution mode (cmdline, eval, embedded) to enable
@@ -134,6 +136,7 @@ public class MSDebugServer implements IDebugProtocolServer {
 	private boolean suspendOnStart = false;
 	private boolean managedExecution = false;
 	private volatile boolean scriptCompleted = false;
+	private boolean startedOnHostMainThread = false;
 	private PrintStream originalOut;
 	private PrintStream originalErr;
 	private DebugSecurity securityMode = DebugSecurity.KEYPAIR;
@@ -142,6 +145,16 @@ public class MSDebugServer implements IDebugProtocolServer {
 	private final ConcurrentHashMap<Integer, Mixed> compoundVariableRefs = new ConcurrentHashMap<>();
 	private int nextCompoundRef = COMPOUND_REF_START;
 
+	/**
+	 * Sets whether this server is in managed execution mode. In managed mode,
+	 * the server does not own the process lifecycle - the host (e.g. Minecraft)
+	 * manages it. This affects thread registration, completion events, and
+	 * how execution resumes after breakpoints.
+	 */
+	public void setManagedExecution(boolean managed) {
+		this.managedExecution = managed;
+	}
+
 	/**
 	 * Starts a DAP TCP listener on the given port with an explicit threading mode.
 	 *
@@ -162,7 +175,6 @@ public Environment startListening(int port, String bindAddress, Environment envi
 			DebugSecurity security, File authorizedKeysFile) throws IOException {
 		this.env = environment;
 		this.suspendOnStart = suspend;
-		this.managedExecution = true;
 		this.securityMode = security;
 
 		if(security == DebugSecurity.KEYPAIR) {
@@ -328,6 +340,7 @@ public void awaitCompletion() throws InterruptedException {
 	 */
 	public void runScript(ParseTree tree, Environment env, List<com.laytonsmith.core.constructs.Variable> vars) {
 		this.env = env;
+		this.startedOnHostMainThread = managedExecution && StaticLayer.IsMainThread();
 		wireUpDaemonManager(env);
 		installOutputRedirect();
 		spawnExecutionThread(() -> MethodScriptCompiler.execute(tree, env, null, null, vars));
@@ -940,6 +953,8 @@ public CompletableFuture<EvaluateResponse> evaluate(EvaluateArguments args) {
 			Environment evalEnv = inspected.getEnvironment();
 			GlobalEnv gEnv = evalEnv.getEnv(GlobalEnv.class);
 			gEnv.SetFlag(GlobalEnv.FLAG_NO_CHECK_UNDEFINED, true);
+			boolean oldDynamic = gEnv.GetDynamicScriptingMode();
+			gEnv.SetDynamicScriptingMode(true);
 			try {
 				Set<Class<? extends Environment.EnvironmentImpl>> envClasses
 						= evalEnv.getEnvClasses();
@@ -952,6 +967,7 @@ public CompletableFuture<EvaluateResponse> evaluate(EvaluateArguments args) {
 				response.setResult(result.val());
 				response.setType(result.typeof(evalEnv).val());
 			} finally {
+				gEnv.SetDynamicScriptingMode(oldDynamic);
 				gEnv.ClearFlag(GlobalEnv.FLAG_NO_CHECK_UNDEFINED);
 			}
 		} catch(Exception e) {
@@ -994,16 +1010,42 @@ private void resumeExecution(int threadId) {
 		pausedStates.remove(threadId);
 		if(debugCtx.getThreadingMode() == DebugContext.ThreadingMode.SYNCHRONOUS
 				|| threadId != DebugContext.MAIN_THREAD_DAP_ID) {
-			// Sync mode or background thread: thread is blocked on the latch — release it
+			// Sync mode or background thread: thread is blocked on the latch - release it
 			asyncSnapshots.remove(threadId);
 			debugCtx.resume(threadId);
+		} else if(startedOnHostMainThread) {
+			// Async mode, managed execution started on host main thread:
+			// resume on that thread so the host's main-thread contract is honored
+			Script.DebugSnapshot snapshot = asyncSnapshots.remove(threadId);
+			resumeOnHostMainThread(snapshot);
 		} else {
 			// Async mode, main thread: spawn a new thread to resume from snapshot
 			Script.DebugSnapshot snapshot = asyncSnapshots.remove(threadId);
 			spawnExecutionThread(() -> Script.resumeEval(snapshot));
 		}
 	}
 
+	/**
+	 * Resumes script execution on the host's main thread. Used in managed/embedded
+	 * mode when the script was originally running on the host's main thread (e.g.
+	 * Minecraft server thread). The host's convertor schedules the work via
+	 * {@link com.laytonsmith.abstraction.AbstractConvertor#runOnMainThreadLater}.
+	 */
+	private void resumeOnHostMainThread(Script.DebugSnapshot snapshot) {
+		StaticLayer.GetConvertor().runOnMainThreadLater(null, () -> {
+			try {
+				Mixed result = Script.resumeEval(snapshot);
+				if(!Script.isDebuggerPaused(result)) {
+					mainThreadFinished();
+					executionCompleted();
+				}
+			} catch(Exception e) {
+				sendOutput("error", "Script error: " + e.getMessage());
+				executionCompleted();
+			}
+		});
+	}
+
 	/**
 	 * Registers the DebugContext with the environment's DaemonManager so that
 	 * background threads (e.g. x_new_thread) are automatically tracked and