@getarbiter/cli 0.5.0

package/dist/templates/api-e2e/postman.collection.json.ejs

@@ -0,0 +1,30 @@
+{
+  "info": {
+    "name": <%- JSON.stringify(`${projectName || 'service'} live API e2e (INV-126)`) %>,
+    "description": "Non-mocked Newman/Postman suite — runs against the REAL booted binary. Boot it via tests/api/run.sh; set baseUrl to the running address.",
+    "schema": "https://schema.getpostman.com/json/collection/v2.1.0/collection.json"
+  },
+  "item": [
+    {
+      "name": "GET /health (live binary)",
+      "request": {
+        "method": "GET",
+        "url": { "raw": "{{baseUrl}}/health", "host": ["{{baseUrl}}"], "path": ["health"] }
+      },
+      "event": [
+        {
+          "listen": "test",
+          "script": {
+            "type": "text/javascript",
+            "exec": [
+              "pm.test('health returns 200 from the running binary', function () {",
+              "  pm.response.to.have.status(200);",
+              "});"
+            ]
+          }
+        }
+      ]
+    }
+  ],
+  "variable": [{ "key": "baseUrl", "value": "http://127.0.0.1:8080" }]
+}

package/dist/templates/api-e2e/python-httpx.py.ejs

@@ -0,0 +1,17 @@
+# SPDX-License-Identifier: Apache-2.0
+# Live-API e2e (INV-126): runs against the REAL booted server, no mocks.
+# API_BASE_URL points at the running binary (tests/api/run.sh boots it).
+import os
+
+import httpx
+
+BASE_URL = os.environ.get("API_BASE_URL", "http://127.0.0.1:8080")
+
+
+def test_health_returns_200_from_running_binary() -> None:
+    resp = httpx.get(f"{BASE_URL}/health", timeout=5.0)
+    assert resp.status_code == 200
+
+    # Add real request/response assertions exercising the live HTTP surface here —
+    # this layer catches "domain green, HTTP wiring broken" bugs (e.g. a field in
+    # the domain/DB never wired into the request input model).

package/dist/templates/api-e2e/run.sh.ejs

@@ -0,0 +1,61 @@
+#!/usr/bin/env bash
+# SPDX-License-Identifier: Apache-2.0
+# Live-API e2e runner (INV-126): builds + boots the REAL binary, runs the non-mocked
+# suite against it over real HTTP, then tears down. No mocks, no stubs.
+#
+# Contract:
+#   - Use a throwaway DB + harness auth-bypass (NEVER production credentials).
+#   - Wait for readiness before running the suite.
+#   - Always tear the server down (trap), even on failure.
+set -euo pipefail
+
+API_BASE_URL="${API_BASE_URL:-http://127.0.0.1:8080}"
+HEALTH_URL="${HEALTH_URL:-${API_BASE_URL}/health}"
+SERVER_PID=""
+
+cleanup() {
+  if [[ -n "${SERVER_PID}" ]] && kill -0 "${SERVER_PID}" 2>/dev/null; then
+    kill "${SERVER_PID}" 2>/dev/null || true
+    wait "${SERVER_PID}" 2>/dev/null || true
+  fi
+}
+trap cleanup EXIT
+
+echo "[api-e2e] building + booting the real binary..."
+<% if (language === 'go') { -%>
+go build -o /tmp/api-e2e-bin ./... && /tmp/api-e2e-bin &
+<% } else if (language === 'java' || language === 'kotlin') { -%>
+# Adjust the boot command to your build tool (gradle bootRun / java -jar build/libs/*.jar).
+./gradlew bootRun &
+<% } else if (language === 'python') { -%>
+# Adjust module:app to your ASGI/WSGI entrypoint.
+python -m uvicorn app.main:app --host 127.0.0.1 --port 8080 &
+<% } else { -%>
+# Adjust to your start command (e.g. node dist/server.js).
+npm run start &
+<% } -%>
+SERVER_PID=$!
+
+echo "[api-e2e] waiting for readiness at ${HEALTH_URL} ..."
+for _ in $(seq 1 60); do
+  if curl -fsS "${HEALTH_URL}" >/dev/null 2>&1; then
+    echo "[api-e2e] server is ready"
+    break
+  fi
+  sleep 1
+done
+
+echo "[api-e2e] running the live suite..."
+<% if (language === 'go') { -%>
+# `apie2e` build tag (#1840 F4 tranche-3) keeps this suite out of the default
+# `go test ./...` — required here to actually compile+run it.
+API_BASE_URL="${API_BASE_URL}" go test -tags apie2e ./tests/api/...
+<% } else if (language === 'java' || language === 'kotlin') { -%>
+API_BASE_URL="${API_BASE_URL}" ./gradlew test --tests '*ApiE2ETest'
+<% } else if (language === 'python') { -%>
+API_BASE_URL="${API_BASE_URL}" python -m pytest tests/api/
+<% } else { -%>
+# Default: vitest supertest suite. For a Postman collection use:
+#   newman run tests/api/postman.collection.json --env-var baseUrl="${API_BASE_URL}"
+API_BASE_URL="${API_BASE_URL}" npx vitest run tests/api/
+<% } -%>

package/dist/templates/api-e2e/ts-supertest.test.ts.ejs

@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: Apache-2.0
+// Live-API e2e (INV-126): runs against the REAL booted server, no mocks.
+// Set API_BASE_URL to the booted binary's address (tests/api/run.sh does this).
+import { describe, it, expect } from 'vitest'
+import request from 'supertest'
+
+const BASE_URL = process.env.API_BASE_URL ?? 'http://127.0.0.1:8080'
+
+describe('live API e2e (non-mocked)', () => {
+  it('GET /health returns 200 from the running binary', async () => {
+    const res = await request(BASE_URL).get('/health')
+    expect(res.status).toBe(200)
+  })
+
+  // Add real request/response assertions that exercise the live HTTP surface.
+  // This is the layer that catches "domain green, HTTP wiring broken" bugs:
+  // e.g. a field present in the domain/DB but never wired into the input struct.
+})

package/dist/templates/archunit/AntiCyclicTest.java.ejs

@@ -0,0 +1,29 @@
+package <%= basePackage ? basePackage + '.architecture' : 'architecture' %>;
+
+import com.tngtech.archunit.core.importer.ImportOption;
+import com.tngtech.archunit.junit.AnalyzeClasses;
+import com.tngtech.archunit.junit.ArchTest;
+import com.tngtech.archunit.lang.ArchRule;
+import com.tngtech.archunit.library.dependencies.SlicesRuleDefinition;
+
+/**
+ * Anti-cyclic dependency enforcement — generated by arbiter (M22, hexagonal).
+ *
+ * No package slice may participate in a cyclic dependency with another slice.
+ * Cycles prevent modular decomposition and make incremental builds unreliable.
+ *
+ * Generated by arbiter. Edit the template to change enforcement.
+ */
+@AnalyzeClasses(
+    packages = "<%= basePackage ? basePackage : '' %>",
+    importOptions = ImportOption.DoNotIncludeTests.class
+)
+public class AntiCyclicTest {
+
+    @ArchTest
+    public static final ArchRule no_cycles_between_slices =
+        SlicesRuleDefinition.slices()
+            .matching("<%= basePackage ? basePackage + '.(*)..': '(*)...' %>")
+            .should().beFreeOfCycles()
+            .because("Cyclic dependencies between packages break modular architecture and complicate testing.");
+}

package/dist/templates/archunit/AntiProformaExempt.java.ejs

@@ -0,0 +1,35 @@
+package <%= basePackage ? basePackage + '.architecture' : 'architecture' %>;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Exempts a @Test method from the anti-proforma gate (AntiProformaTest, INV-118).
+ *
+ * Use when the test intentionally has no assertion (e.g., tests that only verify
+ * that code does not throw, rely on framework assertions via @Test(expected=...),
+ * or are placeholder tests pending implementation).
+ *
+ * Requires CLASS retention (not SOURCE) so ArchUnit can detect via bytecode.
+ *
+ * Example:
+ *   @Test
+ *   @AntiProformaExempt("verifies no exception thrown — contract defined externally")
+ *   void no_exception_on_valid_input() {
+ *       service.process(VALID_PAYLOAD);
+ *   }
+ *
+ * Generated by arbiter (#1249). Edit the template to change enforcement.
+ */
+@Retention(RetentionPolicy.CLASS)
+@Target(ElementType.METHOD)
+public @interface AntiProformaExempt {
+
+    /**
+     * Rationale for exempting this test from the anti-proforma gate.
+     * Must be a non-empty descriptive string.
+     */
+    String value();
+}

package/dist/templates/archunit/AntiProformaTest.java.ejs

@@ -0,0 +1,104 @@
+package <%= basePackage ? basePackage + '.architecture' : 'architecture' %>;
+
+import com.tngtech.archunit.core.domain.JavaClass;
+import com.tngtech.archunit.core.domain.JavaMethod;
+import com.tngtech.archunit.core.importer.ClassFileImporter;
+import com.tngtech.archunit.core.importer.ImportOption;
+import com.tngtech.archunit.junit.AnalyzeClasses;
+import com.tngtech.archunit.junit.ArchTest;
+import com.tngtech.archunit.lang.ArchCondition;
+import com.tngtech.archunit.lang.ArchRule;
+import com.tngtech.archunit.lang.ConditionEvents;
+import com.tngtech.archunit.lang.SimpleConditionEvent;
+
+import org.assertj.core.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import java.util.Set;
+
+import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.methods;
+
+/**
+ * Anti-proforma test gate — enforces that every @Test method contains at least
+ * one real assertion (INV-118, §R-41).
+ *
+ * Detects proforma tests: test methods that do not call any recognized assertion
+ * class (AssertJ, JUnit5 Assertions, Mockito verify, REST Assured, MockMvc).
+ *
+ * Bypass: annotate the method with @AntiProformaExempt("rationale"). Requires
+ * CLASS retention so ArchUnit can detect via bytecode.
+ *
+ * Generated by arbiter (#1249). Edit the template to change enforcement.
+ */
+@AnalyzeClasses(
+    packages = "<%= basePackage ? basePackage : '' %>",
+    importOptions = ImportOption.OnlyIncludeTests.class
+)
+public class AntiProformaTest {
+
+    /** Recognized assertion class name fragments (bytecode-level). */
+    private static final Set<String> ASSERTION_CLASS_FRAGMENTS = Set.of(
+        "org.assertj.core.api",
+        "org.junit.jupiter.api.Assertions",
+        "org.mockito.Mockito",
+        "io.restassured",
+        "org.springframework.test.web.servlet.result"
+    );
+
+    private static final ArchCondition<JavaMethod> HAVE_REAL_ASSERTION =
+        new ArchCondition<>("have at least one real assertion or be exempt") {
+
+            @Override
+            public void check(JavaMethod method, ConditionEvents events) {
+                // Skip if annotated with @AntiProformaExempt
+                if (method.isAnnotatedWith(AntiProformaExempt.class)) {
+                    return;
+                }
+
+                boolean hasAssertion = method.getMethodCallsFromSelf().stream()
+                    .anyMatch(call -> ASSERTION_CLASS_FRAGMENTS.stream()
+                        .anyMatch(fragment -> call.getTargetOwner().getFullName().startsWith(fragment)));
+
+                if (!hasAssertion) {
+                    // One-hop transitive check: look for helper method calls in same class
+                    boolean hasTransitiveAssertion = method.getMethodCallsFromSelf().stream()
+                        .filter(call -> call.getTargetOwner().equals(method.getOwner()))
+                        .flatMap(call -> {
+                            try {
+                                return call.getTargetOwner().getMethods().stream()
+                                    .filter(m -> m.getName().equals(call.getName()))
+                                    .flatMap(m -> m.getMethodCallsFromSelf().stream());
+                            } catch (Exception e) {
+                                return java.util.stream.Stream.empty();
+                            }
+                        })
+                        .anyMatch(call -> ASSERTION_CLASS_FRAGMENTS.stream()
+                            .anyMatch(fragment -> call.getTargetOwner().getFullName().startsWith(fragment)));
+
+                    if (!hasTransitiveAssertion) {
+                        events.add(SimpleConditionEvent.violated(
+                            method,
+                            String.format(
+                                "Method %s in %s has no recognized assertion. " +
+                                "Add an assertion or annotate with @AntiProformaExempt(\"rationale\").",
+                                method.getName(),
+                                method.getOwner().getFullName()
+                            )
+                        ));
+                    }
+                }
+            }
+        };
+
+    @ArchTest
+    public static final ArchRule test_methods_must_have_assertions =
+        methods()
+            .that().areAnnotatedWith(Test.class)
+            .or().areAnnotatedWith("org.junit.jupiter.params.ParameterizedTest")
+            .or().areAnnotatedWith("org.junit.jupiter.api.RepeatedTest")
+            .should(HAVE_REAL_ASSERTION)
+            .because(
+                "Proforma tests (tests without assertions) provide false confidence — " +
+                "they always pass regardless of what the code under test does (INV-118, §R-41)."
+            );
+}

package/dist/templates/archunit/ArchitectureTest.java.ejs

@@ -0,0 +1,87 @@
+package <%= basePackage ? basePackage + '.architecture' : 'architecture' %>;
+
+import com.tngtech.archunit.core.importer.ImportOption;
+import com.tngtech.archunit.junit.AnalyzeClasses;
+import com.tngtech.archunit.junit.ArchTest;
+import com.tngtech.archunit.lang.ArchRule;
+
+import org.junit.jupiter.api.Test;
+import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.noClasses;
+
+/**
+ * Architecture style enforcement — generated by arbiter for architectureStyle: <%= architectureStyle %>.
+ *
+ * Do not edit — update the arbiter template or re-run `arbiter init` to change enforcement.
+ * See docs/ADR/021-archetype-axis.md for the policy behind architecture-style gating.
+ */
+@AnalyzeClasses(
+    packages = "<%= basePackage ? basePackage : '' %>",
+    importOptions = ImportOption.DoNotIncludeTests.class
+)
+public class ArchitectureTest {
+
+<% if (architectureStyle === 'hexagonal') { %>
+    /**
+     * Hexagonal (ports-and-adapters) rules.
+     * Domain layer must not depend on infrastructure or adapter packages.
+     */
+    @ArchTest
+    public static final ArchRule domain_must_not_depend_on_infrastructure =
+        noClasses()
+            .that().resideInAPackage("<%= basePackage ? basePackage + '.domain..' : 'domain..' %>")
+            .should().dependOnClassesThat()
+            .resideInAnyPackage(
+                "<%= basePackage ? basePackage + '.infrastructure..' : 'infrastructure..' %>",
+                "<%= basePackage ? basePackage + '.adapter..' : 'adapter..' %>"
+            )
+            .because("Domain layer must not depend on infrastructure or adapters (hexagonal architecture).");
+
+    @ArchTest
+    public static final ArchRule adapters_must_not_depend_on_each_other =
+        noClasses()
+            .that().resideInAPackage("<%= basePackage ? basePackage + '.adapter..' : 'adapter..' %>")
+            .should().dependOnClassesThat()
+            .resideInAPackage("<%= basePackage ? basePackage + '.adapter..' : 'adapter..' %>")
+            .because("Adapters must be independent — they communicate only through domain ports.");
+<% } else if (architectureStyle === 'layered') { %>
+    /**
+     * Layered architecture rules.
+     * Direction: controller → service → repository. No upward dependencies allowed.
+     */
+    @ArchTest
+    public static final ArchRule repositories_must_not_depend_on_services =
+        noClasses()
+            .that().resideInAPackage("<%= basePackage ? basePackage + '.repository..' : 'repository..' %>")
+            .should().dependOnClassesThat()
+            .resideInAPackage("<%= basePackage ? basePackage + '.service..' : 'service..' %>")
+            .because("Repository layer must not depend on service layer (layered architecture).");
+
+    @ArchTest
+    public static final ArchRule services_must_not_depend_on_controllers =
+        noClasses()
+            .that().resideInAPackage("<%= basePackage ? basePackage + '.service..' : 'service..' %>")
+            .should().dependOnClassesThat()
+            .resideInAPackage("<%= basePackage ? basePackage + '.controller..' : 'controller..' %>")
+            .because("Service layer must not depend on controller layer (layered architecture).");
+<% } else if (architectureStyle === 'modular-monolith') { %>
+    /**
+     * Modular-monolith rules.
+     * Modules must communicate only through their public API packages.
+     * Cross-module imports of internal packages are forbidden.
+     */
+    @ArchTest
+    public static final ArchRule no_cross_module_internal_access =
+        noClasses()
+            .that().resideOutsideOfPackage("<%= basePackage ? basePackage + '.modules.[^.]+.internal..' : 'modules.[^.]+.internal..' %>")
+            .should().accessClassesThat()
+            .resideInAPackage("<%= basePackage ? basePackage + '.modules.[^.]+.internal..' : 'modules.[^.]+.internal..' %>")
+            .because("Module internal packages are private — access only through the module's public API package.");
+<% } else { %>
+    @Test
+    public void architecture_style_unknown() {
+        org.junit.jupiter.api.Assertions.fail(
+            "Unknown architectureStyle '<%= architectureStyle %>'. Re-run `arbiter init` and select: hexagonal, layered, or modular-monolith."
+        );
+    }
+<% } %>
+}

package/dist/templates/archunit/DependencyFlowTest.java.ejs

@@ -0,0 +1,55 @@
+package <%= basePackage ? basePackage + '.architecture' : 'architecture' %>;
+
+import com.tngtech.archunit.core.importer.ImportOption;
+import com.tngtech.archunit.junit.AnalyzeClasses;
+import com.tngtech.archunit.junit.ArchTest;
+import com.tngtech.archunit.lang.ArchRule;
+
+import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.noClasses;
+
+/**
+ * Dependency flow enforcement — generated by arbiter (M22, hexagonal).
+ *
+ * Enforces the inward dependency rule: adapters → application → domain.
+ * No layer may depend on a layer further out in the ring.
+ *
+ * Generated by arbiter. Edit the template to change enforcement.
+ */
+@AnalyzeClasses(
+    packages = "<%= basePackage ? basePackage : '' %>",
+    importOptions = ImportOption.DoNotIncludeTests.class
+)
+public class DependencyFlowTest {
+
+    @ArchTest
+    public static final ArchRule adapters_must_not_depend_on_domain_directly =
+        noClasses()
+            .that().resideInAPackage("<%= basePackage ? basePackage + '.adapter..' : 'adapter..' %>")
+            .should().dependOnClassesThat()
+            .resideInAPackage("<%= basePackage ? basePackage + '.domain..' : 'domain..' %>")
+            .because("Adapters must communicate with the domain only through application ports, not directly.");
+
+    @ArchTest
+    public static final ArchRule application_must_not_depend_on_adapters =
+        noClasses()
+            .that().resideInAPackage("<%= basePackage ? basePackage + '.application..' : 'application..' %>")
+            .should().dependOnClassesThat()
+            .resideInAPackage("<%= basePackage ? basePackage + '.adapter..' : 'adapter..' %>")
+            .because("Application layer must not depend on adapters (dependency inversion principle).");
+
+    @ArchTest
+    public static final ArchRule domain_must_not_depend_on_application =
+        noClasses()
+            .that().resideInAPackage("<%= basePackage ? basePackage + '.domain..' : 'domain..' %>")
+            .should().dependOnClassesThat()
+            .resideInAPackage("<%= basePackage ? basePackage + '.application..' : 'application..' %>")
+            .because("Domain layer must be self-contained: no dependency on application layer.");
+
+    @ArchTest
+    public static final ArchRule domain_must_not_depend_on_infrastructure =
+        noClasses()
+            .that().resideInAPackage("<%= basePackage ? basePackage + '.domain..' : 'domain..' %>")
+            .should().dependOnClassesThat()
+            .resideInAPackage("<%= basePackage ? basePackage + '.infrastructure..' : 'infrastructure..' %>")
+            .because("Domain layer must not depend on infrastructure: keep domain portable.");
+}

package/dist/templates/archunit/DomainPurityTest.java.ejs

@@ -0,0 +1,47 @@
+package <%= basePackage ? basePackage + '.architecture' : 'architecture' %>;
+
+import com.tngtech.archunit.core.importer.ImportOption;
+import com.tngtech.archunit.junit.AnalyzeClasses;
+import com.tngtech.archunit.junit.ArchTest;
+import com.tngtech.archunit.lang.ArchRule;
+
+import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.noClasses;
+
+/**
+ * Domain purity enforcement — generated by arbiter (M22, hexagonal).
+ *
+ * The domain layer must be framework-free: no Spring, Jakarta EE, JPA, or Hibernate
+ * imports allowed. Domain objects are plain Java — no annotations, no coupling to
+ * persistence or web frameworks.
+ *
+ * Generated by arbiter. Edit the template to change enforcement.
+ */
+@AnalyzeClasses(
+    packages = "<%= basePackage ? basePackage : '' %>",
+    importOptions = ImportOption.DoNotIncludeTests.class
+)
+public class DomainPurityTest {
+
+    @ArchTest
+    public static final ArchRule domain_must_not_import_spring =
+        noClasses()
+            .that().resideInAPackage("<%= basePackage ? basePackage + '.domain..' : 'domain..' %>")
+            .should().dependOnClassesThat()
+            .resideInAnyPackage(
+                "org.springframework..",
+                "org.springframework.data.."
+            )
+            .because("Domain layer must be framework-free: no Spring imports allowed.");
+
+    @ArchTest
+    public static final ArchRule domain_must_not_import_jpa =
+        noClasses()
+            .that().resideInAPackage("<%= basePackage ? basePackage + '.domain..' : 'domain..' %>")
+            .should().dependOnClassesThat()
+            .resideInAnyPackage(
+                "jakarta.persistence..",
+                "javax.persistence..",
+                "org.hibernate.."
+            )
+            .because("Domain layer must be framework-free: no JPA/Hibernate imports allowed.");
+}

package/dist/templates/archunit/NamingConventionsTest.java.ejs

@@ -0,0 +1,54 @@
+package <%= basePackage ? basePackage + '.architecture' : 'architecture' %>;
+
+import com.tngtech.archunit.core.importer.ImportOption;
+import com.tngtech.archunit.junit.AnalyzeClasses;
+import com.tngtech.archunit.junit.ArchTest;
+import com.tngtech.archunit.lang.ArchRule;
+
+import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.classes;
+
+/**
+ * Naming conventions enforcement — generated by arbiter (M22, hexagonal).
+ *
+ * Enforces standard naming suffixes for the four core hexagonal stereotypes:
+ * Services, Repositories, Controllers, and Ports.
+ *
+ * Generated by arbiter. Edit the template to change enforcement.
+ */
+@AnalyzeClasses(
+    packages = "<%= basePackage ? basePackage : '' %>",
+    importOptions = ImportOption.DoNotIncludeTests.class
+)
+public class NamingConventionsTest {
+
+    @ArchTest
+    public static final ArchRule services_should_end_with_service =
+        classes()
+            .that().resideInAPackage("<%= basePackage ? basePackage + '.application..' : 'application..' %>")
+            .and().areAnnotatedWith("org.springframework.stereotype.Service")
+            .should().haveSimpleNameEndingWith("Service")
+            .because("Service classes must be named consistently to aid discovery and navigation.");
+
+    @ArchTest
+    public static final ArchRule repositories_should_end_with_repository =
+        classes()
+            .that().areAssignableTo(org.springframework.data.repository.Repository.class)
+            .should().haveSimpleNameEndingWith("Repository")
+            .because("Repository classes must be named consistently to distinguish them from domain objects.");
+
+    @ArchTest
+    public static final ArchRule controllers_should_end_with_controller =
+        classes()
+            .that().resideInAPackage("<%= basePackage ? basePackage + '.adapter.in..' : 'adapter.in..' %>")
+            .and().areAnnotatedWith("org.springframework.web.bind.annotation.RestController")
+            .should().haveSimpleNameEndingWith("Controller")
+            .because("Controller classes must be named consistently to separate concerns in the adapter layer.");
+
+    @ArchTest
+    public static final ArchRule ports_should_end_with_port =
+        classes()
+            .that().resideInAPackage("<%= basePackage ? basePackage + '.application.port..' : 'application.port..' %>")
+            .and().areInterfaces()
+            .should().haveSimpleNameEndingWith("Port")
+            .because("Port interfaces define the boundary of the application; naming them *Port makes the intent explicit.");
+}

package/dist/templates/archunit/NoH2ArchTest.java.ejs

@@ -0,0 +1,30 @@
+package <%= basePackage ? basePackage + '.architecture' : 'architecture' %>;
+
+import com.tngtech.archunit.core.importer.ImportOption;
+import com.tngtech.archunit.junit.AnalyzeClasses;
+import com.tngtech.archunit.junit.ArchTest;
+import com.tngtech.archunit.lang.ArchRule;
+
+import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.noClasses;
+
+/**
+ * H2 in-production enforcement — generated by arbiter (M22, hexagonal).
+ *
+ * H2 is an in-memory database appropriate only for tests. Production code
+ * must not import H2 classes, preventing accidental in-memory persistence.
+ *
+ * Generated by arbiter. Edit the template to change enforcement.
+ */
+@AnalyzeClasses(
+    packages = "<%= basePackage ? basePackage : '' %>",
+    importOptions = ImportOption.DoNotIncludeTests.class
+)
+public class NoH2ArchTest {
+
+    @ArchTest
+    public static final ArchRule no_h2_imports_in_production_code =
+        noClasses()
+            .should().dependOnClassesThat()
+            .resideInAPackage("org.h2..")
+            .because("H2 is a test-only in-memory database. Production code must use a real datasource (PostgreSQL, MySQL, etc.).");
+}

package/dist/templates/archunit/NoMockMvcTest.java.ejs

@@ -0,0 +1,71 @@
+package <%= basePackage ? basePackage + '.architecture' : 'architecture' %>;
+
+import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.noClasses;
+
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+
+import com.tngtech.archunit.core.importer.ClassFileImporter;
+import com.tngtech.archunit.core.importer.ImportOption;
+import com.tngtech.archunit.junit.AnalyzeClasses;
+import com.tngtech.archunit.junit.ArchTest;
+import com.tngtech.archunit.lang.ArchRule;
+import org.junit.jupiter.api.Test;
+
+/**
+ * ArchUnit enforcement of INV-29: No MockMvc — use RestAssured for integration tests.
+ *
+ * <p>MockMvc tests the controller layer through a mock servlet container, bypassing real HTTP
+ * serialization, filter chains, exception handlers, and content negotiation. Use RestAssured with a
+ * real embedded server instead.
+ *
+ * <p>Generated by arbiter. Do not edit — update the arbiter template to change enforcement.
+ */
+<%_
+  // google-java-format (AOSP) is canonical: it joins this annotation onto one
+  // line when it fits the 100-column limit and splits it (8-space continuation)
+  // otherwise. Reproduce that decision here so the emitted file passes
+  // spotlessCheck verbatim for ANY basePackage length.
+  const analyzeOneLine = `@AnalyzeClasses(packages = "${basePackage || ''}", importOptions = ImportOption.DoNotIncludeTests.class)`;
+_%>
+<%_ if (analyzeOneLine.length <= 100) { _%>
+<%- analyzeOneLine %>
+<%_ } else { _%>
+@AnalyzeClasses(
+        packages = "<%= basePackage ? basePackage : '' %>",
+        importOptions = ImportOption.DoNotIncludeTests.class)
+<%_ } _%>
+class NoMockMvcTest {
+
+    @ArchTest
+    public static final ArchRule no_mockmvc_in_production_code =
+            noClasses()
+                    .should()
+                    .dependOnClassesThat()
+                    .resideInAPackage("org.springframework.test.web.servlet..")
+                    .because(
+                            "MockMvc is forbidden (INV-29). Use RestAssured with @SpringBootTest(webEnvironment=RANDOM_PORT) instead.");
+
+    @ArchTest
+    public static final ArchRule no_auto_configure_mockmvc =
+            noClasses()
+                    .should()
+                    .beAnnotatedWith(
+                            "org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc")
+                    .because(
+                            "@AutoConfigureMockMvc is forbidden (INV-29). Use @SpringBootTest(webEnvironment=RANDOM_PORT) with RestAssured instead.");
+
+    @Test
+    void production_code_avoids_mockmvc() {
+        var productionClasses =
+                new ClassFileImporter()
+                        .withImportOption(new ImportOption.DoNotIncludeTests())
+                        .importPackages("<%= basePackage ? basePackage : '' %>");
+
+        assertDoesNotThrow(
+                () -> {
+                    no_mockmvc_in_production_code.check(productionClasses);
+                    no_auto_configure_mockmvc.check(productionClasses);
+                },
+                "production code must comply with the No MockMvc architecture rules");
+    }
+}