From 3a75a023713589e0a5b857eb095da79d94da536a Mon Sep 17 00:00:00 2001
From: Peter Amiri <peter@alurium.com>
Date: Sat, 11 Apr 2026 15:04:48 -0700
Subject: [PATCH 01/13] docs(test): add cli testing design spec and
 implementation plan

---
 .../plans/2026-04-11-cli-testing.md           | 1624 +++++++++++++++++
 .../specs/2026-04-11-cli-testing-design.md    |  262 +++
 2 files changed, 1886 insertions(+)
 create mode 100644 docs/superpowers/plans/2026-04-11-cli-testing.md
 create mode 100644 docs/superpowers/specs/2026-04-11-cli-testing-design.md

diff --git a/docs/superpowers/plans/2026-04-11-cli-testing.md b/docs/superpowers/plans/2026-04-11-cli-testing.md
new file mode 100644
index 000000000..e24efae66
--- /dev/null
+++ b/docs/superpowers/plans/2026-04-11-cli-testing.md
@@ -0,0 +1,1624 @@
+# CLI Test Infrastructure Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Add a TestBox test suite for the LuCLI CLI module services and commands, integrated into the CI pipeline.
+
+**Architecture:** Tests live in `cli/lucli/tests/` with their own `runner.cfm`. A shared `TestHelper.cfc` copies the project skeleton into a temp directory for isolated testing. Service unit tests instantiate CFCs directly; integration tests hit the running server via HTTP. CI runs both suites via `run-tests.sh`.
+
+**Tech Stack:** CFML (Lucee 7), TestBox BDD (describe/it/expect), LuCLI server
+
+**Spec:** `docs/superpowers/specs/2026-04-11-cli-testing-design.md`
+
+---
+
+## File Structure
+
+### New files to create:
+- `cli/lucli/tests/runner.cfm` — TestBox entry point, returns JSON/HTML
+- `cli/lucli/tests/TestHelper.cfc` — Temp project scaffolding, HTTP helper, port detection
+- `cli/lucli/tests/specs/services/HelpersSpec.cfc` — Helpers service tests
+- `cli/lucli/tests/specs/services/DestroySpec.cfc` — Destroy service tests
+- `cli/lucli/tests/specs/services/DoctorSpec.cfc` — Doctor service tests
+- `cli/lucli/tests/specs/services/StatsSpec.cfc` — Stats + notes service tests
+- `cli/lucli/tests/specs/services/AdminSpec.cfc` — Admin service tests
+- `cli/lucli/tests/specs/services/CodeGenSpec.cfc` — CodeGen service tests
+- `cli/lucli/tests/specs/integration/DbCommandsSpec.cfc` — DB endpoint integration tests
+- `cli/lucli/tests/specs/integration/IntrospectSpec.cfc` — Introspect endpoint integration tests
+
+### Existing files to modify:
+- `tools/ci/run-tests.sh` — Add CLI test block after core tests
+
+---
+
+### Task 1: TestHelper and Runner
+
+**Files:**
+- Create: `cli/lucli/tests/TestHelper.cfc`
+- Create: `cli/lucli/tests/runner.cfm`
+
+- [ ] **Step 1: Create directory structure**
+
+```bash
+mkdir -p cli/lucli/tests/specs/services
+mkdir -p cli/lucli/tests/specs/integration
+```
+
+- [ ] **Step 2: Create TestHelper.cfc**
+
+Write `cli/lucli/tests/TestHelper.cfc`:
+
+```cfml
+/**
+ * Shared test utilities for CLI module specs.
+ *
+ * Provides temp project scaffolding (copies project skeleton to temp dir),
+ * HTTP helper for integration tests, and server port detection.
+ */
+component {
+
+	/**
+	 * Copy the project skeleton into a temp directory for isolated testing.
+	 * Returns the absolute path to the temp project root.
+	 */
+	public string function scaffoldTempProject(required string sourceRoot) {
+		var tempBase = getTempDirectory() & "wheels-cli-test-" & createUUID();
+		directoryCreate(tempBase, true);
+
+		// Copy app structure
+		var dirs = ["app", "config", "tests/specs", "public"];
+		for (var dir in dirs) {
+			var srcPath = arguments.sourceRoot & "/" & dir;
+			var destPath = tempBase & "/" & dir;
+			if (directoryExists(srcPath)) {
+				directoryCopy(srcPath, destPath, true);
+			} else {
+				directoryCreate(destPath, true);
+			}
+		}
+
+		// Copy key config files from root
+		var files = [".env", "lucee.json"];
+		for (var f in files) {
+			var srcFile = arguments.sourceRoot & "/" & f;
+			if (fileExists(srcFile)) {
+				fileCopy(srcFile, tempBase & "/" & f);
+			}
+		}
+
+		return tempBase;
+	}
+
+	/**
+	 * Delete the temp project directory.
+	 */
+	public void function cleanupTempProject(required string tempRoot) {
+		if (len(arguments.tempRoot) > 10 && directoryExists(arguments.tempRoot)) {
+			directoryDelete(arguments.tempRoot, true);
+		}
+	}
+
+	/**
+	 * Detect a running server port.
+	 * Checks PORT env var first, then probes 8080 and 60007.
+	 * Returns port number or 0 if no server found.
+	 */
+	public numeric function detectServerPort() {
+		// Check environment variable (set by CI)
+		var envPort = createObject("java", "java.lang.System").getenv("PORT");
+		if (!isNull(envPort) && len(envPort) && isPortResponding(val(envPort))) {
+			return val(envPort);
+		}
+
+		// Probe common ports
+		if (isPortResponding(8080)) return 8080;
+		if (isPortResponding(60007)) return 60007;
+
+		return 0;
+	}
+
+	/**
+	 * HTTP GET request, returns response body string.
+	 * Returns empty string on connection failure.
+	 */
+	public string function httpGet(required string url) {
+		try {
+			var javaUrl = createObject("java", "java.net.URL").init(arguments.url);
+			var conn = javaUrl.openConnection();
+			conn.setRequestMethod("GET");
+			conn.setConnectTimeout(5000);
+			conn.setReadTimeout(30000);
+
+			var responseCode = conn.getResponseCode();
+			var inputStream = responseCode >= 400
+				? conn.getErrorStream()
+				: conn.getInputStream();
+			var scanner = createObject("java", "java.util.Scanner")
+				.init(inputStream, "UTF-8");
+			var response = "";
+			while (scanner.hasNextLine()) {
+				response &= scanner.nextLine() & chr(10);
+			}
+			scanner.close();
+			return trim(response);
+		} catch (any e) {
+			return "";
+		}
+	}
+
+	/**
+	 * Check if a port is responding to HTTP.
+	 */
+	private boolean function isPortResponding(required numeric port) {
+		try {
+			var javaUrl = createObject("java", "java.net.URL")
+				.init("http://localhost:#arguments.port#/");
+			var conn = javaUrl.openConnection();
+			conn.setConnectTimeout(2000);
+			conn.setReadTimeout(2000);
+			conn.getResponseCode();
+			return true;
+		} catch (any e) {
+			return false;
+		}
+	}
+
+}
+```
+
+- [ ] **Step 3: Create runner.cfm**
+
+Write `cli/lucli/tests/runner.cfm`:
+
+```cfml
+<cfsetting requestTimeOut="300">
+<cfscript>
+try {
+	testBox = new wheels.wheelstest.system.TestBox(
+		directory = "cli.lucli.tests.specs",
+		options = { coverage = { enabled = false } }
+	);
+
+	local.sortedArray = testBox.getBundles();
+	arraySort(local.sortedArray, "textNoCase");
+	testBox.setBundles(local.sortedArray);
+
+	if (!structKeyExists(url, "format") || url.format == "html") {
+		result = testBox.run(
+			reporter = "wheels.wheelstest.system.reports.SimpleReporter"
+		);
+	} else if (url.format == "json") {
+		result = testBox.run(
+			reporter = "wheels.wheelstest.system.reports.JSONReporter"
+		);
+		cfcontent(type = "application/json");
+		local.parsed = deserializeJSON(result);
+		if (local.parsed.totalFail > 0 || local.parsed.totalError > 0) {
+			cfheader(statuscode = 417);
+		} else {
+			cfheader(statuscode = 200);
+		}
+	}
+
+	writeOutput(result);
+} catch (any e) {
+	cfheader(statuscode = 500);
+	cfcontent(type = "application/json");
+	writeOutput('{"success":false,"error":"' & replace(e.message, '"', '\"', 'all') & '"}');
+}
+</cfscript>
+```
+
+- [ ] **Step 4: Commit**
+
+```bash
+git add cli/lucli/tests/
+git commit -m "test(cli): add test runner and helper infrastructure"
+```
+
+---
+
+### Task 2: HelpersSpec
+
+**Files:**
+- Create: `cli/lucli/tests/specs/services/HelpersSpec.cfc`
+
+- [ ] **Step 1: Create HelpersSpec.cfc**
+
+Write `cli/lucli/tests/specs/services/HelpersSpec.cfc`:
+
+```cfml
+component extends="wheels.wheelstest.system.BaseSpec" {
+
+	function beforeAll() {
+		variables.helpers = new cli.lucli.services.Helpers();
+	}
+
+	function run() {
+
+		describe("Helpers Service", () => {
+
+			describe("capitalize()", () => {
+
+				it("capitalizes the first letter", () => {
+					expect(helpers.capitalize("user")).toBe("User");
+				});
+
+				it("handles single character", () => {
+					expect(helpers.capitalize("a")).toBe("A");
+				});
+
+				it("returns empty string for empty input", () => {
+					expect(helpers.capitalize("")).toBe("");
+				});
+
+				it("preserves rest of string", () => {
+					expect(helpers.capitalize("firstName")).toBe("FirstName");
+				});
+
+			});
+
+			describe("pluralize()", () => {
+
+				it("pluralizes regular words", () => {
+					expect(helpers.pluralize("user")).toBe("users");
+				});
+
+				it("handles -es suffix", () => {
+					expect(helpers.pluralize("bus")).toBe("buses");
+				});
+
+				it("handles -ies suffix", () => {
+					expect(helpers.pluralize("category")).toBe("categories");
+				});
+
+				it("handles irregular words", () => {
+					expect(helpers.pluralize("person")).toBe("people");
+					expect(helpers.pluralize("child")).toBe("children");
+				});
+
+				it("handles uncountable words", () => {
+					expect(helpers.pluralize("sheep")).toBe("sheep");
+					expect(helpers.pluralize("fish")).toBe("fish");
+				});
+
+			});
+
+			describe("singularize()", () => {
+
+				it("singularizes regular words", () => {
+					expect(helpers.singularize("users")).toBe("user");
+				});
+
+				it("handles irregular words", () => {
+					expect(helpers.singularize("people")).toBe("person");
+					expect(helpers.singularize("children")).toBe("child");
+				});
+
+				it("handles uncountable words", () => {
+					expect(helpers.singularize("sheep")).toBe("sheep");
+				});
+
+			});
+
+			describe("stripSpecialChars()", () => {
+
+				it("removes brackets and special characters", () => {
+					expect(helpers.stripSpecialChars("hello[world]")).toBe("helloworld");
+				});
+
+				it("removes ampersands and percents", () => {
+					expect(helpers.stripSpecialChars("a&b%c")).toBe("abc");
+				});
+
+				it("trims whitespace", () => {
+					expect(helpers.stripSpecialChars("  hello  ")).toBe("hello");
+				});
+
+			});
+
+			describe("generateMigrationTimestamp()", () => {
+
+				it("returns a 14-digit string", () => {
+					var ts = helpers.generateMigrationTimestamp();
+					expect(len(ts)).toBe(14);
+					expect(isNumeric(ts)).toBeTrue();
+				});
+
+			});
+
+		});
+
+	}
+
+}
+```
+
+- [ ] **Step 2: Verify tests run**
+
+```bash
+curl -sf "http://localhost:8080/cli/lucli/tests/runner.cfm?format=json" | python3 -c "
+import json,sys; d=json.load(sys.stdin)
+print(f'{d[\"totalPass\"]} pass, {d[\"totalFail\"]} fail, {d[\"totalError\"]} error')
+"
+```
+
+Expected: All pass, 0 fail, 0 error.
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add cli/lucli/tests/specs/services/HelpersSpec.cfc
+git commit -m "test(cli): add helpers service unit tests"
+```
+
+---
+
+### Task 3: DestroySpec
+
+**Files:**
+- Create: `cli/lucli/tests/specs/services/DestroySpec.cfc`
+
+- [ ] **Step 1: Create DestroySpec.cfc**
+
+Write `cli/lucli/tests/specs/services/DestroySpec.cfc`:
+
+```cfml
+component extends="wheels.wheelstest.system.BaseSpec" {
+
+	function beforeAll() {
+		variables.testHelper = new cli.lucli.tests.TestHelper();
+		variables.tempRoot = testHelper.scaffoldTempProject(expandPath("/"));
+		variables.moduleRoot = expandPath("/cli/lucli/");
+		variables.helpers = new cli.lucli.services.Helpers();
+		variables.destroy = new cli.lucli.services.Destroy(
+			helpers = variables.helpers,
+			projectRoot = variables.tempRoot,
+			moduleRoot = variables.moduleRoot
+		);
+	}
+
+	function afterAll() {
+		testHelper.cleanupTempProject(variables.tempRoot);
+	}
+
+	function run() {
+
+		describe("Destroy Service", () => {
+
+			describe("destroyModel()", () => {
+
+				it("deletes model file and generates migration", () => {
+					// Create a model file to destroy
+					var modelPath = tempRoot & "/app/models/Deleteme.cfc";
+					directoryCreate(getDirectoryFromPath(modelPath), true, true);
+					fileWrite(modelPath, 'component extends="Model" {}');
+
+					var result = destroy.destroyModel("Deleteme");
+					expect(result.success).toBeTrue();
+					expect(fileExists(modelPath)).toBeFalse();
+					expect(len(result.migrationPath)).toBeGT(0);
+					expect(fileExists(result.migrationPath)).toBeTrue();
+
+					// Verify migration content
+					var migContent = fileRead(result.migrationPath);
+					expect(migContent).toInclude("dropTable");
+					expect(migContent).toInclude("deletemes");
+				});
+
+				it("warns when model file does not exist", () => {
+					var result = destroy.destroyModel("Nonexistent");
+					expect(result.success).toBeTrue();
+					expect(arrayLen(result.warnings)).toBeGT(0);
+				});
+
+			});
+
+			describe("destroyController()", () => {
+
+				it("deletes controller and test files", () => {
+					var controllerPath = tempRoot & "/app/controllers/Deletemes.cfc";
+					var testPath = tempRoot & "/tests/specs/controllers/DeletemesSpec.cfc";
+					directoryCreate(getDirectoryFromPath(controllerPath), true, true);
+					directoryCreate(getDirectoryFromPath(testPath), true, true);
+					fileWrite(controllerPath, 'component extends="Controller" {}');
+					fileWrite(testPath, 'component {}');
+
+					var result = destroy.destroyController("Deleteme");
+					expect(fileExists(controllerPath)).toBeFalse();
+					expect(fileExists(testPath)).toBeFalse();
+				});
+
+				it("does not generate a migration", () => {
+					var result = destroy.destroyController("Deleteme");
+					expect(structKeyExists(result, "migrationPath")).toBeFalse();
+				});
+
+			});
+
+			describe("destroyResource()", () => {
+
+				it("deletes all resource files and cleans up route", () => {
+					// Create resource files
+					var modelPath = tempRoot & "/app/models/Widget.cfc";
+					var controllerPath = tempRoot & "/app/controllers/Widgets.cfc";
+					var viewsDir = tempRoot & "/app/views/widgets";
+					var modelTestPath = tempRoot & "/tests/specs/models/WidgetSpec.cfc";
+					var controllerTestPath = tempRoot & "/tests/specs/controllers/WidgetsSpec.cfc";
+					var viewTestsDir = tempRoot & "/tests/specs/views/widgets";
+
+					directoryCreate(getDirectoryFromPath(modelPath), true, true);
+					directoryCreate(getDirectoryFromPath(controllerPath), true, true);
+					directoryCreate(viewsDir, true, true);
+					directoryCreate(getDirectoryFromPath(modelTestPath), true, true);
+					directoryCreate(getDirectoryFromPath(controllerTestPath), true, true);
+					directoryCreate(viewTestsDir, true, true);
+
+					fileWrite(modelPath, 'component extends="Model" {}');
+					fileWrite(controllerPath, 'component extends="Controller" {}');
+					fileWrite(viewsDir & "/index.cfm", "<p>index</p>");
+					fileWrite(modelTestPath, 'component {}');
+					fileWrite(controllerTestPath, 'component {}');
+					fileWrite(viewTestsDir & "/indexSpec.cfc", 'component {}');
+
+					// Add route
+					var routesPath = tempRoot & "/config/routes.cfm";
+					var routeContent = fileRead(routesPath);
+					routeContent = replace(routeContent, "// CLI-Appends-Here",
+						'.resources("widgets")' & chr(10) & chr(9) & chr(9) & "// CLI-Appends-Here");
+					fileWrite(routesPath, routeContent);
+
+					var result = destroy.destroyResource("Widget");
+					expect(fileExists(modelPath)).toBeFalse();
+					expect(fileExists(controllerPath)).toBeFalse();
+					expect(directoryExists(viewsDir)).toBeFalse();
+					expect(fileExists(modelTestPath)).toBeFalse();
+					expect(fileExists(controllerTestPath)).toBeFalse();
+					expect(directoryExists(viewTestsDir)).toBeFalse();
+					expect(len(result.migrationPath)).toBeGT(0);
+
+					// Verify route removed
+					var updatedRoutes = fileRead(routesPath);
+					expect(updatedRoutes).notToInclude('.resources("widgets")');
+				});
+
+			});
+
+			describe("destroyView()", () => {
+
+				it("deletes a single view file when path contains /", () => {
+					var viewDir = tempRoot & "/app/views/items";
+					directoryCreate(viewDir, true, true);
+					fileWrite(viewDir & "/show.cfm", "<p>show</p>");
+
+					var result = destroy.destroyView("items/show");
+					expect(fileExists(viewDir & "/show.cfm")).toBeFalse();
+					// Directory should still exist
+					expect(directoryExists(viewDir)).toBeTrue();
+				});
+
+				it("deletes entire view directory when no /", () => {
+					var viewDir = tempRoot & "/app/views/things";
+					directoryCreate(viewDir, true, true);
+					fileWrite(viewDir & "/index.cfm", "<p>index</p>");
+
+					var result = destroy.destroyView("Thing");
+					expect(directoryExists(viewDir)).toBeFalse();
+				});
+
+				it("returns error for invalid view path", () => {
+					var result = destroy.destroyView("invalid/");
+					expect(result.success).toBeFalse();
+				});
+
+			});
+
+			describe("previewDestroy()", () => {
+
+				it("returns expected items for resource type", () => {
+					var preview = destroy.previewDestroy("Product", "resource");
+					expect(arrayLen(preview)).toBeGTE(6);
+					expect(arrayToList(preview)).toInclude("Product.cfc");
+					expect(arrayToList(preview)).toInclude("Products.cfc");
+					expect(arrayToList(preview)).toInclude("drop table");
+				});
+
+				it("returns expected items for controller type", () => {
+					var preview = destroy.previewDestroy("Product", "controller");
+					expect(arrayLen(preview)).toBe(2);
+				});
+
+			});
+
+		});
+
+	}
+
+}
+```
+
+- [ ] **Step 2: Verify tests run**
+
+```bash
+curl -sf "http://localhost:8080/cli/lucli/tests/runner.cfm?format=json" | python3 -c "
+import json,sys; d=json.load(sys.stdin)
+print(f'{d[\"totalPass\"]} pass, {d[\"totalFail\"]} fail, {d[\"totalError\"]} error')
+"
+```
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add cli/lucli/tests/specs/services/DestroySpec.cfc
+git commit -m "test(cli): add destroy service unit tests"
+```
+
+---
+
+### Task 4: DoctorSpec
+
+**Files:**
+- Create: `cli/lucli/tests/specs/services/DoctorSpec.cfc`
+
+- [ ] **Step 1: Create DoctorSpec.cfc**
+
+Write `cli/lucli/tests/specs/services/DoctorSpec.cfc`:
+
+```cfml
+component extends="wheels.wheelstest.system.BaseSpec" {
+
+	function beforeAll() {
+		variables.testHelper = new cli.lucli.tests.TestHelper();
+		variables.tempRoot = testHelper.scaffoldTempProject(expandPath("/"));
+	}
+
+	function afterAll() {
+		testHelper.cleanupTempProject(variables.tempRoot);
+	}
+
+	function run() {
+
+		describe("Doctor Service", () => {
+
+			it("reports HEALTHY for a valid project", () => {
+				var doctor = new cli.lucli.services.Doctor(projectRoot = tempRoot);
+				var results = doctor.runChecks();
+				expect(results.status).toBe("HEALTHY");
+				expect(arrayLen(results.issues)).toBe(0);
+			});
+
+			it("reports CRITICAL when a required directory is missing", () => {
+				// Remove app/controllers
+				if (directoryExists(tempRoot & "/app/controllers")) {
+					directoryDelete(tempRoot & "/app/controllers", true);
+				}
+
+				var doctor = new cli.lucli.services.Doctor(projectRoot = tempRoot);
+				var results = doctor.runChecks();
+				expect(results.status).toBe("CRITICAL");
+				expect(arrayLen(results.issues)).toBeGT(0);
+
+				var issueText = arrayToList(results.issues, " ");
+				expect(issueText).toInclude("app/controllers");
+
+				// Restore for subsequent tests
+				directoryCreate(tempRoot & "/app/controllers", true);
+			});
+
+			it("reports WARNING when a recommended directory is missing", () => {
+				// Remove tests/specs if it exists
+				var specsDir = tempRoot & "/tests/specs";
+				var existed = directoryExists(specsDir);
+				if (existed) {
+					directoryDelete(specsDir, true);
+				}
+
+				var doctor = new cli.lucli.services.Doctor(projectRoot = tempRoot);
+				var results = doctor.runChecks();
+
+				// Should not be CRITICAL (no required dirs missing)
+				expect(results.status).notToBe("CRITICAL");
+				expect(arrayLen(results.warnings)).toBeGT(0);
+
+				// Restore
+				if (existed) {
+					directoryCreate(specsDir, true);
+				}
+			});
+
+			it("reports CRITICAL when a required file is missing", () => {
+				var routesPath = tempRoot & "/config/routes.cfm";
+				var routesContent = "";
+				if (fileExists(routesPath)) {
+					routesContent = fileRead(routesPath);
+					fileDelete(routesPath);
+				}
+
+				var doctor = new cli.lucli.services.Doctor(projectRoot = tempRoot);
+				var results = doctor.runChecks();
+				expect(results.status).toBe("CRITICAL");
+
+				// Restore
+				if (len(routesContent)) {
+					fileWrite(routesPath, routesContent);
+				}
+			});
+
+			it("warns when config routes.cfm has minimal content", () => {
+				var routesPath = tempRoot & "/config/routes.cfm";
+				var original = fileRead(routesPath);
+				fileWrite(routesPath, "<!--- --->"); // less than 10 chars of content
+
+				var doctor = new cli.lucli.services.Doctor(projectRoot = tempRoot);
+				var results = doctor.runChecks();
+
+				var warningText = arrayToList(results.warnings, " ");
+				expect(warningText).toInclude("routes.cfm");
+
+				fileWrite(routesPath, original);
+			});
+
+			it("generates recommendations based on issues", () => {
+				// Remove tests to trigger recommendation
+				var specsDir = tempRoot & "/tests/specs";
+				var existed = directoryExists(specsDir);
+				if (existed) {
+					directoryDelete(specsDir, true);
+				}
+
+				var doctor = new cli.lucli.services.Doctor(projectRoot = tempRoot);
+				var results = doctor.runChecks();
+				expect(arrayLen(results.recommendations)).toBeGT(0);
+
+				if (existed) {
+					directoryCreate(specsDir, true);
+				}
+			});
+
+			it("passes write permission check on writable directory", () => {
+				var doctor = new cli.lucli.services.Doctor(projectRoot = tempRoot);
+				var results = doctor.runChecks();
+
+				var passedText = arrayToList(results.passed, " ");
+				expect(passedText).toInclude("Write permission");
+			});
+
+		});
+
+	}
+
+}
+```
+
+- [ ] **Step 2: Verify and commit**
+
+```bash
+curl -sf "http://localhost:8080/cli/lucli/tests/runner.cfm?format=json" | python3 -c "
+import json,sys; d=json.load(sys.stdin)
+print(f'{d[\"totalPass\"]} pass, {d[\"totalFail\"]} fail, {d[\"totalError\"]} error')
+"
+git add cli/lucli/tests/specs/services/DoctorSpec.cfc
+git commit -m "test(cli): add doctor service unit tests"
+```
+
+---
+
+### Task 5: StatsSpec
+
+**Files:**
+- Create: `cli/lucli/tests/specs/services/StatsSpec.cfc`
+
+- [ ] **Step 1: Create StatsSpec.cfc**
+
+Write `cli/lucli/tests/specs/services/StatsSpec.cfc`:
+
+```cfml
+component extends="wheels.wheelstest.system.BaseSpec" {
+
+	function beforeAll() {
+		variables.testHelper = new cli.lucli.tests.TestHelper();
+		variables.tempRoot = testHelper.scaffoldTempProject(expandPath("/"));
+		variables.helpers = new cli.lucli.services.Helpers();
+		variables.stats = new cli.lucli.services.Stats(
+			helpers = variables.helpers,
+			projectRoot = variables.tempRoot
+		);
+	}
+
+	function afterAll() {
+		testHelper.cleanupTempProject(variables.tempRoot);
+	}
+
+	function run() {
+
+		describe("Stats Service", () => {
+
+			describe("getStats()", () => {
+
+				it("returns categories array with expected entries", () => {
+					var data = stats.getStats();
+					expect(arrayLen(data.categories)).toBe(7);
+
+					var names = [];
+					for (var cat in data.categories) {
+						arrayAppend(names, cat.name);
+					}
+					expect(names).toInclude("Controllers");
+					expect(names).toInclude("Models");
+					expect(names).toInclude("Views");
+				});
+
+				it("returns totals with non-negative values", () => {
+					var data = stats.getStats();
+					expect(data.totals.files).toBeGTE(0);
+					expect(data.totals.loc).toBeGTE(0);
+					expect(data.totals.comments).toBeGTE(0);
+					expect(data.totals.blanks).toBeGTE(0);
+					expect(data.totals.total).toBeGTE(0);
+				});
+
+				it("total equals sum of categories", () => {
+					var data = stats.getStats();
+					var sumFiles = 0;
+					for (var cat in data.categories) {
+						sumFiles += cat.files;
+					}
+					expect(data.totals.files).toBe(sumFiles);
+				});
+
+				it("counts LOC correctly for a known file", () => {
+					// Create a file with known content
+					var testFile = tempRoot & "/app/models/StatsTestModel.cfc";
+					directoryCreate(getDirectoryFromPath(testFile), true, true);
+					fileWrite(testFile,
+						'component extends="Model" {' & chr(10)
+						& chr(10)
+						& '	// this is a comment' & chr(10)
+						& '	function config() {' & chr(10)
+						& '	}' & chr(10)
+						& chr(10)
+						& '}'
+					);
+
+					var data = stats.getStats();
+					// Find Models category
+					var modelCat = {};
+					for (var cat in data.categories) {
+						if (cat.name == "Models") modelCat = cat;
+					}
+					// Should have at least 1 file and some LOC
+					expect(modelCat.files).toBeGTE(1);
+					expect(modelCat.loc).toBeGTE(3); // 3 code lines in our test file
+					expect(modelCat.comments).toBeGTE(1); // 1 comment line
+					expect(modelCat.blanks).toBeGTE(2); // 2 blank lines
+				});
+
+				it("returns topFiles sorted by line count descending", () => {
+					var data = stats.getStats();
+					if (arrayLen(data.topFiles) >= 2) {
+						expect(data.topFiles[1].lines).toBeGTE(data.topFiles[2].lines);
+					}
+				});
+
+			});
+
+			describe("getNotes()", () => {
+
+				it("finds TODO annotations", () => {
+					// Create a file with a TODO
+					var testFile = tempRoot & "/app/models/NotesTestModel.cfc";
+					directoryCreate(getDirectoryFromPath(testFile), true, true);
+					fileWrite(testFile,
+						'component {' & chr(10)
+						& '	// TODO: implement validation' & chr(10)
+						& '	// FIXME: broken query' & chr(10)
+						& '}'
+					);
+
+					var data = stats.getNotes();
+					expect(data.total).toBeGTE(2);
+					expect(arrayLen(data.annotations["TODO"])).toBeGTE(1);
+					expect(arrayLen(data.annotations["FIXME"])).toBeGTE(1);
+
+					// Check annotation has correct structure
+					var todo = data.annotations["TODO"][1];
+					expect(structKeyExists(todo, "file")).toBeTrue();
+					expect(structKeyExists(todo, "line")).toBeTrue();
+					expect(structKeyExists(todo, "text")).toBeTrue();
+				});
+
+				it("finds custom annotation types", () => {
+					var testFile = tempRoot & "/app/controllers/NotesTestController.cfc";
+					directoryCreate(getDirectoryFromPath(testFile), true, true);
+					fileWrite(testFile,
+						'component {' & chr(10)
+						& '	// HACK: temporary workaround' & chr(10)
+						& '}'
+					);
+
+					var data = stats.getNotes(annotations = "TODO", custom = "HACK");
+					expect(arrayLen(data.annotations["HACK"])).toBeGTE(1);
+					expect(data.annotations["HACK"][1].text).toInclude("temporary");
+				});
+
+				it("returns zero total when no annotations exist", () => {
+					// Create clean file
+					var testFile = tempRoot & "/app/models/CleanModel.cfc";
+					directoryCreate(getDirectoryFromPath(testFile), true, true);
+					fileWrite(testFile, 'component {}');
+
+					// Use a custom annotation type unlikely to exist
+					var data = stats.getNotes(annotations = "XYZNONEXISTENT");
+					expect(data.annotations["XYZNONEXISTENT"]).toBeEmpty();
+				});
+
+			});
+
+		});
+
+	}
+
+}
+```
+
+- [ ] **Step 2: Verify and commit**
+
+```bash
+curl -sf "http://localhost:8080/cli/lucli/tests/runner.cfm?format=json" | python3 -c "
+import json,sys; d=json.load(sys.stdin)
+print(f'{d[\"totalPass\"]} pass, {d[\"totalFail\"]} fail, {d[\"totalError\"]} error')
+"
+git add cli/lucli/tests/specs/services/StatsSpec.cfc
+git commit -m "test(cli): add stats and notes service unit tests"
+```
+
+---
+
+### Task 6: AdminSpec
+
+**Files:**
+- Create: `cli/lucli/tests/specs/services/AdminSpec.cfc`
+
+- [ ] **Step 1: Create AdminSpec.cfc**
+
+Write `cli/lucli/tests/specs/services/AdminSpec.cfc`:
+
+```cfml
+component extends="wheels.wheelstest.system.BaseSpec" {
+
+	function beforeAll() {
+		variables.testHelper = new cli.lucli.tests.TestHelper();
+		variables.tempRoot = testHelper.scaffoldTempProject(expandPath("/"));
+		variables.moduleRoot = expandPath("/cli/lucli/");
+		variables.helpers = new cli.lucli.services.Helpers();
+		variables.admin = new cli.lucli.services.Admin(
+			helpers = variables.helpers,
+			projectRoot = variables.tempRoot,
+			moduleRoot = variables.moduleRoot
+		);
+	}
+
+	function afterAll() {
+		testHelper.cleanupTempProject(variables.tempRoot);
+	}
+
+	function run() {
+
+		describe("Admin Service", () => {
+
+			describe("mapColumnToFormHelper()", () => {
+
+				it("maps string type to textField", () => {
+					var result = admin.mapColumnToFormHelper({name: "title", type: "string"});
+					expect(result).toBe("textField");
+				});
+
+				it("maps text type to textArea", () => {
+					var result = admin.mapColumnToFormHelper({name: "body", type: "text"});
+					expect(result).toBe("textArea");
+				});
+
+				it("maps boolean type to checkBox", () => {
+					var result = admin.mapColumnToFormHelper({name: "active", type: "boolean"});
+					expect(result).toBe("checkBox");
+				});
+
+				it("maps integer type to numberField", () => {
+					var result = admin.mapColumnToFormHelper({name: "quantity", type: "integer"});
+					expect(result).toBe("numberField");
+				});
+
+				it("maps date type to dateField", () => {
+					var result = admin.mapColumnToFormHelper({name: "startDate", type: "date"});
+					expect(result).toBe("dateField");
+				});
+
+				it("maps datetime to dateTimeLocalField", () => {
+					var result = admin.mapColumnToFormHelper({name: "publishedAt", type: "datetime"});
+					expect(result).toBe("dateTimeLocalField");
+				});
+
+				it("maps email column name to emailField", () => {
+					var result = admin.mapColumnToFormHelper({name: "email", type: "string"});
+					expect(result).toBe("emailField");
+				});
+
+				it("maps phone column name to telField", () => {
+					var result = admin.mapColumnToFormHelper({name: "phone", type: "string"});
+					expect(result).toBe("telField");
+				});
+
+				it("maps url column name to urlField", () => {
+					var result = admin.mapColumnToFormHelper({name: "website", type: "string"});
+					expect(result).toBe("urlField");
+				});
+
+			});
+
+			describe("generateAdmin()", () => {
+
+				it("generates controller and view files", () => {
+					var modelData = {
+						model: "Product",
+						tableName: "products",
+						primaryKey: "id",
+						columns: [
+							{name: "id", type: "integer", primaryKey: true},
+							{name: "name", type: "string"},
+							{name: "price", type: "decimal"},
+							{name: "active", type: "boolean"},
+							{name: "createdAt", type: "datetime"},
+							{name: "updatedAt", type: "datetime"}
+						],
+						associations: []
+					};
+
+					var result = admin.generateAdmin(modelData = modelData, force = true);
+					expect(result.success).toBeTrue();
+					expect(arrayLen(result.generated)).toBeGTE(6);
+
+					// Verify controller exists
+					expect(fileExists(tempRoot & "/app/controllers/admin/Products.cfc")).toBeTrue();
+
+					// Verify views exist
+					expect(fileExists(tempRoot & "/app/views/admin/products/index.cfm")).toBeTrue();
+					expect(fileExists(tempRoot & "/app/views/admin/products/show.cfm")).toBeTrue();
+					expect(fileExists(tempRoot & "/app/views/admin/products/new.cfm")).toBeTrue();
+					expect(fileExists(tempRoot & "/app/views/admin/products/edit.cfm")).toBeTrue();
+					expect(fileExists(tempRoot & "/app/views/admin/products/_form.cfm")).toBeTrue();
+				});
+
+				it("excludes id and timestamp columns from form fields", () => {
+					var modelData = {
+						model: "Item",
+						tableName: "items",
+						primaryKey: "id",
+						columns: [
+							{name: "id", type: "integer", primaryKey: true},
+							{name: "title", type: "string"},
+							{name: "createdAt", type: "datetime"},
+							{name: "updatedAt", type: "datetime"}
+						],
+						associations: []
+					};
+
+					var result = admin.generateAdmin(modelData = modelData, force = true);
+					var formContent = fileRead(tempRoot & "/app/views/admin/items/_form.cfm");
+					expect(formContent).toInclude("title");
+					expect(formContent).notToInclude('"id"');
+					expect(formContent).notToInclude('"createdAt"');
+					expect(formContent).notToInclude('"updatedAt"');
+				});
+
+				it("generates foreign key loaders for belongsTo", () => {
+					var modelData = {
+						model: "Post",
+						tableName: "posts",
+						primaryKey: "id",
+						columns: [
+							{name: "id", type: "integer", primaryKey: true},
+							{name: "title", type: "string"},
+							{name: "categoryId", type: "integer"}
+						],
+						associations: [
+							{type: "belongsTo", name: "category", modelName: "Category"}
+						]
+					};
+
+					var result = admin.generateAdmin(modelData = modelData, force = true);
+					var controllerContent = fileRead(tempRoot & "/app/controllers/admin/Posts.cfc");
+					expect(controllerContent).toInclude("loadCategories");
+					expect(controllerContent).toInclude('model("Category")');
+				});
+
+				it("injects admin route into routes.cfm", () => {
+					var modelData = {
+						model: "Order",
+						tableName: "orders",
+						primaryKey: "id",
+						columns: [{name: "id", type: "integer", primaryKey: true}],
+						associations: []
+					};
+
+					var result = admin.generateAdmin(modelData = modelData, force = true);
+					var routesContent = fileRead(tempRoot & "/config/routes.cfm");
+					expect(routesContent).toInclude('scope(path="admin"');
+					expect(routesContent).toInclude('.resources("orders")');
+				});
+
+				it("errors when files exist and force is false", () => {
+					var modelData = {
+						model: "Order",
+						tableName: "orders",
+						primaryKey: "id",
+						columns: [{name: "id", type: "integer", primaryKey: true}],
+						associations: []
+					};
+
+					// Files already exist from previous test
+					var result = admin.generateAdmin(modelData = modelData, force = false);
+					expect(result.success).toBeFalse();
+					expect(arrayLen(result.errors)).toBeGT(0);
+				});
+
+				it("skips route injection with noRoutes flag", () => {
+					// Read current routes to compare
+					var routesBefore = fileRead(tempRoot & "/config/routes.cfm");
+
+					var modelData = {
+						model: "NoRouteTest",
+						tableName: "no_route_tests",
+						primaryKey: "id",
+						columns: [{name: "id", type: "integer", primaryKey: true}],
+						associations: []
+					};
+
+					var result = admin.generateAdmin(
+						modelData = modelData,
+						force = true,
+						noRoutes = true
+					);
+					expect(result.success).toBeTrue();
+
+					var routesAfter = fileRead(tempRoot & "/config/routes.cfm");
+					expect(routesAfter).notToInclude("no_route_tests");
+				});
+
+			});
+
+		});
+
+	}
+
+}
+```
+
+- [ ] **Step 2: Verify and commit**
+
+```bash
+curl -sf "http://localhost:8080/cli/lucli/tests/runner.cfm?format=json" | python3 -c "
+import json,sys; d=json.load(sys.stdin)
+print(f'{d[\"totalPass\"]} pass, {d[\"totalFail\"]} fail, {d[\"totalError\"]} error')
+"
+git add cli/lucli/tests/specs/services/AdminSpec.cfc
+git commit -m "test(cli): add admin service unit tests"
+```
+
+---
+
+### Task 7: CodeGenSpec
+
+**Files:**
+- Create: `cli/lucli/tests/specs/services/CodeGenSpec.cfc`
+
+- [ ] **Step 1: Create CodeGenSpec.cfc**
+
+Write `cli/lucli/tests/specs/services/CodeGenSpec.cfc`:
+
+```cfml
+component extends="wheels.wheelstest.system.BaseSpec" {
+
+	function beforeAll() {
+		variables.testHelper = new cli.lucli.tests.TestHelper();
+		variables.tempRoot = testHelper.scaffoldTempProject(expandPath("/"));
+		variables.moduleRoot = expandPath("/cli/lucli/");
+		variables.helpers = new cli.lucli.services.Helpers();
+		variables.templates = new cli.lucli.services.Templates(
+			helpers = variables.helpers,
+			projectRoot = variables.tempRoot,
+			moduleRoot = variables.moduleRoot
+		);
+		variables.codegen = new cli.lucli.services.CodeGen(
+			templateService = variables.templates,
+			helpers = variables.helpers,
+			projectRoot = variables.tempRoot
+		);
+	}
+
+	function afterAll() {
+		testHelper.cleanupTempProject(variables.tempRoot);
+	}
+
+	function run() {
+
+		describe("CodeGen Service", () => {
+
+			describe("generateModel()", () => {
+
+				it("creates a model CFC with PascalCase name", () => {
+					var result = codegen.generateModel(name = "Article", properties = []);
+					expect(result.success).toBeTrue();
+					expect(fileExists(tempRoot & "/app/models/Article.cfc")).toBeTrue();
+				});
+
+				it("model extends Model", () => {
+					codegen.generateModel(name = "Review", properties = [], force = true);
+					var content = fileRead(tempRoot & "/app/models/Review.cfc");
+					expect(content).toInclude('extends="Model"');
+				});
+
+				it("includes properties in model config", () => {
+					var props = [
+						{name: "title", type: "string"},
+						{name: "price", type: "decimal"}
+					];
+					codegen.generateModel(
+						name = "Product",
+						properties = props,
+						force = true
+					);
+					var content = fileRead(tempRoot & "/app/models/Product.cfc");
+					expect(content).toInclude("config()");
+				});
+
+			});
+
+			describe("generateController()", () => {
+
+				it("creates a controller CFC in app/controllers/", () => {
+					var result = codegen.generateController(
+						name = "Articles",
+						actions = "index,show"
+					);
+					expect(result.success).toBeTrue();
+					expect(fileExists(tempRoot & "/app/controllers/Articles.cfc")).toBeTrue();
+				});
+
+				it("controller extends Controller", () => {
+					codegen.generateController(name = "Reviews", actions = "", force = true);
+					var content = fileRead(tempRoot & "/app/controllers/Reviews.cfc");
+					expect(content).toInclude('extends="Controller"');
+				});
+
+			});
+
+			describe("validateName()", () => {
+
+				it("rejects empty name", () => {
+					var result = codegen.validateName("");
+					expect(result.valid).toBeFalse();
+				});
+
+				it("accepts valid PascalCase name", () => {
+					var result = codegen.validateName("UserProfile");
+					expect(result.valid).toBeTrue();
+				});
+
+			});
+
+		});
+
+	}
+
+}
+```
+
+- [ ] **Step 2: Verify and commit**
+
+```bash
+curl -sf "http://localhost:8080/cli/lucli/tests/runner.cfm?format=json" | python3 -c "
+import json,sys; d=json.load(sys.stdin)
+print(f'{d[\"totalPass\"]} pass, {d[\"totalFail\"]} fail, {d[\"totalError\"]} error')
+"
+git add cli/lucli/tests/specs/services/CodeGenSpec.cfc
+git commit -m "test(cli): add codegen service unit tests"
+```
+
+---
+
+### Task 8: Integration Tests
+
+**Files:**
+- Create: `cli/lucli/tests/specs/integration/DbCommandsSpec.cfc`
+- Create: `cli/lucli/tests/specs/integration/IntrospectSpec.cfc`
+
+- [ ] **Step 1: Create DbCommandsSpec.cfc**
+
+Write `cli/lucli/tests/specs/integration/DbCommandsSpec.cfc`:
+
+```cfml
+component extends="wheels.wheelstest.system.BaseSpec" {
+
+	function beforeAll() {
+		variables.testHelper = new cli.lucli.tests.TestHelper();
+		variables.serverPort = testHelper.detectServerPort();
+		variables.skipIntegration = (variables.serverPort == 0);
+		if (variables.skipIntegration) {
+			variables.skipReason = "No running server detected — skipping integration tests";
+		}
+		variables.baseUrl = "http://localhost:#variables.serverPort#";
+	}
+
+	function run() {
+
+		describe("DB Commands Integration", () => {
+
+			it("dbStatus returns valid JSON with migrations", () => {
+				if (skipIntegration) { debug(skipReason); return; }
+
+				var response = testHelper.httpGet(
+					"#baseUrl#/wheels/cli?command=dbStatus&format=json"
+				);
+				expect(len(response)).toBeGT(0);
+
+				var data = deserializeJSON(response);
+				expect(data.success).toBeTrue();
+				expect(structKeyExists(data, "migrations")).toBeTrue();
+				expect(isArray(data.migrations)).toBeTrue();
+				expect(structKeyExists(data, "summary")).toBeTrue();
+				expect(data.summary.total).toBeGTE(0);
+				expect(data.summary.applied).toBeGTE(0);
+				expect(data.summary.pending).toBeGTE(0);
+			});
+
+			it("dbStatus migration entries have required fields", () => {
+				if (skipIntegration) { debug(skipReason); return; }
+
+				var response = testHelper.httpGet(
+					"#baseUrl#/wheels/cli?command=dbStatus&format=json"
+				);
+				var data = deserializeJSON(response);
+
+				if (arrayLen(data.migrations) > 0) {
+					var m = data.migrations[1];
+					expect(structKeyExists(m, "version")).toBeTrue();
+					expect(structKeyExists(m, "description")).toBeTrue();
+					expect(structKeyExists(m, "status")).toBeTrue();
+				}
+			});
+
+			it("dbVersion returns current version", () => {
+				if (skipIntegration) { debug(skipReason); return; }
+
+				var response = testHelper.httpGet(
+					"#baseUrl#/wheels/cli?command=dbVersion&format=json"
+				);
+				expect(len(response)).toBeGT(0);
+
+				var data = deserializeJSON(response);
+				expect(data.success).toBeTrue();
+				expect(structKeyExists(data, "version")).toBeTrue();
+			});
+
+		});
+
+	}
+
+}
+```
+
+- [ ] **Step 2: Create IntrospectSpec.cfc**
+
+Write `cli/lucli/tests/specs/integration/IntrospectSpec.cfc`:
+
+```cfml
+component extends="wheels.wheelstest.system.BaseSpec" {
+
+	function beforeAll() {
+		variables.testHelper = new cli.lucli.tests.TestHelper();
+		variables.serverPort = testHelper.detectServerPort();
+		variables.skipIntegration = (variables.serverPort == 0);
+		if (variables.skipIntegration) {
+			variables.skipReason = "No running server detected — skipping integration tests";
+		}
+		variables.baseUrl = "http://localhost:#variables.serverPort#";
+	}
+
+	function run() {
+
+		describe("Introspect Endpoint Integration", () => {
+
+			it("returns model metadata for a valid model", () => {
+				if (skipIntegration) { debug(skipReason); return; }
+
+				// Use a test model that exists in the test database
+				var response = testHelper.httpGet(
+					"#baseUrl#/wheels/cli?command=introspect&model=Author&format=json"
+				);
+
+				if (!len(response)) {
+					debug("Empty response — model 'Author' may not exist");
+					return;
+				}
+
+				var data = deserializeJSON(response);
+				if (!data.success) {
+					debug("Introspect failed: #data.message# — test model may not be available");
+					return;
+				}
+
+				expect(structKeyExists(data, "model")).toBeTrue();
+				expect(structKeyExists(data, "tableName")).toBeTrue();
+				expect(structKeyExists(data, "primaryKey")).toBeTrue();
+				expect(structKeyExists(data, "columns")).toBeTrue();
+				expect(isArray(data.columns)).toBeTrue();
+				expect(arrayLen(data.columns)).toBeGT(0);
+				expect(structKeyExists(data, "associations")).toBeTrue();
+			});
+
+			it("column entries have name and type", () => {
+				if (skipIntegration) { debug(skipReason); return; }
+
+				var response = testHelper.httpGet(
+					"#baseUrl#/wheels/cli?command=introspect&model=Author&format=json"
+				);
+				if (!len(response)) return;
+
+				var data = deserializeJSON(response);
+				if (!data.success) return;
+
+				var col = data.columns[1];
+				expect(structKeyExists(col, "name")).toBeTrue();
+				expect(structKeyExists(col, "type")).toBeTrue();
+			});
+
+			it("fails gracefully with missing model parameter", () => {
+				if (skipIntegration) { debug(skipReason); return; }
+
+				var response = testHelper.httpGet(
+					"#baseUrl#/wheels/cli?command=introspect&format=json"
+				);
+				expect(len(response)).toBeGT(0);
+
+				var data = deserializeJSON(response);
+				expect(data.success).toBeFalse();
+				expect(structKeyExists(data, "message")).toBeTrue();
+			});
+
+			it("fails gracefully with non-existent model", () => {
+				if (skipIntegration) { debug(skipReason); return; }
+
+				var response = testHelper.httpGet(
+					"#baseUrl#/wheels/cli?command=introspect&model=NonExistentModelXyz&format=json"
+				);
+				expect(len(response)).toBeGT(0);
+
+				var data = deserializeJSON(response);
+				expect(data.success).toBeFalse();
+			});
+
+		});
+
+	}
+
+}
+```
+
+- [ ] **Step 3: Verify and commit**
+
+```bash
+curl -sf "http://localhost:8080/cli/lucli/tests/runner.cfm?format=json" | python3 -c "
+import json,sys; d=json.load(sys.stdin)
+print(f'{d[\"totalPass\"]} pass, {d[\"totalFail\"]} fail, {d[\"totalError\"]} error')
+"
+git add cli/lucli/tests/specs/integration/
+git commit -m "test(cli): add integration tests for db commands and introspect endpoint"
+```
+
+---
+
+### Task 9: CI Integration
+
+**Files:**
+- Modify: `tools/ci/run-tests.sh`
+
+- [ ] **Step 1: Update run-tests.sh**
+
+Read `tools/ci/run-tests.sh` and add a CLI test block after the core test block. The script currently exits on failure at line 118 (`exit 1`). We need to defer the exit so both suites run.
+
+Replace the entire file with the updated version that:
+1. Tracks core test success/failure in a variable instead of exiting immediately
+2. Adds a CLI test block after core tests
+3. Generates separate JUnit XML for CLI tests
+4. Writes combined step summary
+5. Exits non-zero if either suite fails
+
+The key additions after the core test results parsing (after the existing `echo "All tests passed!"` on line 121):
+
+```bash
+# --- Run CLI module tests ---
+CLI_TEST_URL="${BASE_URL}/cli/lucli/tests/runner.cfm?format=json"
+CLI_RESULT_FILE="${RESULT_DIR}/cli-test-results.json"
+CLI_JUNIT_FILE="${JUNIT_DIR}/cli-junit.xml"
+
+echo ""
+echo "Running CLI module tests..."
+CLI_HTTP_CODE=$(curl -s -o "$CLI_RESULT_FILE" \
+  --max-time 300 \
+  --write-out "%{http_code}" \
+  "$CLI_TEST_URL" || echo "000")
+
+echo "[CLI Tests] HTTP status: ${CLI_HTTP_CODE}"
+```
+
+Then parse CLI results with the same pattern as core tests, prefixing output with `[CLI Tests]`.
+
+The full modification: change the exit strategy from immediate `exit 1` to tracking `CORE_OK` and `CLI_OK` variables, then exiting based on both at the end.
+
+Edit `tools/ci/run-tests.sh` to make the following changes:
+
+**Near the top** (after line 11), add:
+```bash
+CLI_TEST_URL="${BASE_URL}/cli/lucli/tests/runner.cfm?format=json"
+CLI_RESULT_FILE="${RESULT_DIR:-/tmp}/cli-test-results.json"
+CLI_JUNIT_FILE="${JUNIT_DIR:-/tmp}/cli-junit.xml"
+CORE_OK=true
+CLI_OK=true
+```
+
+**Replace `exit 1` on line 118** with `CORE_OK=false`.
+
+**Replace `echo "All tests passed!"` on line 121** with `echo "[Core Tests] All tests passed!"`.
+
+**After the core test `fi` block** (after line 127), add the full CLI test block:
+
+```bash
+# --- Run CLI module tests ---
+echo ""
+echo "Running CLI module tests..."
+CLI_HTTP_CODE=$(curl -s -o "$CLI_RESULT_FILE" \
+  --max-time 300 \
+  --write-out "%{http_code}" \
+  "$CLI_TEST_URL" || echo "000")
+
+echo "[CLI Tests] HTTP status: ${CLI_HTTP_CODE}"
+
+if [ "$CLI_HTTP_CODE" = "200" ] || [ "$CLI_HTTP_CODE" = "417" ]; then
+  CLI_PASS=$(python3 -c "import json; d=json.load(open('$CLI_RESULT_FILE')); print(int(d.get('totalPass',0)))" 2>/dev/null || echo "?")
+  CLI_FAIL=$(python3 -c "import json; d=json.load(open('$CLI_RESULT_FILE')); print(int(d.get('totalFail',0)))" 2>/dev/null || echo "?")
+  CLI_ERROR=$(python3 -c "import json; d=json.load(open('$CLI_RESULT_FILE')); print(int(d.get('totalError',0)))" 2>/dev/null || echo "?")
+
+  echo "[CLI Tests] Results: ${CLI_PASS} passed, ${CLI_FAIL} failed, ${CLI_ERROR} errors"
+
+  # Generate JUnit XML for CLI tests
+  python3 -c "
+import json, sys
+from xml.etree.ElementTree import Element, SubElement, tostring
+
+def safe_str(v):
+    return str(v) if v else ''
+
+d = json.load(open('$CLI_RESULT_FILE'))
+root = Element('testsuites')
+root.set('name', 'CLI Module Tests')
+root.set('tests', str(int(d.get('totalPass',0)) + int(d.get('totalFail',0)) + int(d.get('totalError',0))))
+root.set('failures', str(int(d.get('totalFail',0))))
+root.set('errors', str(int(d.get('totalError',0))))
+
+for b in d.get('bundleStats', []):
+    for s in b.get('suiteStats', []):
+        ts = SubElement(root, 'testsuite')
+        ts.set('name', safe_str(s.get('name')))
+        ts.set('tests', str(int(s.get('totalSpecs',0))))
+        ts.set('failures', str(int(s.get('totalFail',0))))
+        ts.set('errors', str(int(s.get('totalError',0))))
+        ts.set('time', str(float(s.get('totalDuration',0))/1000))
+        for sp in s.get('specStats', []):
+            tc = SubElement(ts, 'testcase')
+            tc.set('name', safe_str(sp.get('name')))
+            tc.set('classname', safe_str(b.get('name','')))
+            tc.set('time', str(float(sp.get('totalDuration',0))/1000))
+            if sp.get('status') == 'Failed':
+                f = SubElement(tc, 'failure', message=safe_str(sp.get('failMessage')))
+                f.text = safe_str(sp.get('failDetail'))
+            elif sp.get('status') == 'Error':
+                e = SubElement(tc, 'error', message=safe_str(sp.get('failMessage')))
+                e.text = safe_str(sp.get('failDetail'))
+
+with open('$CLI_JUNIT_FILE', 'wb') as f:
+    f.write(b'<?xml version=\"1.0\" encoding=\"UTF-8\"?>')
+    f.write(tostring(root))
+" 2>/dev/null || echo "Warning: Could not generate CLI JUnit XML"
+
+  # Write CLI step summary
+  if [ -n "${GITHUB_STEP_SUMMARY:-}" ]; then
+    echo "" >> "$GITHUB_STEP_SUMMARY"
+    echo "### CLI Module Test Results" >> "$GITHUB_STEP_SUMMARY"
+    echo "" >> "$GITHUB_STEP_SUMMARY"
+    echo "| Metric | Count |" >> "$GITHUB_STEP_SUMMARY"
+    echo "|--------|-------|" >> "$GITHUB_STEP_SUMMARY"
+    echo "| Passed | ${CLI_PASS} |" >> "$GITHUB_STEP_SUMMARY"
+    echo "| Failed | ${CLI_FAIL} |" >> "$GITHUB_STEP_SUMMARY"
+    echo "| Errors | ${CLI_ERROR} |" >> "$GITHUB_STEP_SUMMARY"
+  fi
+
+  CLI_TOTAL_FAILURES=$((CLI_FAIL + CLI_ERROR))
+  if [ "$CLI_TOTAL_FAILURES" -gt 0 ]; then
+    echo "::error::[CLI Tests] ${CLI_TOTAL_FAILURES} test failures/errors"
+    python3 -c "
+import json
+d = json.load(open('$CLI_RESULT_FILE'))
+for b in d.get('bundleStats', []):
+    for s in b.get('suiteStats', []):
+        for sp in s.get('specStats', []):
+            if sp.get('status') in ('Failed', 'Error'):
+                print(f\"  {sp['status']}: {sp.get('name','?')}: {sp.get('failMessage','')[:200]}\")
+" 2>/dev/null || true
+    CLI_OK=false
+  else
+    echo "[CLI Tests] All tests passed!"
+  fi
+else
+  echo "::error::[CLI Tests] returned HTTP ${CLI_HTTP_CODE}"
+  head -50 "$CLI_RESULT_FILE" 2>/dev/null || true
+  CLI_OK=false
+fi
+
+# --- Final exit ---
+if [ "$CORE_OK" = false ] || [ "$CLI_OK" = false ]; then
+  echo ""
+  echo "::error::Test suite(s) failed"
+  exit 1
+fi
+
+echo ""
+echo "All test suites passed!"
+```
+
+- [ ] **Step 2: Verify the script is syntactically valid**
+
+```bash
+bash -n tools/ci/run-tests.sh
+```
+
+Expected: No output (syntax OK).
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add tools/ci/run-tests.sh
+git commit -m "ci(test): add cli module tests to ci pipeline"
+```
+
+---
+
+## Self-Review
+
+**Spec coverage:**
+
+| Spec Requirement | Task |
+|-----------------|------|
+| TestHelper.cfc with scaffoldTempProject, cleanupTempProject, detectServerPort, httpGet | Task 1 |
+| runner.cfm with TestBox, JSON/HTML, HTTP 417 on failure | Task 1 |
+| HelpersSpec — pluralize, singularize, capitalize, stripSpecialChars, timestamp | Task 2 |
+| DestroySpec — all 4 destroy types, preview, route cleanup, migration gen | Task 3 |
+| DoctorSpec — HEALTHY, CRITICAL, WARNING, permissions, recommendations | Task 4 |
+| StatsSpec — categories, LOC, comments, blanks, getNotes, custom annotations | Task 5 |
+| AdminSpec — form helpers, generateAdmin, FK loaders, route injection, force flag | Task 6 |
+| CodeGenSpec — model, controller, properties, validateName | Task 7 |
+| DbCommandsSpec — dbStatus, dbVersion HTTP responses | Task 8 |
+| IntrospectSpec — valid model, missing param, non-existent model | Task 8 |
+| CI integration — separate curl, JUnit XML, combined exit code, [CLI Tests] prefix | Task 9 |
+| Skip behavior for integration tests | Task 8 (each spec checks skipIntegration) |
+| All tests use temp project copy | Tasks 3-7 (beforeAll scaffolds, afterAll cleans) |
+
+All spec sections covered.
+
+**Placeholder scan:** No TBD, TODO, or "implement later". All test code is complete.
+
+**Type consistency:**
+- `TestHelper.scaffoldTempProject(sourceRoot)` — called consistently as `testHelper.scaffoldTempProject(expandPath("/"))`
+- `TestHelper.cleanupTempProject(tempRoot)` — called consistently in `afterAll()`
+- `TestHelper.detectServerPort()` — returns numeric, compared to 0 for skip check
+- Service constructors match actual signatures verified from source
+- `mapColumnToFormHelper` is called as a public method on Admin.cfc — verified it's `public` in the source
diff --git a/docs/superpowers/specs/2026-04-11-cli-testing-design.md b/docs/superpowers/specs/2026-04-11-cli-testing-design.md
new file mode 100644
index 000000000..848906cca
--- /dev/null
+++ b/docs/superpowers/specs/2026-04-11-cli-testing-design.md
@@ -0,0 +1,262 @@
+# CLI Test Infrastructure Design
+
+## Goal
+
+Add a TestBox-based test suite for the LuCLI CLI module commands and services, runnable in CI alongside existing core framework tests using the same server instance.
+
+## Scope Decisions
+
+| Decision | Choice | Rationale |
+|----------|--------|-----------|
+| Test location | `cli/lucli/tests/` with own runner | CLI module is a separate concern from framework core; tests ship with the module |
+| Base class | `wheels.wheelstest.system.BaseSpec` | Pure TestBox BDD; services are independent of `application.wheels` |
+| Project isolation | Copy project skeleton to temp dir | Single source of truth (no fixture maintenance); all tests use same copy |
+| Server port | `PORT` env var, fallback 60007 | Matches CI convention in `run-tests.sh` |
+| Integration test skip | Skip with message if no server | Suite stays green locally without a server running |
+| REPL | Not used for test execution | HTTP tests verify actual endpoints; REPL is a debugging tool |
+
+## Architecture
+
+### Test Directory
+
+```
+cli/lucli/tests/
+├── runner.cfm              # TestBox entry point
+├── TestHelper.cfc          # Shared: temp project setup, HTTP helper, cleanup
+└── specs/
+    ├── services/
+    │   ├── HelpersSpec.cfc
+    │   ├── DestroySpec.cfc
+    │   ├── DoctorSpec.cfc
+    │   ├── StatsSpec.cfc
+    │   ├── AdminSpec.cfc
+    │   └── CodeGenSpec.cfc
+    └── integration/
+        ├── DbCommandsSpec.cfc
+        └── IntrospectSpec.cfc
+```
+
+### Test Lifecycle
+
+```
+beforeAll():
+  1. helper = new cli.lucli.tests.TestHelper()
+  2. tempRoot = helper.scaffoldTempProject(expandPath("/"))
+  3. Instantiate services with projectRoot = tempRoot, moduleRoot = expandPath("/cli/lucli/")
+
+afterAll():
+  1. helper.cleanupTempProject(tempRoot)
+```
+
+All CLI tests — unit and integration — run against the temp dir. No tests operate on the real project root.
+
+### Temp Project Copy
+
+**Copied from project root:**
+- `app/` — controllers, models, views, helpers, migrator/migrations
+- `config/` — routes.cfm, settings.cfm, environment.cfm
+- `tests/specs/` — directory structure (for doctor/stats scanning)
+- `public/` — directory structure
+- `.env` (if exists)
+
+**Not copied:**
+- `vendor/`, `.git/`, `node_modules/`, `docs/`, `tools/`, `.claude/`, build artifacts
+
+**Module root** points to the real `cli/lucli/` path — templates aren't project-specific and don't need copying.
+
+## Test Categories
+
+### Category A: Service Unit Tests
+
+Direct CFC instantiation with real `Helpers.cfc` dependency and temp project root.
+
+#### HelpersSpec.cfc — Pure Logic (no temp dir needed)
+
+- `pluralize()`: user→users, person→people, sheep→sheep, child→children
+- `singularize()`: users→user, people→person, mice→mouse
+- `capitalize()`: user→User, empty string→empty string
+- `stripSpecialChars()`: removes brackets, ampersands, etc.
+- `generateMigrationTimestamp()`: returns 14-digit numeric string
+
+#### DestroySpec.cfc
+
+- Create a model file in temp, destroy model type → file gone + migration CFC created
+- Create controller + test files, destroy controller type → only controller files removed, no migration
+- Destroy resource type → all 6 file paths removed + route line removed from routes.cfm + migration generated
+- Destroy view with "/" syntax → single .cfm file removed
+- Destroy view without "/" → entire views dir + test views dir removed
+- `previewDestroy()` returns array matching what actual destroy would delete
+- Destroying non-existent files produces warnings array, not errors
+- Route cleanup: `.resources("plural")` line removed, other lines preserved
+
+#### DoctorSpec.cfc
+
+- All required dirs/files present → status `HEALTHY`, zero issues
+- Remove a required dir (e.g., `app/controllers/`) → status `CRITICAL`
+- Remove recommended dir (`tests/`) → status `WARNING` with recommendation
+- Write permission test passes on writable temp dir
+- Empty routes.cfm (< 10 chars) → config validation warning
+- No datasource keyword in settings.cfm → database config warning
+- No .cfc files in tests/specs/ → test coverage warning
+- Recommendations array populated based on detected issues
+
+#### StatsSpec.cfc
+
+- File counts per category match actual files in temp project
+- LOC counting: pure code line classified as LOC, not comment or blank
+- CFML block comment `<!--- ... --->` spanning multiple lines tracked correctly
+- `//` line comment detected
+- Blank lines detected
+- `getNotes()` finds `// TODO: text` with correct file path and line number
+- Custom annotation types (`--custom=HACK`) searched
+- Annotation text extracted after colon, trailing delimiters stripped
+
+#### AdminSpec.cfc
+
+- `mapColumnToFormHelper()`: string→textField, boolean→checkBox, text→textArea, integer→numberField, date→dateField, datetime→dateTimeLocalField
+- Name conventions: column named "email"→emailField, "phone"→telField, "website"→urlField
+- `buildFormFields()` excludes columns named id, createdAt, updatedAt
+- `buildForeignKeyLoaders()` generates private loader function per belongsTo association
+- `injectAdminRoute()` creates `.scope(path="admin")` block in routes.cfm
+- `injectAdminRoute()` appends to existing admin scope without duplicating
+- `generateAdmin()` creates controller CFC + 5 view files in correct paths
+- `generateAdmin()` with `force=false` errors when files already exist
+
+#### CodeGenSpec.cfc
+
+- `generateModel()` creates CFC in app/models/ with correct PascalCase name
+- `generateController()` creates CFC in app/controllers/
+- Properties parsed from attribute strings: `name` → `{name: "name", type: "string"}`, `price:decimal` → `{name: "price", type: "decimal"}`
+- Route injection adds `.resources("plural")` to routes.cfm
+- Generated model includes `config()` function with associations and validations
+
+### Category B: Integration Tests
+
+HTTP calls to the running server. Skip gracefully if no server is detected.
+
+#### DbCommandsSpec.cfc
+
+- `GET /wheels/cli?command=dbStatus&format=json` returns valid JSON with `success`, `migrations` array, `summary` struct
+- `summary` contains `total`, `applied`, `pending` as non-negative integers
+- `GET /wheels/cli?command=dbVersion&format=json` returns `success` and `version` string
+- Each migration entry has `version`, `description`, `status` fields
+
+#### IntrospectSpec.cfc
+
+- `GET /wheels/cli?command=introspect&model=<testmodel>&format=json` returns column metadata
+- Response has `success: true`, `model`, `tableName`, `primaryKey`, `columns` array, `associations` array
+- Each column has `name` and `type` fields
+- Missing model parameter → `success: false` with error message
+- Non-existent model → `success: false` with error message
+- Primary key column has `primaryKey: true`
+
+**Test model:** Uses one of the existing test models in `vendor/wheels/tests/_assets/models/` that the core test suite already seeds (e.g., `Author` or `Post`). This avoids needing to create test-specific models.
+
+### Skip Behavior for Integration Tests
+
+Each integration spec checks for a running server in `beforeAll()`:
+
+```cfml
+variables.serverPort = helper.detectServerPort();
+if (!variables.serverPort) {
+    variables.skipIntegration = true;
+}
+```
+
+Each `it()` block checks `if (variables.skipIntegration) return;` at the top. This keeps the tests discoverable (they show up in results) but they don't fail when no server is running.
+
+## Test Runner
+
+### runner.cfm
+
+- Creates `TestBox` instance: `new wheels.wheelstest.system.TestBox(directory="cli.lucli.tests.specs")`
+- Reads `url.format` (default: `json`)
+- Uses `JSONReporter` for CI, `SimpleReporter` for browser
+- Sets HTTP status 417 on failures, 200 on success (same convention as core tests)
+- No framework initialization needed — specs use `BaseSpec`, not `WheelsTest`
+
+### URL
+
+```
+http://localhost:<port>/cli/lucli/tests/runner.cfm?format=json
+```
+
+Served directly by the LuCLI web server since it serves the project root as webroot.
+
+## CI Integration
+
+### tools/ci/run-tests.sh Changes
+
+After the existing core test execution block, add a CLI test block:
+
+```bash
+# CLI Module Tests
+CLI_URL="${BASE_URL}/cli/lucli/tests/runner.cfm?format=json"
+CLI_RESULT_FILE="${RESULT_DIR}/cli-test-results.json"
+CLI_JUNIT_FILE="${JUNIT_DIR}/cli-junit.xml"
+echo "Running CLI module tests..."
+HTTP_CODE=$(curl -s -o "$CLI_RESULT_FILE" -w "%{http_code}" "$CLI_URL")
+```
+
+**Result capture requirements:**
+- CLI test JSON results saved to `$RESULT_DIR/cli-test-results.json` — uploaded as artifact alongside core test results
+- CLI JUnit XML generated at `$JUNIT_DIR/cli-junit.xml` — picked up by the existing JUnit artifact upload step
+- Pass/fail/error counts printed to CI log with clear `[CLI Tests]` prefix to distinguish from core test output
+- Non-zero exit code if any CLI tests fail — the script's overall exit code must reflect both core AND CLI test results
+- If CLI test runner returns HTTP 417 (failures) or non-200, treat as failure
+
+**CI log output format:**
+```
+[CLI Tests] 45 pass, 0 fail, 0 error
+```
+or on failure:
+```
+[CLI Tests] 42 pass, 2 fail, 1 error
+[CLI Tests] FAILED — see cli-test-results.json for details
+```
+
+### Workflow Artifact Handling
+
+The `snapshot.yml` workflow already uploads `$RESULT_DIR/` and `$JUNIT_DIR/` contents as artifacts. Since CLI results write to the same directories, they're captured automatically — no workflow file changes needed.
+
+### Combined Exit Code
+
+The script must track both core and CLI test outcomes. If either suite has failures, the script exits non-zero to fail the CI job:
+
+```bash
+CORE_OK=true   # set false if core tests fail
+CLI_OK=true    # set false if CLI tests fail
+# ... run both suites ...
+if [ "$CORE_OK" = false ] || [ "$CLI_OK" = false ]; then
+  exit 1
+fi
+```
+
+## TestHelper.cfc
+
+### Public Methods
+
+- `scaffoldTempProject(sourceRoot)` — copies project skeleton to temp dir under system temp path, returns temp root path
+- `cleanupTempProject(tempRoot)` — recursively deletes temp dir
+- `detectServerPort()` — reads `PORT` env var → checks port 8080 → checks port 60007, returns port number or 0
+- `httpGet(url)` — HTTP GET using `java.net.URL.openConnection()`, returns response string. Same pattern as Module.cfc's `makeHttpRequest()`.
+
+### Debugging
+
+The LuCLI REPL (`wheels console`) shares the running server's runtime context and can be used to interactively debug test failures — inspect `application.wheels`, call `model().$classData()`, verify server state.
+
+## Files Summary
+
+| File | Type | Description |
+|------|------|-------------|
+| `cli/lucli/tests/runner.cfm` | New | TestBox entry point |
+| `cli/lucli/tests/TestHelper.cfc` | New | Temp project scaffolding, HTTP helper |
+| `cli/lucli/tests/specs/services/HelpersSpec.cfc` | New | Helpers service tests |
+| `cli/lucli/tests/specs/services/DestroySpec.cfc` | New | Destroy service tests |
+| `cli/lucli/tests/specs/services/DoctorSpec.cfc` | New | Doctor service tests |
+| `cli/lucli/tests/specs/services/StatsSpec.cfc` | New | Stats + notes service tests |
+| `cli/lucli/tests/specs/services/AdminSpec.cfc` | New | Admin service tests |
+| `cli/lucli/tests/specs/services/CodeGenSpec.cfc` | New | CodeGen service tests |
+| `cli/lucli/tests/specs/integration/DbCommandsSpec.cfc` | New | DB endpoint integration tests |
+| `cli/lucli/tests/specs/integration/IntrospectSpec.cfc` | New | Introspect endpoint integration tests |
+| `tools/ci/run-tests.sh` | Modified | Add CLI test curl block |

From 24f6209a1a86b1155256142179ce7920f56a0725 Mon Sep 17 00:00:00 2001
From: Peter Amiri <peter@alurium.com>
Date: Sat, 11 Apr 2026 15:05:55 -0700
Subject: [PATCH 02/13] test(cli): add test runner and helper infrastructure

---
 cli/lucli/tests/TestHelper.cfc | 115 +++++++++++++++++++++++++++++++++
 cli/lucli/tests/runner.cfm     |  36 +++++++++++
 2 files changed, 151 insertions(+)
 create mode 100644 cli/lucli/tests/TestHelper.cfc
 create mode 100644 cli/lucli/tests/runner.cfm

diff --git a/cli/lucli/tests/TestHelper.cfc b/cli/lucli/tests/TestHelper.cfc
new file mode 100644
index 000000000..a3ea1333c
--- /dev/null
+++ b/cli/lucli/tests/TestHelper.cfc
@@ -0,0 +1,115 @@
+/**
+ * Shared test utilities for CLI module specs.
+ *
+ * Provides temp project scaffolding (copies project skeleton to temp dir),
+ * HTTP helper for integration tests, and server port detection.
+ */
+component {
+
+	/**
+	 * Copy the project skeleton into a temp directory for isolated testing.
+	 * Returns the absolute path to the temp project root.
+	 */
+	public string function scaffoldTempProject(required string sourceRoot) {
+		var tempBase = getTempDirectory() & "wheels-cli-test-" & createUUID();
+		directoryCreate(tempBase, true);
+
+		// Copy app structure
+		var dirs = ["app", "config", "tests/specs", "public"];
+		for (var dir in dirs) {
+			var srcPath = arguments.sourceRoot & "/" & dir;
+			var destPath = tempBase & "/" & dir;
+			if (directoryExists(srcPath)) {
+				directoryCopy(srcPath, destPath, true);
+			} else {
+				directoryCreate(destPath, true);
+			}
+		}
+
+		// Copy key config files from root
+		var files = [".env", "lucee.json"];
+		for (var f in files) {
+			var srcFile = arguments.sourceRoot & "/" & f;
+			if (fileExists(srcFile)) {
+				fileCopy(srcFile, tempBase & "/" & f);
+			}
+		}
+
+		return tempBase;
+	}
+
+	/**
+	 * Delete the temp project directory.
+	 */
+	public void function cleanupTempProject(required string tempRoot) {
+		if (len(arguments.tempRoot) > 10 && directoryExists(arguments.tempRoot)) {
+			directoryDelete(arguments.tempRoot, true);
+		}
+	}
+
+	/**
+	 * Detect a running server port.
+	 * Checks PORT env var first, then probes 8080 and 60007.
+	 * Returns port number or 0 if no server found.
+	 */
+	public numeric function detectServerPort() {
+		// Check environment variable (set by CI)
+		var envPort = createObject("java", "java.lang.System").getenv("PORT");
+		if (!isNull(envPort) && len(envPort) && isPortResponding(val(envPort))) {
+			return val(envPort);
+		}
+
+		// Probe common ports
+		if (isPortResponding(8080)) return 8080;
+		if (isPortResponding(60007)) return 60007;
+
+		return 0;
+	}
+
+	/**
+	 * HTTP GET request, returns response body string.
+	 * Returns empty string on connection failure.
+	 */
+	public string function httpGet(required string url) {
+		try {
+			var javaUrl = createObject("java", "java.net.URL").init(arguments.url);
+			var conn = javaUrl.openConnection();
+			conn.setRequestMethod("GET");
+			conn.setConnectTimeout(5000);
+			conn.setReadTimeout(30000);
+
+			var responseCode = conn.getResponseCode();
+			var inputStream = responseCode >= 400
+				? conn.getErrorStream()
+				: conn.getInputStream();
+			var scanner = createObject("java", "java.util.Scanner")
+				.init(inputStream, "UTF-8");
+			var response = "";
+			while (scanner.hasNextLine()) {
+				response &= scanner.nextLine() & chr(10);
+			}
+			scanner.close();
+			return trim(response);
+		} catch (any e) {
+			return "";
+		}
+	}
+
+	/**
+	 * Check if a port is responding to HTTP.
+	 */
+	private boolean function isPortResponding(required numeric port) {
+		try {
+			var javaUrl = createObject("java", "java.net.URL")
+				.init("http://localhost:#arguments.port#/");
+			var conn = javaUrl.openConnection();
+			conn.setConnectTimeout(2000);
+			conn.setReadTimeout(2000);
+			conn.getResponseCode();
+			return true;
+		} catch (any e) {
+			return false;
+		}
+	}
+
+}
diff --git a/cli/lucli/tests/runner.cfm b/cli/lucli/tests/runner.cfm
new file mode 100644
index 000000000..466159192
--- /dev/null
+++ b/cli/lucli/tests/runner.cfm
@@ -0,0 +1,36 @@
+<cfsetting requestTimeOut="300">
+<cfscript>
+try {
+	testBox = new wheels.wheelstest.system.TestBox(
+		directory = "cli.lucli.tests.specs",
+		options = { coverage = { enabled = false } }
+	);
+
+	local.sortedArray = testBox.getBundles();
+	arraySort(local.sortedArray, "textNoCase");
+	testBox.setBundles(local.sortedArray);
+
+	if (!structKeyExists(url, "format") || url.format == "html") {
+		result = testBox.run(
+			reporter = "wheels.wheelstest.system.reports.SimpleReporter"
+		);
+	} else if (url.format == "json") {
+		result = testBox.run(
+			reporter = "wheels.wheelstest.system.reports.JSONReporter"
+		);
+		cfcontent(type = "application/json");
+		local.parsed = deserializeJSON(result);
+		if (local.parsed.totalFail > 0 || local.parsed.totalError > 0) {
+			cfheader(statuscode = 417);
+		} else {
+			cfheader(statuscode = 200);
+		}
+	}
+
+	writeOutput(result);
+} catch (any e) {
+	cfheader(statuscode = 500);
+	cfcontent(type = "application/json");
+	writeOutput('{"success":false,"error":"' & replace(e.message, '"', '\"', 'all') & '"}');
+}
+</cfscript>

From 88e91ea650958d11baa6485ff3c7bd07bb43bfcc Mon Sep 17 00:00:00 2001
From: Peter Amiri <peter@alurium.com>
Date: Sat, 11 Apr 2026 15:06:39 -0700
Subject: [PATCH 03/13] test(cli): add helpers service unit tests

---
 .../tests/specs/services/HelpersSpec.cfc      | 104 ++++++++++++++++++
 1 file changed, 104 insertions(+)
 create mode 100644 cli/lucli/tests/specs/services/HelpersSpec.cfc

diff --git a/cli/lucli/tests/specs/services/HelpersSpec.cfc b/cli/lucli/tests/specs/services/HelpersSpec.cfc
new file mode 100644
index 000000000..d7e374b3e
--- /dev/null
+++ b/cli/lucli/tests/specs/services/HelpersSpec.cfc
@@ -0,0 +1,104 @@
+component extends="wheels.wheelstest.system.BaseSpec" {
+
+	function beforeAll() {
+		variables.helpers = new cli.lucli.services.Helpers();
+	}
+
+	function run() {
+
+		describe("Helpers Service", () => {
+
+			describe("capitalize()", () => {
+
+				it("capitalizes the first letter", () => {
+					expect(helpers.capitalize("user")).toBe("User");
+				});
+
+				it("handles single character", () => {
+					expect(helpers.capitalize("a")).toBe("A");
+				});
+
+				it("returns empty string for empty input", () => {
+					expect(helpers.capitalize("")).toBe("");
+				});
+
+				it("preserves rest of string", () => {
+					expect(helpers.capitalize("firstName")).toBe("FirstName");
+				});
+
+			});
+
+			describe("pluralize()", () => {
+
+				it("pluralizes regular words", () => {
+					expect(helpers.pluralize("user")).toBe("users");
+				});
+
+				it("handles -es suffix", () => {
+					expect(helpers.pluralize("bus")).toBe("buses");
+				});
+
+				it("handles -ies suffix", () => {
+					expect(helpers.pluralize("category")).toBe("categories");
+				});
+
+				it("handles irregular words", () => {
+					expect(helpers.pluralize("person")).toBe("people");
+					expect(helpers.pluralize("child")).toBe("children");
+				});
+
+				it("handles uncountable words", () => {
+					expect(helpers.pluralize("sheep")).toBe("sheep");
+					expect(helpers.pluralize("fish")).toBe("fish");
+				});
+
+			});
+
+			describe("singularize()", () => {
+
+				it("singularizes regular words", () => {
+					expect(helpers.singularize("users")).toBe("user");
+				});
+
+				it("handles irregular words", () => {
+					expect(helpers.singularize("people")).toBe("person");
+					expect(helpers.singularize("children")).toBe("child");
+				});
+
+				it("handles uncountable words", () => {
+					expect(helpers.singularize("sheep")).toBe("sheep");
+				});
+
+			});
+
+			describe("stripSpecialChars()", () => {
+
+				it("removes brackets and special characters", () => {
+					expect(helpers.stripSpecialChars("hello[world]")).toBe("helloworld");
+				});
+
+				it("removes ampersands and percents", () => {
+					expect(helpers.stripSpecialChars("a&b%c")).toBe("abc");
+				});
+
+				it("trims whitespace", () => {
+					expect(helpers.stripSpecialChars("  hello  ")).toBe("hello");
+				});
+
+			});
+
+			describe("generateMigrationTimestamp()", () => {
+
+				it("returns a 14-digit string", () => {
+					var ts = helpers.generateMigrationTimestamp();
+					expect(len(ts)).toBe(14);
+					expect(isNumeric(ts)).toBeTrue();
+				});
+
+			});
+
+		});
+
+	}
+
+}

From 9787272093723299a7aa1c23f7d66f6b78f76144 Mon Sep 17 00:00:00 2001
From: Peter Amiri <peter@alurium.com>
Date: Sat, 11 Apr 2026 15:07:46 -0700
Subject: [PATCH 04/13] test(cli): add destroy service unit tests

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .../tests/specs/services/DestroySpec.cfc      | 171 ++++++++++++++++++
 1 file changed, 171 insertions(+)
 create mode 100644 cli/lucli/tests/specs/services/DestroySpec.cfc

diff --git a/cli/lucli/tests/specs/services/DestroySpec.cfc b/cli/lucli/tests/specs/services/DestroySpec.cfc
new file mode 100644
index 000000000..d18398dc1
--- /dev/null
+++ b/cli/lucli/tests/specs/services/DestroySpec.cfc
@@ -0,0 +1,171 @@
+component extends="wheels.wheelstest.system.BaseSpec" {
+
+	function beforeAll() {
+		variables.testHelper = new cli.lucli.tests.TestHelper();
+		variables.tempRoot = testHelper.scaffoldTempProject(expandPath("/"));
+		variables.moduleRoot = expandPath("/cli/lucli/");
+		variables.helpers = new cli.lucli.services.Helpers();
+		variables.destroy = new cli.lucli.services.Destroy(
+			helpers = variables.helpers,
+			projectRoot = variables.tempRoot,
+			moduleRoot = variables.moduleRoot
+		);
+	}
+
+	function afterAll() {
+		testHelper.cleanupTempProject(variables.tempRoot);
+	}
+
+	function run() {
+
+		describe("Destroy Service", () => {
+
+			describe("destroyModel()", () => {
+
+				it("deletes model file and generates migration", () => {
+					// Create a model file to destroy
+					var modelPath = tempRoot & "/app/models/Deleteme.cfc";
+					directoryCreate(getDirectoryFromPath(modelPath), true, true);
+					fileWrite(modelPath, 'component extends="Model" {}');
+
+					var result = destroy.destroyModel("Deleteme");
+					expect(result.success).toBeTrue();
+					expect(fileExists(modelPath)).toBeFalse();
+					expect(len(result.migrationPath)).toBeGT(0);
+					expect(fileExists(result.migrationPath)).toBeTrue();
+
+					// Verify migration content
+					var migContent = fileRead(result.migrationPath);
+					expect(migContent).toInclude("dropTable");
+					expect(migContent).toInclude("deletemes");
+				});
+
+				it("warns when model file does not exist", () => {
+					var result = destroy.destroyModel("Nonexistent");
+					expect(result.success).toBeTrue();
+					expect(arrayLen(result.warnings)).toBeGT(0);
+				});
+
+			});
+
+			describe("destroyController()", () => {
+
+				it("deletes controller and test files", () => {
+					var controllerPath = tempRoot & "/app/controllers/Deletemes.cfc";
+					var testPath = tempRoot & "/tests/specs/controllers/DeletemesSpec.cfc";
+					directoryCreate(getDirectoryFromPath(controllerPath), true, true);
+					directoryCreate(getDirectoryFromPath(testPath), true, true);
+					fileWrite(controllerPath, 'component extends="Controller" {}');
+					fileWrite(testPath, 'component {}');
+
+					var result = destroy.destroyController("Deleteme");
+					expect(fileExists(controllerPath)).toBeFalse();
+					expect(fileExists(testPath)).toBeFalse();
+				});
+
+				it("does not generate a migration", () => {
+					var result = destroy.destroyController("Deleteme");
+					expect(structKeyExists(result, "migrationPath")).toBeFalse();
+				});
+
+			});
+
+			describe("destroyResource()", () => {
+
+				it("deletes all resource files and cleans up route", () => {
+					// Create resource files
+					var modelPath = tempRoot & "/app/models/Widget.cfc";
+					var controllerPath = tempRoot & "/app/controllers/Widgets.cfc";
+					var viewsDir = tempRoot & "/app/views/widgets";
+					var modelTestPath = tempRoot & "/tests/specs/models/WidgetSpec.cfc";
+					var controllerTestPath = tempRoot & "/tests/specs/controllers/WidgetsSpec.cfc";
+					var viewTestsDir = tempRoot & "/tests/specs/views/widgets";
+
+					directoryCreate(getDirectoryFromPath(modelPath), true, true);
+					directoryCreate(getDirectoryFromPath(controllerPath), true, true);
+					directoryCreate(viewsDir, true, true);
+					directoryCreate(getDirectoryFromPath(modelTestPath), true, true);
+					directoryCreate(getDirectoryFromPath(controllerTestPath), true, true);
+					directoryCreate(viewTestsDir, true, true);
+
+					fileWrite(modelPath, 'component extends="Model" {}');
+					fileWrite(controllerPath, 'component extends="Controller" {}');
+					fileWrite(viewsDir & "/index.cfm", "<p>index</p>");
+					fileWrite(modelTestPath, 'component {}');
+					fileWrite(controllerTestPath, 'component {}');
+					fileWrite(viewTestsDir & "/indexSpec.cfc", 'component {}');
+
+					// Add route
+					var routesPath = tempRoot & "/config/routes.cfm";
+					var routeContent = fileRead(routesPath);
+					routeContent = replace(routeContent, "// CLI-Appends-Here",
+						'.resources("widgets")' & chr(10) & chr(9) & chr(9) & "// CLI-Appends-Here");
+					fileWrite(routesPath, routeContent);
+
+					var result = destroy.destroyResource("Widget");
+					expect(fileExists(modelPath)).toBeFalse();
+					expect(fileExists(controllerPath)).toBeFalse();
+					expect(directoryExists(viewsDir)).toBeFalse();
+					expect(fileExists(modelTestPath)).toBeFalse();
+					expect(fileExists(controllerTestPath)).toBeFalse();
+					expect(directoryExists(viewTestsDir)).toBeFalse();
+					expect(len(result.migrationPath)).toBeGT(0);
+
+					// Verify route removed
+					var updatedRoutes = fileRead(routesPath);
+					expect(updatedRoutes).notToInclude('.resources("widgets")');
+				});
+
+			});
+
+			describe("destroyView()", () => {
+
+				it("deletes a single view file when path contains /", () => {
+					var viewDir = tempRoot & "/app/views/items";
+					directoryCreate(viewDir, true, true);
+					fileWrite(viewDir & "/show.cfm", "<p>show</p>");
+
+					var result = destroy.destroyView("items/show");
+					expect(fileExists(viewDir & "/show.cfm")).toBeFalse();
+					// Directory should still exist
+					expect(directoryExists(viewDir)).toBeTrue();
+				});
+
+				it("deletes entire view directory when no /", () => {
+					var viewDir = tempRoot & "/app/views/things";
+					directoryCreate(viewDir, true, true);
+					fileWrite(viewDir & "/index.cfm", "<p>index</p>");
+
+					var result = destroy.destroyView("Thing");
+					expect(directoryExists(viewDir)).toBeFalse();
+				});
+
+				it("returns error for invalid view path", () => {
+					var result = destroy.destroyView("invalid/");
+					expect(result.success).toBeFalse();
+				});
+
+			});
+
+			describe("previewDestroy()", () => {
+
+				it("returns expected items for resource type", () => {
+					var preview = destroy.previewDestroy("Product", "resource");
+					expect(arrayLen(preview)).toBeGTE(6);
+					expect(arrayToList(preview)).toInclude("Product.cfc");
+					expect(arrayToList(preview)).toInclude("Products.cfc");
+					expect(arrayToList(preview)).toInclude("drop table");
+				});
+
+				it("returns expected items for controller type", () => {
+					var preview = destroy.previewDestroy("Product", "controller");
+					expect(arrayLen(preview)).toBe(2);
+				});
+
+			});
+
+		});
+
+	}
+
+}

From 32977888e2fc16f0568a54e341737bd311e089d7 Mon Sep 17 00:00:00 2001
From: Peter Amiri <peter@alurium.com>
Date: Sat, 11 Apr 2026 15:08:51 -0700
Subject: [PATCH 05/13] test(cli): add doctor service unit tests

---
 cli/lucli/tests/specs/services/DoctorSpec.cfc | 123 ++++++++++++++++++
 1 file changed, 123 insertions(+)
 create mode 100644 cli/lucli/tests/specs/services/DoctorSpec.cfc

diff --git a/cli/lucli/tests/specs/services/DoctorSpec.cfc b/cli/lucli/tests/specs/services/DoctorSpec.cfc
new file mode 100644
index 000000000..25aafd706
--- /dev/null
+++ b/cli/lucli/tests/specs/services/DoctorSpec.cfc
@@ -0,0 +1,123 @@
+component extends="wheels.wheelstest.system.BaseSpec" {
+
+	function beforeAll() {
+		variables.testHelper = new cli.lucli.tests.TestHelper();
+		variables.tempRoot = testHelper.scaffoldTempProject(expandPath("/"));
+	}
+
+	function afterAll() {
+		testHelper.cleanupTempProject(variables.tempRoot);
+	}
+
+	function run() {
+
+		describe("Doctor Service", () => {
+
+			it("reports HEALTHY for a valid project", () => {
+				var doctor = new cli.lucli.services.Doctor(projectRoot = tempRoot);
+				var results = doctor.runChecks();
+				expect(results.status).toBe("HEALTHY");
+				expect(arrayLen(results.issues)).toBe(0);
+			});
+
+			it("reports CRITICAL when a required directory is missing", () => {
+				// Remove app/controllers
+				if (directoryExists(tempRoot & "/app/controllers")) {
+					directoryDelete(tempRoot & "/app/controllers", true);
+				}
+
+				var doctor = new cli.lucli.services.Doctor(projectRoot = tempRoot);
+				var results = doctor.runChecks();
+				expect(results.status).toBe("CRITICAL");
+				expect(arrayLen(results.issues)).toBeGT(0);
+
+				var issueText = arrayToList(results.issues, " ");
+				expect(issueText).toInclude("app/controllers");
+
+				// Restore for subsequent tests
+				directoryCreate(tempRoot & "/app/controllers", true);
+			});
+
+			it("reports WARNING when a recommended directory is missing", () => {
+				// Remove tests/specs if it exists
+				var specsDir = tempRoot & "/tests/specs";
+				var existed = directoryExists(specsDir);
+				if (existed) {
+					directoryDelete(specsDir, true);
+				}
+
+				var doctor = new cli.lucli.services.Doctor(projectRoot = tempRoot);
+				var results = doctor.runChecks();
+
+				// Should not be CRITICAL (no required dirs missing)
+				expect(results.status).notToBe("CRITICAL");
+				expect(arrayLen(results.warnings)).toBeGT(0);
+
+				// Restore
+				if (existed) {
+					directoryCreate(specsDir, true);
+				}
+			});
+
+			it("reports CRITICAL when a required file is missing", () => {
+				var routesPath = tempRoot & "/config/routes.cfm";
+				var routesContent = "";
+				if (fileExists(routesPath)) {
+					routesContent = fileRead(routesPath);
+					fileDelete(routesPath);
+				}
+
+				var doctor = new cli.lucli.services.Doctor(projectRoot = tempRoot);
+				var results = doctor.runChecks();
+				expect(results.status).toBe("CRITICAL");
+
+				// Restore
+				if (len(routesContent)) {
+					fileWrite(routesPath, routesContent);
+				}
+			});
+
+			it("warns when config routes.cfm has minimal content", () => {
+				var routesPath = tempRoot & "/config/routes.cfm";
+				var original = fileRead(routesPath);
+				fileWrite(routesPath, "<!--- --->"); // less than 10 chars of content
+
+				var doctor = new cli.lucli.services.Doctor(projectRoot = tempRoot);
+				var results = doctor.runChecks();
+
+				var warningText = arrayToList(results.warnings, " ");
+				expect(warningText).toInclude("routes.cfm");
+
+				fileWrite(routesPath, original);
+			});
+
+			it("generates recommendations based on issues", () => {
+				// Remove tests to trigger recommendation
+				var specsDir = tempRoot & "/tests/specs";
+				var existed = directoryExists(specsDir);
+				if (existed) {
+					directoryDelete(specsDir, true);
+				}
+
+				var doctor = new cli.lucli.services.Doctor(projectRoot = tempRoot);
+				var results = doctor.runChecks();
+				expect(arrayLen(results.recommendations)).toBeGT(0);
+
+				if (existed) {
+					directoryCreate(specsDir, true);
+				}
+			});
+
+			it("passes write permission check on writable directory", () => {
+				var doctor = new cli.lucli.services.Doctor(projectRoot = tempRoot);
+				var results = doctor.runChecks();
+
+				var passedText = arrayToList(results.passed, " ");
+				expect(passedText).toInclude("Write permission");
+			});
+
+		});
+
+	}
+
+}

From cdf4421e7376fcfcbc7e94bec825076f21d6780f Mon Sep 17 00:00:00 2001
From: Peter Amiri <peter@alurium.com>
Date: Sat, 11 Apr 2026 15:09:47 -0700
Subject: [PATCH 06/13] test(cli): add stats and notes service unit tests

---
 cli/lucli/tests/specs/services/StatsSpec.cfc | 146 +++++++++++++++++++
 1 file changed, 146 insertions(+)
 create mode 100644 cli/lucli/tests/specs/services/StatsSpec.cfc

diff --git a/cli/lucli/tests/specs/services/StatsSpec.cfc b/cli/lucli/tests/specs/services/StatsSpec.cfc
new file mode 100644
index 000000000..499ee707a
--- /dev/null
+++ b/cli/lucli/tests/specs/services/StatsSpec.cfc
@@ -0,0 +1,146 @@
+component extends="wheels.wheelstest.system.BaseSpec" {
+
+	function beforeAll() {
+		variables.testHelper = new cli.lucli.tests.TestHelper();
+		variables.tempRoot = testHelper.scaffoldTempProject(expandPath("/"));
+		variables.helpers = new cli.lucli.services.Helpers();
+		variables.stats = new cli.lucli.services.Stats(
+			helpers = variables.helpers,
+			projectRoot = variables.tempRoot
+		);
+	}
+
+	function afterAll() {
+		testHelper.cleanupTempProject(variables.tempRoot);
+	}
+
+	function run() {
+
+		describe("Stats Service", () => {
+
+			describe("getStats()", () => {
+
+				it("returns categories array with expected entries", () => {
+					var data = stats.getStats();
+					expect(arrayLen(data.categories)).toBe(7);
+
+					var names = [];
+					for (var cat in data.categories) {
+						arrayAppend(names, cat.name);
+					}
+					expect(names).toInclude("Controllers");
+					expect(names).toInclude("Models");
+					expect(names).toInclude("Views");
+				});
+
+				it("returns totals with non-negative values", () => {
+					var data = stats.getStats();
+					expect(data.totals.files).toBeGTE(0);
+					expect(data.totals.loc).toBeGTE(0);
+					expect(data.totals.comments).toBeGTE(0);
+					expect(data.totals.blanks).toBeGTE(0);
+					expect(data.totals.total).toBeGTE(0);
+				});
+
+				it("total equals sum of categories", () => {
+					var data = stats.getStats();
+					var sumFiles = 0;
+					for (var cat in data.categories) {
+						sumFiles += cat.files;
+					}
+					expect(data.totals.files).toBe(sumFiles);
+				});
+
+				it("counts LOC correctly for a known file", () => {
+					// Create a file with known content
+					var testFile = tempRoot & "/app/models/StatsTestModel.cfc";
+					directoryCreate(getDirectoryFromPath(testFile), true, true);
+					fileWrite(testFile,
+						'component extends="Model" {' & chr(10)
+						& chr(10)
+						& '	// this is a comment' & chr(10)
+						& '	function config() {' & chr(10)
+						& '	}' & chr(10)
+						& chr(10)
+						& '}'
+					);
+
+					var data = stats.getStats();
+					// Find Models category
+					var modelCat = {};
+					for (var cat in data.categories) {
+						if (cat.name == "Models") modelCat = cat;
+					}
+					// Should have at least 1 file and some LOC
+					expect(modelCat.files).toBeGTE(1);
+					expect(modelCat.loc).toBeGTE(3); // 3 code lines in our test file
+					expect(modelCat.comments).toBeGTE(1); // 1 comment line
+					expect(modelCat.blanks).toBeGTE(2); // 2 blank lines
+				});
+
+				it("returns topFiles sorted by line count descending", () => {
+					var data = stats.getStats();
+					if (arrayLen(data.topFiles) >= 2) {
+						expect(data.topFiles[1].lines).toBeGTE(data.topFiles[2].lines);
+					}
+				});
+
+			});
+
+			describe("getNotes()", () => {
+
+				it("finds TODO annotations", () => {
+					// Create a file with a TODO
+					var testFile = tempRoot & "/app/models/NotesTestModel.cfc";
+					directoryCreate(getDirectoryFromPath(testFile), true, true);
+					fileWrite(testFile,
+						'component {' & chr(10)
+						& '	// TODO: implement validation' & chr(10)
+						& '	// FIXME: broken query' & chr(10)
+						& '}'
+					);
+
+					var data = stats.getNotes();
+					expect(data.total).toBeGTE(2);
+					expect(arrayLen(data.annotations["TODO"])).toBeGTE(1);
+					expect(arrayLen(data.annotations["FIXME"])).toBeGTE(1);
+
+					// Check annotation has correct structure
+					var todo = data.annotations["TODO"][1];
+					expect(structKeyExists(todo, "file")).toBeTrue();
+					expect(structKeyExists(todo, "line")).toBeTrue();
+					expect(structKeyExists(todo, "text")).toBeTrue();
+				});
+
+				it("finds custom annotation types", () => {
+					var testFile = tempRoot & "/app/controllers/NotesTestController.cfc";
+					directoryCreate(getDirectoryFromPath(testFile), true, true);
+					fileWrite(testFile,
+						'component {' & chr(10)
+						& '	// HACK: temporary workaround' & chr(10)
+						& '}'
+					);
+
+					var data = stats.getNotes(annotations = "TODO", custom = "HACK");
+					expect(arrayLen(data.annotations["HACK"])).toBeGTE(1);
+					expect(data.annotations["HACK"][1].text).toInclude("temporary");
+				});
+
+				it("returns zero total when no annotations exist", () => {
+					// Create clean file
+					var testFile = tempRoot & "/app/models/CleanModel.cfc";
+					directoryCreate(getDirectoryFromPath(testFile), true, true);
+					fileWrite(testFile, 'component {}');
+
+					// Use a custom annotation type unlikely to exist
+					var data = stats.getNotes(annotations = "XYZNONEXISTENT");
+					expect(data.annotations["XYZNONEXISTENT"]).toBeEmpty();
+				});
+
+			});
+
+		});
+
+	}
+
+}

From 1ec22651fb1d2b57d285870233ab9f21c55aa8b9 Mon Sep 17 00:00:00 2001
From: Peter Amiri <peter@alurium.com>
Date: Sat, 11 Apr 2026 15:11:09 -0700
Subject: [PATCH 07/13] test(cli): add admin service unit tests

Tests for Admin.generateAdmin() (controller + 5 views, form column filtering,
FK loaders, route injection, force flag, noRoutes flag) and form helper type
mapping covered indirectly via generated _form.cfm content (mapColumnToFormHelper
is private).
---
 cli/lucli/tests/specs/services/AdminSpec.cfc | 307 +++++++++++++++++++
 1 file changed, 307 insertions(+)
 create mode 100644 cli/lucli/tests/specs/services/AdminSpec.cfc

diff --git a/cli/lucli/tests/specs/services/AdminSpec.cfc b/cli/lucli/tests/specs/services/AdminSpec.cfc
new file mode 100644
index 000000000..221aa15f6
--- /dev/null
+++ b/cli/lucli/tests/specs/services/AdminSpec.cfc
@@ -0,0 +1,307 @@
+component extends="wheels.wheelstest.system.BaseSpec" {
+
+	function beforeAll() {
+		variables.testHelper = new cli.lucli.tests.TestHelper();
+		variables.tempRoot = testHelper.scaffoldTempProject(expandPath("/"));
+		variables.moduleRoot = expandPath("/cli/lucli/");
+		variables.helpers = new cli.lucli.services.Helpers();
+		variables.admin = new cli.lucli.services.Admin(
+			helpers = variables.helpers,
+			projectRoot = variables.tempRoot,
+			moduleRoot = variables.moduleRoot
+		);
+	}
+
+	function afterAll() {
+		testHelper.cleanupTempProject(variables.tempRoot);
+	}
+
+	function run() {
+
+		describe("Admin Service", () => {
+
+			// mapColumnToFormHelper() is private — test via generated _form.cfm content
+
+			describe("mapColumnToFormHelper() — via generated form", () => {
+
+				it("maps string type to textField", () => {
+					var modelData = {
+						model: "FormHelperStr",
+						tableName: "form_helper_strs",
+						primaryKey: "id",
+						columns: [
+							{name: "id", type: "integer", primaryKey: true},
+							{name: "title", type: "string"}
+						],
+						associations: []
+					};
+					var result = admin.generateAdmin(modelData = modelData, force = true, noRoutes = true);
+					var form = fileRead(tempRoot & "/app/views/admin/form_helper_strs/_form.cfm");
+					expect(form).toInclude("textField");
+				});
+
+				it("maps text type to textArea", () => {
+					var modelData = {
+						model: "FormHelperTxt",
+						tableName: "form_helper_txts",
+						primaryKey: "id",
+						columns: [
+							{name: "id", type: "integer", primaryKey: true},
+							{name: "body", type: "text"}
+						],
+						associations: []
+					};
+					var result = admin.generateAdmin(modelData = modelData, force = true, noRoutes = true);
+					var form = fileRead(tempRoot & "/app/views/admin/form_helper_txts/_form.cfm");
+					expect(form).toInclude("textArea");
+				});
+
+				it("maps boolean type to checkBox", () => {
+					var modelData = {
+						model: "FormHelperBool",
+						tableName: "form_helper_bools",
+						primaryKey: "id",
+						columns: [
+							{name: "id", type: "integer", primaryKey: true},
+							{name: "active", type: "boolean"}
+						],
+						associations: []
+					};
+					var result = admin.generateAdmin(modelData = modelData, force = true, noRoutes = true);
+					var form = fileRead(tempRoot & "/app/views/admin/form_helper_bools/_form.cfm");
+					expect(form).toInclude("checkBox");
+				});
+
+				it("maps integer type to numberField", () => {
+					var modelData = {
+						model: "FormHelperInt",
+						tableName: "form_helper_ints",
+						primaryKey: "id",
+						columns: [
+							{name: "id", type: "integer", primaryKey: true},
+							{name: "quantity", type: "integer"}
+						],
+						associations: []
+					};
+					var result = admin.generateAdmin(modelData = modelData, force = true, noRoutes = true);
+					var form = fileRead(tempRoot & "/app/views/admin/form_helper_ints/_form.cfm");
+					expect(form).toInclude("numberField");
+				});
+
+				it("maps date type to dateField", () => {
+					var modelData = {
+						model: "FormHelperDt",
+						tableName: "form_helper_dts",
+						primaryKey: "id",
+						columns: [
+							{name: "id", type: "integer", primaryKey: true},
+							{name: "startDate", type: "date"}
+						],
+						associations: []
+					};
+					var result = admin.generateAdmin(modelData = modelData, force = true, noRoutes = true);
+					var form = fileRead(tempRoot & "/app/views/admin/form_helper_dts/_form.cfm");
+					expect(form).toInclude("dateField");
+				});
+
+				it("maps datetime to dateTimeLocalField", () => {
+					var modelData = {
+						model: "FormHelperDtl",
+						tableName: "form_helper_dtls",
+						primaryKey: "id",
+						columns: [
+							{name: "id", type: "integer", primaryKey: true},
+							{name: "publishedAt", type: "datetime"}
+						],
+						associations: []
+					};
+					var result = admin.generateAdmin(modelData = modelData, force = true, noRoutes = true);
+					var form = fileRead(tempRoot & "/app/views/admin/form_helper_dtls/_form.cfm");
+					expect(form).toInclude("dateTimeLocalField");
+				});
+
+				it("maps email column name to emailField", () => {
+					var modelData = {
+						model: "FormHelperEmail",
+						tableName: "form_helper_emails",
+						primaryKey: "id",
+						columns: [
+							{name: "id", type: "integer", primaryKey: true},
+							{name: "email", type: "string"}
+						],
+						associations: []
+					};
+					var result = admin.generateAdmin(modelData = modelData, force = true, noRoutes = true);
+					var form = fileRead(tempRoot & "/app/views/admin/form_helper_emails/_form.cfm");
+					expect(form).toInclude("emailField");
+				});
+
+				it("maps phone column name to telField", () => {
+					var modelData = {
+						model: "FormHelperPhone",
+						tableName: "form_helper_phones",
+						primaryKey: "id",
+						columns: [
+							{name: "id", type: "integer", primaryKey: true},
+							{name: "phone", type: "string"}
+						],
+						associations: []
+					};
+					var result = admin.generateAdmin(modelData = modelData, force = true, noRoutes = true);
+					var form = fileRead(tempRoot & "/app/views/admin/form_helper_phones/_form.cfm");
+					expect(form).toInclude("telField");
+				});
+
+				it("maps website column name to urlField", () => {
+					var modelData = {
+						model: "FormHelperUrl",
+						tableName: "form_helper_urls",
+						primaryKey: "id",
+						columns: [
+							{name: "id", type: "integer", primaryKey: true},
+							{name: "website", type: "string"}
+						],
+						associations: []
+					};
+					var result = admin.generateAdmin(modelData = modelData, force = true, noRoutes = true);
+					var form = fileRead(tempRoot & "/app/views/admin/form_helper_urls/_form.cfm");
+					expect(form).toInclude("urlField");
+				});
+
+			});
+
+			describe("generateAdmin()", () => {
+
+				it("generates controller and view files", () => {
+					var modelData = {
+						model: "Product",
+						tableName: "products",
+						primaryKey: "id",
+						columns: [
+							{name: "id", type: "integer", primaryKey: true},
+							{name: "name", type: "string"},
+							{name: "price", type: "decimal"},
+							{name: "active", type: "boolean"},
+							{name: "createdAt", type: "datetime"},
+							{name: "updatedAt", type: "datetime"}
+						],
+						associations: []
+					};
+
+					var result = admin.generateAdmin(modelData = modelData, force = true);
+					expect(result.success).toBeTrue();
+					expect(arrayLen(result.generated)).toBeGTE(6);
+
+					// Verify controller exists
+					expect(fileExists(tempRoot & "/app/controllers/admin/Products.cfc")).toBeTrue();
+
+					// Verify views exist
+					expect(fileExists(tempRoot & "/app/views/admin/products/index.cfm")).toBeTrue();
+					expect(fileExists(tempRoot & "/app/views/admin/products/show.cfm")).toBeTrue();
+					expect(fileExists(tempRoot & "/app/views/admin/products/new.cfm")).toBeTrue();
+					expect(fileExists(tempRoot & "/app/views/admin/products/edit.cfm")).toBeTrue();
+					expect(fileExists(tempRoot & "/app/views/admin/products/_form.cfm")).toBeTrue();
+				});
+
+				it("excludes id and timestamp columns from form fields", () => {
+					var modelData = {
+						model: "Item",
+						tableName: "items",
+						primaryKey: "id",
+						columns: [
+							{name: "id", type: "integer", primaryKey: true},
+							{name: "title", type: "string"},
+							{name: "createdAt", type: "datetime"},
+							{name: "updatedAt", type: "datetime"}
+						],
+						associations: []
+					};
+
+					var result = admin.generateAdmin(modelData = modelData, force = true);
+					var formContent = fileRead(tempRoot & "/app/views/admin/items/_form.cfm");
+					expect(formContent).toInclude("title");
+					expect(formContent).notToInclude('"id"');
+					expect(formContent).notToInclude('"createdAt"');
+					expect(formContent).notToInclude('"updatedAt"');
+				});
+
+				it("generates foreign key loaders for belongsTo associations", () => {
+					var modelData = {
+						model: "Post",
+						tableName: "posts",
+						primaryKey: "id",
+						columns: [
+							{name: "id", type: "integer", primaryKey: true},
+							{name: "title", type: "string"},
+							{name: "categoryId", type: "integer"}
+						],
+						associations: [
+							{type: "belongsTo", name: "category", modelName: "Category"}
+						]
+					};
+
+					var result = admin.generateAdmin(modelData = modelData, force = true);
+					var controllerContent = fileRead(tempRoot & "/app/controllers/admin/Posts.cfc");
+					expect(controllerContent).toInclude("loadCategories");
+					expect(controllerContent).toInclude('model("Category")');
+				});
+
+				it("injects admin route into routes.cfm", () => {
+					var modelData = {
+						model: "Order",
+						tableName: "orders",
+						primaryKey: "id",
+						columns: [{name: "id", type: "integer", primaryKey: true}],
+						associations: []
+					};
+
+					var result = admin.generateAdmin(modelData = modelData, force = true);
+					var routesContent = fileRead(tempRoot & "/config/routes.cfm");
+					expect(routesContent).toInclude('scope(path="admin"');
+					expect(routesContent).toInclude('.resources("orders")');
+				});
+
+				it("errors when files exist and force is false", () => {
+					var modelData = {
+						model: "Order",
+						tableName: "orders",
+						primaryKey: "id",
+						columns: [{name: "id", type: "integer", primaryKey: true}],
+						associations: []
+					};
+
+					// Files already exist from previous test
+					var result = admin.generateAdmin(modelData = modelData, force = false);
+					expect(result.success).toBeFalse();
+					expect(arrayLen(result.errors)).toBeGT(0);
+				});
+
+				it("skips route injection with noRoutes flag", () => {
+					var routesBefore = fileRead(tempRoot & "/config/routes.cfm");
+
+					var modelData = {
+						model: "NoRouteTest",
+						tableName: "no_route_tests",
+						primaryKey: "id",
+						columns: [{name: "id", type: "integer", primaryKey: true}],
+						associations: []
+					};
+
+					var result = admin.generateAdmin(
+						modelData = modelData,
+						force = true,
+						noRoutes = true
+					);
+					expect(result.success).toBeTrue();
+
+					var routesAfter = fileRead(tempRoot & "/config/routes.cfm");
+					expect(routesAfter).notToInclude("no_route_tests");
+				});
+
+			});
+
+		});
+
+	}
+
+}

From f49e788db70eb6740641c2d3a57d66386795604d Mon Sep 17 00:00:00 2001
From: Peter Amiri <peter@alurium.com>
Date: Sat, 11 Apr 2026 15:11:53 -0700
Subject: [PATCH 08/13] test(cli): add codegen service unit tests

---
 .../tests/specs/services/CodeGenSpec.cfc      | 95 +++++++++++++++++++
 1 file changed, 95 insertions(+)
 create mode 100644 cli/lucli/tests/specs/services/CodeGenSpec.cfc

diff --git a/cli/lucli/tests/specs/services/CodeGenSpec.cfc b/cli/lucli/tests/specs/services/CodeGenSpec.cfc
new file mode 100644
index 000000000..3c5b84486
--- /dev/null
+++ b/cli/lucli/tests/specs/services/CodeGenSpec.cfc
@@ -0,0 +1,95 @@
+component extends="wheels.wheelstest.system.BaseSpec" {
+
+	function beforeAll() {
+		variables.testHelper = new cli.lucli.tests.TestHelper();
+		variables.tempRoot = testHelper.scaffoldTempProject(expandPath("/"));
+		variables.moduleRoot = expandPath("/cli/lucli/");
+		variables.helpers = new cli.lucli.services.Helpers();
+		variables.templates = new cli.lucli.services.Templates(
+			helpers = variables.helpers,
+			projectRoot = variables.tempRoot,
+			moduleRoot = variables.moduleRoot
+		);
+		variables.codegen = new cli.lucli.services.CodeGen(
+			templateService = variables.templates,
+			helpers = variables.helpers,
+			projectRoot = variables.tempRoot
+		);
+	}
+
+	function afterAll() {
+		testHelper.cleanupTempProject(variables.tempRoot);
+	}
+
+	function run() {
+
+		describe("CodeGen Service", () => {
+
+			describe("generateModel()", () => {
+
+				it("creates a model CFC with PascalCase name", () => {
+					var result = codegen.generateModel(name = "Article", properties = []);
+					expect(result.success).toBeTrue();
+					expect(fileExists(tempRoot & "/app/models/Article.cfc")).toBeTrue();
+				});
+
+				it("model extends Model", () => {
+					codegen.generateModel(name = "Review", properties = [], force = true);
+					var content = fileRead(tempRoot & "/app/models/Review.cfc");
+					expect(content).toInclude('extends="Model"');
+				});
+
+				it("includes properties in model config", () => {
+					var props = [
+						{name: "title", type: "string"},
+						{name: "price", type: "decimal"}
+					];
+					codegen.generateModel(
+						name = "Product",
+						properties = props,
+						force = true
+					);
+					var content = fileRead(tempRoot & "/app/models/Product.cfc");
+					expect(content).toInclude("config()");
+				});
+
+			});
+
+			describe("generateController()", () => {
+
+				it("creates a controller CFC in app/controllers/", () => {
+					var result = codegen.generateController(
+						name = "Articles",
+						actions = "index,show"
+					);
+					expect(result.success).toBeTrue();
+					expect(fileExists(tempRoot & "/app/controllers/Articles.cfc")).toBeTrue();
+				});
+
+				it("controller extends Controller", () => {
+					codegen.generateController(name = "Reviews", actions = "", force = true);
+					var content = fileRead(tempRoot & "/app/controllers/Reviews.cfc");
+					expect(content).toInclude('extends="Controller"');
+				});
+
+			});
+
+			describe("validateName()", () => {
+
+				it("rejects empty name", () => {
+					var result = codegen.validateName("");
+					expect(result.valid).toBeFalse();
+				});
+
+				it("accepts valid PascalCase name", () => {
+					var result = codegen.validateName("UserProfile");
+					expect(result.valid).toBeTrue();
+				});
+
+			});
+
+		});
+
+	}
+
+}

From ad6d766f725deaa9de89cf0cd5372b7237e253c2 Mon Sep 17 00:00:00 2001
From: Peter Amiri <peter@alurium.com>
Date: Sat, 11 Apr 2026 15:12:53 -0700
Subject: [PATCH 09/13] test(cli): add integration tests for db commands and
 introspect endpoint

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .../specs/integration/DbCommandsSpec.cfc      | 68 ++++++++++++++
 .../specs/integration/IntrospectSpec.cfc      | 90 +++++++++++++++++++
 2 files changed, 158 insertions(+)
 create mode 100644 cli/lucli/tests/specs/integration/DbCommandsSpec.cfc
 create mode 100644 cli/lucli/tests/specs/integration/IntrospectSpec.cfc

diff --git a/cli/lucli/tests/specs/integration/DbCommandsSpec.cfc b/cli/lucli/tests/specs/integration/DbCommandsSpec.cfc
new file mode 100644
index 000000000..0d3f06d9f
--- /dev/null
+++ b/cli/lucli/tests/specs/integration/DbCommandsSpec.cfc
@@ -0,0 +1,68 @@
+component extends="wheels.wheelstest.system.BaseSpec" {
+
+	function beforeAll() {
+		variables.testHelper = new cli.lucli.tests.TestHelper();
+		variables.serverPort = testHelper.detectServerPort();
+		variables.skipIntegration = (variables.serverPort == 0);
+		if (variables.skipIntegration) {
+			variables.skipReason = "No running server detected — skipping integration tests";
+		}
+		variables.baseUrl = "http://localhost:#variables.serverPort#";
+	}
+
+	function run() {
+
+		describe("DB Commands Integration", () => {
+
+			it("dbStatus returns valid JSON with migrations", () => {
+				if (skipIntegration) { debug(skipReason); return; }
+
+				var response = testHelper.httpGet(
+					"#baseUrl#/wheels/cli?command=dbStatus&format=json"
+				);
+				expect(len(response)).toBeGT(0);
+
+				var data = deserializeJSON(response);
+				expect(data.success).toBeTrue();
+				expect(structKeyExists(data, "migrations")).toBeTrue();
+				expect(isArray(data.migrations)).toBeTrue();
+				expect(structKeyExists(data, "summary")).toBeTrue();
+				expect(data.summary.total).toBeGTE(0);
+				expect(data.summary.applied).toBeGTE(0);
+				expect(data.summary.pending).toBeGTE(0);
+			});
+
+			it("dbStatus migration entries have required fields", () => {
+				if (skipIntegration) { debug(skipReason); return; }
+
+				var response = testHelper.httpGet(
+					"#baseUrl#/wheels/cli?command=dbStatus&format=json"
+				);
+				var data = deserializeJSON(response);
+
+				if (arrayLen(data.migrations) > 0) {
+					var m = data.migrations[1];
+					expect(structKeyExists(m, "version")).toBeTrue();
+					expect(structKeyExists(m, "description")).toBeTrue();
+					expect(structKeyExists(m, "status")).toBeTrue();
+				}
+			});
+
+			it("dbVersion returns current version", () => {
+				if (skipIntegration) { debug(skipReason); return; }
+
+				var response = testHelper.httpGet(
+					"#baseUrl#/wheels/cli?command=dbVersion&format=json"
+				);
+				expect(len(response)).toBeGT(0);
+
+				var data = deserializeJSON(response);
+				expect(data.success).toBeTrue();
+				expect(structKeyExists(data, "version")).toBeTrue();
+			});
+
+		});
+
+	}
+
+}
diff --git a/cli/lucli/tests/specs/integration/IntrospectSpec.cfc b/cli/lucli/tests/specs/integration/IntrospectSpec.cfc
new file mode 100644
index 000000000..9d5862310
--- /dev/null
+++ b/cli/lucli/tests/specs/integration/IntrospectSpec.cfc
@@ -0,0 +1,90 @@
+component extends="wheels.wheelstest.system.BaseSpec" {
+
+	function beforeAll() {
+		variables.testHelper = new cli.lucli.tests.TestHelper();
+		variables.serverPort = testHelper.detectServerPort();
+		variables.skipIntegration = (variables.serverPort == 0);
+		if (variables.skipIntegration) {
+			variables.skipReason = "No running server detected — skipping integration tests";
+		}
+		variables.baseUrl = "http://localhost:#variables.serverPort#";
+	}
+
+	function run() {
+
+		describe("Introspect Endpoint Integration", () => {
+
+			it("returns model metadata for a valid model", () => {
+				if (skipIntegration) { debug(skipReason); return; }
+
+				// Use a test model that exists in the test database
+				var response = testHelper.httpGet(
+					"#baseUrl#/wheels/cli?command=introspect&model=Author&format=json"
+				);
+
+				if (!len(response)) {
+					debug("Empty response — model 'Author' may not exist");
+					return;
+				}
+
+				var data = deserializeJSON(response);
+				if (!data.success) {
+					debug("Introspect failed: #data.message# — test model may not be available");
+					return;
+				}
+
+				expect(structKeyExists(data, "model")).toBeTrue();
+				expect(structKeyExists(data, "tableName")).toBeTrue();
+				expect(structKeyExists(data, "primaryKey")).toBeTrue();
+				expect(structKeyExists(data, "columns")).toBeTrue();
+				expect(isArray(data.columns)).toBeTrue();
+				expect(arrayLen(data.columns)).toBeGT(0);
+				expect(structKeyExists(data, "associations")).toBeTrue();
+			});
+
+			it("column entries have name and type", () => {
+				if (skipIntegration) { debug(skipReason); return; }
+
+				var response = testHelper.httpGet(
+					"#baseUrl#/wheels/cli?command=introspect&model=Author&format=json"
+				);
+				if (!len(response)) return;
+
+				var data = deserializeJSON(response);
+				if (!data.success) return;
+
+				var col = data.columns[1];
+				expect(structKeyExists(col, "name")).toBeTrue();
+				expect(structKeyExists(col, "type")).toBeTrue();
+			});
+
+			it("fails gracefully with missing model parameter", () => {
+				if (skipIntegration) { debug(skipReason); return; }
+
+				var response = testHelper.httpGet(
+					"#baseUrl#/wheels/cli?command=introspect&format=json"
+				);
+				expect(len(response)).toBeGT(0);
+
+				var data = deserializeJSON(response);
+				expect(data.success).toBeFalse();
+				expect(structKeyExists(data, "message")).toBeTrue();
+			});
+
+			it("fails gracefully with non-existent model", () => {
+				if (skipIntegration) { debug(skipReason); return; }
+
+				var response = testHelper.httpGet(
+					"#baseUrl#/wheels/cli?command=introspect&model=NonExistentModelXyz&format=json"
+				);
+				expect(len(response)).toBeGT(0);
+
+				var data = deserializeJSON(response);
+				expect(data.success).toBeFalse();
+			});
+
+		});
+
+	}
+
+}

From 8c0be715aecd79a2853cc426ffaa4254f22cb765 Mon Sep 17 00:00:00 2001
From: Peter Amiri <peter@alurium.com>
Date: Sat, 11 Apr 2026 15:14:16 -0700
Subject: [PATCH 10/13] ci(test): add cli module tests to ci pipeline

---
 tools/ci/run-tests.sh | 112 ++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 109 insertions(+), 3 deletions(-)

diff --git a/tools/ci/run-tests.sh b/tools/ci/run-tests.sh
index 60a1ebcc6..1c206380c 100755
--- a/tools/ci/run-tests.sh
+++ b/tools/ci/run-tests.sh
@@ -9,6 +9,11 @@ BASE_URL="http://localhost:${PORT}"
 TEST_URL="${BASE_URL}/wheels/core/tests?db=sqlite&format=json"
 RESULT_FILE="${RESULT_DIR:-/tmp}/test-results.json"
 JUNIT_FILE="${JUNIT_DIR:-/tmp}/junit-results.xml"
+CLI_TEST_URL="${BASE_URL}/cli/lucli/tests/runner.cfm?format=json"
+CLI_RESULT_FILE="${RESULT_DIR:-/tmp}/cli-test-results.json"
+CLI_JUNIT_FILE="${JUNIT_DIR:-/tmp}/cli-junit.xml"
+CORE_OK=true
+CLI_OK=true
 
 # --- Wait for server to be ready ---
 echo "Waiting for Lucee on port ${PORT}..."
@@ -115,13 +120,114 @@ for b in d.get('bundleStats', []):
             if sp.get('status') in ('Failed', 'Error'):
                 print(f\"  {sp['status']}: {sp.get('name','?')}: {sp.get('failMessage','')[:200]}\")
 " 2>/dev/null || true
-    exit 1
+    CORE_OK=false
+  else
+    echo "[Core Tests] All tests passed!"
   fi
-
-  echo "All tests passed!"
 else
   echo "::error::Tests returned HTTP ${HTTP_CODE}"
   # Show first 50 lines of response for debugging
   head -50 "$RESULT_FILE" 2>/dev/null || true
+  CORE_OK=false
+fi
+
+# --- Run CLI module tests ---
+echo ""
+echo "Running CLI module tests..."
+CLI_HTTP_CODE=$(curl -s -o "$CLI_RESULT_FILE" \
+  --max-time 300 \
+  --write-out "%{http_code}" \
+  "$CLI_TEST_URL" || echo "000")
+
+echo "[CLI Tests] HTTP status: ${CLI_HTTP_CODE}"
+
+if [ "$CLI_HTTP_CODE" = "200" ] || [ "$CLI_HTTP_CODE" = "417" ]; then
+  CLI_PASS=$(python3 -c "import json; d=json.load(open('$CLI_RESULT_FILE')); print(int(d.get('totalPass',0)))" 2>/dev/null || echo "?")
+  CLI_FAIL=$(python3 -c "import json; d=json.load(open('$CLI_RESULT_FILE')); print(int(d.get('totalFail',0)))" 2>/dev/null || echo "?")
+  CLI_ERROR=$(python3 -c "import json; d=json.load(open('$CLI_RESULT_FILE')); print(int(d.get('totalError',0)))" 2>/dev/null || echo "?")
+
+  echo "[CLI Tests] Results: ${CLI_PASS} passed, ${CLI_FAIL} failed, ${CLI_ERROR} errors"
+
+  # Generate JUnit XML for CLI tests
+  python3 -c "
+import json, sys
+from xml.etree.ElementTree import Element, SubElement, tostring
+
+def safe_str(v):
+    return str(v) if v else ''
+
+d = json.load(open('$CLI_RESULT_FILE'))
+root = Element('testsuites')
+root.set('name', 'CLI Module Tests')
+root.set('tests', str(int(d.get('totalPass',0)) + int(d.get('totalFail',0)) + int(d.get('totalError',0))))
+root.set('failures', str(int(d.get('totalFail',0))))
+root.set('errors', str(int(d.get('totalError',0))))
+
+for b in d.get('bundleStats', []):
+    for s in b.get('suiteStats', []):
+        ts = SubElement(root, 'testsuite')
+        ts.set('name', safe_str(s.get('name')))
+        ts.set('tests', str(int(s.get('totalSpecs',0))))
+        ts.set('failures', str(int(s.get('totalFail',0))))
+        ts.set('errors', str(int(s.get('totalError',0))))
+        ts.set('time', str(float(s.get('totalDuration',0))/1000))
+        for sp in s.get('specStats', []):
+            tc = SubElement(ts, 'testcase')
+            tc.set('name', safe_str(sp.get('name')))
+            tc.set('classname', safe_str(b.get('name','')))
+            tc.set('time', str(float(sp.get('totalDuration',0))/1000))
+            if sp.get('status') == 'Failed':
+                f = SubElement(tc, 'failure', message=safe_str(sp.get('failMessage')))
+                f.text = safe_str(sp.get('failDetail'))
+            elif sp.get('status') == 'Error':
+                e = SubElement(tc, 'error', message=safe_str(sp.get('failMessage')))
+                e.text = safe_str(sp.get('failDetail'))
+
+with open('$CLI_JUNIT_FILE', 'wb') as f:
+    f.write(b'<?xml version=\"1.0\" encoding=\"UTF-8\"?>')
+    f.write(tostring(root))
+" 2>/dev/null || echo "Warning: Could not generate CLI JUnit XML"
+
+  # Write CLI step summary
+  if [ -n "${GITHUB_STEP_SUMMARY:-}" ]; then
+    echo "" >> "$GITHUB_STEP_SUMMARY"
+    echo "### CLI Module Test Results" >> "$GITHUB_STEP_SUMMARY"
+    echo "" >> "$GITHUB_STEP_SUMMARY"
+    echo "| Metric | Count |" >> "$GITHUB_STEP_SUMMARY"
+    echo "|--------|-------|" >> "$GITHUB_STEP_SUMMARY"
+    echo "| Passed | ${CLI_PASS} |" >> "$GITHUB_STEP_SUMMARY"
+    echo "| Failed | ${CLI_FAIL} |" >> "$GITHUB_STEP_SUMMARY"
+    echo "| Errors | ${CLI_ERROR} |" >> "$GITHUB_STEP_SUMMARY"
+  fi
+
+  CLI_TOTAL_FAILURES=$((CLI_FAIL + CLI_ERROR))
+  if [ "$CLI_TOTAL_FAILURES" -gt 0 ]; then
+    echo "::error::[CLI Tests] ${CLI_TOTAL_FAILURES} test failures/errors"
+    python3 -c "
+import json
+d = json.load(open('$CLI_RESULT_FILE'))
+for b in d.get('bundleStats', []):
+    for s in b.get('suiteStats', []):
+        for sp in s.get('specStats', []):
+            if sp.get('status') in ('Failed', 'Error'):
+                print(f\"  {sp['status']}: {sp.get('name','?')}: {sp.get('failMessage','')[:200]}\")
+" 2>/dev/null || true
+    CLI_OK=false
+  else
+    echo "[CLI Tests] All tests passed!"
+  fi
+else
+  echo "::error::[CLI Tests] returned HTTP ${CLI_HTTP_CODE}"
+  head -50 "$CLI_RESULT_FILE" 2>/dev/null || true
+  CLI_OK=false
+fi
+
+# --- Final exit ---
+if [ "$CORE_OK" = false ] || [ "$CLI_OK" = false ]; then
+  echo ""
+  echo "::error::Test suite(s) failed"
   exit 1
 fi
+
+echo ""
+echo "All test suites passed!"

From 6ae499707405a0dc2252577d3e17b165b61727cb Mon Sep 17 00:00:00 2001
From: Peter Amiri <peter@alurium.com>
Date: Sat, 11 Apr 2026 15:19:38 -0700
Subject: [PATCH 11/13] fix(test): wire cli test runner through wheels route
 dispatch

Add /wheels/cli/tests route, clitests view, Public.cfc handler, and
/cli mapping so TestBox can discover cli.lucli.tests.specs.
Remove standalone runner.cfm approach (Wheels Application.cfc
intercepts all requests).
---
 cli/lucli/tests/Application.cfc         | 11 +++++++
 public/Application.cfc                  |  1 +
 vendor/wheels/Public.cfc                |  5 ++++
 vendor/wheels/public/routes.cfm         |  1 +
 vendor/wheels/public/views/clitests.cfm | 39 +++++++++++++++++++++++++
 5 files changed, 57 insertions(+)
 create mode 100644 cli/lucli/tests/Application.cfc
 create mode 100644 vendor/wheels/public/views/clitests.cfm

diff --git a/cli/lucli/tests/Application.cfc b/cli/lucli/tests/Application.cfc
new file mode 100644
index 000000000..45f7c97cf
--- /dev/null
+++ b/cli/lucli/tests/Application.cfc
@@ -0,0 +1,11 @@
+component {
+
+	this.name = "WheelsCLITests_" & hash(getCurrentTemplatePath());
+
+	// Map to project root so tests can instantiate cli.lucli.services.* and wheels.wheelstest.*
+	local.projectRoot = expandPath("../../../");
+	this.mappings["/cli"] = local.projectRoot & "cli/";
+	this.mappings["/wheels"] = local.projectRoot & "vendor/wheels/";
+	this.mappings["/vendor"] = local.projectRoot & "vendor/";
+
+}
diff --git a/public/Application.cfc b/public/Application.cfc
index e6ea8ba21..2200211a0 100644
--- a/public/Application.cfc
+++ b/public/Application.cfc
@@ -21,6 +21,7 @@ component output="false" {
 	this.mappings["/tests"] = expandPath("../tests");
 	this.mappings["/config"] = expandPath("../config");
 	this.mappings["/plugins"] = expandPath("../plugins");
+	this.mappings["/cli"] = expandPath("../cli/");
 
 	// Load app-level configuration (datasources, custom settings, etc.)
 	// This is the recommended place for developers to define this.datasources,
diff --git a/vendor/wheels/Public.cfc b/vendor/wheels/Public.cfc
index 012de2b4a..fa34c8ce8 100644
--- a/vendor/wheels/Public.cfc
+++ b/vendor/wheels/Public.cfc
@@ -78,6 +78,11 @@ component output="false" displayName="Internal GUI" extends="wheels.Global" {
 		// Ensure we abort to prevent any further processing
 		abort;
 	}
+	public function clitests() {
+		include "/wheels/public/views/clitests.cfm";
+		abort;
+	}
+
 	function packages() {
 		include "/wheels/public/views/packages.cfm";
 		return "";
diff --git a/vendor/wheels/public/routes.cfm b/vendor/wheels/public/routes.cfm
index ae8138dd3..a4d4862e0 100644
--- a/vendor/wheels/public/routes.cfm
+++ b/vendor/wheels/public/routes.cfm
@@ -12,6 +12,7 @@ mapper()
 		.get(name = "packages", pattern = "legacy/[type]/tests", to = "public##packages")
 		.get(name = "wheelsPackages", pattern = "legacy/app/tests", to = "public##packages")
 		.get(name = "testbox", pattern = "/core/tests", to = "public##tests_testbox")
+		.get(name = "cliTests", pattern = "cli/tests", to = "public##clitests")
 		.get(name = "migratorTemplates", pattern = "migrator/templates", to = "public##migratortemplates")
 		.post(name = "migratorTemplatesCreate", pattern = "migrator/templates", to = "public##migratortemplatescreate")
 		.get(name = "migratorSQL", pattern = "migrator/sql/[version]", to = "public##migratorsql")
diff --git a/vendor/wheels/public/views/clitests.cfm b/vendor/wheels/public/views/clitests.cfm
new file mode 100644
index 000000000..57dd0380b
--- /dev/null
+++ b/vendor/wheels/public/views/clitests.cfm
@@ -0,0 +1,39 @@
+<cfsetting requestTimeOut="300">
+<cfscript>
+setting showDebugOutput="no";
+try {
+	testBox = new wheels.wheelstest.system.TestBox(
+		directory = "cli.lucli.tests.specs",
+		options = { coverage = { enabled = false } }
+	);
+
+	local.sortedArray = testBox.getBundles();
+	arraySort(local.sortedArray, "textNoCase");
+	testBox.setBundles(local.sortedArray);
+
+	param name="request.wheels.params.format" default="json";
+
+	if (request.wheels.params.format == "json") {
+		result = testBox.run(
+			reporter = "wheels.wheelstest.system.reports.JSONReporter"
+		);
+		cfcontent(type = "application/json");
+		local.parsed = deserializeJSON(result);
+		if (local.parsed.totalFail > 0 || local.parsed.totalError > 0) {
+			cfheader(statuscode = 417);
+		} else {
+			cfheader(statuscode = 200);
+		}
+	} else {
+		result = testBox.run(
+			reporter = "wheels.wheelstest.system.reports.SimpleReporter"
+		);
+	}
+
+	writeOutput(result);
+} catch (any e) {
+	cfheader(statuscode = 500);
+	cfcontent(type = "application/json");
+	writeOutput('{"success":false,"error":"' & replace(e.message, '"', '\"', 'all') & '"}');
+}
+</cfscript>

From ecf4926cb29d8edcd0b0a7343a34fd7c9796b814 Mon Sep 17 00:00:00 2001
From: Peter Amiri <peter@alurium.com>
Date: Sat, 11 Apr 2026 15:35:09 -0700
Subject: [PATCH 12/13] fix(test): ensure temp project has complete directory
 structure for cli tests

- fix reFindNoCase -> reFind for uppercase detection in Helpers.cfc pluralize/singularize,
  preventing case-insensitive match from corrupting all-lowercase words like "user"
- scaffold temp project with all required dirs, config files, placeholder migration and
  test spec so Doctor health checks report HEALTHY instead of CRITICAL
- fix TestHelper to avoid cfscript/tag parser confusion in string literals
- add recommendation for missing tests/ directory in Doctor.buildRecommendations
- use modelData.tableName for Admin view/controller paths to match spec expectations
- fix CodeGenSpec: pass array for actions param, add required type to validateName
- fix AdminSpec: rename form -> formContent to avoid CFML form scope collision
- fix DoctorSpec: use < 10 char content to trigger routes.cfm minimal warning

Result: 70/70 CLI tests pass (was 37 pass, 14 fail, 19 error)
---
 cli/lucli/services/Admin.cfc                  |  3 +-
 cli/lucli/services/Doctor.cfc                 |  2 +-
 cli/lucli/services/Helpers.cfc                |  2 +-
 cli/lucli/tests/TestHelper.cfc                | 55 +++++++++++++++++++
 cli/lucli/tests/specs/services/AdminSpec.cfc  | 36 ++++++------
 .../tests/specs/services/CodeGenSpec.cfc      |  8 +--
 cli/lucli/tests/specs/services/DoctorSpec.cfc |  2 +-
 7 files changed, 82 insertions(+), 26 deletions(-)

diff --git a/cli/lucli/services/Admin.cfc b/cli/lucli/services/Admin.cfc
index 79e0b9f7f..384919c43 100644
--- a/cli/lucli/services/Admin.cfc
+++ b/cli/lucli/services/Admin.cfc
@@ -27,7 +27,8 @@ component {
 	) {
 		var result = {success: true, generated: [], errors: []};
 		var singular = lCase(arguments.modelData.model);
-		var plural = variables.helpers.pluralize(singular);
+		// Prefer tableName from modelData for view/controller paths when provided
+		var plural = len(arguments.modelData.tableName ?: "") ? lCase(arguments.modelData.tableName) : variables.helpers.pluralize(singular);
 		var singularCap = variables.helpers.capitalize(singular);
 		var pluralCap = variables.helpers.capitalize(plural);
 
diff --git a/cli/lucli/services/Doctor.cfc b/cli/lucli/services/Doctor.cfc
index 66860eaa4..41695bea9 100644
--- a/cli/lucli/services/Doctor.cfc
+++ b/cli/lucli/services/Doctor.cfc
@@ -203,7 +203,7 @@ component {
 		if (findNoCase("No migrations", combined)) {
 			arrayAppend(recs, "Run 'wheels generate migration' to create your first migration");
 		}
-		if (findNoCase("No test files", combined)) {
+		if (findNoCase("No test files", combined) || findNoCase("Missing recommended directory: tests", combined)) {
 			arrayAppend(recs, "Run 'wheels generate test' to add test coverage");
 		}
 		if (findNoCase("Missing required directory", combined)) {
diff --git a/cli/lucli/services/Helpers.cfc b/cli/lucli/services/Helpers.cfc
index 8e45da8bf..982a58b20 100644
--- a/cli/lucli/services/Helpers.cfc
+++ b/cli/lucli/services/Helpers.cfc
@@ -40,7 +40,7 @@ component {
 		loc.rv = loc.text;
 
 		if (count != 1) {
-			if (reFindNoCase("[A-Z]", loc.text)) {
+			if (reFind("[A-Z]", loc.text)) {
 				loc.upperCasePos = reFind("[A-Z]", reverse(loc.text));
 				loc.prepend = mid(loc.text, 1, len(loc.text) - loc.upperCasePos);
 				loc.text = reverse(mid(reverse(loc.text), 1, loc.upperCasePos));
diff --git a/cli/lucli/tests/TestHelper.cfc b/cli/lucli/tests/TestHelper.cfc
index a3ea1333c..fa94d3fc5 100644
--- a/cli/lucli/tests/TestHelper.cfc
+++ b/cli/lucli/tests/TestHelper.cfc
@@ -26,6 +26,61 @@ component {
 			}
 		}
 
+		// Ensure all required and recommended directories exist in the temp project.
+		// directoryCopy skips empty source directories, so we create them explicitly.
+		var requiredDirs = [
+			"app",
+			"app/controllers",
+			"app/models",
+			"app/views",
+			"app/helpers",
+			"app/migrator",
+			"app/migrator/migrations",
+			"config",
+			"public",
+			"public/files",
+			"tests",
+			"tests/specs",
+			"tests/specs/models",
+			"tests/specs/controllers",
+			"tests/specs/views"
+		];
+		for (var reqDir in requiredDirs) {
+			var fullPath = tempBase & "/" & reqDir;
+			if (!directoryExists(fullPath)) {
+				directoryCreate(fullPath, true);
+			}
+		}
+
+		// Ensure config/routes.cfm exists with minimal valid content
+		var routesPath = tempBase & "/config/routes.cfm";
+		if (!fileExists(routesPath)) {
+			var nl = chr(10);
+			var t = chr(9);
+			var routesContent = "// routes" & nl & "mapper()" & nl & t & "// CLI-Appends-Here" & nl & t & ".wildcard()" & nl & ".end();";
+			fileWrite(routesPath, routesContent);
+		}
+
+		// Ensure config/settings.cfm exists with datasource config (satisfies Doctor health check)
+		var settingsPath = tempBase & "/config/settings.cfm";
+		if (!fileExists(settingsPath)) {
+			var nl = chr(10);
+			var settingsContent = "// settings" & nl & "set(dataSourceName=" & chr(34) & "wheels" & chr(34) & ");";
+			fileWrite(settingsPath, settingsContent);
+		}
+
+		// Create a placeholder migration so Doctor doesn't warn about missing migrations
+		var migrationPlaceholderPath = tempBase & "/app/migrator/migrations/00000000000000_placeholder.cfc";
+		if (!fileExists(migrationPlaceholderPath)) {
+			fileWrite(migrationPlaceholderPath, "component extends=" & chr(34) & "wheels.migrator.Migration" & chr(34) & " {}");
+		}
+
+		// Create a placeholder test spec so Doctor doesn't warn about missing tests
+		var testPlaceholderPath = tempBase & "/tests/specs/PlaceholderSpec.cfc";
+		if (!fileExists(testPlaceholderPath)) {
+			fileWrite(testPlaceholderPath, "component extends=" & chr(34) & "wheels.WheelsTest" & chr(34) & " {}");
+		}
+
 		// Copy key config files from root
 		var files = [".env", "lucee.json"];
 		for (var f in files) {
diff --git a/cli/lucli/tests/specs/services/AdminSpec.cfc b/cli/lucli/tests/specs/services/AdminSpec.cfc
index 221aa15f6..789e69aa1 100644
--- a/cli/lucli/tests/specs/services/AdminSpec.cfc
+++ b/cli/lucli/tests/specs/services/AdminSpec.cfc
@@ -36,8 +36,8 @@ component extends="wheels.wheelstest.system.BaseSpec" {
 						associations: []
 					};
 					var result = admin.generateAdmin(modelData = modelData, force = true, noRoutes = true);
-					var form = fileRead(tempRoot & "/app/views/admin/form_helper_strs/_form.cfm");
-					expect(form).toInclude("textField");
+					var formContent = fileRead(tempRoot & "/app/views/admin/form_helper_strs/_form.cfm");
+					expect(formContent).toInclude("textField");
 				});
 
 				it("maps text type to textArea", () => {
@@ -52,8 +52,8 @@ component extends="wheels.wheelstest.system.BaseSpec" {
 						associations: []
 					};
 					var result = admin.generateAdmin(modelData = modelData, force = true, noRoutes = true);
-					var form = fileRead(tempRoot & "/app/views/admin/form_helper_txts/_form.cfm");
-					expect(form).toInclude("textArea");
+					var formContent = fileRead(tempRoot & "/app/views/admin/form_helper_txts/_form.cfm");
+					expect(formContent).toInclude("textArea");
 				});
 
 				it("maps boolean type to checkBox", () => {
@@ -68,8 +68,8 @@ component extends="wheels.wheelstest.system.BaseSpec" {
 						associations: []
 					};
 					var result = admin.generateAdmin(modelData = modelData, force = true, noRoutes = true);
-					var form = fileRead(tempRoot & "/app/views/admin/form_helper_bools/_form.cfm");
-					expect(form).toInclude("checkBox");
+					var formContent = fileRead(tempRoot & "/app/views/admin/form_helper_bools/_form.cfm");
+					expect(formContent).toInclude("checkBox");
 				});
 
 				it("maps integer type to numberField", () => {
@@ -84,8 +84,8 @@ component extends="wheels.wheelstest.system.BaseSpec" {
 						associations: []
 					};
 					var result = admin.generateAdmin(modelData = modelData, force = true, noRoutes = true);
-					var form = fileRead(tempRoot & "/app/views/admin/form_helper_ints/_form.cfm");
-					expect(form).toInclude("numberField");
+					var formContent = fileRead(tempRoot & "/app/views/admin/form_helper_ints/_form.cfm");
+					expect(formContent).toInclude("numberField");
 				});
 
 				it("maps date type to dateField", () => {
@@ -100,8 +100,8 @@ component extends="wheels.wheelstest.system.BaseSpec" {
 						associations: []
 					};
 					var result = admin.generateAdmin(modelData = modelData, force = true, noRoutes = true);
-					var form = fileRead(tempRoot & "/app/views/admin/form_helper_dts/_form.cfm");
-					expect(form).toInclude("dateField");
+					var formContent = fileRead(tempRoot & "/app/views/admin/form_helper_dts/_form.cfm");
+					expect(formContent).toInclude("dateField");
 				});
 
 				it("maps datetime to dateTimeLocalField", () => {
@@ -116,8 +116,8 @@ component extends="wheels.wheelstest.system.BaseSpec" {
 						associations: []
 					};
 					var result = admin.generateAdmin(modelData = modelData, force = true, noRoutes = true);
-					var form = fileRead(tempRoot & "/app/views/admin/form_helper_dtls/_form.cfm");
-					expect(form).toInclude("dateTimeLocalField");
+					var formContent = fileRead(tempRoot & "/app/views/admin/form_helper_dtls/_form.cfm");
+					expect(formContent).toInclude("dateTimeLocalField");
 				});
 
 				it("maps email column name to emailField", () => {
@@ -132,8 +132,8 @@ component extends="wheels.wheelstest.system.BaseSpec" {
 						associations: []
 					};
 					var result = admin.generateAdmin(modelData = modelData, force = true, noRoutes = true);
-					var form = fileRead(tempRoot & "/app/views/admin/form_helper_emails/_form.cfm");
-					expect(form).toInclude("emailField");
+					var formContent = fileRead(tempRoot & "/app/views/admin/form_helper_emails/_form.cfm");
+					expect(formContent).toInclude("emailField");
 				});
 
 				it("maps phone column name to telField", () => {
@@ -148,8 +148,8 @@ component extends="wheels.wheelstest.system.BaseSpec" {
 						associations: []
 					};
 					var result = admin.generateAdmin(modelData = modelData, force = true, noRoutes = true);
-					var form = fileRead(tempRoot & "/app/views/admin/form_helper_phones/_form.cfm");
-					expect(form).toInclude("telField");
+					var formContent = fileRead(tempRoot & "/app/views/admin/form_helper_phones/_form.cfm");
+					expect(formContent).toInclude("telField");
 				});
 
 				it("maps website column name to urlField", () => {
@@ -164,8 +164,8 @@ component extends="wheels.wheelstest.system.BaseSpec" {
 						associations: []
 					};
 					var result = admin.generateAdmin(modelData = modelData, force = true, noRoutes = true);
-					var form = fileRead(tempRoot & "/app/views/admin/form_helper_urls/_form.cfm");
-					expect(form).toInclude("urlField");
+					var formContent = fileRead(tempRoot & "/app/views/admin/form_helper_urls/_form.cfm");
+					expect(formContent).toInclude("urlField");
 				});
 
 			});
diff --git a/cli/lucli/tests/specs/services/CodeGenSpec.cfc b/cli/lucli/tests/specs/services/CodeGenSpec.cfc
index 3c5b84486..0fbc85e89 100644
--- a/cli/lucli/tests/specs/services/CodeGenSpec.cfc
+++ b/cli/lucli/tests/specs/services/CodeGenSpec.cfc
@@ -60,14 +60,14 @@ component extends="wheels.wheelstest.system.BaseSpec" {
 				it("creates a controller CFC in app/controllers/", () => {
 					var result = codegen.generateController(
 						name = "Articles",
-						actions = "index,show"
+						actions = ["index", "show"]
 					);
 					expect(result.success).toBeTrue();
 					expect(fileExists(tempRoot & "/app/controllers/Articles.cfc")).toBeTrue();
 				});
 
 				it("controller extends Controller", () => {
-					codegen.generateController(name = "Reviews", actions = "", force = true);
+					codegen.generateController(name = "Reviews", actions = [], force = true);
 					var content = fileRead(tempRoot & "/app/controllers/Reviews.cfc");
 					expect(content).toInclude('extends="Controller"');
 				});
@@ -77,12 +77,12 @@ component extends="wheels.wheelstest.system.BaseSpec" {
 			describe("validateName()", () => {
 
 				it("rejects empty name", () => {
-					var result = codegen.validateName("");
+					var result = codegen.validateName("", "model");
 					expect(result.valid).toBeFalse();
 				});
 
 				it("accepts valid PascalCase name", () => {
-					var result = codegen.validateName("UserProfile");
+					var result = codegen.validateName("UserProfile", "model");
 					expect(result.valid).toBeTrue();
 				});
 
diff --git a/cli/lucli/tests/specs/services/DoctorSpec.cfc b/cli/lucli/tests/specs/services/DoctorSpec.cfc
index 25aafd706..8064925bd 100644
--- a/cli/lucli/tests/specs/services/DoctorSpec.cfc
+++ b/cli/lucli/tests/specs/services/DoctorSpec.cfc
@@ -80,7 +80,7 @@ component extends="wheels.wheelstest.system.BaseSpec" {
 			it("warns when config routes.cfm has minimal content", () => {
 				var routesPath = tempRoot & "/config/routes.cfm";
 				var original = fileRead(routesPath);
-				fileWrite(routesPath, "<!--- --->"); // less than 10 chars of content
+				fileWrite(routesPath, "// "); // less than 10 chars of content
 
 				var doctor = new cli.lucli.services.Doctor(projectRoot = tempRoot);
 				var results = doctor.runChecks();

From 1260a1604321dbda68ea1d4ee0392217e7f33ff5 Mon Sep 17 00:00:00 2001
From: Peter Amiri <peter@alurium.com>
Date: Sat, 11 Apr 2026 18:17:39 -0700
Subject: [PATCH 13/13] fix(test): use wheels route for cli tests and improve
 error handling

---
 tools/ci/run-tests.sh                   |  5 ++++-
 vendor/wheels/public/views/clitests.cfm | 14 +++++++++-----
 2 files changed, 13 insertions(+), 6 deletions(-)

diff --git a/tools/ci/run-tests.sh b/tools/ci/run-tests.sh
index 1c206380c..38712a602 100755
--- a/tools/ci/run-tests.sh
+++ b/tools/ci/run-tests.sh
@@ -9,7 +9,7 @@ BASE_URL="http://localhost:${PORT}"
 TEST_URL="${BASE_URL}/wheels/core/tests?db=sqlite&format=json"
 RESULT_FILE="${RESULT_DIR:-/tmp}/test-results.json"
 JUNIT_FILE="${JUNIT_DIR:-/tmp}/junit-results.xml"
-CLI_TEST_URL="${BASE_URL}/cli/lucli/tests/runner.cfm?format=json"
+CLI_TEST_URL="${BASE_URL}/wheels/cli/tests?format=json"
 CLI_RESULT_FILE="${RESULT_DIR:-/tmp}/cli-test-results.json"
 CLI_JUNIT_FILE="${JUNIT_DIR:-/tmp}/cli-junit.xml"
 CORE_OK=true
@@ -133,6 +133,9 @@ fi
 
 # --- Run CLI module tests ---
 echo ""
+echo "Reloading app for CLI tests..."
+curl -s -o /dev/null --max-time 30 "${BASE_URL}/?reload=true&password=wheels-dev" || true
+sleep 2
 echo "Running CLI module tests..."
 CLI_HTTP_CODE=$(curl -s -o "$CLI_RESULT_FILE" \
   --max-time 300 \
diff --git a/vendor/wheels/public/views/clitests.cfm b/vendor/wheels/public/views/clitests.cfm
index 57dd0380b..801248d75 100644
--- a/vendor/wheels/public/views/clitests.cfm
+++ b/vendor/wheels/public/views/clitests.cfm
@@ -1,6 +1,14 @@
 <cfsetting requestTimeOut="300">
 <cfscript>
 setting showDebugOutput="no";
+
+param name="request.wheels.params.format" default="json";
+
+// Set content type early so errors return JSON, not HTML
+if (request.wheels.params.format == "json") {
+	cfcontent(type = "application/json");
+}
+
 try {
 	testBox = new wheels.wheelstest.system.TestBox(
 		directory = "cli.lucli.tests.specs",
@@ -11,13 +19,10 @@ try {
 	arraySort(local.sortedArray, "textNoCase");
 	testBox.setBundles(local.sortedArray);
 
-	param name="request.wheels.params.format" default="json";
-
 	if (request.wheels.params.format == "json") {
 		result = testBox.run(
 			reporter = "wheels.wheelstest.system.reports.JSONReporter"
 		);
-		cfcontent(type = "application/json");
 		local.parsed = deserializeJSON(result);
 		if (local.parsed.totalFail > 0 || local.parsed.totalError > 0) {
 			cfheader(statuscode = 417);
@@ -33,7 +38,6 @@ try {
 	writeOutput(result);
 } catch (any e) {
 	cfheader(statuscode = 500);
-	cfcontent(type = "application/json");
-	writeOutput('{"success":false,"error":"' & replace(e.message, '"', '\"', 'all') & '"}');
+	writeOutput('{"success":false,"error":"' & replace(e.message, '"', '\"', 'all') & '","detail":"' & replace(e.detail ?: '', '"', '\"', 'all') & '"}');
 }
 </cfscript>