[PR] docs: create AGENTS.md for AI LLM crawlers [grails-core]

["sanjana2505006 (via GitHub)" <gi...@apache.org>]

sanjana2505006 opened a new pull request, #15340:
URL: https://github.com/apache/grails-core/pull/15340

   Created AGENTS.md with instructions for LLMs on licence headers, project structure, and coding principles, as requested in fixes #15145.


-- 
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

To unsubscribe, e-mail: notifications-unsubscribe@grails.apache.org

For queries about this service, please contact Infrastructure at:
users@infra.apache.org

Re: [PR] Add AGENTS.md and AI coding assistant support [grails-core]

["matrei (via GitHub)" <gi...@apache.org>]

matrei commented on code in PR #15340:
URL: https://github.com/apache/grails-core/pull/15340#discussion_r2740435319


##########
.agents/skills/grails-developer/SKILL.md:
##########
@@ -0,0 +1,883 @@
+<!--
+SPDX-License-Identifier: Apache-2.0
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+---
+name: grails-developer
+description: Comprehensive guide for Grails 7 development, covering web applications, REST APIs, GORM, controllers, services, views, plugins, and testing with Spock and Geb
+license: Apache-2.0
+compatibility: opencode, claude, grok, gemini, copilot, cursor, windsurf
+metadata:
+  audience: developers
+  frameworks: grails
+  versions: 7
+---
+
+## What I Do
+
+- Provide detailed guidance for building Grails 7 web applications and REST APIs.
+- Assist with GORM for data modeling, controllers for request handling, services for business logic, and views (GSP, JSON, Markup).
+- Support testing with Spock 2.3 (unit/integration tests) and Geb for browser automation.
+- Guide plugin usage and development, security implementation, and deployment strategies.
+- Help with configuration, internationalization, async programming, and performance optimization.
+
+## When to Use Me
+
+Activate this skill when developing with Grails 7, including:
+
+- Building CRUD applications, RESTful APIs, or full-stack web applications.
+- Working with GORM domain classes, constraints, and relationships.
+- Creating controllers, services, interceptors, or tag libraries.
+- Writing Spock specifications or Geb functional tests.
+- Configuring plugins, security, caching, or database migrations.
+- Deploying Grails applications to containers or cloud platforms.
+
+## Technology Stack
+
+Grails 7 is built on:
+- **Spring Boot**: 3.5.x
+- **Spring Framework**: 6.2.x
+- **Groovy**: 4.0.x
+- **Gradle**: 8.14.x
+- **Spock**: 2.3-groovy-4.0
+- **Jakarta EE**: 10 (migrated from javax.*)
+- **Micronaut**: Optional via `grails-micronaut` plugin
+
+## Project Structure
+
+```
+myapp/
+├── grails-app/
+│   ├── conf/                 # Configuration
+│   │   ├── application.yml   # Main config
+│   │   ├── logback.xml       # Logging config
+│   │   └── spring/           # Spring bean definitions

Review Comment:
   `spring/resources.groovy`?



##########
.agents/skills/grails-developer/SKILL.md:
##########
@@ -0,0 +1,883 @@
+<!--
+SPDX-License-Identifier: Apache-2.0
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+---
+name: grails-developer
+description: Comprehensive guide for Grails 7 development, covering web applications, REST APIs, GORM, controllers, services, views, plugins, and testing with Spock and Geb
+license: Apache-2.0
+compatibility: opencode, claude, grok, gemini, copilot, cursor, windsurf
+metadata:
+  audience: developers
+  frameworks: grails
+  versions: 7
+---
+
+## What I Do
+
+- Provide detailed guidance for building Grails 7 web applications and REST APIs.
+- Assist with GORM for data modeling, controllers for request handling, services for business logic, and views (GSP, JSON, Markup).
+- Support testing with Spock 2.3 (unit/integration tests) and Geb for browser automation.
+- Guide plugin usage and development, security implementation, and deployment strategies.
+- Help with configuration, internationalization, async programming, and performance optimization.
+
+## When to Use Me
+
+Activate this skill when developing with Grails 7, including:
+
+- Building CRUD applications, RESTful APIs, or full-stack web applications.
+- Working with GORM domain classes, constraints, and relationships.
+- Creating controllers, services, interceptors, or tag libraries.
+- Writing Spock specifications or Geb functional tests.
+- Configuring plugins, security, caching, or database migrations.
+- Deploying Grails applications to containers or cloud platforms.
+
+## Technology Stack
+
+Grails 7 is built on:
+- **Spring Boot**: 3.5.x
+- **Spring Framework**: 6.2.x
+- **Groovy**: 4.0.x
+- **Gradle**: 8.14.x
+- **Spock**: 2.3-groovy-4.0
+- **Jakarta EE**: 10 (migrated from javax.*)
+- **Micronaut**: Optional via `grails-micronaut` plugin
+
+## Project Structure
+
+```
+myapp/
+├── grails-app/
+│   ├── conf/                 # Configuration
+│   │   ├── application.yml   # Main config
+│   │   ├── logback.xml       # Logging config
+│   │   └── spring/           # Spring bean definitions
+│   ├── controllers/          # Request handlers
+│   ├── domain/               # GORM domain classes
+│   ├── i18n/                 # Message bundles
+│   ├── init/                 # Bootstrap classes
+│   ├── services/             # Business logic
+│   ├── taglib/               # Custom GSP tags
+│   ├── utils/                # Utility classes
+│   └── views/                # GSP templates
+├── src/

Review Comment:
   `integration-test/groovy`?



##########
AGENTS.md:
##########
@@ -0,0 +1,260 @@
+<!--
+SPDX-License-Identifier: Apache-2.0
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+
+# Agent Guide for grails-core
+
+> **IMPORTANT**: This is the Grails Framework source repository (60+ modules), NOT a Grails application.
+> For building Grails apps, see `.agents/skills/grails-developer/SKILL.md`.
+
+## Quick Reference
+
+```bash
+# Build (no tests)
+./gradlew build -PskipTests
+
+# Build single module
+./gradlew :grails-core:build
+
+# Run tests
+./gradlew :<module>:test
+./gradlew :<module>:test --tests "com.example.SomeSpec"
+
+# Style check
+./gradlew codeStyle
+
+# Out of memory? Set:
+export GRADLE_OPTS="-Xms2G -Xmx5G"
+```
+
+## Critical Rules
+
+1. **Use `jakarta.*` NOT `javax.*`** - All packages migrated to Jakarta EE 10
+2. **Use `@GrailsCompileStatic`** - Not plain `@CompileStatic` in Grails classes
+3. **Use `GrailsWebRequest.lookup()`** - For thread-safe request context in tests
+4. **No wildcard imports** - Use explicit imports
+5. **4 spaces, no tabs** - See `.editorconfig`
+6. **Apache license header** - Required on all new source files
+
+## Available Skills
+
+> **AI AGENTS - MANDATORY**: Before writing or modifying any code, you **MUST** read the relevant skill file(s) below. Do not write Groovy/Grails code without first loading these instructions:
+> - Writing Grails code → Read `.agents/skills/grails-developer/SKILL.md`
+> - Writing Groovy code → Read `.agents/skills/groovy-developer/SKILL.md`
+> - Writing Java code → Read `.agents/skills/java-developer/SKILL.md`
+>
+> Use your file reading capability to load the skill content before proceeding with any code changes.
+
+| Skill | Path | Use For |
+|-------|------|---------|
+| **grails-developer** | `.agents/skills/grails-developer/SKILL.md` | Grails 7 apps, GORM, controllers, views |
+| **groovy-developer** | `.agents/skills/groovy-developer/SKILL.md` | Groovy 4 syntax, closures, DSLs, Spock |
+| **java-developer** | `.agents/skills/java-developer/SKILL.md` | Java 17 features, Groovy interop |
+
+## Technology Stack
+
+| Component | Version |
+|-----------|---------|
+| JDK | 17+ (baseline 17) |
+| Groovy | 4.0.x |
+| Spring Boot | 3.5.x |
+| Spring Framework | 6.2.x |
+| Spock | 2.3-groovy-4.0 |
+| Gradle | 8.14.x |
+| Jakarta EE | 10 |
+
+## Project Structure
+
+This repository contains multiple independent Gradle projects:
+
+| Project | Description | Build Command |
+|---------|-------------|---------------|
+| **grails-core** (root) | Main framework with 60+ modules | `./gradlew build` |
+| **build-logic/** | Gradle convention plugins for the build | `cd build-logic && ../gradlew build` |
+| **grails-gradle/** | Grails Gradle plugins | `cd grails-gradle && ./gradlew build` |
+| **grails-forge/** | Application generator (like Spring Initializr) | `cd grails-forge && ./gradlew build` |
+
+Each project has its own `settings.gradle` and independent build. When working on a specific project, run Gradle commands from that project's directory.
+
+## Key Modules
+
+**Core**: `grails-core`, `grails-bootstrap`, `grails-spring`, `grails-common`
+
+**Web**: `grails-web-core`, `grails-web-mvc`, `grails-controllers`, `grails-url-mappings`, `grails-interceptors`
+
+**GORM**: `grails-datastore-core`, `grails-datamapping-core`, `grails-domain-class`, `grails-validation`, `grails-databinding`
+
+**Views**: `grails-views-core`, `grails-views-gson`, `grails-views-markup`
+
+**Testing**: `grails-testing-support-core`, `grails-testing-support-web`, `grails-geb`
+
+**Other**: `grails-bom` (dependency management), `grails-doc`, `grails-shell-cli`, `grails-forge`
+
+## Artefact Types
+
+| Type | Pattern | Handler |
+|------|---------|---------|
+| Domain | `**/domain/**/*.groovy` | `DomainClassArtefactHandler` |
+| Controller | `**/*Controller.groovy` | `ControllerArtefactHandler` |
+| Service | `**/*Service.groovy` | `ServiceArtefactHandler` |
+| TagLib | `**/*TagLib.groovy` | `TagLibArtefactHandler` |
+| Interceptor | `**/*Interceptor.groovy` | `InterceptorArtefactHandler` |
+
+## Code Patterns
+
+### Spock Test Structure
+```groovy
+class MyServiceSpec extends Specification implements ServiceUnitTest<MyService> {
+    def "feature description"() {
+        given: "preconditions"
+        def input = "test"
+
+        when: "action"
+        def result = service.process(input)
+
+        then: "assertions"
+        result != null
+        result.status == "OK"
+    }
+}
+```
+
+### Mocking
+```groovy
+def repo = Mock(BookRepository)
+1 * repo.save(_) >> savedBook  // expect 1 call, return savedBook
+```
+
+### Data-Driven Tests
+```groovy
+@Unroll
+def "#a + #b == #c"() {
+    expect: a + b == c
+    where:
+    a | b || c
+    1 | 2 || 3
+    4 | 5 || 9
+}
+```
+
+### Framework Access
+```groovy
+// Thread-safe request context
+GrailsWebRequest webRequest = GrailsWebRequest.lookup()
+
+// Artefact registry
+grailsApplication.getArtefacts(DomainClassArtefactHandler.TYPE)
+```
+
+## Groovy Style
+
+```groovy
+// DO: Safe navigation
+book?.author?.name
+
+// DO: Elvis operator
+name ?: 'Unknown'
+
+// DO: GStrings
+"Hello ${user.name}"
+
+// DO: Spread operator
+books*.title
+
+// DO: Static compilation
+@GrailsCompileStatic
+class MyService { }
+
+// DON'T: Wildcard imports
+// import java.util.*  ❌
+
+// DON'T: javax packages
+// import javax.servlet.*  ❌ → use jakarta.servlet.*
+```
+
+## Test Isolation
+
+> **WARNING**: Tests run in parallel (`maxParallelForks > 1`). Static state causes flaky tests.

Review Comment:
   Static state does not cause flaky tests in parallel forks. It is when neglecting to reset the environment and any changed static state in test cleanup, that the next sequential tests (in the same fork) can be affected. 



##########
.agents/skills/grails-developer/SKILL.md:
##########
@@ -0,0 +1,883 @@
+<!--
+SPDX-License-Identifier: Apache-2.0
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+---
+name: grails-developer
+description: Comprehensive guide for Grails 7 development, covering web applications, REST APIs, GORM, controllers, services, views, plugins, and testing with Spock and Geb
+license: Apache-2.0
+compatibility: opencode, claude, grok, gemini, copilot, cursor, windsurf
+metadata:
+  audience: developers
+  frameworks: grails
+  versions: 7
+---
+
+## What I Do
+
+- Provide detailed guidance for building Grails 7 web applications and REST APIs.
+- Assist with GORM for data modeling, controllers for request handling, services for business logic, and views (GSP, JSON, Markup).
+- Support testing with Spock 2.3 (unit/integration tests) and Geb for browser automation.
+- Guide plugin usage and development, security implementation, and deployment strategies.
+- Help with configuration, internationalization, async programming, and performance optimization.
+
+## When to Use Me
+
+Activate this skill when developing with Grails 7, including:
+
+- Building CRUD applications, RESTful APIs, or full-stack web applications.
+- Working with GORM domain classes, constraints, and relationships.
+- Creating controllers, services, interceptors, or tag libraries.
+- Writing Spock specifications or Geb functional tests.
+- Configuring plugins, security, caching, or database migrations.
+- Deploying Grails applications to containers or cloud platforms.
+
+## Technology Stack
+
+Grails 7 is built on:
+- **Spring Boot**: 3.5.x
+- **Spring Framework**: 6.2.x
+- **Groovy**: 4.0.x
+- **Gradle**: 8.14.x
+- **Spock**: 2.3-groovy-4.0
+- **Jakarta EE**: 10 (migrated from javax.*)
+- **Micronaut**: Optional via `grails-micronaut` plugin
+
+## Project Structure
+
+```
+myapp/
+├── grails-app/
+│   ├── conf/                 # Configuration
+│   │   ├── application.yml   # Main config
+│   │   ├── logback.xml       # Logging config
+│   │   └── spring/           # Spring bean definitions
+│   ├── controllers/          # Request handlers
+│   ├── domain/               # GORM domain classes
+│   ├── i18n/                 # Message bundles
+│   ├── init/                 # Bootstrap classes
+│   ├── services/             # Business logic
+│   ├── taglib/               # Custom GSP tags
+│   ├── utils/                # Utility classes
+│   └── views/                # GSP templates
+├── src/
+│   ├── main/groovy/          # Additional Groovy classes
+│   ├── main/java/            # Java classes
+│   └── test/groovy/          # Test specifications
+├── build.gradle              # Build configuration
+└── gradle.properties         # Project properties
+```
+
+## Domain Classes (GORM)
+
+### Basic Domain Class
+```groovy
+class Book {
+    String title
+    String author
+    Date datePublished
+    Integer pages
+
+    static constraints = {
+        title blank: false, maxSize: 255
+        author blank: false
+        datePublished nullable: true
+        pages min: 1, nullable: true
+    }
+
+    static mapping = {
+        table 'books'
+        title column: 'book_title'
+        datePublished type: 'date'
+    }
+}
+```
+
+### Relationships
+```groovy
+class Author {
+    String name
+
+    static hasMany = [books: Book]
+
+    static mapping = {
+        books cascade: 'all-delete-orphan'
+    }
+}
+
+class Book {
+    String title
+
+    static belongsTo = [author: Author]
+}
+
+// Many-to-Many
+class Book {
+    static hasMany = [categories: Category]
+    static belongsTo = Category
+}
+
+class Category {
+    String name
+    static hasMany = [books: Book]
+}
+```
+
+### GORM Queries
+```groovy
+// Dynamic finders
+Book.findByTitle("Grails Guide")
+Book.findAllByAuthorLike("%Smith%")
+Book.findByTitleAndAuthor("Guide", "Smith")
+Book.countByPagesGreaterThan(100)
+
+// Where queries
+Book.where {
+    title =~ "%Grails%" && pages > 100
+}.list()
+
+// Criteria queries
+Book.withCriteria {
+    like('title', '%Grails%')
+    gt('pages', 100)
+    order('datePublished', 'desc')
+    maxResults(10)
+}
+
+// HQL queries
+Book.executeQuery(
+    "from Book b where b.author.name = :name",
+    [name: 'Smith']
+)
+
+// Detached criteria (reusable)
+def criteria = Book.where {
+    pages > 100
+}
+criteria.list()
+criteria.count()
+```
+
+### Transactions
+```groovy
+// In services (default transactional)
+@Transactional
+class BookService {
+    def saveBook(Book book) {
+        book.save(failOnError: true)
+    }
+}
+
+// Manual transaction control
+Book.withTransaction { status ->
+    def book = new Book(title: "Test")
+    book.save()
+    if (someCondition) {
+        status.setRollbackOnly()
+    }
+}
+```
+
+## Controllers
+
+### Basic Controller
+```groovy
+class BookController {
+
+    BookService bookService
+
+    static allowedMethods = [save: 'POST', update: 'PUT', delete: 'DELETE']
+
+    def index() {
+        respond Book.list(), model: [bookCount: Book.count()]
+    }
+
+    def show(Long id) {
+        respond Book.get(id)
+    }
+
+    def create() {
+        respond new Book(params)
+    }
+
+    def save(Book book) {
+        if (book.hasErrors()) {
+            respond book.errors, view: 'create'
+            return
+        }
+        bookService.save(book)
+        redirect action: 'show', id: book.id
+    }
+
+    def edit(Long id) {
+        respond Book.get(id)
+    }
+
+    def update(Book book) {
+        if (book.hasErrors()) {
+            respond book.errors, view: 'edit'
+            return
+        }
+        bookService.save(book)
+        redirect action: 'show', id: book.id
+    }
+
+    def delete(Long id) {
+        bookService.delete(id)
+        redirect action: 'index'
+    }
+}
+```
+
+### REST Controller
+```groovy
+import grails.rest.RestfulController
+
+class BookController extends RestfulController<Book> {
+
+    static responseFormats = ['json', 'xml']
+
+    BookController() {
+        super(Book)
+    }
+
+    // Override to customize
+    @Override
+    protected Book queryForResource(Serializable id) {
+        Book.where { id == id && active == true }.find()
+    }
+}
+```
+
+### Command Objects
+```groovy
+class BookCommand implements Validateable {
+    String title
+    String author
+    Integer pages
+
+    static constraints = {
+        title blank: false
+        author blank: false
+        pages min: 1, nullable: true
+    }
+}
+
+class BookController {
+    def save(BookCommand cmd) {
+        if (cmd.hasErrors()) {
+            respond cmd.errors
+            return
+        }
+        // Process valid command
+    }
+}
+```
+
+### Content Negotiation
+```groovy
+class BookController {
+    def show(Long id) {
+        def book = Book.get(id)
+        respond book  // Auto-negotiates based on Accept header
+    }
+}
+
+// Or explicit
+def show(Long id) {
+    def book = Book.get(id)
+    withFormat {
+        html { render view: 'show', model: [book: book] }
+        json { render book as JSON }
+        xml { render book as XML }
+    }
+}
+```
+
+## Services
+
+### Basic Service
+```groovy
+import grails.gorm.transactions.Transactional
+
+@Transactional
+class BookService {
+
+    def findByTitle(String title) {
+        Book.findByTitle(title)
+    }
+
+    def save(Book book) {
+        book.save(failOnError: true)
+    }
+
+    @Transactional(readOnly = true)
+    def list(Map params) {
+        Book.list(params)
+    }
+
+    def delete(Long id) {
+        Book.get(id)?.delete()
+    }
+}
+```
+
+### Service with Events
+```groovy
+import grails.events.annotation.Publisher
+import grails.events.annotation.Subscriber
+
+class BookService {
+
+    @Publisher
+    def save(Book book) {
+        book.save()
+        // Automatically publishes 'book.saved' event
+    }
+}
+
+class NotificationService {
+
+    @Subscriber('book.saved')
+    def onBookSaved(Book book) {
+        // Handle event
+        log.info "Book saved: ${book.title}"
+    }
+}
+```
+
+### Async Service
+```groovy
+import grails.async.Promise
+import static grails.async.Promises.*
+
+class BookService {
+
+    Promise<Book> findAsync(Long id) {
+        task {
+            Book.get(id)
+        }
+    }
+
+    def processBooks() {
+        def p1 = task { Book.findAllByActive(true) }
+        def p2 = task { Author.list() }
+
+        waitAll(p1, p2)
+        // Both complete
+    }
+}
+```
+
+## Views
+
+### GSP (Groovy Server Pages)
+```html
+<!-- grails-app/views/book/list.gsp -->
+<!DOCTYPE html>
+<html>
+<head>
+    <title>Books</title>
+    <asset:stylesheet src="application.css"/>
+</head>
+<body>
+    <h1>Books (${bookCount})</h1>
+
+    <g:each in="${bookList}" var="book">
+        <div class="book">
+            <h2>${book.title}</h2>
+            <p>By ${book.author}</p>
+            <g:link action="show" id="${book.id}">View</g:link>
+        </div>
+    </g:each>
+
+    <g:if test="${bookList.empty}">
+        <p>No books found.</p>
+    </g:if>
+
+    <g:paginate total="${bookCount}"/>
+
+    <asset:javascript src="application.js"/>
+</body>
+</html>
+```
+
+### Common GSP Tags
+```html
+<!-- Links -->
+<g:link controller="book" action="show" id="${book.id}">View</g:link>
+<g:createLink action="list"/>
+
+<!-- Forms -->
+<g:form action="save">
+    <g:textField name="title" value="${book?.title}"/>
+    <g:textArea name="description" value="${book?.description}"/>
+    <g:select name="category" from="${categories}" optionKey="id" optionValue="name"/>
+    <g:checkBox name="active" value="${book?.active}"/>
+    <g:submitButton name="submit" value="Save"/>
+</g:form>
+
+<!-- Conditionals -->
+<g:if test="${condition}">...</g:if>
+<g:elseif test="${other}">...</g:elseif>
+<g:else>...</g:else>
+
+<!-- Iteration -->
+<g:each in="${items}" var="item" status="i">
+    ${i}: ${item.name}
+</g:each>
+
+<!-- Rendering -->
+<g:render template="bookRow" model="[book: book]"/>
+<g:render template="bookRow" collection="${books}" var="book"/>
+
+<!-- Security (with Spring Security plugin) -->
+<sec:ifLoggedIn>Welcome, ${sec.username()}</sec:ifLoggedIn>
+<sec:ifNotLoggedIn><g:link controller="login">Login</g:link></sec:ifNotLoggedIn>
+```
+
+### JSON Views
+```groovy
+// grails-app/views/book/show.gson
+import myapp.Book
+
+model {
+    Book book
+}
+
+json {
+    id book.id
+    title book.title
+    author book.author
+    datePublished book.datePublished?.format('yyyy-MM-dd')
+    _links {
+        self {
+            href "/books/${book.id}"
+        }
+    }
+}
+```
+
+### Layouts
+```html
+<!-- grails-app/views/layouts/main.gsp -->
+<!DOCTYPE html>
+<html>
+<head>
+    <title><g:layoutTitle default="My App"/></title>
+    <asset:stylesheet src="application.css"/>
+    <g:layoutHead/>
+</head>
+<body>
+    <nav><!-- Navigation --></nav>
+    <main>
+        <g:layoutBody/>
+    </main>
+    <footer><!-- Footer --></footer>
+    <asset:javascript src="application.js"/>
+</body>
+</html>
+
+<!-- Use in views -->
+<html>
+<head>
+    <meta name="layout" content="main"/>
+    <title>Books</title>
+</head>
+<body>
+    <!-- Page content -->
+</body>
+</html>
+```
+
+## Interceptors
+
+```groovy
+class AuthInterceptor {
+
+    AuthInterceptor() {
+        matchAll()
+            .excludes(controller: 'login')
+            .excludes(controller: 'error')
+    }
+
+    boolean before() {
+        if (!session.user) {
+            redirect(controller: 'login')
+            return false
+        }
+        true
+    }
+
+    boolean after() {
+        // After action executes
+        true
+    }
+
+    void afterView() {
+        // After view renders
+    }
+}
+```
+
+## Tag Libraries
+
+```groovy
+class BookTagLib {
+
+    static namespace = 'book'
+    static defaultEncodeAs = [taglib: 'html']
+
+    def formatTitle = { attrs, body ->
+        def title = attrs.title ?: body()
+        out << "<span class='book-title'>${title}</span>"
+    }
+
+    def ifHasBooks = { attrs, body ->
+        if (Book.count() > 0) {
+            out << body()
+        }
+    }
+}
+
+// Usage in GSP
+<book:formatTitle title="${book.title}"/>
+<book:ifHasBooks>
+    <p>We have books!</p>
+</book:ifHasBooks>
+```
+
+## Configuration
+
+### application.yml
+```yaml
+grails:
+    profile: web
+    codegen:
+        defaultPackage: myapp
+    gorm:
+        reactor:
+            events: false
+    mime:
+        types:
+            json: ['application/json', 'text/json']
+            xml: ['text/xml', 'application/xml']
+
+environments:
+    development:
+        dataSource:
+            dbCreate: create-drop
+            url: jdbc:h2:mem:devDb
+    test:
+        dataSource:
+            dbCreate: update
+            url: jdbc:h2:mem:testDb
+    production:
+        dataSource:
+            dbCreate: none
+            url: jdbc:postgresql://localhost/myapp
+            driverClassName: org.postgresql.Driver
+            dialect: org.hibernate.dialect.PostgreSQLDialect
+            properties:
+                jmxEnabled: true
+                initialSize: 5
+                maxActive: 50
+
+server:
+    port: 8080
+    servlet:
+        context-path: /myapp
+```
+
+### URL Mappings
+```groovy
+// grails-app/controllers/myapp/UrlMappings.groovy
+class UrlMappings {
+
+    static mappings = {
+        // Default
+        "/$controller/$action?/$id?(.$format)?" {
+            constraints {
+                // apply constraints here
+            }
+        }
+
+        // REST resources
+        "/api/books"(resources: 'book')
+
+        // Custom mappings
+        "/books/$id"(controller: 'book', action: 'show')
+        "/search"(controller: 'book', action: 'search')
+
+        // Named URL mappings
+        name bookShow: "/books/$id" {
+            controller = 'book'
+            action = 'show'
+        }
+
+        // Error pages
+        "500"(view: '/error')
+        "404"(view: '/notFound')
+    }
+}
+```
+
+## Testing with Spock
+
+### Unit Test - Controller
+```groovy
+import grails.testing.web.controllers.ControllerUnitTest
+import spock.lang.Specification
+
+class BookControllerSpec extends Specification
+        implements ControllerUnitTest<BookController> {
+
+    def setup() {
+        controller.bookService = Mock(BookService)
+    }
+
+    void "index returns list of books"() {
+        given:
+        def books = [new Book(title: "Test")]
+        controller.bookService.list(_) >> books
+
+        when:
+        controller.index()
+
+        then:
+        model.bookList == books
+        view == '/book/index'
+    }
+
+    void "show returns 404 for missing book"() {
+        when:
+        controller.show(999)
+
+        then:
+        response.status == 404
+    }
+}
+```
+
+### Unit Test - Service
+```groovy
+import grails.testing.services.ServiceUnitTest
+import spock.lang.Specification
+
+class BookServiceSpec extends Specification
+        implements ServiceUnitTest<BookService> {
+
+    void "save persists book"() {
+        given:
+        def book = new Book(title: "Test", author: "Author")
+
+        when:
+        def result = service.save(book)
+
+        then:
+        result.id != null
+        Book.count() == 1
+    }
+}
+```
+
+### Unit Test - Domain
+```groovy
+import grails.testing.gorm.DomainUnitTest
+import spock.lang.Specification
+
+class BookSpec extends Specification
+        implements DomainUnitTest<Book> {
+
+    void "title cannot be blank"() {
+        when:
+        domain.title = ""
+        domain.author = "Test"
+
+        then:
+        !domain.validate(['title'])
+        domain.errors['title'].code == 'blank'
+    }
+
+    void "valid book passes validation"() {
+        when:
+        domain.title = "Valid Title"
+        domain.author = "Author"
+
+        then:
+        domain.validate()
+    }
+}
+```
+
+### Integration Test
+```groovy
+import grails.testing.mixin.integration.Integration
+import grails.gorm.transactions.Rollback
+import spock.lang.Specification
+
+@Integration
+@Rollback
+class BookServiceIntegrationSpec extends Specification {
+
+    BookService bookService
+
+    void "save and retrieve book"() {
+        given:
+        def book = new Book(title: "Integration Test", author: "Tester")
+
+        when:
+        bookService.save(book)
+        def found = Book.findByTitle("Integration Test")
+
+        then:
+        found != null
+        found.author == "Tester"
+    }
+}
+```
+
+### Functional Test with Geb
+```groovy
+import geb.spock.GebSpec
+import grails.testing.mixin.integration.Integration
+
+@Integration
+class BookFunctionalSpec extends GebSpec {
+
+    void "can view book list"() {
+        when:
+        go '/book/index'
+
+        then:
+        title == 'Book List'
+        $('h1').text() == 'Books'
+    }
+
+    void "can create new book"() {
+        when:
+        go '/book/create'
+        $('form').title = 'New Book'
+        $('form').author = 'Test Author'
+        $('input[type=submit]').click()
+
+        then:
+        $('h1').text().contains('New Book')
+    }
+}
+```
+
+## Plugins
+
+### Common Plugins
+```groovy
+// build.gradle
+
+// Spring Security
+implementation 'org.grails.plugins:spring-security-core:6.0.0'
+
+// Database Migration (Liquibase)
+implementation 'org.grails.plugins:database-migration:4.2.0'
+
+// Caching
+implementation 'org.grails.plugins:cache:6.0.0'
+
+// Async support
+implementation 'org.grails.plugins:async:5.0.0'
+
+// Fields plugin for form rendering
+implementation 'org.grails.plugins:fields:5.0.0'
+
+// Asset Pipeline
+runtimeOnly 'org.grails.plugins:asset-pipeline:5.0.0'
+```
+
+### Spring Security Configuration
+```groovy
+// grails-app/conf/application.groovy
+grails.plugin.springsecurity.userLookup.userDomainClassName = 'myapp.User'
+grails.plugin.springsecurity.userLookup.authorityJoinClassName = 'myapp.UserRole'
+grails.plugin.springsecurity.authority.className = 'myapp.Role'
+
+grails.plugin.springsecurity.controllerAnnotations.staticRules = [
+    [pattern: '/',               access: ['permitAll']],
+    [pattern: '/error',          access: ['permitAll']],
+    [pattern: '/index',          access: ['permitAll']],
+    [pattern: '/admin/**',       access: ['ROLE_ADMIN']],
+    [pattern: '/api/**',         access: ['isAuthenticated()']],
+]
+```
+
+## Build Commands
+
+```bash
+# Run application
+./gradlew bootRun
+
+# Run tests
+./gradlew test                                    # All tests
+./gradlew test --tests "BookServiceSpec"          # Single spec
+./gradlew test --tests "*Spec.save*"              # Pattern match
+./gradlew integrationTest                         # Integration tests
+
+# Build
+./gradlew build -PskipTests                       # Build without tests
+./gradlew bootJar                                 # Executable JAR
+./gradlew bootWar                                 # WAR file
+
+# Code quality
+./gradlew codeStyle                               # Check style

Review Comment:
   The `codeStyle` task is specific to Grails Core repository?



##########
.agents/skills/grails-developer/SKILL.md:
##########
@@ -0,0 +1,883 @@
+<!--
+SPDX-License-Identifier: Apache-2.0
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+---
+name: grails-developer
+description: Comprehensive guide for Grails 7 development, covering web applications, REST APIs, GORM, controllers, services, views, plugins, and testing with Spock and Geb
+license: Apache-2.0
+compatibility: opencode, claude, grok, gemini, copilot, cursor, windsurf
+metadata:
+  audience: developers
+  frameworks: grails
+  versions: 7
+---
+
+## What I Do
+
+- Provide detailed guidance for building Grails 7 web applications and REST APIs.
+- Assist with GORM for data modeling, controllers for request handling, services for business logic, and views (GSP, JSON, Markup).
+- Support testing with Spock 2.3 (unit/integration tests) and Geb for browser automation.
+- Guide plugin usage and development, security implementation, and deployment strategies.
+- Help with configuration, internationalization, async programming, and performance optimization.
+
+## When to Use Me
+
+Activate this skill when developing with Grails 7, including:
+
+- Building CRUD applications, RESTful APIs, or full-stack web applications.
+- Working with GORM domain classes, constraints, and relationships.
+- Creating controllers, services, interceptors, or tag libraries.
+- Writing Spock specifications or Geb functional tests.
+- Configuring plugins, security, caching, or database migrations.
+- Deploying Grails applications to containers or cloud platforms.
+
+## Technology Stack
+
+Grails 7 is built on:
+- **Spring Boot**: 3.5.x
+- **Spring Framework**: 6.2.x
+- **Groovy**: 4.0.x
+- **Gradle**: 8.14.x
+- **Spock**: 2.3-groovy-4.0
+- **Jakarta EE**: 10 (migrated from javax.*)
+- **Micronaut**: Optional via `grails-micronaut` plugin
+
+## Project Structure
+
+```
+myapp/
+├── grails-app/
+│   ├── conf/                 # Configuration
+│   │   ├── application.yml   # Main config
+│   │   ├── logback.xml       # Logging config

Review Comment:
   `logback-spring.xml`?



##########
.agents/skills/grails-developer/SKILL.md:
##########
@@ -0,0 +1,883 @@
+<!--
+SPDX-License-Identifier: Apache-2.0
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+---
+name: grails-developer
+description: Comprehensive guide for Grails 7 development, covering web applications, REST APIs, GORM, controllers, services, views, plugins, and testing with Spock and Geb
+license: Apache-2.0
+compatibility: opencode, claude, grok, gemini, copilot, cursor, windsurf
+metadata:
+  audience: developers
+  frameworks: grails
+  versions: 7
+---
+
+## What I Do
+
+- Provide detailed guidance for building Grails 7 web applications and REST APIs.
+- Assist with GORM for data modeling, controllers for request handling, services for business logic, and views (GSP, JSON, Markup).
+- Support testing with Spock 2.3 (unit/integration tests) and Geb for browser automation.
+- Guide plugin usage and development, security implementation, and deployment strategies.
+- Help with configuration, internationalization, async programming, and performance optimization.
+
+## When to Use Me
+
+Activate this skill when developing with Grails 7, including:
+
+- Building CRUD applications, RESTful APIs, or full-stack web applications.
+- Working with GORM domain classes, constraints, and relationships.
+- Creating controllers, services, interceptors, or tag libraries.
+- Writing Spock specifications or Geb functional tests.
+- Configuring plugins, security, caching, or database migrations.
+- Deploying Grails applications to containers or cloud platforms.
+
+## Technology Stack
+
+Grails 7 is built on:
+- **Spring Boot**: 3.5.x
+- **Spring Framework**: 6.2.x
+- **Groovy**: 4.0.x
+- **Gradle**: 8.14.x
+- **Spock**: 2.3-groovy-4.0
+- **Jakarta EE**: 10 (migrated from javax.*)
+- **Micronaut**: Optional via `grails-micronaut` plugin
+
+## Project Structure
+
+```
+myapp/
+├── grails-app/
+│   ├── conf/                 # Configuration
+│   │   ├── application.yml   # Main config
+│   │   ├── logback.xml       # Logging config
+│   │   └── spring/           # Spring bean definitions
+│   ├── controllers/          # Request handlers
+│   ├── domain/               # GORM domain classes
+│   ├── i18n/                 # Message bundles
+│   ├── init/                 # Bootstrap classes
+│   ├── services/             # Business logic
+│   ├── taglib/               # Custom GSP tags
+│   ├── utils/                # Utility classes
+│   └── views/                # GSP templates
+├── src/
+│   ├── main/groovy/          # Additional Groovy classes
+│   ├── main/java/            # Java classes
+│   └── test/groovy/          # Test specifications
+├── build.gradle              # Build configuration
+└── gradle.properties         # Project properties
+```
+
+## Domain Classes (GORM)
+
+### Basic Domain Class
+```groovy
+class Book {
+    String title
+    String author
+    Date datePublished
+    Integer pages
+
+    static constraints = {
+        title blank: false, maxSize: 255
+        author blank: false
+        datePublished nullable: true
+        pages min: 1, nullable: true
+    }
+
+    static mapping = {
+        table 'books'
+        title column: 'book_title'
+        datePublished type: 'date'
+    }
+}
+```
+
+### Relationships
+```groovy
+class Author {
+    String name
+
+    static hasMany = [books: Book]
+
+    static mapping = {
+        books cascade: 'all-delete-orphan'
+    }
+}
+
+class Book {
+    String title
+
+    static belongsTo = [author: Author]
+}
+
+// Many-to-Many
+class Book {
+    static hasMany = [categories: Category]
+    static belongsTo = Category
+}
+
+class Category {
+    String name
+    static hasMany = [books: Book]
+}
+```
+
+### GORM Queries
+```groovy
+// Dynamic finders
+Book.findByTitle("Grails Guide")
+Book.findAllByAuthorLike("%Smith%")
+Book.findByTitleAndAuthor("Guide", "Smith")
+Book.countByPagesGreaterThan(100)
+
+// Where queries
+Book.where {
+    title =~ "%Grails%" && pages > 100
+}.list()
+
+// Criteria queries
+Book.withCriteria {
+    like('title', '%Grails%')
+    gt('pages', 100)
+    order('datePublished', 'desc')
+    maxResults(10)
+}
+
+// HQL queries
+Book.executeQuery(
+    "from Book b where b.author.name = :name",
+    [name: 'Smith']
+)
+
+// Detached criteria (reusable)
+def criteria = Book.where {
+    pages > 100
+}
+criteria.list()
+criteria.count()
+```
+
+### Transactions
+```groovy
+// In services (default transactional)
+@Transactional
+class BookService {
+    def saveBook(Book book) {
+        book.save(failOnError: true)
+    }
+}
+
+// Manual transaction control
+Book.withTransaction { status ->
+    def book = new Book(title: "Test")
+    book.save()
+    if (someCondition) {
+        status.setRollbackOnly()
+    }
+}
+```
+
+## Controllers
+
+### Basic Controller
+```groovy
+class BookController {
+
+    BookService bookService
+
+    static allowedMethods = [save: 'POST', update: 'PUT', delete: 'DELETE']
+
+    def index() {
+        respond Book.list(), model: [bookCount: Book.count()]
+    }
+
+    def show(Long id) {
+        respond Book.get(id)
+    }
+
+    def create() {
+        respond new Book(params)
+    }
+
+    def save(Book book) {
+        if (book.hasErrors()) {
+            respond book.errors, view: 'create'
+            return
+        }
+        bookService.save(book)
+        redirect action: 'show', id: book.id
+    }
+
+    def edit(Long id) {
+        respond Book.get(id)
+    }
+
+    def update(Book book) {
+        if (book.hasErrors()) {
+            respond book.errors, view: 'edit'
+            return
+        }
+        bookService.save(book)
+        redirect action: 'show', id: book.id
+    }
+
+    def delete(Long id) {
+        bookService.delete(id)
+        redirect action: 'index'
+    }
+}
+```
+
+### REST Controller
+```groovy
+import grails.rest.RestfulController
+
+class BookController extends RestfulController<Book> {
+
+    static responseFormats = ['json', 'xml']
+
+    BookController() {
+        super(Book)
+    }
+
+    // Override to customize
+    @Override
+    protected Book queryForResource(Serializable id) {
+        Book.where { id == id && active == true }.find()
+    }
+}
+```
+
+### Command Objects
+```groovy
+class BookCommand implements Validateable {
+    String title
+    String author
+    Integer pages
+
+    static constraints = {
+        title blank: false
+        author blank: false
+        pages min: 1, nullable: true
+    }
+}
+
+class BookController {
+    def save(BookCommand cmd) {
+        if (cmd.hasErrors()) {
+            respond cmd.errors
+            return
+        }
+        // Process valid command
+    }
+}
+```
+
+### Content Negotiation
+```groovy
+class BookController {
+    def show(Long id) {
+        def book = Book.get(id)
+        respond book  // Auto-negotiates based on Accept header
+    }
+}
+
+// Or explicit
+def show(Long id) {
+    def book = Book.get(id)
+    withFormat {
+        html { render view: 'show', model: [book: book] }
+        json { render book as JSON }
+        xml { render book as XML }
+    }
+}
+```
+
+## Services
+
+### Basic Service
+```groovy
+import grails.gorm.transactions.Transactional
+
+@Transactional
+class BookService {
+
+    def findByTitle(String title) {
+        Book.findByTitle(title)
+    }
+
+    def save(Book book) {
+        book.save(failOnError: true)
+    }
+
+    @Transactional(readOnly = true)
+    def list(Map params) {
+        Book.list(params)
+    }
+
+    def delete(Long id) {
+        Book.get(id)?.delete()
+    }
+}
+```
+
+### Service with Events
+```groovy
+import grails.events.annotation.Publisher
+import grails.events.annotation.Subscriber
+
+class BookService {
+
+    @Publisher
+    def save(Book book) {
+        book.save()
+        // Automatically publishes 'book.saved' event
+    }
+}
+
+class NotificationService {
+
+    @Subscriber('book.saved')
+    def onBookSaved(Book book) {
+        // Handle event
+        log.info "Book saved: ${book.title}"
+    }
+}
+```
+
+### Async Service
+```groovy
+import grails.async.Promise
+import static grails.async.Promises.*
+
+class BookService {
+
+    Promise<Book> findAsync(Long id) {
+        task {
+            Book.get(id)
+        }
+    }
+
+    def processBooks() {
+        def p1 = task { Book.findAllByActive(true) }
+        def p2 = task { Author.list() }
+
+        waitAll(p1, p2)
+        // Both complete
+    }
+}
+```
+
+## Views
+
+### GSP (Groovy Server Pages)
+```html
+<!-- grails-app/views/book/list.gsp -->
+<!DOCTYPE html>
+<html>
+<head>
+    <title>Books</title>
+    <asset:stylesheet src="application.css"/>
+</head>
+<body>
+    <h1>Books (${bookCount})</h1>
+
+    <g:each in="${bookList}" var="book">
+        <div class="book">
+            <h2>${book.title}</h2>
+            <p>By ${book.author}</p>
+            <g:link action="show" id="${book.id}">View</g:link>
+        </div>
+    </g:each>
+
+    <g:if test="${bookList.empty}">
+        <p>No books found.</p>
+    </g:if>
+
+    <g:paginate total="${bookCount}"/>
+
+    <asset:javascript src="application.js"/>
+</body>
+</html>
+```
+
+### Common GSP Tags
+```html
+<!-- Links -->
+<g:link controller="book" action="show" id="${book.id}">View</g:link>
+<g:createLink action="list"/>
+
+<!-- Forms -->
+<g:form action="save">
+    <g:textField name="title" value="${book?.title}"/>
+    <g:textArea name="description" value="${book?.description}"/>
+    <g:select name="category" from="${categories}" optionKey="id" optionValue="name"/>
+    <g:checkBox name="active" value="${book?.active}"/>
+    <g:submitButton name="submit" value="Save"/>
+</g:form>
+
+<!-- Conditionals -->
+<g:if test="${condition}">...</g:if>
+<g:elseif test="${other}">...</g:elseif>
+<g:else>...</g:else>
+
+<!-- Iteration -->
+<g:each in="${items}" var="item" status="i">
+    ${i}: ${item.name}
+</g:each>
+
+<!-- Rendering -->
+<g:render template="bookRow" model="[book: book]"/>
+<g:render template="bookRow" collection="${books}" var="book"/>
+
+<!-- Security (with Spring Security plugin) -->
+<sec:ifLoggedIn>Welcome, ${sec.username()}</sec:ifLoggedIn>
+<sec:ifNotLoggedIn><g:link controller="login">Login</g:link></sec:ifNotLoggedIn>
+```
+
+### JSON Views
+```groovy
+// grails-app/views/book/show.gson
+import myapp.Book
+
+model {
+    Book book
+}
+
+json {
+    id book.id
+    title book.title
+    author book.author
+    datePublished book.datePublished?.format('yyyy-MM-dd')
+    _links {
+        self {
+            href "/books/${book.id}"
+        }
+    }
+}
+```
+
+### Layouts
+```html
+<!-- grails-app/views/layouts/main.gsp -->
+<!DOCTYPE html>
+<html>
+<head>
+    <title><g:layoutTitle default="My App"/></title>
+    <asset:stylesheet src="application.css"/>
+    <g:layoutHead/>
+</head>
+<body>
+    <nav><!-- Navigation --></nav>
+    <main>
+        <g:layoutBody/>
+    </main>
+    <footer><!-- Footer --></footer>
+    <asset:javascript src="application.js"/>
+</body>
+</html>
+
+<!-- Use in views -->
+<html>
+<head>
+    <meta name="layout" content="main"/>
+    <title>Books</title>
+</head>
+<body>
+    <!-- Page content -->
+</body>
+</html>
+```
+
+## Interceptors
+
+```groovy
+class AuthInterceptor {
+
+    AuthInterceptor() {
+        matchAll()
+            .excludes(controller: 'login')
+            .excludes(controller: 'error')
+    }
+
+    boolean before() {
+        if (!session.user) {
+            redirect(controller: 'login')
+            return false
+        }
+        true
+    }
+
+    boolean after() {
+        // After action executes
+        true
+    }
+
+    void afterView() {
+        // After view renders
+    }
+}
+```
+
+## Tag Libraries
+
+```groovy
+class BookTagLib {
+
+    static namespace = 'book'
+    static defaultEncodeAs = [taglib: 'html']
+
+    def formatTitle = { attrs, body ->
+        def title = attrs.title ?: body()
+        out << "<span class='book-title'>${title}</span>"
+    }
+
+    def ifHasBooks = { attrs, body ->
+        if (Book.count() > 0) {
+            out << body()
+        }
+    }
+}
+
+// Usage in GSP
+<book:formatTitle title="${book.title}"/>
+<book:ifHasBooks>
+    <p>We have books!</p>
+</book:ifHasBooks>
+```
+
+## Configuration
+
+### application.yml
+```yaml
+grails:
+    profile: web
+    codegen:
+        defaultPackage: myapp
+    gorm:
+        reactor:
+            events: false
+    mime:
+        types:
+            json: ['application/json', 'text/json']
+            xml: ['text/xml', 'application/xml']
+
+environments:
+    development:
+        dataSource:
+            dbCreate: create-drop
+            url: jdbc:h2:mem:devDb
+    test:
+        dataSource:
+            dbCreate: update
+            url: jdbc:h2:mem:testDb
+    production:
+        dataSource:
+            dbCreate: none
+            url: jdbc:postgresql://localhost/myapp
+            driverClassName: org.postgresql.Driver
+            dialect: org.hibernate.dialect.PostgreSQLDialect
+            properties:
+                jmxEnabled: true
+                initialSize: 5
+                maxActive: 50
+
+server:
+    port: 8080
+    servlet:
+        context-path: /myapp
+```
+
+### URL Mappings
+```groovy
+// grails-app/controllers/myapp/UrlMappings.groovy
+class UrlMappings {
+
+    static mappings = {
+        // Default
+        "/$controller/$action?/$id?(.$format)?" {
+            constraints {
+                // apply constraints here
+            }
+        }
+
+        // REST resources
+        "/api/books"(resources: 'book')
+
+        // Custom mappings
+        "/books/$id"(controller: 'book', action: 'show')
+        "/search"(controller: 'book', action: 'search')
+
+        // Named URL mappings
+        name bookShow: "/books/$id" {
+            controller = 'book'
+            action = 'show'
+        }
+
+        // Error pages
+        "500"(view: '/error')
+        "404"(view: '/notFound')
+    }
+}
+```
+
+## Testing with Spock
+
+### Unit Test - Controller
+```groovy
+import grails.testing.web.controllers.ControllerUnitTest
+import spock.lang.Specification
+
+class BookControllerSpec extends Specification
+        implements ControllerUnitTest<BookController> {
+
+    def setup() {
+        controller.bookService = Mock(BookService)
+    }
+
+    void "index returns list of books"() {
+        given:
+        def books = [new Book(title: "Test")]
+        controller.bookService.list(_) >> books
+
+        when:
+        controller.index()
+
+        then:
+        model.bookList == books
+        view == '/book/index'
+    }
+
+    void "show returns 404 for missing book"() {
+        when:
+        controller.show(999)
+
+        then:
+        response.status == 404
+    }
+}
+```
+
+### Unit Test - Service
+```groovy
+import grails.testing.services.ServiceUnitTest
+import spock.lang.Specification
+
+class BookServiceSpec extends Specification
+        implements ServiceUnitTest<BookService> {
+
+    void "save persists book"() {
+        given:
+        def book = new Book(title: "Test", author: "Author")
+
+        when:
+        def result = service.save(book)
+
+        then:
+        result.id != null
+        Book.count() == 1
+    }
+}
+```
+
+### Unit Test - Domain
+```groovy
+import grails.testing.gorm.DomainUnitTest
+import spock.lang.Specification
+
+class BookSpec extends Specification
+        implements DomainUnitTest<Book> {
+
+    void "title cannot be blank"() {
+        when:
+        domain.title = ""
+        domain.author = "Test"
+
+        then:
+        !domain.validate(['title'])
+        domain.errors['title'].code == 'blank'
+    }
+
+    void "valid book passes validation"() {
+        when:
+        domain.title = "Valid Title"
+        domain.author = "Author"
+
+        then:
+        domain.validate()
+    }
+}
+```
+
+### Integration Test
+```groovy
+import grails.testing.mixin.integration.Integration
+import grails.gorm.transactions.Rollback
+import spock.lang.Specification
+
+@Integration
+@Rollback
+class BookServiceIntegrationSpec extends Specification {
+
+    BookService bookService
+
+    void "save and retrieve book"() {
+        given:
+        def book = new Book(title: "Integration Test", author: "Tester")
+
+        when:
+        bookService.save(book)
+        def found = Book.findByTitle("Integration Test")
+
+        then:
+        found != null
+        found.author == "Tester"
+    }
+}
+```
+
+### Functional Test with Geb
+```groovy
+import geb.spock.GebSpec
+import grails.testing.mixin.integration.Integration
+
+@Integration
+class BookFunctionalSpec extends GebSpec {
+
+    void "can view book list"() {
+        when:
+        go '/book/index'
+
+        then:
+        title == 'Book List'
+        $('h1').text() == 'Books'
+    }
+
+    void "can create new book"() {
+        when:
+        go '/book/create'
+        $('form').title = 'New Book'
+        $('form').author = 'Test Author'
+        $('input[type=submit]').click()
+
+        then:
+        $('h1').text().contains('New Book')
+    }
+}
+```
+
+## Plugins
+
+### Common Plugins
+```groovy
+// build.gradle
+
+// Spring Security
+implementation 'org.grails.plugins:spring-security-core:6.0.0'
+
+// Database Migration (Liquibase)
+implementation 'org.grails.plugins:database-migration:4.2.0'
+
+// Caching
+implementation 'org.grails.plugins:cache:6.0.0'
+
+// Async support
+implementation 'org.grails.plugins:async:5.0.0'
+
+// Fields plugin for form rendering
+implementation 'org.grails.plugins:fields:5.0.0'
+
+// Asset Pipeline
+runtimeOnly 'org.grails.plugins:asset-pipeline:5.0.0'
+```
+
+### Spring Security Configuration
+```groovy
+// grails-app/conf/application.groovy
+grails.plugin.springsecurity.userLookup.userDomainClassName = 'myapp.User'
+grails.plugin.springsecurity.userLookup.authorityJoinClassName = 'myapp.UserRole'
+grails.plugin.springsecurity.authority.className = 'myapp.Role'
+
+grails.plugin.springsecurity.controllerAnnotations.staticRules = [
+    [pattern: '/',               access: ['permitAll']],
+    [pattern: '/error',          access: ['permitAll']],
+    [pattern: '/index',          access: ['permitAll']],
+    [pattern: '/admin/**',       access: ['ROLE_ADMIN']],
+    [pattern: '/api/**',         access: ['isAuthenticated()']],
+]
+```
+
+## Build Commands
+
+```bash
+# Run application
+./gradlew bootRun
+
+# Run tests
+./gradlew test                                    # All tests
+./gradlew test --tests "BookServiceSpec"          # Single spec
+./gradlew test --tests "*Spec.save*"              # Pattern match
+./gradlew integrationTest                         # Integration tests
+
+# Build
+./gradlew build -PskipTests                       # Build without tests
+./gradlew bootJar                                 # Executable JAR
+./gradlew bootWar                                 # WAR file
+
+# Code quality
+./gradlew codeStyle                               # Check style
+
+# Clean
+./gradlew clean
+```
+
+## Best Practices
+
+### Convention Over Configuration
+- Follow Grails naming conventions for automatic wiring.
+- Use standard directory structure.
+- Let Grails infer configurations where possible.
+
+### Performance
+- Use `@GrailsCompileStatic` on controllers and services.

Review Comment:
   domain classes?



##########
.agents/skills/groovy-developer/SKILL.md:
##########
@@ -0,0 +1,520 @@
+<!--
+SPDX-License-Identifier: Apache-2.0
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+---
+name: groovy-developer
+description: Expert guide for Groovy 4 development, covering concise syntax, closures, DSLs, metaprogramming, static compilation, and integration with Java 17 and Grails
+license: Apache-2.0
+compatibility: opencode, claude, grok, gemini, copilot, cursor, windsurf
+metadata:
+  audience: developers
+  languages: groovy, java
+  versions: 4.0
+  paradigms: dynamic, static, functional, object-oriented, DSL-oriented
+---
+
+## What I Do
+
+- Provide deep expertise in Groovy 4.0, including core language features: syntax, closures, traits, GStrings, operators, and Groovy Truth.
+- Guide metaprogramming techniques: runtime (categories, ExpandoMetaClass, extension modules) and compile-time (AST transformations like @Immutable, @Builder, @Delegate, @Singleton, @Log, @Memoized).
+- Assist with DSL creation and usage (MarkupBuilder, JsonBuilder, builders for configuration).
+- Support testing with Spock Framework (BDD, data-driven tests, mocking) and built-in power assertions.
+- Help integrate Groovy with Java 17: joint compilation, Gradle builds, Grails, and Spring Boot.
+- Cover data handling: JSON/XML parsing and building, Groovy SQL, collection processing.
+- Advise on performance: @CompileStatic, @TypeChecked, @GrailsCompileStatic for optimal execution.
+
+## When to Use Me
+
+Activate this skill for any Groovy-related task, including:
+
+- Writing or debugging Groovy classes in Grails domain, controllers, services, or taglibs.
+- Building or enhancing Gradle build scripts (build.gradle).
+- Creating DSLs for configuration, testing, or business rules.
+- Writing Spock specifications for unit and integration tests.
+- Migrating from older Groovy versions (2.x/3.x) to 4.0.
+- Performance optimization with static compilation.
+- Working with JSON/XML data, GORM criteria queries, or builders.
+
+## Groovy 4 Key Features
+
+### Concise Syntax
+```groovy
+// No semicolons required
+def name = "Grails"
+
+// Optional parentheses for method calls
+println "Hello World"
+list.each { println it }
+
+// Optional return keyword
+String greet(String name) {
+    "Hello, $name"  // Last expression is returned
+}
+```
+
+### GStrings (String Interpolation)
+```groovy
+def user = "Alice"
+def count = 42
+
+// Simple interpolation
+println "User: $user"
+
+// Expression interpolation
+println "Items: ${count * 2}"
+
+// Lazy GStrings (evaluated when accessed)
+def lazy = "Count is ${ -> counter }"
+
+// Multi-line strings
+def sql = """
+    SELECT * FROM users
+    WHERE name = '$user'
+    ORDER BY created_at
+"""
+```
+
+### Closures
+```groovy
+// Basic closure
+def greet = { name -> "Hello, $name" }
+println greet("World")
+
+// Implicit 'it' parameter
+def double = { it * 2 }
+println [1, 2, 3].collect(double)
+
+// Closure with delegate (for DSLs)
+def configure = {
+    name = "MyApp"
+    version = "1.0"
+}
+configure.delegate = new Config()
+configure.resolveStrategy = Closure.DELEGATE_FIRST
+configure()
+
+// Method references
+def upper = String.&toUpperCase
+println ["a", "b"].collect(upper)
+```
+
+### Safe Navigation and Elvis Operator
+```groovy
+// Safe navigation - returns null if any part is null
+def city = user?.address?.city
+
+// Elvis operator - default value if null
+def name = user?.name ?: "Anonymous"
+
+// Safe method calls
+def length = text?.length() ?: 0
+
+// Combine with collections
+def firstTitle = books?.first()?.title ?: "No books"
+```
+
+### Spread Operator
+```groovy
+// Spread operator for collections
+def names = users*.name  // Same as users.collect { it.name }
+
+// Spread for method arguments
+def args = [1, 2, 3]
+someMethod(*args)
+
+// Spread in list literals
+def combined = [*list1, *list2]
+```
+
+### Collection Literals and Methods
+```groovy
+// List literal
+def list = [1, 2, 3, 4, 5]
+
+// Map literal
+def map = [name: "Grails", version: 7]
+
+// Range
+def range = 1..10
+def exclusive = 1..<10
+
+// Powerful collection methods
+list.find { it > 3 }           // First match: 4
+list.findAll { it > 3 }        // All matches: [4, 5]
+list.any { it > 3 }            // true
+list.every { it > 0 }          // true
+list.groupBy { it % 2 }        // [0:[2,4], 1:[1,3,5]]
+list.collectEntries { [it, it * 2] }  // [1:2, 2:4, ...]
+
+// Sorting
+list.sort { a, b -> b <=> a }  // Descending
+list.sort { -it }              // Descending (numeric)
+```
+
+### Groovy Truth
+```groovy
+// Falsy values: null, empty string, empty collection, 0, false
+if (list) { }      // True if not null and not empty
+if (string) { }    // True if not null and not blank
+if (number) { }    // True if not 0
+
+// Useful in conditionals
+def items = getItems() ?: []  // Default to empty list
+```
+
+### Records (Incubating)
+```groovy
+// Immutable data class
+record Point(int x, int y) {}
+
+def p = new Point(10, 20)
+println p.x()  // 10
+println p      // Point[x=10, y=20]
+```
+
+### Traits
+```groovy
+trait Auditable {
+    Date dateCreated
+    Date lastUpdated
+
+    def beforeInsert() {
+        dateCreated = new Date()
+    }
+
+    def beforeUpdate() {
+        lastUpdated = new Date()
+    }
+}
+
+class Book implements Auditable {
+    String title
+}
+```
+
+## Static Compilation
+
+### @CompileStatic
+Enables static type checking and compilation for better performance:
+```groovy
+import groovy.transform.CompileStatic
+
+@CompileStatic
+class BookService {
+    List<Book> findByAuthor(String author) {
+        Book.findAllByAuthor(author)
+    }
+
+    int calculateTotal(List<Integer> prices) {
+        prices.sum() as int
+    }
+}
+```
+
+### @TypeChecked
+Type checking without full static compilation:
+```groovy
+import groovy.transform.TypeChecked
+
+@TypeChecked
+void process(String input) {
+    println input.toUppercase()  // Compile error: method not found
+}
+```
+
+### @GrailsCompileStatic
+Grails-aware static compilation that understands dynamic finders:
+```groovy
+import grails.compiler.GrailsCompileStatic
+
+@GrailsCompileStatic
+class BookController {
+    def show(Long id) {
+        respond Book.get(id)  // Works with static compilation
+    }
+}
+```
+
+## AST Transformations
+
+### @Immutable
+```groovy
+import groovy.transform.Immutable
+
+@Immutable
+class Person {
+    String name
+    int age
+}
+
+def p = new Person(name: "Alice", age: 30)
+// p.name = "Bob"  // Error: read-only
+```
+
+### @Builder
+```groovy
+import groovy.transform.builder.Builder
+
+@Builder
+class Email {
+    String to
+    String subject
+    String body
+}
+
+def email = Email.builder()
+    .to("user@example.com")
+    .subject("Hello")
+    .body("Content here")
+    .build()
+```
+
+### @Delegate
+```groovy
+import groovy.transform.Delegate
+
+class EnhancedList<T> {
+    @Delegate List<T> list = []
+
+    T secondLast() {
+        list[-2]
+    }
+}
+
+def enhanced = new EnhancedList<String>()
+enhanced.add("a")  // Delegated to list
+enhanced.add("b")
+println enhanced.secondLast()  // "a"
+```
+
+### @Singleton
+```groovy
+import groovy.transform.Singleton
+
+@Singleton
+class ConfigManager {
+    Map settings = [:]
+}
+
+ConfigManager.instance.settings['key'] = 'value'
+```
+
+### @Memoized
+```groovy
+import groovy.transform.Memoized
+
+class Calculator {
+    @Memoized
+    BigInteger fibonacci(int n) {
+        if (n <= 1) return n
+        fibonacci(n - 1) + fibonacci(n - 2)
+    }
+}
+```
+
+### @Log Variants
+```groovy
+import groovy.util.logging.Slf4j
+
+@Slf4j
+class BookService {
+    def save(Book book) {
+        log.info "Saving book: ${book.title}"
+        // ...
+    }
+}
+```
+
+## Builders and DSLs
+
+### JsonBuilder
+```groovy
+import groovy.json.JsonBuilder
+
+def builder = new JsonBuilder()
+builder {
+    name "Grails"
+    version 7
+    features(["GORM", "GSP", "Plugins"])
+    metadata {
+        author "Grails Team"
+        license "Apache 2.0"
+    }
+}
+println builder.toPrettyString()
+```
+
+### JsonSlurper
+```groovy
+import groovy.json.JsonSlurper
+
+def json = '{"name": "Grails", "version": 7}'
+def data = new JsonSlurper().parseText(json)
+println data.name  // Grails
+```
+
+### MarkupBuilder (XML/HTML)
+```groovy
+import groovy.xml.MarkupBuilder
+
+def writer = new StringWriter()
+def xml = new MarkupBuilder(writer)
+xml.books {
+    book(id: 1) {
+        title "Grails Guide"
+        author "Team"
+    }
+}
+println writer.toString()
+```
+
+### Custom DSL Example
+```groovy
+class HtmlBuilder {
+    def html(@DelegatesTo(HtmlBuilder) Closure c) {
+        c.delegate = this
+        c.resolveStrategy = Closure.DELEGATE_FIRST
+        "<html>${c()}</html>"
+    }
+
+    def body(String content) {
+        "<body>$content</body>"
+    }
+}
+
+def builder = new HtmlBuilder()
+def result = builder.html {
+    body "Hello World"
+}
+```
+
+## Testing with Spock
+
+### Basic Specification
+```groovy
+class BookServiceSpec extends Specification {
+
+    def service = new BookService()
+
+    def "should find book by title"() {
+        given: "a book title"
+        def title = "Grails Guide"
+
+        when: "searching for the book"
+        def book = service.findByTitle(title)
+
+        then: "the book is found"
+        book != null
+        book.title == title
+    }
+}
+```
+
+### Data-Driven Tests
+```groovy
+@Unroll
+def "max of #a and #b is #expected"() {
+    expect:
+    Math.max(a, b) == expected
+
+    where:
+    a | b || expected
+    1 | 3 || 3
+    7 | 4 || 7
+    0 | 0 || 0
+}
+```
+
+### Mocking
+```groovy
+def "should call repository when saving"() {
+    given:
+    def repo = Mock(BookRepository)
+    def service = new BookService(repo)
+    def book = new Book(title: "Test")
+
+    when:
+    service.save(book)
+
+    then:
+    1 * repo.save(book)
+}
+```
+
+### Exception Testing
+```groovy
+def "should throw exception for invalid input"() {
+    when:
+    service.process(null)
+
+    then:
+    thrown(IllegalArgumentException)
+}
+```
+
+## Groovy SQL
+```groovy
+import groovy.sql.Sql
+
+def sql = Sql.newInstance(dataSource)
+
+// Query
+sql.eachRow("SELECT * FROM books WHERE author = ?", [authorName]) { row ->
+    println "${row.title} by ${row.author}"
+}
+
+// Insert
+sql.execute("INSERT INTO books (title, author) VALUES (?, ?)",
+            [title, author])
+
+// With GString (auto-parameterized)
+sql.execute("INSERT INTO books (title) VALUES ($title)")
+```
+
+## Best Practices
+
+### Performance
+- Use `@CompileStatic` or `@GrailsCompileStatic` in production code.
+- Avoid runtime metaprogramming in hot paths.
+- Prefer `collect`/`findAll` over manual loops.
+- Use `@Memoized` for expensive computations.
+
+### Code Style
+- Use safe navigation (`?.`) instead of null checks.
+- Prefer Elvis operator (`?:`) for default values.
+- Use GStrings for string interpolation.
+- Prefer traits over inheritance for mixins.
+- Use explicit types for public APIs, `def` for local variables.
+
+### Grails-Specific
+- Use `@GrailsCompileStatic` instead of `@CompileStatic` in Grails classes.
+- Leverage GORM dynamic finders and where queries.
+- Use command objects for form binding and validation.
+- Follow convention over configuration.
+
+## Common Pitfalls
+
+- **`==` vs `is`**: `==` calls `equals()`, use `is` for identity comparison.
+- **GString in maps**: Use `"key".toString()` as map keys if needed.
+- **Closure scope**: Understand `delegate`, `owner`, and `this` in closures.
+- **Optional parentheses**: Can cause ambiguity; use parentheses when unclear.
+- **Static imports**: Groovy may not find statically imported methods without explicit import.

Review Comment:
   What does this mean? Does this differ from Java?



##########
.agents/skills/groovy-developer/SKILL.md:
##########
@@ -0,0 +1,520 @@
+<!--
+SPDX-License-Identifier: Apache-2.0
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+---
+name: groovy-developer
+description: Expert guide for Groovy 4 development, covering concise syntax, closures, DSLs, metaprogramming, static compilation, and integration with Java 17 and Grails
+license: Apache-2.0
+compatibility: opencode, claude, grok, gemini, copilot, cursor, windsurf
+metadata:
+  audience: developers
+  languages: groovy, java
+  versions: 4.0
+  paradigms: dynamic, static, functional, object-oriented, DSL-oriented
+---
+
+## What I Do
+
+- Provide deep expertise in Groovy 4.0, including core language features: syntax, closures, traits, GStrings, operators, and Groovy Truth.
+- Guide metaprogramming techniques: runtime (categories, ExpandoMetaClass, extension modules) and compile-time (AST transformations like @Immutable, @Builder, @Delegate, @Singleton, @Log, @Memoized).
+- Assist with DSL creation and usage (MarkupBuilder, JsonBuilder, builders for configuration).
+- Support testing with Spock Framework (BDD, data-driven tests, mocking) and built-in power assertions.
+- Help integrate Groovy with Java 17: joint compilation, Gradle builds, Grails, and Spring Boot.
+- Cover data handling: JSON/XML parsing and building, Groovy SQL, collection processing.
+- Advise on performance: @CompileStatic, @TypeChecked, @GrailsCompileStatic for optimal execution.
+
+## When to Use Me
+
+Activate this skill for any Groovy-related task, including:
+
+- Writing or debugging Groovy classes in Grails domain, controllers, services, or taglibs.
+- Building or enhancing Gradle build scripts (build.gradle).
+- Creating DSLs for configuration, testing, or business rules.
+- Writing Spock specifications for unit and integration tests.
+- Migrating from older Groovy versions (2.x/3.x) to 4.0.
+- Performance optimization with static compilation.
+- Working with JSON/XML data, GORM criteria queries, or builders.
+
+## Groovy 4 Key Features
+
+### Concise Syntax
+```groovy
+// No semicolons required
+def name = "Grails"
+
+// Optional parentheses for method calls
+println "Hello World"
+list.each { println it }
+
+// Optional return keyword
+String greet(String name) {
+    "Hello, $name"  // Last expression is returned
+}
+```
+
+### GStrings (String Interpolation)
+```groovy
+def user = "Alice"
+def count = 42
+
+// Simple interpolation
+println "User: $user"
+
+// Expression interpolation
+println "Items: ${count * 2}"
+
+// Lazy GStrings (evaluated when accessed)
+def lazy = "Count is ${ -> counter }"
+
+// Multi-line strings
+def sql = """
+    SELECT * FROM users
+    WHERE name = '$user'
+    ORDER BY created_at
+"""
+```
+
+### Closures
+```groovy
+// Basic closure
+def greet = { name -> "Hello, $name" }
+println greet("World")
+
+// Implicit 'it' parameter
+def double = { it * 2 }
+println [1, 2, 3].collect(double)
+
+// Closure with delegate (for DSLs)
+def configure = {
+    name = "MyApp"
+    version = "1.0"
+}
+configure.delegate = new Config()
+configure.resolveStrategy = Closure.DELEGATE_FIRST
+configure()
+
+// Method references
+def upper = String.&toUpperCase
+println ["a", "b"].collect(upper)
+```
+
+### Safe Navigation and Elvis Operator
+```groovy
+// Safe navigation - returns null if any part is null
+def city = user?.address?.city
+
+// Elvis operator - default value if null
+def name = user?.name ?: "Anonymous"
+
+// Safe method calls
+def length = text?.length() ?: 0
+
+// Combine with collections
+def firstTitle = books?.first()?.title ?: "No books"
+```
+
+### Spread Operator
+```groovy
+// Spread operator for collections
+def names = users*.name  // Same as users.collect { it.name }
+
+// Spread for method arguments
+def args = [1, 2, 3]
+someMethod(*args)
+
+// Spread in list literals
+def combined = [*list1, *list2]
+```
+
+### Collection Literals and Methods
+```groovy
+// List literal
+def list = [1, 2, 3, 4, 5]
+
+// Map literal
+def map = [name: "Grails", version: 7]
+
+// Range
+def range = 1..10
+def exclusive = 1..<10
+
+// Powerful collection methods
+list.find { it > 3 }           // First match: 4
+list.findAll { it > 3 }        // All matches: [4, 5]
+list.any { it > 3 }            // true
+list.every { it > 0 }          // true
+list.groupBy { it % 2 }        // [0:[2,4], 1:[1,3,5]]
+list.collectEntries { [it, it * 2] }  // [1:2, 2:4, ...]
+
+// Sorting
+list.sort { a, b -> b <=> a }  // Descending
+list.sort { -it }              // Descending (numeric)
+```
+
+### Groovy Truth
+```groovy
+// Falsy values: null, empty string, empty collection, 0, false
+if (list) { }      // True if not null and not empty
+if (string) { }    // True if not null and not blank
+if (number) { }    // True if not 0
+
+// Useful in conditionals
+def items = getItems() ?: []  // Default to empty list
+```
+
+### Records (Incubating)
+```groovy
+// Immutable data class
+record Point(int x, int y) {}
+
+def p = new Point(10, 20)
+println p.x()  // 10
+println p      // Point[x=10, y=20]
+```
+
+### Traits
+```groovy
+trait Auditable {
+    Date dateCreated
+    Date lastUpdated
+
+    def beforeInsert() {
+        dateCreated = new Date()
+    }
+
+    def beforeUpdate() {
+        lastUpdated = new Date()
+    }
+}
+
+class Book implements Auditable {
+    String title
+}
+```
+
+## Static Compilation
+
+### @CompileStatic
+Enables static type checking and compilation for better performance:
+```groovy
+import groovy.transform.CompileStatic
+
+@CompileStatic
+class BookService {
+    List<Book> findByAuthor(String author) {
+        Book.findAllByAuthor(author)
+    }
+
+    int calculateTotal(List<Integer> prices) {
+        prices.sum() as int
+    }
+}
+```
+
+### @TypeChecked
+Type checking without full static compilation:
+```groovy
+import groovy.transform.TypeChecked
+
+@TypeChecked
+void process(String input) {
+    println input.toUppercase()  // Compile error: method not found
+}
+```
+
+### @GrailsCompileStatic
+Grails-aware static compilation that understands dynamic finders:
+```groovy
+import grails.compiler.GrailsCompileStatic
+
+@GrailsCompileStatic
+class BookController {
+    def show(Long id) {
+        respond Book.get(id)  // Works with static compilation
+    }
+}
+```
+
+## AST Transformations
+
+### @Immutable
+```groovy
+import groovy.transform.Immutable
+
+@Immutable
+class Person {
+    String name
+    int age
+}
+
+def p = new Person(name: "Alice", age: 30)
+// p.name = "Bob"  // Error: read-only
+```
+
+### @Builder
+```groovy
+import groovy.transform.builder.Builder
+
+@Builder
+class Email {
+    String to
+    String subject
+    String body
+}
+
+def email = Email.builder()
+    .to("user@example.com")
+    .subject("Hello")
+    .body("Content here")
+    .build()
+```
+
+### @Delegate
+```groovy
+import groovy.transform.Delegate
+
+class EnhancedList<T> {
+    @Delegate List<T> list = []
+
+    T secondLast() {
+        list[-2]
+    }
+}
+
+def enhanced = new EnhancedList<String>()
+enhanced.add("a")  // Delegated to list
+enhanced.add("b")
+println enhanced.secondLast()  // "a"
+```
+
+### @Singleton
+```groovy
+import groovy.transform.Singleton
+
+@Singleton
+class ConfigManager {
+    Map settings = [:]
+}
+
+ConfigManager.instance.settings['key'] = 'value'
+```
+
+### @Memoized
+```groovy
+import groovy.transform.Memoized
+
+class Calculator {
+    @Memoized
+    BigInteger fibonacci(int n) {
+        if (n <= 1) return n
+        fibonacci(n - 1) + fibonacci(n - 2)
+    }
+}
+```
+
+### @Log Variants
+```groovy
+import groovy.util.logging.Slf4j
+
+@Slf4j
+class BookService {
+    def save(Book book) {
+        log.info "Saving book: ${book.title}"
+        // ...
+    }
+}
+```
+
+## Builders and DSLs
+
+### JsonBuilder
+```groovy
+import groovy.json.JsonBuilder
+
+def builder = new JsonBuilder()
+builder {
+    name "Grails"
+    version 7
+    features(["GORM", "GSP", "Plugins"])
+    metadata {
+        author "Grails Team"
+        license "Apache 2.0"
+    }
+}
+println builder.toPrettyString()
+```
+
+### JsonSlurper
+```groovy
+import groovy.json.JsonSlurper
+
+def json = '{"name": "Grails", "version": 7}'
+def data = new JsonSlurper().parseText(json)
+println data.name  // Grails
+```
+
+### MarkupBuilder (XML/HTML)
+```groovy
+import groovy.xml.MarkupBuilder
+
+def writer = new StringWriter()
+def xml = new MarkupBuilder(writer)
+xml.books {
+    book(id: 1) {
+        title "Grails Guide"
+        author "Team"
+    }
+}
+println writer.toString()
+```
+
+### Custom DSL Example
+```groovy
+class HtmlBuilder {
+    def html(@DelegatesTo(HtmlBuilder) Closure c) {
+        c.delegate = this
+        c.resolveStrategy = Closure.DELEGATE_FIRST
+        "<html>${c()}</html>"
+    }
+
+    def body(String content) {
+        "<body>$content</body>"
+    }
+}
+
+def builder = new HtmlBuilder()
+def result = builder.html {
+    body "Hello World"
+}
+```
+
+## Testing with Spock
+
+### Basic Specification
+```groovy
+class BookServiceSpec extends Specification {
+
+    def service = new BookService()
+
+    def "should find book by title"() {
+        given: "a book title"
+        def title = "Grails Guide"
+
+        when: "searching for the book"
+        def book = service.findByTitle(title)
+
+        then: "the book is found"
+        book != null
+        book.title == title
+    }
+}
+```
+
+### Data-Driven Tests
+```groovy
+@Unroll
+def "max of #a and #b is #expected"() {
+    expect:
+    Math.max(a, b) == expected
+
+    where:
+    a | b || expected
+    1 | 3 || 3
+    7 | 4 || 7
+    0 | 0 || 0
+}
+```
+
+### Mocking
+```groovy
+def "should call repository when saving"() {
+    given:
+    def repo = Mock(BookRepository)
+    def service = new BookService(repo)
+    def book = new Book(title: "Test")
+
+    when:
+    service.save(book)
+
+    then:
+    1 * repo.save(book)
+}
+```
+
+### Exception Testing
+```groovy
+def "should throw exception for invalid input"() {
+    when:
+    service.process(null)
+
+    then:
+    thrown(IllegalArgumentException)
+}
+```
+
+## Groovy SQL
+```groovy
+import groovy.sql.Sql
+
+def sql = Sql.newInstance(dataSource)
+
+// Query
+sql.eachRow("SELECT * FROM books WHERE author = ?", [authorName]) { row ->
+    println "${row.title} by ${row.author}"
+}
+
+// Insert
+sql.execute("INSERT INTO books (title, author) VALUES (?, ?)",
+            [title, author])
+
+// With GString (auto-parameterized)
+sql.execute("INSERT INTO books (title) VALUES ($title)")
+```
+
+## Best Practices
+
+### Performance
+- Use `@CompileStatic` or `@GrailsCompileStatic` in production code.
+- Avoid runtime metaprogramming in hot paths.
+- Prefer `collect`/`findAll` over manual loops.
+- Use `@Memoized` for expensive computations.
+
+### Code Style
+- Use safe navigation (`?.`) instead of null checks.
+- Prefer Elvis operator (`?:`) for default values.
+- Use GStrings for string interpolation.
+- Prefer traits over inheritance for mixins.
+- Use explicit types for public APIs, `def` for local variables.

Review Comment:
   ⭐



##########
.agents/skills/grails-developer/SKILL.md:
##########
@@ -0,0 +1,883 @@
+<!--
+SPDX-License-Identifier: Apache-2.0
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+---
+name: grails-developer
+description: Comprehensive guide for Grails 7 development, covering web applications, REST APIs, GORM, controllers, services, views, plugins, and testing with Spock and Geb
+license: Apache-2.0
+compatibility: opencode, claude, grok, gemini, copilot, cursor, windsurf
+metadata:
+  audience: developers
+  frameworks: grails
+  versions: 7
+---
+
+## What I Do
+
+- Provide detailed guidance for building Grails 7 web applications and REST APIs.
+- Assist with GORM for data modeling, controllers for request handling, services for business logic, and views (GSP, JSON, Markup).
+- Support testing with Spock 2.3 (unit/integration tests) and Geb for browser automation.
+- Guide plugin usage and development, security implementation, and deployment strategies.
+- Help with configuration, internationalization, async programming, and performance optimization.
+
+## When to Use Me
+
+Activate this skill when developing with Grails 7, including:
+
+- Building CRUD applications, RESTful APIs, or full-stack web applications.
+- Working with GORM domain classes, constraints, and relationships.
+- Creating controllers, services, interceptors, or tag libraries.
+- Writing Spock specifications or Geb functional tests.
+- Configuring plugins, security, caching, or database migrations.
+- Deploying Grails applications to containers or cloud platforms.
+
+## Technology Stack
+
+Grails 7 is built on:
+- **Spring Boot**: 3.5.x
+- **Spring Framework**: 6.2.x
+- **Groovy**: 4.0.x
+- **Gradle**: 8.14.x
+- **Spock**: 2.3-groovy-4.0
+- **Jakarta EE**: 10 (migrated from javax.*)
+- **Micronaut**: Optional via `grails-micronaut` plugin
+
+## Project Structure
+
+```
+myapp/
+├── grails-app/
+│   ├── conf/                 # Configuration
+│   │   ├── application.yml   # Main config
+│   │   ├── logback.xml       # Logging config
+│   │   └── spring/           # Spring bean definitions
+│   ├── controllers/          # Request handlers
+│   ├── domain/               # GORM domain classes
+│   ├── i18n/                 # Message bundles
+│   ├── init/                 # Bootstrap classes
+│   ├── services/             # Business logic
+│   ├── taglib/               # Custom GSP tags
+│   ├── utils/                # Utility classes
+│   └── views/                # GSP templates
+├── src/
+│   ├── main/groovy/          # Additional Groovy classes
+│   ├── main/java/            # Java classes
+│   └── test/groovy/          # Test specifications
+├── build.gradle              # Build configuration
+└── gradle.properties         # Project properties
+```
+
+## Domain Classes (GORM)
+
+### Basic Domain Class
+```groovy
+class Book {
+    String title
+    String author
+    Date datePublished
+    Integer pages
+
+    static constraints = {
+        title blank: false, maxSize: 255
+        author blank: false
+        datePublished nullable: true
+        pages min: 1, nullable: true
+    }
+
+    static mapping = {
+        table 'books'
+        title column: 'book_title'
+        datePublished type: 'date'
+    }
+}
+```
+
+### Relationships
+```groovy
+class Author {
+    String name
+
+    static hasMany = [books: Book]
+
+    static mapping = {
+        books cascade: 'all-delete-orphan'
+    }
+}
+
+class Book {
+    String title
+
+    static belongsTo = [author: Author]
+}
+
+// Many-to-Many
+class Book {
+    static hasMany = [categories: Category]
+    static belongsTo = Category
+}
+
+class Category {
+    String name
+    static hasMany = [books: Book]
+}
+```
+
+### GORM Queries
+```groovy
+// Dynamic finders
+Book.findByTitle("Grails Guide")
+Book.findAllByAuthorLike("%Smith%")
+Book.findByTitleAndAuthor("Guide", "Smith")
+Book.countByPagesGreaterThan(100)
+
+// Where queries
+Book.where {
+    title =~ "%Grails%" && pages > 100
+}.list()
+
+// Criteria queries
+Book.withCriteria {
+    like('title', '%Grails%')
+    gt('pages', 100)
+    order('datePublished', 'desc')
+    maxResults(10)
+}
+
+// HQL queries
+Book.executeQuery(
+    "from Book b where b.author.name = :name",
+    [name: 'Smith']
+)
+
+// Detached criteria (reusable)
+def criteria = Book.where {
+    pages > 100
+}
+criteria.list()
+criteria.count()
+```
+
+### Transactions
+```groovy
+// In services (default transactional)
+@Transactional
+class BookService {
+    def saveBook(Book book) {
+        book.save(failOnError: true)
+    }
+}
+
+// Manual transaction control
+Book.withTransaction { status ->
+    def book = new Book(title: "Test")
+    book.save()
+    if (someCondition) {
+        status.setRollbackOnly()
+    }
+}
+```
+
+## Controllers
+
+### Basic Controller
+```groovy
+class BookController {
+
+    BookService bookService
+
+    static allowedMethods = [save: 'POST', update: 'PUT', delete: 'DELETE']
+
+    def index() {
+        respond Book.list(), model: [bookCount: Book.count()]
+    }
+
+    def show(Long id) {
+        respond Book.get(id)
+    }
+
+    def create() {
+        respond new Book(params)
+    }
+
+    def save(Book book) {
+        if (book.hasErrors()) {
+            respond book.errors, view: 'create'
+            return
+        }
+        bookService.save(book)
+        redirect action: 'show', id: book.id
+    }
+
+    def edit(Long id) {
+        respond Book.get(id)
+    }
+
+    def update(Book book) {
+        if (book.hasErrors()) {
+            respond book.errors, view: 'edit'
+            return
+        }
+        bookService.save(book)
+        redirect action: 'show', id: book.id
+    }
+
+    def delete(Long id) {
+        bookService.delete(id)
+        redirect action: 'index'
+    }
+}
+```
+
+### REST Controller
+```groovy
+import grails.rest.RestfulController
+
+class BookController extends RestfulController<Book> {
+
+    static responseFormats = ['json', 'xml']
+
+    BookController() {
+        super(Book)
+    }
+
+    // Override to customize
+    @Override
+    protected Book queryForResource(Serializable id) {
+        Book.where { id == id && active == true }.find()
+    }
+}
+```
+
+### Command Objects
+```groovy
+class BookCommand implements Validateable {
+    String title
+    String author
+    Integer pages
+
+    static constraints = {
+        title blank: false
+        author blank: false
+        pages min: 1, nullable: true
+    }
+}
+
+class BookController {
+    def save(BookCommand cmd) {
+        if (cmd.hasErrors()) {
+            respond cmd.errors
+            return
+        }
+        // Process valid command
+    }
+}
+```
+
+### Content Negotiation
+```groovy
+class BookController {
+    def show(Long id) {
+        def book = Book.get(id)
+        respond book  // Auto-negotiates based on Accept header
+    }
+}
+
+// Or explicit
+def show(Long id) {
+    def book = Book.get(id)
+    withFormat {
+        html { render view: 'show', model: [book: book] }
+        json { render book as JSON }
+        xml { render book as XML }
+    }
+}
+```
+
+## Services
+
+### Basic Service
+```groovy
+import grails.gorm.transactions.Transactional
+
+@Transactional
+class BookService {
+
+    def findByTitle(String title) {
+        Book.findByTitle(title)
+    }
+
+    def save(Book book) {
+        book.save(failOnError: true)
+    }
+
+    @Transactional(readOnly = true)
+    def list(Map params) {
+        Book.list(params)
+    }
+
+    def delete(Long id) {
+        Book.get(id)?.delete()
+    }
+}
+```
+
+### Service with Events
+```groovy
+import grails.events.annotation.Publisher
+import grails.events.annotation.Subscriber
+
+class BookService {
+
+    @Publisher
+    def save(Book book) {
+        book.save()
+        // Automatically publishes 'book.saved' event
+    }
+}
+
+class NotificationService {
+
+    @Subscriber('book.saved')
+    def onBookSaved(Book book) {
+        // Handle event
+        log.info "Book saved: ${book.title}"
+    }
+}
+```
+
+### Async Service
+```groovy
+import grails.async.Promise
+import static grails.async.Promises.*
+
+class BookService {
+
+    Promise<Book> findAsync(Long id) {
+        task {
+            Book.get(id)
+        }
+    }
+
+    def processBooks() {
+        def p1 = task { Book.findAllByActive(true) }
+        def p2 = task { Author.list() }
+
+        waitAll(p1, p2)
+        // Both complete
+    }
+}
+```
+
+## Views
+
+### GSP (Groovy Server Pages)
+```html
+<!-- grails-app/views/book/list.gsp -->
+<!DOCTYPE html>
+<html>
+<head>
+    <title>Books</title>
+    <asset:stylesheet src="application.css"/>
+</head>
+<body>
+    <h1>Books (${bookCount})</h1>
+
+    <g:each in="${bookList}" var="book">
+        <div class="book">
+            <h2>${book.title}</h2>
+            <p>By ${book.author}</p>
+            <g:link action="show" id="${book.id}">View</g:link>
+        </div>
+    </g:each>
+
+    <g:if test="${bookList.empty}">
+        <p>No books found.</p>
+    </g:if>
+
+    <g:paginate total="${bookCount}"/>
+
+    <asset:javascript src="application.js"/>
+</body>
+</html>
+```
+
+### Common GSP Tags
+```html
+<!-- Links -->
+<g:link controller="book" action="show" id="${book.id}">View</g:link>
+<g:createLink action="list"/>
+
+<!-- Forms -->
+<g:form action="save">
+    <g:textField name="title" value="${book?.title}"/>
+    <g:textArea name="description" value="${book?.description}"/>
+    <g:select name="category" from="${categories}" optionKey="id" optionValue="name"/>
+    <g:checkBox name="active" value="${book?.active}"/>
+    <g:submitButton name="submit" value="Save"/>
+</g:form>
+
+<!-- Conditionals -->
+<g:if test="${condition}">...</g:if>
+<g:elseif test="${other}">...</g:elseif>
+<g:else>...</g:else>
+
+<!-- Iteration -->
+<g:each in="${items}" var="item" status="i">
+    ${i}: ${item.name}
+</g:each>
+
+<!-- Rendering -->
+<g:render template="bookRow" model="[book: book]"/>
+<g:render template="bookRow" collection="${books}" var="book"/>
+
+<!-- Security (with Spring Security plugin) -->
+<sec:ifLoggedIn>Welcome, ${sec.username()}</sec:ifLoggedIn>
+<sec:ifNotLoggedIn><g:link controller="login">Login</g:link></sec:ifNotLoggedIn>
+```
+
+### JSON Views
+```groovy
+// grails-app/views/book/show.gson
+import myapp.Book
+
+model {
+    Book book
+}
+
+json {
+    id book.id
+    title book.title
+    author book.author
+    datePublished book.datePublished?.format('yyyy-MM-dd')
+    _links {
+        self {
+            href "/books/${book.id}"
+        }
+    }
+}
+```
+
+### Layouts
+```html
+<!-- grails-app/views/layouts/main.gsp -->
+<!DOCTYPE html>
+<html>
+<head>
+    <title><g:layoutTitle default="My App"/></title>
+    <asset:stylesheet src="application.css"/>
+    <g:layoutHead/>
+</head>
+<body>
+    <nav><!-- Navigation --></nav>
+    <main>
+        <g:layoutBody/>
+    </main>
+    <footer><!-- Footer --></footer>
+    <asset:javascript src="application.js"/>
+</body>
+</html>
+
+<!-- Use in views -->
+<html>
+<head>
+    <meta name="layout" content="main"/>
+    <title>Books</title>
+</head>
+<body>
+    <!-- Page content -->
+</body>
+</html>
+```
+
+## Interceptors
+
+```groovy
+class AuthInterceptor {
+
+    AuthInterceptor() {
+        matchAll()
+            .excludes(controller: 'login')
+            .excludes(controller: 'error')
+    }
+
+    boolean before() {
+        if (!session.user) {
+            redirect(controller: 'login')
+            return false
+        }
+        true
+    }
+
+    boolean after() {
+        // After action executes
+        true
+    }
+
+    void afterView() {
+        // After view renders
+    }
+}
+```
+
+## Tag Libraries
+
+```groovy
+class BookTagLib {
+
+    static namespace = 'book'
+    static defaultEncodeAs = [taglib: 'html']
+
+    def formatTitle = { attrs, body ->
+        def title = attrs.title ?: body()
+        out << "<span class='book-title'>${title}</span>"
+    }
+
+    def ifHasBooks = { attrs, body ->
+        if (Book.count() > 0) {
+            out << body()
+        }
+    }
+}
+
+// Usage in GSP
+<book:formatTitle title="${book.title}"/>
+<book:ifHasBooks>
+    <p>We have books!</p>
+</book:ifHasBooks>
+```
+
+## Configuration
+
+### application.yml
+```yaml
+grails:
+    profile: web
+    codegen:
+        defaultPackage: myapp
+    gorm:
+        reactor:
+            events: false
+    mime:
+        types:
+            json: ['application/json', 'text/json']
+            xml: ['text/xml', 'application/xml']
+
+environments:
+    development:
+        dataSource:
+            dbCreate: create-drop
+            url: jdbc:h2:mem:devDb
+    test:
+        dataSource:
+            dbCreate: update
+            url: jdbc:h2:mem:testDb
+    production:
+        dataSource:
+            dbCreate: none
+            url: jdbc:postgresql://localhost/myapp
+            driverClassName: org.postgresql.Driver
+            dialect: org.hibernate.dialect.PostgreSQLDialect
+            properties:
+                jmxEnabled: true
+                initialSize: 5
+                maxActive: 50
+
+server:
+    port: 8080
+    servlet:
+        context-path: /myapp
+```
+
+### URL Mappings
+```groovy
+// grails-app/controllers/myapp/UrlMappings.groovy
+class UrlMappings {
+
+    static mappings = {
+        // Default
+        "/$controller/$action?/$id?(.$format)?" {
+            constraints {
+                // apply constraints here
+            }
+        }
+
+        // REST resources
+        "/api/books"(resources: 'book')
+
+        // Custom mappings
+        "/books/$id"(controller: 'book', action: 'show')
+        "/search"(controller: 'book', action: 'search')
+
+        // Named URL mappings
+        name bookShow: "/books/$id" {
+            controller = 'book'
+            action = 'show'
+        }
+
+        // Error pages
+        "500"(view: '/error')
+        "404"(view: '/notFound')
+    }
+}
+```
+
+## Testing with Spock
+
+### Unit Test - Controller
+```groovy
+import grails.testing.web.controllers.ControllerUnitTest
+import spock.lang.Specification
+
+class BookControllerSpec extends Specification
+        implements ControllerUnitTest<BookController> {
+
+    def setup() {
+        controller.bookService = Mock(BookService)
+    }
+
+    void "index returns list of books"() {
+        given:
+        def books = [new Book(title: "Test")]
+        controller.bookService.list(_) >> books
+
+        when:
+        controller.index()
+
+        then:
+        model.bookList == books
+        view == '/book/index'
+    }
+
+    void "show returns 404 for missing book"() {
+        when:
+        controller.show(999)
+
+        then:
+        response.status == 404
+    }
+}
+```
+
+### Unit Test - Service
+```groovy
+import grails.testing.services.ServiceUnitTest
+import spock.lang.Specification
+
+class BookServiceSpec extends Specification
+        implements ServiceUnitTest<BookService> {
+
+    void "save persists book"() {
+        given:
+        def book = new Book(title: "Test", author: "Author")
+
+        when:
+        def result = service.save(book)
+
+        then:
+        result.id != null
+        Book.count() == 1
+    }
+}
+```
+
+### Unit Test - Domain
+```groovy
+import grails.testing.gorm.DomainUnitTest
+import spock.lang.Specification
+
+class BookSpec extends Specification
+        implements DomainUnitTest<Book> {
+
+    void "title cannot be blank"() {
+        when:
+        domain.title = ""
+        domain.author = "Test"
+
+        then:
+        !domain.validate(['title'])
+        domain.errors['title'].code == 'blank'
+    }
+
+    void "valid book passes validation"() {
+        when:
+        domain.title = "Valid Title"
+        domain.author = "Author"
+
+        then:
+        domain.validate()
+    }
+}
+```
+
+### Integration Test
+```groovy
+import grails.testing.mixin.integration.Integration
+import grails.gorm.transactions.Rollback
+import spock.lang.Specification
+
+@Integration
+@Rollback
+class BookServiceIntegrationSpec extends Specification {
+
+    BookService bookService
+
+    void "save and retrieve book"() {
+        given:
+        def book = new Book(title: "Integration Test", author: "Tester")
+
+        when:
+        bookService.save(book)
+        def found = Book.findByTitle("Integration Test")
+
+        then:
+        found != null
+        found.author == "Tester"
+    }
+}
+```
+
+### Functional Test with Geb
+```groovy
+import geb.spock.GebSpec
+import grails.testing.mixin.integration.Integration
+
+@Integration
+class BookFunctionalSpec extends GebSpec {
+
+    void "can view book list"() {
+        when:
+        go '/book/index'
+
+        then:
+        title == 'Book List'
+        $('h1').text() == 'Books'
+    }
+
+    void "can create new book"() {
+        when:
+        go '/book/create'
+        $('form').title = 'New Book'
+        $('form').author = 'Test Author'
+        $('input[type=submit]').click()
+
+        then:
+        $('h1').text().contains('New Book')
+    }
+}
+```
+
+## Plugins
+
+### Common Plugins
+```groovy
+// build.gradle
+
+// Spring Security
+implementation 'org.grails.plugins:spring-security-core:6.0.0'
+
+// Database Migration (Liquibase)
+implementation 'org.grails.plugins:database-migration:4.2.0'
+
+// Caching
+implementation 'org.grails.plugins:cache:6.0.0'
+
+// Async support
+implementation 'org.grails.plugins:async:5.0.0'
+
+// Fields plugin for form rendering
+implementation 'org.grails.plugins:fields:5.0.0'
+
+// Asset Pipeline
+runtimeOnly 'org.grails.plugins:asset-pipeline:5.0.0'
+```
+
+### Spring Security Configuration
+```groovy
+// grails-app/conf/application.groovy
+grails.plugin.springsecurity.userLookup.userDomainClassName = 'myapp.User'
+grails.plugin.springsecurity.userLookup.authorityJoinClassName = 'myapp.UserRole'
+grails.plugin.springsecurity.authority.className = 'myapp.Role'
+
+grails.plugin.springsecurity.controllerAnnotations.staticRules = [
+    [pattern: '/',               access: ['permitAll']],
+    [pattern: '/error',          access: ['permitAll']],
+    [pattern: '/index',          access: ['permitAll']],
+    [pattern: '/admin/**',       access: ['ROLE_ADMIN']],
+    [pattern: '/api/**',         access: ['isAuthenticated()']],
+]
+```
+
+## Build Commands
+
+```bash
+# Run application
+./gradlew bootRun
+
+# Run tests
+./gradlew test                                    # All tests

Review Comment:
   I believe `check` will run all verification tasks like `codenarc*` and `checkstyle*`?



##########
AGENTS.md:
##########
@@ -0,0 +1,260 @@
+<!--
+SPDX-License-Identifier: Apache-2.0
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+
+# Agent Guide for grails-core
+
+> **IMPORTANT**: This is the Grails Framework source repository (60+ modules), NOT a Grails application.
+> For building Grails apps, see `.agents/skills/grails-developer/SKILL.md`.
+
+## Quick Reference
+
+```bash
+# Build (no tests)
+./gradlew build -PskipTests
+
+# Build single module
+./gradlew :grails-core:build
+
+# Run tests
+./gradlew :<module>:test
+./gradlew :<module>:test --tests "com.example.SomeSpec"
+
+# Style check
+./gradlew codeStyle
+
+# Out of memory? Set:
+export GRADLE_OPTS="-Xms2G -Xmx5G"
+```
+
+## Critical Rules
+
+1. **Use `jakarta.*` NOT `javax.*`** - All packages migrated to Jakarta EE 10
+2. **Use `@GrailsCompileStatic`** - Not plain `@CompileStatic` in Grails classes
+3. **Use `GrailsWebRequest.lookup()`** - For thread-safe request context in tests
+4. **No wildcard imports** - Use explicit imports
+5. **4 spaces, no tabs** - See `.editorconfig`
+6. **Apache license header** - Required on all new source files
+
+## Available Skills
+
+> **AI AGENTS - MANDATORY**: Before writing or modifying any code, you **MUST** read the relevant skill file(s) below. Do not write Groovy/Grails code without first loading these instructions:
+> - Writing Grails code → Read `.agents/skills/grails-developer/SKILL.md`
+> - Writing Groovy code → Read `.agents/skills/groovy-developer/SKILL.md`
+> - Writing Java code → Read `.agents/skills/java-developer/SKILL.md`
+>
+> Use your file reading capability to load the skill content before proceeding with any code changes.
+
+| Skill | Path | Use For |
+|-------|------|---------|
+| **grails-developer** | `.agents/skills/grails-developer/SKILL.md` | Grails 7 apps, GORM, controllers, views |
+| **groovy-developer** | `.agents/skills/groovy-developer/SKILL.md` | Groovy 4 syntax, closures, DSLs, Spock |
+| **java-developer** | `.agents/skills/java-developer/SKILL.md` | Java 17 features, Groovy interop |
+
+## Technology Stack
+
+| Component | Version |
+|-----------|---------|
+| JDK | 17+ (baseline 17) |
+| Groovy | 4.0.x |
+| Spring Boot | 3.5.x |
+| Spring Framework | 6.2.x |
+| Spock | 2.3-groovy-4.0 |
+| Gradle | 8.14.x |
+| Jakarta EE | 10 |
+
+## Project Structure
+
+This repository contains multiple independent Gradle projects:
+
+| Project | Description | Build Command |
+|---------|-------------|---------------|
+| **grails-core** (root) | Main framework with 60+ modules | `./gradlew build` |
+| **build-logic/** | Gradle convention plugins for the build | `cd build-logic && ../gradlew build` |
+| **grails-gradle/** | Grails Gradle plugins | `cd grails-gradle && ./gradlew build` |
+| **grails-forge/** | Application generator (like Spring Initializr) | `cd grails-forge && ./gradlew build` |
+
+Each project has its own `settings.gradle` and independent build. When working on a specific project, run Gradle commands from that project's directory.
+
+## Key Modules
+
+**Core**: `grails-core`, `grails-bootstrap`, `grails-spring`, `grails-common`
+
+**Web**: `grails-web-core`, `grails-web-mvc`, `grails-controllers`, `grails-url-mappings`, `grails-interceptors`
+
+**GORM**: `grails-datastore-core`, `grails-datamapping-core`, `grails-domain-class`, `grails-validation`, `grails-databinding`
+
+**Views**: `grails-views-core`, `grails-views-gson`, `grails-views-markup`
+
+**Testing**: `grails-testing-support-core`, `grails-testing-support-web`, `grails-geb`
+
+**Other**: `grails-bom` (dependency management), `grails-doc`, `grails-shell-cli`, `grails-forge`
+
+## Artefact Types
+
+| Type | Pattern | Handler |
+|------|---------|---------|
+| Domain | `**/domain/**/*.groovy` | `DomainClassArtefactHandler` |
+| Controller | `**/*Controller.groovy` | `ControllerArtefactHandler` |
+| Service | `**/*Service.groovy` | `ServiceArtefactHandler` |
+| TagLib | `**/*TagLib.groovy` | `TagLibArtefactHandler` |
+| Interceptor | `**/*Interceptor.groovy` | `InterceptorArtefactHandler` |
+
+## Code Patterns
+
+### Spock Test Structure
+```groovy
+class MyServiceSpec extends Specification implements ServiceUnitTest<MyService> {
+    def "feature description"() {
+        given: "preconditions"
+        def input = "test"
+
+        when: "action"
+        def result = service.process(input)
+
+        then: "assertions"
+        result != null
+        result.status == "OK"
+    }
+}
+```
+
+### Mocking
+```groovy
+def repo = Mock(BookRepository)
+1 * repo.save(_) >> savedBook  // expect 1 call, return savedBook
+```
+
+### Data-Driven Tests
+```groovy
+@Unroll
+def "#a + #b == #c"() {
+    expect: a + b == c
+    where:
+    a | b || c
+    1 | 2 || 3
+    4 | 5 || 9
+}
+```
+
+### Framework Access
+```groovy
+// Thread-safe request context
+GrailsWebRequest webRequest = GrailsWebRequest.lookup()
+
+// Artefact registry
+grailsApplication.getArtefacts(DomainClassArtefactHandler.TYPE)
+```
+
+## Groovy Style
+
+```groovy
+// DO: Safe navigation
+book?.author?.name
+
+// DO: Elvis operator
+name ?: 'Unknown'
+
+// DO: GStrings
+"Hello ${user.name}"
+
+// DO: Spread operator
+books*.title
+
+// DO: Static compilation
+@GrailsCompileStatic

Review Comment:
   Or `@CompileStatic` if this is not a Grails artefact or not using any Grails specific dynamic conventions



##########
AGENTS.md:
##########
@@ -0,0 +1,260 @@
+<!--
+SPDX-License-Identifier: Apache-2.0
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+
+# Agent Guide for grails-core
+
+> **IMPORTANT**: This is the Grails Framework source repository (60+ modules), NOT a Grails application.
+> For building Grails apps, see `.agents/skills/grails-developer/SKILL.md`.
+
+## Quick Reference
+
+```bash
+# Build (no tests)
+./gradlew build -PskipTests
+
+# Build single module
+./gradlew :grails-core:build
+
+# Run tests
+./gradlew :<module>:test
+./gradlew :<module>:test --tests "com.example.SomeSpec"
+
+# Style check
+./gradlew codeStyle
+
+# Out of memory? Set:
+export GRADLE_OPTS="-Xms2G -Xmx5G"
+```
+
+## Critical Rules
+
+1. **Use `jakarta.*` NOT `javax.*`** - All packages migrated to Jakarta EE 10
+2. **Use `@GrailsCompileStatic`** - Not plain `@CompileStatic` in Grails classes
+3. **Use `GrailsWebRequest.lookup()`** - For thread-safe request context in tests
+4. **No wildcard imports** - Use explicit imports
+5. **4 spaces, no tabs** - See `.editorconfig`
+6. **Apache license header** - Required on all new source files
+
+## Available Skills
+
+> **AI AGENTS - MANDATORY**: Before writing or modifying any code, you **MUST** read the relevant skill file(s) below. Do not write Groovy/Grails code without first loading these instructions:
+> - Writing Grails code → Read `.agents/skills/grails-developer/SKILL.md`
+> - Writing Groovy code → Read `.agents/skills/groovy-developer/SKILL.md`
+> - Writing Java code → Read `.agents/skills/java-developer/SKILL.md`
+>
+> Use your file reading capability to load the skill content before proceeding with any code changes.
+
+| Skill | Path | Use For |
+|-------|------|---------|
+| **grails-developer** | `.agents/skills/grails-developer/SKILL.md` | Grails 7 apps, GORM, controllers, views |
+| **groovy-developer** | `.agents/skills/groovy-developer/SKILL.md` | Groovy 4 syntax, closures, DSLs, Spock |
+| **java-developer** | `.agents/skills/java-developer/SKILL.md` | Java 17 features, Groovy interop |
+
+## Technology Stack
+
+| Component | Version |
+|-----------|---------|
+| JDK | 17+ (baseline 17) |
+| Groovy | 4.0.x |
+| Spring Boot | 3.5.x |
+| Spring Framework | 6.2.x |
+| Spock | 2.3-groovy-4.0 |
+| Gradle | 8.14.x |
+| Jakarta EE | 10 |
+
+## Project Structure
+
+This repository contains multiple independent Gradle projects:
+
+| Project | Description | Build Command |
+|---------|-------------|---------------|
+| **grails-core** (root) | Main framework with 60+ modules | `./gradlew build` |
+| **build-logic/** | Gradle convention plugins for the build | `cd build-logic && ../gradlew build` |
+| **grails-gradle/** | Grails Gradle plugins | `cd grails-gradle && ./gradlew build` |
+| **grails-forge/** | Application generator (like Spring Initializr) | `cd grails-forge && ./gradlew build` |
+
+Each project has its own `settings.gradle` and independent build. When working on a specific project, run Gradle commands from that project's directory.
+
+## Key Modules
+
+**Core**: `grails-core`, `grails-bootstrap`, `grails-spring`, `grails-common`
+
+**Web**: `grails-web-core`, `grails-web-mvc`, `grails-controllers`, `grails-url-mappings`, `grails-interceptors`
+
+**GORM**: `grails-datastore-core`, `grails-datamapping-core`, `grails-domain-class`, `grails-validation`, `grails-databinding`
+
+**Views**: `grails-views-core`, `grails-views-gson`, `grails-views-markup`
+
+**Testing**: `grails-testing-support-core`, `grails-testing-support-web`, `grails-geb`
+
+**Other**: `grails-bom` (dependency management), `grails-doc`, `grails-shell-cli`, `grails-forge`
+
+## Artefact Types
+
+| Type | Pattern | Handler |
+|------|---------|---------|
+| Domain | `**/domain/**/*.groovy` | `DomainClassArtefactHandler` |
+| Controller | `**/*Controller.groovy` | `ControllerArtefactHandler` |
+| Service | `**/*Service.groovy` | `ServiceArtefactHandler` |
+| TagLib | `**/*TagLib.groovy` | `TagLibArtefactHandler` |
+| Interceptor | `**/*Interceptor.groovy` | `InterceptorArtefactHandler` |
+
+## Code Patterns
+
+### Spock Test Structure
+```groovy
+class MyServiceSpec extends Specification implements ServiceUnitTest<MyService> {
+    def "feature description"() {
+        given: "preconditions"
+        def input = "test"
+
+        when: "action"
+        def result = service.process(input)
+
+        then: "assertions"
+        result != null
+        result.status == "OK"
+    }
+}
+```
+
+### Mocking
+```groovy
+def repo = Mock(BookRepository)
+1 * repo.save(_) >> savedBook  // expect 1 call, return savedBook
+```
+
+### Data-Driven Tests
+```groovy
+@Unroll
+def "#a + #b == #c"() {
+    expect: a + b == c
+    where:
+    a | b || c
+    1 | 2 || 3
+    4 | 5 || 9
+}
+```
+
+### Framework Access
+```groovy
+// Thread-safe request context
+GrailsWebRequest webRequest = GrailsWebRequest.lookup()
+
+// Artefact registry
+grailsApplication.getArtefacts(DomainClassArtefactHandler.TYPE)
+```
+
+## Groovy Style
+
+```groovy
+// DO: Safe navigation
+book?.author?.name
+
+// DO: Elvis operator
+name ?: 'Unknown'
+
+// DO: GStrings
+"Hello ${user.name}"
+
+// DO: Spread operator
+books*.title
+
+// DO: Static compilation
+@GrailsCompileStatic
+class MyService { }
+
+// DON'T: Wildcard imports
+// import java.util.*  ❌
+
+// DON'T: javax packages
+// import javax.servlet.*  ❌ → use jakarta.servlet.*
+```
+
+## Test Isolation
+
+> **WARNING**: Tests run in parallel (`maxParallelForks > 1`). Static state causes flaky tests.
+
+- Use `GrailsWebRequest.lookup()` for thread-local context
+- Clear artefacts: `grailsApplication.artefactInfo.clear()`
+- Use `@ResourceLock` for shared resources
+
+## Build Commands
+
+| Task | Command |
+|------|---------|
+| Build (no tests) | `./gradlew build -PskipTests` |
+| Build module | `./gradlew :grails-core:build` |
+| Test module | `./gradlew :grails-core:test` |
+| Single test | `./gradlew :module:test --tests "pkg.MySpec"` |
+| Single feature | `./gradlew :module:test --tests "pkg.MySpec.feature name"` |
+| Force rerun | `./gradlew :module:test --rerun-tasks` |
+| Style check | `./gradlew codeStyle` |
+| Build docs | `./gradlew :grails-doc:publishGuide -x aggregateGroovydoc` |
+| Debug | `./gradlew bootRun --debug-jvm` |
+
+## Branch Naming (Auto-Labels PRs)
+
+| Prefix | Label |
+|--------|-------|
+| `fix/` | bug |
+| `feat/`, `feature/` | feature |
+| `docs/` | documentation |
+| `chore/`, `refactor/`, `test/`, `ci/`, `perf/`, `build/` | maintenance |
+| `deps/` | deps |
+
+## Pull Request Guidelines
+
+1. **Fork & branch** from the target release branch (e.g., `7.0.x`)
+2. **Run tests** before submitting: `./gradlew build --rerun-tasks`
+3. **Run code style checks**: `./gradlew codeStyle`
+4. **Squash commits** into a single meaningful commit message
+5. **Reference issues** in PR description (e.g., "Fixes #1234")
+
+### Review Process
+
+| Change Type | Review Policy | Reviewers | Wait Period |
+|-------------|---------------|-----------|-------------|
+| Build/CI changes | Commit then Review | - | - |
+| Documentation | Commit then Review (obvious fixes) | 1 minimum | - |
+| Groovy/Spring dependency changes | Review then Commit | 2-3 required | 3 days (weekend) / 1 day (weekday) |
+| All other changes | Review then Commit | 1 required | - |
+
+See `CONTRIBUTING.md` for full details.
+
+## Common Issues
+
+| Problem | Solution |
+|---------|----------|
+| Out of memory | `export GRADLE_OPTS="-Xms2G -Xmx5G"` |
+| Container missing | Use `-PskipTests` or install Docker/Podman |
+| Flaky tests | Check static state pollution, use `@ResourceLock` |
+| Cache issues | `./gradlew --rerun-tasks` |
+| Deprecation details | `./gradlew <task> --warning-mode all` |
+
+
+### Reporting Vulnerabilities
+
+Please see the page of the [ASF Security Team](https://www.apache.org/security/) for further information and contact information.
+
+## Resources
+
+- **Grails 7 Guide**: https://docs.grails.org/latest/guide/single.html
+- **Groovy 4 Docs**: https://docs.groovy-lang.org/docs/groovy-4.0.30/html/documentation/
+- **Spock 2.3 Docs**: https://spockframework.org/spock/docs/2.3/all_in_one.html
+- **GORM Docs**: https://gorm.grails.org/latest/

Review Comment:
   https://grails.apache.org/docs/latest/grails-data/



##########
AGENTS.md:
##########
@@ -0,0 +1,260 @@
+<!--
+SPDX-License-Identifier: Apache-2.0
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+
+# Agent Guide for grails-core
+
+> **IMPORTANT**: This is the Grails Framework source repository (60+ modules), NOT a Grails application.
+> For building Grails apps, see `.agents/skills/grails-developer/SKILL.md`.
+
+## Quick Reference
+
+```bash
+# Build (no tests)
+./gradlew build -PskipTests
+
+# Build single module
+./gradlew :grails-core:build
+
+# Run tests
+./gradlew :<module>:test
+./gradlew :<module>:test --tests "com.example.SomeSpec"
+
+# Style check
+./gradlew codeStyle
+
+# Out of memory? Set:
+export GRADLE_OPTS="-Xms2G -Xmx5G"
+```
+
+## Critical Rules
+
+1. **Use `jakarta.*` NOT `javax.*`** - All packages migrated to Jakarta EE 10
+2. **Use `@GrailsCompileStatic`** - Not plain `@CompileStatic` in Grails classes
+3. **Use `GrailsWebRequest.lookup()`** - For thread-safe request context in tests
+4. **No wildcard imports** - Use explicit imports
+5. **4 spaces, no tabs** - See `.editorconfig`
+6. **Apache license header** - Required on all new source files
+
+## Available Skills
+
+> **AI AGENTS - MANDATORY**: Before writing or modifying any code, you **MUST** read the relevant skill file(s) below. Do not write Groovy/Grails code without first loading these instructions:
+> - Writing Grails code → Read `.agents/skills/grails-developer/SKILL.md`
+> - Writing Groovy code → Read `.agents/skills/groovy-developer/SKILL.md`
+> - Writing Java code → Read `.agents/skills/java-developer/SKILL.md`
+>
+> Use your file reading capability to load the skill content before proceeding with any code changes.
+
+| Skill | Path | Use For |
+|-------|------|---------|
+| **grails-developer** | `.agents/skills/grails-developer/SKILL.md` | Grails 7 apps, GORM, controllers, views |
+| **groovy-developer** | `.agents/skills/groovy-developer/SKILL.md` | Groovy 4 syntax, closures, DSLs, Spock |
+| **java-developer** | `.agents/skills/java-developer/SKILL.md` | Java 17 features, Groovy interop |
+
+## Technology Stack
+
+| Component | Version |
+|-----------|---------|
+| JDK | 17+ (baseline 17) |
+| Groovy | 4.0.x |
+| Spring Boot | 3.5.x |
+| Spring Framework | 6.2.x |
+| Spock | 2.3-groovy-4.0 |
+| Gradle | 8.14.x |
+| Jakarta EE | 10 |
+
+## Project Structure
+
+This repository contains multiple independent Gradle projects:
+
+| Project | Description | Build Command |
+|---------|-------------|---------------|
+| **grails-core** (root) | Main framework with 60+ modules | `./gradlew build` |
+| **build-logic/** | Gradle convention plugins for the build | `cd build-logic && ../gradlew build` |
+| **grails-gradle/** | Grails Gradle plugins | `cd grails-gradle && ./gradlew build` |
+| **grails-forge/** | Application generator (like Spring Initializr) | `cd grails-forge && ./gradlew build` |
+
+Each project has its own `settings.gradle` and independent build. When working on a specific project, run Gradle commands from that project's directory.
+
+## Key Modules
+
+**Core**: `grails-core`, `grails-bootstrap`, `grails-spring`, `grails-common`
+
+**Web**: `grails-web-core`, `grails-web-mvc`, `grails-controllers`, `grails-url-mappings`, `grails-interceptors`
+
+**GORM**: `grails-datastore-core`, `grails-datamapping-core`, `grails-domain-class`, `grails-validation`, `grails-databinding`
+
+**Views**: `grails-views-core`, `grails-views-gson`, `grails-views-markup`
+
+**Testing**: `grails-testing-support-core`, `grails-testing-support-web`, `grails-geb`
+
+**Other**: `grails-bom` (dependency management), `grails-doc`, `grails-shell-cli`, `grails-forge`
+
+## Artefact Types
+
+| Type | Pattern | Handler |
+|------|---------|---------|
+| Domain | `**/domain/**/*.groovy` | `DomainClassArtefactHandler` |
+| Controller | `**/*Controller.groovy` | `ControllerArtefactHandler` |
+| Service | `**/*Service.groovy` | `ServiceArtefactHandler` |
+| TagLib | `**/*TagLib.groovy` | `TagLibArtefactHandler` |
+| Interceptor | `**/*Interceptor.groovy` | `InterceptorArtefactHandler` |
+
+## Code Patterns
+
+### Spock Test Structure
+```groovy
+class MyServiceSpec extends Specification implements ServiceUnitTest<MyService> {
+    def "feature description"() {
+        given: "preconditions"
+        def input = "test"
+
+        when: "action"
+        def result = service.process(input)
+
+        then: "assertions"
+        result != null
+        result.status == "OK"
+    }
+}
+```
+
+### Mocking
+```groovy
+def repo = Mock(BookRepository)
+1 * repo.save(_) >> savedBook  // expect 1 call, return savedBook
+```
+
+### Data-Driven Tests
+```groovy
+@Unroll
+def "#a + #b == #c"() {
+    expect: a + b == c
+    where:
+    a | b || c
+    1 | 2 || 3
+    4 | 5 || 9
+}
+```
+
+### Framework Access
+```groovy
+// Thread-safe request context
+GrailsWebRequest webRequest = GrailsWebRequest.lookup()
+
+// Artefact registry
+grailsApplication.getArtefacts(DomainClassArtefactHandler.TYPE)
+```
+
+## Groovy Style
+
+```groovy
+// DO: Safe navigation
+book?.author?.name
+
+// DO: Elvis operator
+name ?: 'Unknown'
+
+// DO: GStrings
+"Hello ${user.name}"
+
+// DO: Spread operator
+books*.title
+
+// DO: Static compilation
+@GrailsCompileStatic
+class MyService { }
+
+// DON'T: Wildcard imports
+// import java.util.*  ❌
+
+// DON'T: javax packages
+// import javax.servlet.*  ❌ → use jakarta.servlet.*
+```
+
+## Test Isolation
+
+> **WARNING**: Tests run in parallel (`maxParallelForks > 1`). Static state causes flaky tests.
+
+- Use `GrailsWebRequest.lookup()` for thread-local context
+- Clear artefacts: `grailsApplication.artefactInfo.clear()`
+- Use `@ResourceLock` for shared resources
+
+## Build Commands
+
+| Task | Command |
+|------|---------|
+| Build (no tests) | `./gradlew build -PskipTests` |
+| Build module | `./gradlew :grails-core:build` |
+| Test module | `./gradlew :grails-core:test` |
+| Single test | `./gradlew :module:test --tests "pkg.MySpec"` |
+| Single feature | `./gradlew :module:test --tests "pkg.MySpec.feature name"` |
+| Force rerun | `./gradlew :module:test --rerun-tasks` |
+| Style check | `./gradlew codeStyle` |
+| Build docs | `./gradlew :grails-doc:publishGuide -x aggregateGroovydoc` |
+| Debug | `./gradlew bootRun --debug-jvm` |
+
+## Branch Naming (Auto-Labels PRs)
+
+| Prefix | Label |
+|--------|-------|
+| `fix/` | bug |
+| `feat/`, `feature/` | feature |
+| `docs/` | documentation |
+| `chore/`, `refactor/`, `test/`, `ci/`, `perf/`, `build/` | maintenance |
+| `deps/` | deps |
+
+## Pull Request Guidelines
+
+1. **Fork & branch** from the target release branch (e.g., `7.0.x`)
+2. **Run tests** before submitting: `./gradlew build --rerun-tasks`
+3. **Run code style checks**: `./gradlew codeStyle`
+4. **Squash commits** into a single meaningful commit message
+5. **Reference issues** in PR description (e.g., "Fixes #1234")
+
+### Review Process
+
+| Change Type | Review Policy | Reviewers | Wait Period |
+|-------------|---------------|-----------|-------------|
+| Build/CI changes | Commit then Review | - | - |
+| Documentation | Commit then Review (obvious fixes) | 1 minimum | - |
+| Groovy/Spring dependency changes | Review then Commit | 2-3 required | 3 days (weekend) / 1 day (weekday) |
+| All other changes | Review then Commit | 1 required | - |
+
+See `CONTRIBUTING.md` for full details.
+
+## Common Issues
+
+| Problem | Solution |
+|---------|----------|
+| Out of memory | `export GRADLE_OPTS="-Xms2G -Xmx5G"` |
+| Container missing | Use `-PskipTests` or install Docker/Podman |
+| Flaky tests | Check static state pollution, use `@ResourceLock` |

Review Comment:
   Remove `@ResourceLock`?



##########
AGENTS.md:
##########
@@ -0,0 +1,260 @@
+<!--
+SPDX-License-Identifier: Apache-2.0
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+
+# Agent Guide for grails-core
+
+> **IMPORTANT**: This is the Grails Framework source repository (60+ modules), NOT a Grails application.
+> For building Grails apps, see `.agents/skills/grails-developer/SKILL.md`.
+
+## Quick Reference
+
+```bash
+# Build (no tests)
+./gradlew build -PskipTests
+
+# Build single module
+./gradlew :grails-core:build
+
+# Run tests
+./gradlew :<module>:test
+./gradlew :<module>:test --tests "com.example.SomeSpec"
+
+# Style check
+./gradlew codeStyle
+
+# Out of memory? Set:
+export GRADLE_OPTS="-Xms2G -Xmx5G"
+```
+
+## Critical Rules
+
+1. **Use `jakarta.*` NOT `javax.*`** - All packages migrated to Jakarta EE 10
+2. **Use `@GrailsCompileStatic`** - Not plain `@CompileStatic` in Grails classes
+3. **Use `GrailsWebRequest.lookup()`** - For thread-safe request context in tests
+4. **No wildcard imports** - Use explicit imports
+5. **4 spaces, no tabs** - See `.editorconfig`
+6. **Apache license header** - Required on all new source files
+
+## Available Skills
+
+> **AI AGENTS - MANDATORY**: Before writing or modifying any code, you **MUST** read the relevant skill file(s) below. Do not write Groovy/Grails code without first loading these instructions:
+> - Writing Grails code → Read `.agents/skills/grails-developer/SKILL.md`
+> - Writing Groovy code → Read `.agents/skills/groovy-developer/SKILL.md`
+> - Writing Java code → Read `.agents/skills/java-developer/SKILL.md`
+>
+> Use your file reading capability to load the skill content before proceeding with any code changes.
+
+| Skill | Path | Use For |
+|-------|------|---------|
+| **grails-developer** | `.agents/skills/grails-developer/SKILL.md` | Grails 7 apps, GORM, controllers, views |
+| **groovy-developer** | `.agents/skills/groovy-developer/SKILL.md` | Groovy 4 syntax, closures, DSLs, Spock |
+| **java-developer** | `.agents/skills/java-developer/SKILL.md` | Java 17 features, Groovy interop |
+
+## Technology Stack
+
+| Component | Version |
+|-----------|---------|
+| JDK | 17+ (baseline 17) |
+| Groovy | 4.0.x |
+| Spring Boot | 3.5.x |
+| Spring Framework | 6.2.x |
+| Spock | 2.3-groovy-4.0 |
+| Gradle | 8.14.x |
+| Jakarta EE | 10 |
+
+## Project Structure
+
+This repository contains multiple independent Gradle projects:
+
+| Project | Description | Build Command |
+|---------|-------------|---------------|
+| **grails-core** (root) | Main framework with 60+ modules | `./gradlew build` |
+| **build-logic/** | Gradle convention plugins for the build | `cd build-logic && ../gradlew build` |
+| **grails-gradle/** | Grails Gradle plugins | `cd grails-gradle && ./gradlew build` |
+| **grails-forge/** | Application generator (like Spring Initializr) | `cd grails-forge && ./gradlew build` |
+
+Each project has its own `settings.gradle` and independent build. When working on a specific project, run Gradle commands from that project's directory.
+
+## Key Modules
+
+**Core**: `grails-core`, `grails-bootstrap`, `grails-spring`, `grails-common`
+
+**Web**: `grails-web-core`, `grails-web-mvc`, `grails-controllers`, `grails-url-mappings`, `grails-interceptors`
+
+**GORM**: `grails-datastore-core`, `grails-datamapping-core`, `grails-domain-class`, `grails-validation`, `grails-databinding`
+
+**Views**: `grails-views-core`, `grails-views-gson`, `grails-views-markup`
+
+**Testing**: `grails-testing-support-core`, `grails-testing-support-web`, `grails-geb`
+
+**Other**: `grails-bom` (dependency management), `grails-doc`, `grails-shell-cli`, `grails-forge`
+
+## Artefact Types
+
+| Type | Pattern | Handler |
+|------|---------|---------|
+| Domain | `**/domain/**/*.groovy` | `DomainClassArtefactHandler` |
+| Controller | `**/*Controller.groovy` | `ControllerArtefactHandler` |
+| Service | `**/*Service.groovy` | `ServiceArtefactHandler` |
+| TagLib | `**/*TagLib.groovy` | `TagLibArtefactHandler` |
+| Interceptor | `**/*Interceptor.groovy` | `InterceptorArtefactHandler` |
+
+## Code Patterns
+
+### Spock Test Structure
+```groovy
+class MyServiceSpec extends Specification implements ServiceUnitTest<MyService> {
+    def "feature description"() {
+        given: "preconditions"
+        def input = "test"
+
+        when: "action"
+        def result = service.process(input)
+
+        then: "assertions"
+        result != null
+        result.status == "OK"
+    }
+}
+```
+
+### Mocking
+```groovy
+def repo = Mock(BookRepository)
+1 * repo.save(_) >> savedBook  // expect 1 call, return savedBook
+```
+
+### Data-Driven Tests
+```groovy
+@Unroll
+def "#a + #b == #c"() {
+    expect: a + b == c
+    where:
+    a | b || c
+    1 | 2 || 3
+    4 | 5 || 9
+}
+```
+
+### Framework Access
+```groovy
+// Thread-safe request context
+GrailsWebRequest webRequest = GrailsWebRequest.lookup()
+
+// Artefact registry
+grailsApplication.getArtefacts(DomainClassArtefactHandler.TYPE)
+```
+
+## Groovy Style
+
+```groovy
+// DO: Safe navigation
+book?.author?.name
+
+// DO: Elvis operator
+name ?: 'Unknown'
+
+// DO: GStrings
+"Hello ${user.name}"
+
+// DO: Spread operator
+books*.title
+
+// DO: Static compilation
+@GrailsCompileStatic
+class MyService { }
+
+// DON'T: Wildcard imports
+// import java.util.*  ❌
+
+// DON'T: javax packages
+// import javax.servlet.*  ❌ → use jakarta.servlet.*
+```
+
+## Test Isolation
+
+> **WARNING**: Tests run in parallel (`maxParallelForks > 1`). Static state causes flaky tests.
+
+- Use `GrailsWebRequest.lookup()` for thread-local context
+- Clear artefacts: `grailsApplication.artefactInfo.clear()`
+- Use `@ResourceLock` for shared resources

Review Comment:
   `@ResourceLock` is used with Spock parallel execution. We do not use Spock parallel execution. `@Shared` is used for fields that should be reused by multiple feature methods in a Spec. 



##########
AGENTS.md:
##########
@@ -0,0 +1,260 @@
+<!--
+SPDX-License-Identifier: Apache-2.0
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+
+# Agent Guide for grails-core
+
+> **IMPORTANT**: This is the Grails Framework source repository (60+ modules), NOT a Grails application.
+> For building Grails apps, see `.agents/skills/grails-developer/SKILL.md`.
+
+## Quick Reference
+
+```bash
+# Build (no tests)
+./gradlew build -PskipTests
+
+# Build single module
+./gradlew :grails-core:build
+
+# Run tests
+./gradlew :<module>:test
+./gradlew :<module>:test --tests "com.example.SomeSpec"
+
+# Style check
+./gradlew codeStyle
+
+# Out of memory? Set:
+export GRADLE_OPTS="-Xms2G -Xmx5G"
+```
+
+## Critical Rules
+
+1. **Use `jakarta.*` NOT `javax.*`** - All packages migrated to Jakarta EE 10
+2. **Use `@GrailsCompileStatic`** - Not plain `@CompileStatic` in Grails classes
+3. **Use `GrailsWebRequest.lookup()`** - For thread-safe request context in tests
+4. **No wildcard imports** - Use explicit imports
+5. **4 spaces, no tabs** - See `.editorconfig`
+6. **Apache license header** - Required on all new source files
+
+## Available Skills
+
+> **AI AGENTS - MANDATORY**: Before writing or modifying any code, you **MUST** read the relevant skill file(s) below. Do not write Groovy/Grails code without first loading these instructions:
+> - Writing Grails code → Read `.agents/skills/grails-developer/SKILL.md`
+> - Writing Groovy code → Read `.agents/skills/groovy-developer/SKILL.md`
+> - Writing Java code → Read `.agents/skills/java-developer/SKILL.md`
+>
+> Use your file reading capability to load the skill content before proceeding with any code changes.
+
+| Skill | Path | Use For |
+|-------|------|---------|
+| **grails-developer** | `.agents/skills/grails-developer/SKILL.md` | Grails 7 apps, GORM, controllers, views |
+| **groovy-developer** | `.agents/skills/groovy-developer/SKILL.md` | Groovy 4 syntax, closures, DSLs, Spock |
+| **java-developer** | `.agents/skills/java-developer/SKILL.md` | Java 17 features, Groovy interop |
+
+## Technology Stack
+
+| Component | Version |
+|-----------|---------|
+| JDK | 17+ (baseline 17) |
+| Groovy | 4.0.x |
+| Spring Boot | 3.5.x |
+| Spring Framework | 6.2.x |
+| Spock | 2.3-groovy-4.0 |
+| Gradle | 8.14.x |
+| Jakarta EE | 10 |
+
+## Project Structure
+
+This repository contains multiple independent Gradle projects:
+
+| Project | Description | Build Command |
+|---------|-------------|---------------|
+| **grails-core** (root) | Main framework with 60+ modules | `./gradlew build` |
+| **build-logic/** | Gradle convention plugins for the build | `cd build-logic && ../gradlew build` |
+| **grails-gradle/** | Grails Gradle plugins | `cd grails-gradle && ./gradlew build` |
+| **grails-forge/** | Application generator (like Spring Initializr) | `cd grails-forge && ./gradlew build` |
+
+Each project has its own `settings.gradle` and independent build. When working on a specific project, run Gradle commands from that project's directory.
+
+## Key Modules
+
+**Core**: `grails-core`, `grails-bootstrap`, `grails-spring`, `grails-common`
+
+**Web**: `grails-web-core`, `grails-web-mvc`, `grails-controllers`, `grails-url-mappings`, `grails-interceptors`
+
+**GORM**: `grails-datastore-core`, `grails-datamapping-core`, `grails-domain-class`, `grails-validation`, `grails-databinding`
+
+**Views**: `grails-views-core`, `grails-views-gson`, `grails-views-markup`
+
+**Testing**: `grails-testing-support-core`, `grails-testing-support-web`, `grails-geb`
+
+**Other**: `grails-bom` (dependency management), `grails-doc`, `grails-shell-cli`, `grails-forge`
+
+## Artefact Types
+
+| Type | Pattern | Handler |
+|------|---------|---------|
+| Domain | `**/domain/**/*.groovy` | `DomainClassArtefactHandler` |
+| Controller | `**/*Controller.groovy` | `ControllerArtefactHandler` |
+| Service | `**/*Service.groovy` | `ServiceArtefactHandler` |
+| TagLib | `**/*TagLib.groovy` | `TagLibArtefactHandler` |
+| Interceptor | `**/*Interceptor.groovy` | `InterceptorArtefactHandler` |
+
+## Code Patterns
+
+### Spock Test Structure
+```groovy
+class MyServiceSpec extends Specification implements ServiceUnitTest<MyService> {
+    def "feature description"() {
+        given: "preconditions"
+        def input = "test"
+
+        when: "action"
+        def result = service.process(input)
+
+        then: "assertions"
+        result != null
+        result.status == "OK"
+    }
+}
+```
+
+### Mocking
+```groovy
+def repo = Mock(BookRepository)
+1 * repo.save(_) >> savedBook  // expect 1 call, return savedBook
+```
+
+### Data-Driven Tests
+```groovy
+@Unroll
+def "#a + #b == #c"() {
+    expect: a + b == c
+    where:
+    a | b || c
+    1 | 2 || 3
+    4 | 5 || 9
+}
+```
+
+### Framework Access
+```groovy
+// Thread-safe request context
+GrailsWebRequest webRequest = GrailsWebRequest.lookup()
+
+// Artefact registry
+grailsApplication.getArtefacts(DomainClassArtefactHandler.TYPE)
+```
+
+## Groovy Style
+
+```groovy
+// DO: Safe navigation
+book?.author?.name
+
+// DO: Elvis operator
+name ?: 'Unknown'
+
+// DO: GStrings
+"Hello ${user.name}"
+
+// DO: Spread operator
+books*.title
+
+// DO: Static compilation
+@GrailsCompileStatic
+class MyService { }
+
+// DON'T: Wildcard imports
+// import java.util.*  ❌
+
+// DON'T: javax packages
+// import javax.servlet.*  ❌ → use jakarta.servlet.*
+```
+
+## Test Isolation
+
+> **WARNING**: Tests run in parallel (`maxParallelForks > 1`). Static state causes flaky tests.
+
+- Use `GrailsWebRequest.lookup()` for thread-local context
+- Clear artefacts: `grailsApplication.artefactInfo.clear()`
+- Use `@ResourceLock` for shared resources
+
+## Build Commands
+
+| Task | Command |
+|------|---------|
+| Build (no tests) | `./gradlew build -PskipTests` |
+| Build module | `./gradlew :grails-core:build` |
+| Test module | `./gradlew :grails-core:test` |
+| Single test | `./gradlew :module:test --tests "pkg.MySpec"` |
+| Single feature | `./gradlew :module:test --tests "pkg.MySpec.feature name"` |
+| Force rerun | `./gradlew :module:test --rerun-tasks` |
+| Style check | `./gradlew codeStyle` |
+| Build docs | `./gradlew :grails-doc:publishGuide -x aggregateGroovydoc` |
+| Debug | `./gradlew bootRun --debug-jvm` |
+
+## Branch Naming (Auto-Labels PRs)
+
+| Prefix | Label |
+|--------|-------|
+| `fix/` | bug |
+| `feat/`, `feature/` | feature |
+| `docs/` | documentation |
+| `chore/`, `refactor/`, `test/`, `ci/`, `perf/`, `build/` | maintenance |
+| `deps/` | deps |
+
+## Pull Request Guidelines
+
+1. **Fork & branch** from the target release branch (e.g., `7.0.x`)
+2. **Run tests** before submitting: `./gradlew build --rerun-tasks`
+3. **Run code style checks**: `./gradlew codeStyle`
+4. **Squash commits** into a single meaningful commit message
+5. **Reference issues** in PR description (e.g., "Fixes #1234")
+
+### Review Process
+
+| Change Type | Review Policy | Reviewers | Wait Period |
+|-------------|---------------|-----------|-------------|
+| Build/CI changes | Commit then Review | - | - |
+| Documentation | Commit then Review (obvious fixes) | 1 minimum | - |
+| Groovy/Spring dependency changes | Review then Commit | 2-3 required | 3 days (weekend) / 1 day (weekday) |
+| All other changes | Review then Commit | 1 required | - |
+
+See `CONTRIBUTING.md` for full details.
+
+## Common Issues
+
+| Problem | Solution |
+|---------|----------|
+| Out of memory | `export GRADLE_OPTS="-Xms2G -Xmx5G"` |
+| Container missing | Use `-PskipTests` or install Docker/Podman |
+| Flaky tests | Check static state pollution, use `@ResourceLock` |
+| Cache issues | `./gradlew --rerun-tasks` |
+| Deprecation details | `./gradlew <task> --warning-mode all` |
+
+
+### Reporting Vulnerabilities
+
+Please see the page of the [ASF Security Team](https://www.apache.org/security/) for further information and contact information.
+
+## Resources
+
+- **Grails 7 Guide**: https://docs.grails.org/latest/guide/single.html

Review Comment:
   https://grails.apache.org/docs/latest/guide/single.html



##########
.agents/skills/groovy-developer/SKILL.md:
##########
@@ -0,0 +1,520 @@
+<!--
+SPDX-License-Identifier: Apache-2.0
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+---
+name: groovy-developer
+description: Expert guide for Groovy 4 development, covering concise syntax, closures, DSLs, metaprogramming, static compilation, and integration with Java 17 and Grails
+license: Apache-2.0
+compatibility: opencode, claude, grok, gemini, copilot, cursor, windsurf
+metadata:
+  audience: developers
+  languages: groovy, java
+  versions: 4.0
+  paradigms: dynamic, static, functional, object-oriented, DSL-oriented
+---
+
+## What I Do
+
+- Provide deep expertise in Groovy 4.0, including core language features: syntax, closures, traits, GStrings, operators, and Groovy Truth.
+- Guide metaprogramming techniques: runtime (categories, ExpandoMetaClass, extension modules) and compile-time (AST transformations like @Immutable, @Builder, @Delegate, @Singleton, @Log, @Memoized).
+- Assist with DSL creation and usage (MarkupBuilder, JsonBuilder, builders for configuration).
+- Support testing with Spock Framework (BDD, data-driven tests, mocking) and built-in power assertions.
+- Help integrate Groovy with Java 17: joint compilation, Gradle builds, Grails, and Spring Boot.
+- Cover data handling: JSON/XML parsing and building, Groovy SQL, collection processing.
+- Advise on performance: @CompileStatic, @TypeChecked, @GrailsCompileStatic for optimal execution.
+
+## When to Use Me
+
+Activate this skill for any Groovy-related task, including:
+
+- Writing or debugging Groovy classes in Grails domain, controllers, services, or taglibs.
+- Building or enhancing Gradle build scripts (build.gradle).
+- Creating DSLs for configuration, testing, or business rules.
+- Writing Spock specifications for unit and integration tests.
+- Migrating from older Groovy versions (2.x/3.x) to 4.0.
+- Performance optimization with static compilation.
+- Working with JSON/XML data, GORM criteria queries, or builders.
+
+## Groovy 4 Key Features
+
+### Concise Syntax
+```groovy
+// No semicolons required
+def name = "Grails"
+
+// Optional parentheses for method calls
+println "Hello World"
+list.each { println it }
+
+// Optional return keyword
+String greet(String name) {
+    "Hello, $name"  // Last expression is returned
+}
+```
+
+### GStrings (String Interpolation)
+```groovy
+def user = "Alice"
+def count = 42
+
+// Simple interpolation
+println "User: $user"
+
+// Expression interpolation
+println "Items: ${count * 2}"
+
+// Lazy GStrings (evaluated when accessed)
+def lazy = "Count is ${ -> counter }"
+
+// Multi-line strings
+def sql = """
+    SELECT * FROM users
+    WHERE name = '$user'
+    ORDER BY created_at
+"""
+```
+
+### Closures
+```groovy
+// Basic closure
+def greet = { name -> "Hello, $name" }
+println greet("World")
+
+// Implicit 'it' parameter
+def double = { it * 2 }
+println [1, 2, 3].collect(double)
+
+// Closure with delegate (for DSLs)
+def configure = {
+    name = "MyApp"
+    version = "1.0"
+}
+configure.delegate = new Config()
+configure.resolveStrategy = Closure.DELEGATE_FIRST
+configure()
+
+// Method references
+def upper = String.&toUpperCase
+println ["a", "b"].collect(upper)
+```
+
+### Safe Navigation and Elvis Operator
+```groovy
+// Safe navigation - returns null if any part is null
+def city = user?.address?.city
+
+// Elvis operator - default value if null
+def name = user?.name ?: "Anonymous"
+
+// Safe method calls
+def length = text?.length() ?: 0
+
+// Combine with collections
+def firstTitle = books?.first()?.title ?: "No books"
+```
+
+### Spread Operator
+```groovy
+// Spread operator for collections
+def names = users*.name  // Same as users.collect { it.name }
+
+// Spread for method arguments
+def args = [1, 2, 3]
+someMethod(*args)
+
+// Spread in list literals
+def combined = [*list1, *list2]
+```
+
+### Collection Literals and Methods
+```groovy
+// List literal
+def list = [1, 2, 3, 4, 5]
+
+// Map literal
+def map = [name: "Grails", version: 7]
+
+// Range
+def range = 1..10
+def exclusive = 1..<10
+
+// Powerful collection methods
+list.find { it > 3 }           // First match: 4
+list.findAll { it > 3 }        // All matches: [4, 5]
+list.any { it > 3 }            // true
+list.every { it > 0 }          // true
+list.groupBy { it % 2 }        // [0:[2,4], 1:[1,3,5]]
+list.collectEntries { [it, it * 2] }  // [1:2, 2:4, ...]
+
+// Sorting
+list.sort { a, b -> b <=> a }  // Descending
+list.sort { -it }              // Descending (numeric)
+```
+
+### Groovy Truth
+```groovy
+// Falsy values: null, empty string, empty collection, 0, false
+if (list) { }      // True if not null and not empty
+if (string) { }    // True if not null and not blank
+if (number) { }    // True if not 0
+
+// Useful in conditionals
+def items = getItems() ?: []  // Default to empty list
+```
+
+### Records (Incubating)

Review Comment:
   Are records incubating?



##########
.agents/skills/groovy-developer/SKILL.md:
##########
@@ -0,0 +1,520 @@
+<!--
+SPDX-License-Identifier: Apache-2.0
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+---
+name: groovy-developer
+description: Expert guide for Groovy 4 development, covering concise syntax, closures, DSLs, metaprogramming, static compilation, and integration with Java 17 and Grails
+license: Apache-2.0
+compatibility: opencode, claude, grok, gemini, copilot, cursor, windsurf
+metadata:
+  audience: developers
+  languages: groovy, java
+  versions: 4.0
+  paradigms: dynamic, static, functional, object-oriented, DSL-oriented
+---
+
+## What I Do
+
+- Provide deep expertise in Groovy 4.0, including core language features: syntax, closures, traits, GStrings, operators, and Groovy Truth.
+- Guide metaprogramming techniques: runtime (categories, ExpandoMetaClass, extension modules) and compile-time (AST transformations like @Immutable, @Builder, @Delegate, @Singleton, @Log, @Memoized).
+- Assist with DSL creation and usage (MarkupBuilder, JsonBuilder, builders for configuration).
+- Support testing with Spock Framework (BDD, data-driven tests, mocking) and built-in power assertions.
+- Help integrate Groovy with Java 17: joint compilation, Gradle builds, Grails, and Spring Boot.
+- Cover data handling: JSON/XML parsing and building, Groovy SQL, collection processing.
+- Advise on performance: @CompileStatic, @TypeChecked, @GrailsCompileStatic for optimal execution.
+
+## When to Use Me
+
+Activate this skill for any Groovy-related task, including:
+
+- Writing or debugging Groovy classes in Grails domain, controllers, services, or taglibs.
+- Building or enhancing Gradle build scripts (build.gradle).
+- Creating DSLs for configuration, testing, or business rules.
+- Writing Spock specifications for unit and integration tests.
+- Migrating from older Groovy versions (2.x/3.x) to 4.0.
+- Performance optimization with static compilation.
+- Working with JSON/XML data, GORM criteria queries, or builders.
+
+## Groovy 4 Key Features
+
+### Concise Syntax
+```groovy
+// No semicolons required
+def name = "Grails"
+
+// Optional parentheses for method calls
+println "Hello World"
+list.each { println it }
+
+// Optional return keyword
+String greet(String name) {
+    "Hello, $name"  // Last expression is returned
+}
+```
+
+### GStrings (String Interpolation)
+```groovy
+def user = "Alice"
+def count = 42
+
+// Simple interpolation
+println "User: $user"
+
+// Expression interpolation
+println "Items: ${count * 2}"
+
+// Lazy GStrings (evaluated when accessed)
+def lazy = "Count is ${ -> counter }"
+
+// Multi-line strings
+def sql = """
+    SELECT * FROM users
+    WHERE name = '$user'
+    ORDER BY created_at
+"""
+```
+
+### Closures
+```groovy
+// Basic closure
+def greet = { name -> "Hello, $name" }
+println greet("World")
+
+// Implicit 'it' parameter
+def double = { it * 2 }

Review Comment:
   `double` is a reserved word?



##########
AGENTS.md:
##########
@@ -0,0 +1,260 @@
+<!--
+SPDX-License-Identifier: Apache-2.0
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+
+# Agent Guide for grails-core
+
+> **IMPORTANT**: This is the Grails Framework source repository (60+ modules), NOT a Grails application.
+> For building Grails apps, see `.agents/skills/grails-developer/SKILL.md`.
+
+## Quick Reference
+
+```bash
+# Build (no tests)
+./gradlew build -PskipTests
+
+# Build single module
+./gradlew :grails-core:build
+
+# Run tests
+./gradlew :<module>:test
+./gradlew :<module>:test --tests "com.example.SomeSpec"
+
+# Style check
+./gradlew codeStyle
+
+# Out of memory? Set:
+export GRADLE_OPTS="-Xms2G -Xmx5G"
+```
+
+## Critical Rules
+
+1. **Use `jakarta.*` NOT `javax.*`** - All packages migrated to Jakarta EE 10
+2. **Use `@GrailsCompileStatic`** - Not plain `@CompileStatic` in Grails classes

Review Comment:
   ..."in Grails artefact classes"



##########
.agents/skills/grails-developer/SKILL.md:
##########
@@ -0,0 +1,883 @@
+<!--
+SPDX-License-Identifier: Apache-2.0
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+---
+name: grails-developer
+description: Comprehensive guide for Grails 7 development, covering web applications, REST APIs, GORM, controllers, services, views, plugins, and testing with Spock and Geb
+license: Apache-2.0
+compatibility: opencode, claude, grok, gemini, copilot, cursor, windsurf
+metadata:
+  audience: developers
+  frameworks: grails
+  versions: 7
+---
+
+## What I Do
+
+- Provide detailed guidance for building Grails 7 web applications and REST APIs.
+- Assist with GORM for data modeling, controllers for request handling, services for business logic, and views (GSP, JSON, Markup).
+- Support testing with Spock 2.3 (unit/integration tests) and Geb for browser automation.
+- Guide plugin usage and development, security implementation, and deployment strategies.
+- Help with configuration, internationalization, async programming, and performance optimization.
+
+## When to Use Me
+
+Activate this skill when developing with Grails 7, including:
+
+- Building CRUD applications, RESTful APIs, or full-stack web applications.
+- Working with GORM domain classes, constraints, and relationships.
+- Creating controllers, services, interceptors, or tag libraries.
+- Writing Spock specifications or Geb functional tests.
+- Configuring plugins, security, caching, or database migrations.
+- Deploying Grails applications to containers or cloud platforms.
+
+## Technology Stack
+
+Grails 7 is built on:
+- **Spring Boot**: 3.5.x
+- **Spring Framework**: 6.2.x
+- **Groovy**: 4.0.x
+- **Gradle**: 8.14.x
+- **Spock**: 2.3-groovy-4.0
+- **Jakarta EE**: 10 (migrated from javax.*)
+- **Micronaut**: Optional via `grails-micronaut` plugin
+
+## Project Structure
+
+```
+myapp/
+├── grails-app/
+│   ├── conf/                 # Configuration
+│   │   ├── application.yml   # Main config
+│   │   ├── logback.xml       # Logging config
+│   │   └── spring/           # Spring bean definitions
+│   ├── controllers/          # Request handlers
+│   ├── domain/               # GORM domain classes
+│   ├── i18n/                 # Message bundles
+│   ├── init/                 # Bootstrap classes
+│   ├── services/             # Business logic
+│   ├── taglib/               # Custom GSP tags
+│   ├── utils/                # Utility classes
+│   └── views/                # GSP templates
+├── src/
+│   ├── main/groovy/          # Additional Groovy classes
+│   ├── main/java/            # Java classes
+│   └── test/groovy/          # Test specifications
+├── build.gradle              # Build configuration
+└── gradle.properties         # Project properties
+```
+
+## Domain Classes (GORM)
+
+### Basic Domain Class
+```groovy
+class Book {
+    String title
+    String author
+    Date datePublished
+    Integer pages
+
+    static constraints = {
+        title blank: false, maxSize: 255
+        author blank: false
+        datePublished nullable: true
+        pages min: 1, nullable: true
+    }
+
+    static mapping = {
+        table 'books'
+        title column: 'book_title'
+        datePublished type: 'date'
+    }
+}
+```
+
+### Relationships
+```groovy
+class Author {
+    String name
+
+    static hasMany = [books: Book]
+
+    static mapping = {
+        books cascade: 'all-delete-orphan'
+    }
+}
+
+class Book {
+    String title
+
+    static belongsTo = [author: Author]
+}
+
+// Many-to-Many
+class Book {
+    static hasMany = [categories: Category]
+    static belongsTo = Category
+}
+
+class Category {
+    String name
+    static hasMany = [books: Book]
+}
+```
+
+### GORM Queries
+```groovy
+// Dynamic finders
+Book.findByTitle("Grails Guide")
+Book.findAllByAuthorLike("%Smith%")
+Book.findByTitleAndAuthor("Guide", "Smith")
+Book.countByPagesGreaterThan(100)
+
+// Where queries
+Book.where {
+    title =~ "%Grails%" && pages > 100
+}.list()
+
+// Criteria queries
+Book.withCriteria {
+    like('title', '%Grails%')
+    gt('pages', 100)
+    order('datePublished', 'desc')
+    maxResults(10)
+}
+
+// HQL queries
+Book.executeQuery(
+    "from Book b where b.author.name = :name",
+    [name: 'Smith']
+)
+
+// Detached criteria (reusable)
+def criteria = Book.where {
+    pages > 100
+}
+criteria.list()
+criteria.count()
+```
+
+### Transactions
+```groovy
+// In services (default transactional)
+@Transactional
+class BookService {
+    def saveBook(Book book) {
+        book.save(failOnError: true)
+    }
+}
+
+// Manual transaction control
+Book.withTransaction { status ->
+    def book = new Book(title: "Test")
+    book.save()
+    if (someCondition) {
+        status.setRollbackOnly()
+    }
+}
+```
+
+## Controllers
+
+### Basic Controller
+```groovy
+class BookController {
+
+    BookService bookService
+
+    static allowedMethods = [save: 'POST', update: 'PUT', delete: 'DELETE']
+
+    def index() {
+        respond Book.list(), model: [bookCount: Book.count()]
+    }
+
+    def show(Long id) {
+        respond Book.get(id)
+    }
+
+    def create() {
+        respond new Book(params)
+    }
+
+    def save(Book book) {
+        if (book.hasErrors()) {
+            respond book.errors, view: 'create'
+            return
+        }
+        bookService.save(book)
+        redirect action: 'show', id: book.id
+    }
+
+    def edit(Long id) {
+        respond Book.get(id)
+    }
+
+    def update(Book book) {
+        if (book.hasErrors()) {
+            respond book.errors, view: 'edit'
+            return
+        }
+        bookService.save(book)
+        redirect action: 'show', id: book.id
+    }
+
+    def delete(Long id) {
+        bookService.delete(id)
+        redirect action: 'index'
+    }
+}
+```
+
+### REST Controller
+```groovy
+import grails.rest.RestfulController
+
+class BookController extends RestfulController<Book> {
+
+    static responseFormats = ['json', 'xml']
+
+    BookController() {
+        super(Book)
+    }
+
+    // Override to customize
+    @Override
+    protected Book queryForResource(Serializable id) {
+        Book.where { id == id && active == true }.find()
+    }
+}
+```
+
+### Command Objects
+```groovy
+class BookCommand implements Validateable {
+    String title
+    String author
+    Integer pages
+
+    static constraints = {
+        title blank: false
+        author blank: false
+        pages min: 1, nullable: true
+    }
+}
+
+class BookController {
+    def save(BookCommand cmd) {
+        if (cmd.hasErrors()) {
+            respond cmd.errors
+            return
+        }
+        // Process valid command
+    }
+}
+```
+
+### Content Negotiation
+```groovy
+class BookController {
+    def show(Long id) {
+        def book = Book.get(id)
+        respond book  // Auto-negotiates based on Accept header
+    }
+}
+
+// Or explicit
+def show(Long id) {
+    def book = Book.get(id)
+    withFormat {
+        html { render view: 'show', model: [book: book] }
+        json { render book as JSON }
+        xml { render book as XML }
+    }
+}
+```
+
+## Services
+
+### Basic Service
+```groovy
+import grails.gorm.transactions.Transactional
+
+@Transactional
+class BookService {
+
+    def findByTitle(String title) {
+        Book.findByTitle(title)
+    }
+
+    def save(Book book) {
+        book.save(failOnError: true)
+    }
+
+    @Transactional(readOnly = true)
+    def list(Map params) {
+        Book.list(params)
+    }
+
+    def delete(Long id) {
+        Book.get(id)?.delete()
+    }
+}
+```
+
+### Service with Events
+```groovy
+import grails.events.annotation.Publisher
+import grails.events.annotation.Subscriber
+
+class BookService {
+
+    @Publisher
+    def save(Book book) {
+        book.save()
+        // Automatically publishes 'book.saved' event
+    }
+}
+
+class NotificationService {
+
+    @Subscriber('book.saved')
+    def onBookSaved(Book book) {
+        // Handle event
+        log.info "Book saved: ${book.title}"
+    }
+}
+```
+
+### Async Service
+```groovy
+import grails.async.Promise
+import static grails.async.Promises.*
+
+class BookService {
+
+    Promise<Book> findAsync(Long id) {
+        task {
+            Book.get(id)
+        }
+    }
+
+    def processBooks() {
+        def p1 = task { Book.findAllByActive(true) }
+        def p2 = task { Author.list() }
+
+        waitAll(p1, p2)
+        // Both complete
+    }
+}
+```
+
+## Views
+
+### GSP (Groovy Server Pages)
+```html
+<!-- grails-app/views/book/list.gsp -->
+<!DOCTYPE html>
+<html>
+<head>
+    <title>Books</title>
+    <asset:stylesheet src="application.css"/>
+</head>
+<body>
+    <h1>Books (${bookCount})</h1>
+
+    <g:each in="${bookList}" var="book">
+        <div class="book">
+            <h2>${book.title}</h2>
+            <p>By ${book.author}</p>
+            <g:link action="show" id="${book.id}">View</g:link>
+        </div>
+    </g:each>
+
+    <g:if test="${bookList.empty}">
+        <p>No books found.</p>
+    </g:if>
+
+    <g:paginate total="${bookCount}"/>
+
+    <asset:javascript src="application.js"/>
+</body>
+</html>
+```
+
+### Common GSP Tags
+```html
+<!-- Links -->
+<g:link controller="book" action="show" id="${book.id}">View</g:link>
+<g:createLink action="list"/>
+
+<!-- Forms -->
+<g:form action="save">
+    <g:textField name="title" value="${book?.title}"/>
+    <g:textArea name="description" value="${book?.description}"/>
+    <g:select name="category" from="${categories}" optionKey="id" optionValue="name"/>
+    <g:checkBox name="active" value="${book?.active}"/>
+    <g:submitButton name="submit" value="Save"/>
+</g:form>
+
+<!-- Conditionals -->
+<g:if test="${condition}">...</g:if>
+<g:elseif test="${other}">...</g:elseif>
+<g:else>...</g:else>
+
+<!-- Iteration -->
+<g:each in="${items}" var="item" status="i">
+    ${i}: ${item.name}
+</g:each>
+
+<!-- Rendering -->
+<g:render template="bookRow" model="[book: book]"/>
+<g:render template="bookRow" collection="${books}" var="book"/>
+
+<!-- Security (with Spring Security plugin) -->
+<sec:ifLoggedIn>Welcome, ${sec.username()}</sec:ifLoggedIn>
+<sec:ifNotLoggedIn><g:link controller="login">Login</g:link></sec:ifNotLoggedIn>
+```
+
+### JSON Views
+```groovy
+// grails-app/views/book/show.gson
+import myapp.Book
+
+model {
+    Book book
+}
+
+json {
+    id book.id
+    title book.title
+    author book.author
+    datePublished book.datePublished?.format('yyyy-MM-dd')
+    _links {
+        self {
+            href "/books/${book.id}"
+        }
+    }
+}
+```
+
+### Layouts
+```html
+<!-- grails-app/views/layouts/main.gsp -->
+<!DOCTYPE html>
+<html>
+<head>
+    <title><g:layoutTitle default="My App"/></title>
+    <asset:stylesheet src="application.css"/>
+    <g:layoutHead/>
+</head>
+<body>
+    <nav><!-- Navigation --></nav>
+    <main>
+        <g:layoutBody/>
+    </main>
+    <footer><!-- Footer --></footer>
+    <asset:javascript src="application.js"/>
+</body>
+</html>
+
+<!-- Use in views -->
+<html>
+<head>
+    <meta name="layout" content="main"/>
+    <title>Books</title>
+</head>
+<body>
+    <!-- Page content -->
+</body>
+</html>
+```
+
+## Interceptors
+
+```groovy
+class AuthInterceptor {
+
+    AuthInterceptor() {
+        matchAll()
+            .excludes(controller: 'login')
+            .excludes(controller: 'error')
+    }
+
+    boolean before() {
+        if (!session.user) {
+            redirect(controller: 'login')
+            return false
+        }
+        true
+    }
+
+    boolean after() {
+        // After action executes
+        true
+    }
+
+    void afterView() {
+        // After view renders
+    }
+}
+```
+
+## Tag Libraries
+
+```groovy
+class BookTagLib {
+
+    static namespace = 'book'
+    static defaultEncodeAs = [taglib: 'html']
+
+    def formatTitle = { attrs, body ->
+        def title = attrs.title ?: body()
+        out << "<span class='book-title'>${title}</span>"
+    }
+
+    def ifHasBooks = { attrs, body ->
+        if (Book.count() > 0) {
+            out << body()
+        }
+    }
+}
+
+// Usage in GSP
+<book:formatTitle title="${book.title}"/>
+<book:ifHasBooks>
+    <p>We have books!</p>
+</book:ifHasBooks>
+```
+
+## Configuration
+
+### application.yml
+```yaml
+grails:
+    profile: web
+    codegen:
+        defaultPackage: myapp
+    gorm:
+        reactor:
+            events: false
+    mime:
+        types:
+            json: ['application/json', 'text/json']
+            xml: ['text/xml', 'application/xml']
+
+environments:
+    development:
+        dataSource:
+            dbCreate: create-drop
+            url: jdbc:h2:mem:devDb
+    test:
+        dataSource:
+            dbCreate: update
+            url: jdbc:h2:mem:testDb
+    production:
+        dataSource:
+            dbCreate: none
+            url: jdbc:postgresql://localhost/myapp
+            driverClassName: org.postgresql.Driver
+            dialect: org.hibernate.dialect.PostgreSQLDialect
+            properties:
+                jmxEnabled: true
+                initialSize: 5
+                maxActive: 50
+
+server:
+    port: 8080
+    servlet:
+        context-path: /myapp
+```
+
+### URL Mappings
+```groovy
+// grails-app/controllers/myapp/UrlMappings.groovy
+class UrlMappings {
+
+    static mappings = {
+        // Default
+        "/$controller/$action?/$id?(.$format)?" {
+            constraints {
+                // apply constraints here
+            }
+        }
+
+        // REST resources
+        "/api/books"(resources: 'book')
+
+        // Custom mappings
+        "/books/$id"(controller: 'book', action: 'show')
+        "/search"(controller: 'book', action: 'search')
+
+        // Named URL mappings
+        name bookShow: "/books/$id" {
+            controller = 'book'
+            action = 'show'
+        }
+
+        // Error pages
+        "500"(view: '/error')
+        "404"(view: '/notFound')
+    }
+}
+```
+
+## Testing with Spock
+
+### Unit Test - Controller
+```groovy
+import grails.testing.web.controllers.ControllerUnitTest
+import spock.lang.Specification
+
+class BookControllerSpec extends Specification
+        implements ControllerUnitTest<BookController> {
+
+    def setup() {
+        controller.bookService = Mock(BookService)
+    }
+
+    void "index returns list of books"() {
+        given:
+        def books = [new Book(title: "Test")]
+        controller.bookService.list(_) >> books
+
+        when:
+        controller.index()
+
+        then:
+        model.bookList == books
+        view == '/book/index'
+    }
+
+    void "show returns 404 for missing book"() {
+        when:
+        controller.show(999)
+
+        then:
+        response.status == 404
+    }
+}
+```
+
+### Unit Test - Service
+```groovy
+import grails.testing.services.ServiceUnitTest
+import spock.lang.Specification
+
+class BookServiceSpec extends Specification
+        implements ServiceUnitTest<BookService> {
+
+    void "save persists book"() {
+        given:
+        def book = new Book(title: "Test", author: "Author")
+
+        when:
+        def result = service.save(book)
+
+        then:
+        result.id != null
+        Book.count() == 1
+    }
+}
+```
+
+### Unit Test - Domain
+```groovy
+import grails.testing.gorm.DomainUnitTest
+import spock.lang.Specification
+
+class BookSpec extends Specification
+        implements DomainUnitTest<Book> {
+
+    void "title cannot be blank"() {
+        when:
+        domain.title = ""
+        domain.author = "Test"
+
+        then:
+        !domain.validate(['title'])
+        domain.errors['title'].code == 'blank'
+    }
+
+    void "valid book passes validation"() {
+        when:
+        domain.title = "Valid Title"
+        domain.author = "Author"
+
+        then:
+        domain.validate()
+    }
+}
+```
+
+### Integration Test
+```groovy
+import grails.testing.mixin.integration.Integration
+import grails.gorm.transactions.Rollback
+import spock.lang.Specification
+
+@Integration
+@Rollback
+class BookServiceIntegrationSpec extends Specification {
+
+    BookService bookService
+
+    void "save and retrieve book"() {
+        given:
+        def book = new Book(title: "Integration Test", author: "Tester")
+
+        when:
+        bookService.save(book)
+        def found = Book.findByTitle("Integration Test")
+
+        then:
+        found != null
+        found.author == "Tester"
+    }
+}
+```
+
+### Functional Test with Geb
+```groovy
+import geb.spock.GebSpec
+import grails.testing.mixin.integration.Integration
+
+@Integration
+class BookFunctionalSpec extends GebSpec {
+
+    void "can view book list"() {
+        when:
+        go '/book/index'
+
+        then:
+        title == 'Book List'
+        $('h1').text() == 'Books'
+    }
+
+    void "can create new book"() {
+        when:
+        go '/book/create'
+        $('form').title = 'New Book'
+        $('form').author = 'Test Author'
+        $('input[type=submit]').click()
+
+        then:
+        $('h1').text().contains('New Book')
+    }
+}
+```
+
+## Plugins
+
+### Common Plugins
+```groovy
+// build.gradle
+
+// Spring Security
+implementation 'org.grails.plugins:spring-security-core:6.0.0'
+
+// Database Migration (Liquibase)
+implementation 'org.grails.plugins:database-migration:4.2.0'
+
+// Caching
+implementation 'org.grails.plugins:cache:6.0.0'
+
+// Async support
+implementation 'org.grails.plugins:async:5.0.0'
+
+// Fields plugin for form rendering
+implementation 'org.grails.plugins:fields:5.0.0'
+
+// Asset Pipeline
+runtimeOnly 'org.grails.plugins:asset-pipeline:5.0.0'
+```
+
+### Spring Security Configuration
+```groovy
+// grails-app/conf/application.groovy
+grails.plugin.springsecurity.userLookup.userDomainClassName = 'myapp.User'
+grails.plugin.springsecurity.userLookup.authorityJoinClassName = 'myapp.UserRole'
+grails.plugin.springsecurity.authority.className = 'myapp.Role'
+
+grails.plugin.springsecurity.controllerAnnotations.staticRules = [
+    [pattern: '/',               access: ['permitAll']],
+    [pattern: '/error',          access: ['permitAll']],
+    [pattern: '/index',          access: ['permitAll']],
+    [pattern: '/admin/**',       access: ['ROLE_ADMIN']],
+    [pattern: '/api/**',         access: ['isAuthenticated()']],
+]
+```
+
+## Build Commands
+
+```bash
+# Run application
+./gradlew bootRun
+
+# Run tests
+./gradlew test                                    # All tests
+./gradlew test --tests "BookServiceSpec"          # Single spec
+./gradlew test --tests "*Spec.save*"              # Pattern match
+./gradlew integrationTest                         # Integration tests
+
+# Build
+./gradlew build -PskipTests                       # Build without tests
+./gradlew bootJar                                 # Executable JAR
+./gradlew bootWar                                 # WAR file
+
+# Code quality
+./gradlew codeStyle                               # Check style
+
+# Clean
+./gradlew clean
+```
+
+## Best Practices
+
+### Convention Over Configuration
+- Follow Grails naming conventions for automatic wiring.
+- Use standard directory structure.
+- Let Grails infer configurations where possible.
+
+### Performance
+- Use `@GrailsCompileStatic` on controllers and services.
+- Enable query caching for read-heavy operations.
+- Use pagination for large result sets.
+- Avoid N+1 queries with eager fetching or batch size.
+
+### Security
+- Use CSRF tokens in forms: `<g:form useToken="true">`.
+- Apply Spring Security for authentication/authorization.
+- Use parameterized queries (GORM handles this automatically).
+- Encode output to prevent XSS.
+
+### Testing
+- Write unit tests for domain constraints.
+- Test controllers with `ControllerUnitTest`.
+- Use integration tests for service/database interactions.
+- Use Geb for critical user workflows.
+
+### Code Style
+- Use `@GrailsCompileStatic` for type safety and performance.
+- Prefer services for business logic over controllers.
+- Use command objects for complex form handling.
+- Keep controllers thin, services fat.
+
+## Resources
+
+- **Grails 7 User Guide**: https://docs.grails.org/latest/guide/single.html
+- **GORM Documentation**: https://gorm.grails.org/latest/

Review Comment:
   https://grails.apache.org/docs/latest/grails-data/



##########
.agents/skills/grails-developer/SKILL.md:
##########
@@ -0,0 +1,883 @@
+<!--
+SPDX-License-Identifier: Apache-2.0
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+---
+name: grails-developer
+description: Comprehensive guide for Grails 7 development, covering web applications, REST APIs, GORM, controllers, services, views, plugins, and testing with Spock and Geb
+license: Apache-2.0
+compatibility: opencode, claude, grok, gemini, copilot, cursor, windsurf
+metadata:
+  audience: developers
+  frameworks: grails
+  versions: 7
+---
+
+## What I Do
+
+- Provide detailed guidance for building Grails 7 web applications and REST APIs.
+- Assist with GORM for data modeling, controllers for request handling, services for business logic, and views (GSP, JSON, Markup).
+- Support testing with Spock 2.3 (unit/integration tests) and Geb for browser automation.
+- Guide plugin usage and development, security implementation, and deployment strategies.
+- Help with configuration, internationalization, async programming, and performance optimization.
+
+## When to Use Me
+
+Activate this skill when developing with Grails 7, including:
+
+- Building CRUD applications, RESTful APIs, or full-stack web applications.
+- Working with GORM domain classes, constraints, and relationships.
+- Creating controllers, services, interceptors, or tag libraries.
+- Writing Spock specifications or Geb functional tests.
+- Configuring plugins, security, caching, or database migrations.
+- Deploying Grails applications to containers or cloud platforms.
+
+## Technology Stack
+
+Grails 7 is built on:
+- **Spring Boot**: 3.5.x
+- **Spring Framework**: 6.2.x
+- **Groovy**: 4.0.x
+- **Gradle**: 8.14.x
+- **Spock**: 2.3-groovy-4.0
+- **Jakarta EE**: 10 (migrated from javax.*)
+- **Micronaut**: Optional via `grails-micronaut` plugin
+
+## Project Structure
+
+```
+myapp/
+├── grails-app/
+│   ├── conf/                 # Configuration
+│   │   ├── application.yml   # Main config
+│   │   ├── logback.xml       # Logging config
+│   │   └── spring/           # Spring bean definitions
+│   ├── controllers/          # Request handlers
+│   ├── domain/               # GORM domain classes
+│   ├── i18n/                 # Message bundles
+│   ├── init/                 # Bootstrap classes
+│   ├── services/             # Business logic
+│   ├── taglib/               # Custom GSP tags
+│   ├── utils/                # Utility classes
+│   └── views/                # GSP templates
+├── src/
+│   ├── main/groovy/          # Additional Groovy classes
+│   ├── main/java/            # Java classes
+│   └── test/groovy/          # Test specifications
+├── build.gradle              # Build configuration
+└── gradle.properties         # Project properties
+```
+
+## Domain Classes (GORM)
+
+### Basic Domain Class
+```groovy
+class Book {
+    String title
+    String author
+    Date datePublished
+    Integer pages
+
+    static constraints = {
+        title blank: false, maxSize: 255
+        author blank: false
+        datePublished nullable: true
+        pages min: 1, nullable: true
+    }
+
+    static mapping = {
+        table 'books'
+        title column: 'book_title'
+        datePublished type: 'date'
+    }
+}
+```
+
+### Relationships
+```groovy
+class Author {
+    String name
+
+    static hasMany = [books: Book]
+
+    static mapping = {
+        books cascade: 'all-delete-orphan'
+    }
+}
+
+class Book {
+    String title
+
+    static belongsTo = [author: Author]
+}
+
+// Many-to-Many
+class Book {
+    static hasMany = [categories: Category]
+    static belongsTo = Category
+}
+
+class Category {
+    String name
+    static hasMany = [books: Book]
+}
+```
+
+### GORM Queries
+```groovy
+// Dynamic finders
+Book.findByTitle("Grails Guide")
+Book.findAllByAuthorLike("%Smith%")
+Book.findByTitleAndAuthor("Guide", "Smith")
+Book.countByPagesGreaterThan(100)
+
+// Where queries
+Book.where {
+    title =~ "%Grails%" && pages > 100
+}.list()
+
+// Criteria queries
+Book.withCriteria {
+    like('title', '%Grails%')
+    gt('pages', 100)
+    order('datePublished', 'desc')
+    maxResults(10)
+}
+
+// HQL queries
+Book.executeQuery(
+    "from Book b where b.author.name = :name",
+    [name: 'Smith']
+)
+
+// Detached criteria (reusable)
+def criteria = Book.where {
+    pages > 100
+}
+criteria.list()
+criteria.count()
+```
+
+### Transactions
+```groovy
+// In services (default transactional)
+@Transactional
+class BookService {
+    def saveBook(Book book) {
+        book.save(failOnError: true)
+    }
+}
+
+// Manual transaction control
+Book.withTransaction { status ->
+    def book = new Book(title: "Test")
+    book.save()
+    if (someCondition) {
+        status.setRollbackOnly()
+    }
+}
+```
+
+## Controllers
+
+### Basic Controller
+```groovy
+class BookController {
+
+    BookService bookService
+
+    static allowedMethods = [save: 'POST', update: 'PUT', delete: 'DELETE']
+
+    def index() {
+        respond Book.list(), model: [bookCount: Book.count()]
+    }
+
+    def show(Long id) {
+        respond Book.get(id)
+    }
+
+    def create() {
+        respond new Book(params)
+    }
+
+    def save(Book book) {
+        if (book.hasErrors()) {
+            respond book.errors, view: 'create'
+            return
+        }
+        bookService.save(book)
+        redirect action: 'show', id: book.id
+    }
+
+    def edit(Long id) {
+        respond Book.get(id)
+    }
+
+    def update(Book book) {
+        if (book.hasErrors()) {
+            respond book.errors, view: 'edit'
+            return
+        }
+        bookService.save(book)
+        redirect action: 'show', id: book.id
+    }
+
+    def delete(Long id) {
+        bookService.delete(id)
+        redirect action: 'index'
+    }
+}
+```
+
+### REST Controller
+```groovy
+import grails.rest.RestfulController
+
+class BookController extends RestfulController<Book> {
+
+    static responseFormats = ['json', 'xml']
+
+    BookController() {
+        super(Book)
+    }
+
+    // Override to customize
+    @Override
+    protected Book queryForResource(Serializable id) {
+        Book.where { id == id && active == true }.find()
+    }
+}
+```
+
+### Command Objects
+```groovy
+class BookCommand implements Validateable {
+    String title
+    String author
+    Integer pages
+
+    static constraints = {
+        title blank: false
+        author blank: false
+        pages min: 1, nullable: true
+    }
+}
+
+class BookController {
+    def save(BookCommand cmd) {
+        if (cmd.hasErrors()) {
+            respond cmd.errors
+            return
+        }
+        // Process valid command
+    }
+}
+```
+
+### Content Negotiation
+```groovy
+class BookController {
+    def show(Long id) {
+        def book = Book.get(id)
+        respond book  // Auto-negotiates based on Accept header
+    }
+}
+
+// Or explicit
+def show(Long id) {
+    def book = Book.get(id)
+    withFormat {
+        html { render view: 'show', model: [book: book] }
+        json { render book as JSON }
+        xml { render book as XML }
+    }
+}
+```
+
+## Services
+
+### Basic Service
+```groovy
+import grails.gorm.transactions.Transactional
+
+@Transactional
+class BookService {
+
+    def findByTitle(String title) {
+        Book.findByTitle(title)
+    }
+
+    def save(Book book) {
+        book.save(failOnError: true)
+    }
+
+    @Transactional(readOnly = true)
+    def list(Map params) {
+        Book.list(params)
+    }
+
+    def delete(Long id) {
+        Book.get(id)?.delete()
+    }
+}
+```
+
+### Service with Events
+```groovy
+import grails.events.annotation.Publisher
+import grails.events.annotation.Subscriber
+
+class BookService {
+
+    @Publisher
+    def save(Book book) {
+        book.save()
+        // Automatically publishes 'book.saved' event
+    }
+}
+
+class NotificationService {
+
+    @Subscriber('book.saved')
+    def onBookSaved(Book book) {
+        // Handle event
+        log.info "Book saved: ${book.title}"
+    }
+}
+```
+
+### Async Service
+```groovy
+import grails.async.Promise
+import static grails.async.Promises.*
+
+class BookService {
+
+    Promise<Book> findAsync(Long id) {
+        task {
+            Book.get(id)
+        }
+    }
+
+    def processBooks() {
+        def p1 = task { Book.findAllByActive(true) }
+        def p2 = task { Author.list() }
+
+        waitAll(p1, p2)
+        // Both complete
+    }
+}
+```
+
+## Views
+
+### GSP (Groovy Server Pages)
+```html
+<!-- grails-app/views/book/list.gsp -->
+<!DOCTYPE html>
+<html>
+<head>
+    <title>Books</title>
+    <asset:stylesheet src="application.css"/>
+</head>
+<body>
+    <h1>Books (${bookCount})</h1>
+
+    <g:each in="${bookList}" var="book">
+        <div class="book">
+            <h2>${book.title}</h2>
+            <p>By ${book.author}</p>
+            <g:link action="show" id="${book.id}">View</g:link>
+        </div>
+    </g:each>
+
+    <g:if test="${bookList.empty}">
+        <p>No books found.</p>
+    </g:if>
+
+    <g:paginate total="${bookCount}"/>
+
+    <asset:javascript src="application.js"/>
+</body>
+</html>
+```
+
+### Common GSP Tags
+```html
+<!-- Links -->
+<g:link controller="book" action="show" id="${book.id}">View</g:link>
+<g:createLink action="list"/>
+
+<!-- Forms -->
+<g:form action="save">
+    <g:textField name="title" value="${book?.title}"/>
+    <g:textArea name="description" value="${book?.description}"/>
+    <g:select name="category" from="${categories}" optionKey="id" optionValue="name"/>
+    <g:checkBox name="active" value="${book?.active}"/>
+    <g:submitButton name="submit" value="Save"/>
+</g:form>
+
+<!-- Conditionals -->
+<g:if test="${condition}">...</g:if>
+<g:elseif test="${other}">...</g:elseif>
+<g:else>...</g:else>
+
+<!-- Iteration -->
+<g:each in="${items}" var="item" status="i">
+    ${i}: ${item.name}
+</g:each>
+
+<!-- Rendering -->
+<g:render template="bookRow" model="[book: book]"/>
+<g:render template="bookRow" collection="${books}" var="book"/>
+
+<!-- Security (with Spring Security plugin) -->
+<sec:ifLoggedIn>Welcome, ${sec.username()}</sec:ifLoggedIn>
+<sec:ifNotLoggedIn><g:link controller="login">Login</g:link></sec:ifNotLoggedIn>
+```
+
+### JSON Views
+```groovy
+// grails-app/views/book/show.gson
+import myapp.Book
+
+model {
+    Book book
+}
+
+json {
+    id book.id
+    title book.title
+    author book.author
+    datePublished book.datePublished?.format('yyyy-MM-dd')
+    _links {
+        self {
+            href "/books/${book.id}"
+        }
+    }
+}
+```
+
+### Layouts
+```html
+<!-- grails-app/views/layouts/main.gsp -->
+<!DOCTYPE html>
+<html>
+<head>
+    <title><g:layoutTitle default="My App"/></title>
+    <asset:stylesheet src="application.css"/>
+    <g:layoutHead/>
+</head>
+<body>
+    <nav><!-- Navigation --></nav>
+    <main>
+        <g:layoutBody/>
+    </main>
+    <footer><!-- Footer --></footer>
+    <asset:javascript src="application.js"/>
+</body>
+</html>
+
+<!-- Use in views -->
+<html>
+<head>
+    <meta name="layout" content="main"/>
+    <title>Books</title>
+</head>
+<body>
+    <!-- Page content -->
+</body>
+</html>
+```
+
+## Interceptors
+
+```groovy
+class AuthInterceptor {
+
+    AuthInterceptor() {
+        matchAll()
+            .excludes(controller: 'login')
+            .excludes(controller: 'error')
+    }
+
+    boolean before() {
+        if (!session.user) {
+            redirect(controller: 'login')
+            return false
+        }
+        true
+    }
+
+    boolean after() {
+        // After action executes
+        true
+    }
+
+    void afterView() {
+        // After view renders
+    }
+}
+```
+
+## Tag Libraries
+
+```groovy
+class BookTagLib {
+
+    static namespace = 'book'
+    static defaultEncodeAs = [taglib: 'html']
+
+    def formatTitle = { attrs, body ->
+        def title = attrs.title ?: body()
+        out << "<span class='book-title'>${title}</span>"
+    }
+
+    def ifHasBooks = { attrs, body ->
+        if (Book.count() > 0) {
+            out << body()
+        }
+    }
+}
+
+// Usage in GSP
+<book:formatTitle title="${book.title}"/>
+<book:ifHasBooks>
+    <p>We have books!</p>
+</book:ifHasBooks>
+```
+
+## Configuration
+
+### application.yml
+```yaml
+grails:
+    profile: web
+    codegen:
+        defaultPackage: myapp
+    gorm:
+        reactor:
+            events: false
+    mime:
+        types:
+            json: ['application/json', 'text/json']
+            xml: ['text/xml', 'application/xml']
+
+environments:
+    development:
+        dataSource:
+            dbCreate: create-drop
+            url: jdbc:h2:mem:devDb
+    test:
+        dataSource:
+            dbCreate: update
+            url: jdbc:h2:mem:testDb
+    production:
+        dataSource:
+            dbCreate: none
+            url: jdbc:postgresql://localhost/myapp
+            driverClassName: org.postgresql.Driver
+            dialect: org.hibernate.dialect.PostgreSQLDialect
+            properties:
+                jmxEnabled: true
+                initialSize: 5
+                maxActive: 50
+
+server:
+    port: 8080
+    servlet:
+        context-path: /myapp
+```
+
+### URL Mappings
+```groovy
+// grails-app/controllers/myapp/UrlMappings.groovy
+class UrlMappings {
+
+    static mappings = {
+        // Default
+        "/$controller/$action?/$id?(.$format)?" {
+            constraints {
+                // apply constraints here
+            }
+        }
+
+        // REST resources
+        "/api/books"(resources: 'book')
+
+        // Custom mappings
+        "/books/$id"(controller: 'book', action: 'show')
+        "/search"(controller: 'book', action: 'search')
+
+        // Named URL mappings
+        name bookShow: "/books/$id" {
+            controller = 'book'
+            action = 'show'
+        }
+
+        // Error pages
+        "500"(view: '/error')
+        "404"(view: '/notFound')
+    }
+}
+```
+
+## Testing with Spock
+
+### Unit Test - Controller
+```groovy
+import grails.testing.web.controllers.ControllerUnitTest
+import spock.lang.Specification
+
+class BookControllerSpec extends Specification
+        implements ControllerUnitTest<BookController> {
+
+    def setup() {
+        controller.bookService = Mock(BookService)
+    }
+
+    void "index returns list of books"() {
+        given:
+        def books = [new Book(title: "Test")]
+        controller.bookService.list(_) >> books
+
+        when:
+        controller.index()
+
+        then:
+        model.bookList == books
+        view == '/book/index'
+    }
+
+    void "show returns 404 for missing book"() {
+        when:
+        controller.show(999)
+
+        then:
+        response.status == 404
+    }
+}
+```
+
+### Unit Test - Service
+```groovy
+import grails.testing.services.ServiceUnitTest
+import spock.lang.Specification
+
+class BookServiceSpec extends Specification
+        implements ServiceUnitTest<BookService> {
+
+    void "save persists book"() {
+        given:
+        def book = new Book(title: "Test", author: "Author")
+
+        when:
+        def result = service.save(book)
+
+        then:
+        result.id != null
+        Book.count() == 1
+    }
+}
+```
+
+### Unit Test - Domain
+```groovy
+import grails.testing.gorm.DomainUnitTest
+import spock.lang.Specification
+
+class BookSpec extends Specification
+        implements DomainUnitTest<Book> {
+
+    void "title cannot be blank"() {
+        when:
+        domain.title = ""
+        domain.author = "Test"
+
+        then:
+        !domain.validate(['title'])
+        domain.errors['title'].code == 'blank'
+    }
+
+    void "valid book passes validation"() {
+        when:
+        domain.title = "Valid Title"
+        domain.author = "Author"
+
+        then:
+        domain.validate()
+    }
+}
+```
+
+### Integration Test
+```groovy
+import grails.testing.mixin.integration.Integration
+import grails.gorm.transactions.Rollback
+import spock.lang.Specification
+
+@Integration
+@Rollback
+class BookServiceIntegrationSpec extends Specification {
+
+    BookService bookService
+
+    void "save and retrieve book"() {
+        given:
+        def book = new Book(title: "Integration Test", author: "Tester")
+
+        when:
+        bookService.save(book)
+        def found = Book.findByTitle("Integration Test")
+
+        then:
+        found != null
+        found.author == "Tester"
+    }
+}
+```
+
+### Functional Test with Geb
+```groovy
+import geb.spock.GebSpec
+import grails.testing.mixin.integration.Integration
+
+@Integration
+class BookFunctionalSpec extends GebSpec {
+
+    void "can view book list"() {
+        when:
+        go '/book/index'
+
+        then:
+        title == 'Book List'
+        $('h1').text() == 'Books'
+    }
+
+    void "can create new book"() {
+        when:
+        go '/book/create'
+        $('form').title = 'New Book'
+        $('form').author = 'Test Author'
+        $('input[type=submit]').click()
+
+        then:
+        $('h1').text().contains('New Book')
+    }
+}
+```
+
+## Plugins
+
+### Common Plugins
+```groovy
+// build.gradle
+
+// Spring Security
+implementation 'org.grails.plugins:spring-security-core:6.0.0'
+
+// Database Migration (Liquibase)
+implementation 'org.grails.plugins:database-migration:4.2.0'
+
+// Caching
+implementation 'org.grails.plugins:cache:6.0.0'
+
+// Async support
+implementation 'org.grails.plugins:async:5.0.0'
+
+// Fields plugin for form rendering
+implementation 'org.grails.plugins:fields:5.0.0'
+
+// Asset Pipeline
+runtimeOnly 'org.grails.plugins:asset-pipeline:5.0.0'
+```
+
+### Spring Security Configuration
+```groovy
+// grails-app/conf/application.groovy
+grails.plugin.springsecurity.userLookup.userDomainClassName = 'myapp.User'
+grails.plugin.springsecurity.userLookup.authorityJoinClassName = 'myapp.UserRole'
+grails.plugin.springsecurity.authority.className = 'myapp.Role'
+
+grails.plugin.springsecurity.controllerAnnotations.staticRules = [
+    [pattern: '/',               access: ['permitAll']],
+    [pattern: '/error',          access: ['permitAll']],
+    [pattern: '/index',          access: ['permitAll']],
+    [pattern: '/admin/**',       access: ['ROLE_ADMIN']],
+    [pattern: '/api/**',         access: ['isAuthenticated()']],
+]
+```
+
+## Build Commands
+
+```bash
+# Run application
+./gradlew bootRun
+
+# Run tests
+./gradlew test                                    # All tests
+./gradlew test --tests "BookServiceSpec"          # Single spec
+./gradlew test --tests "*Spec.save*"              # Pattern match
+./gradlew integrationTest                         # Integration tests
+
+# Build
+./gradlew build -PskipTests                       # Build without tests
+./gradlew bootJar                                 # Executable JAR
+./gradlew bootWar                                 # WAR file
+
+# Code quality
+./gradlew codeStyle                               # Check style
+
+# Clean
+./gradlew clean
+```
+
+## Best Practices
+
+### Convention Over Configuration
+- Follow Grails naming conventions for automatic wiring.
+- Use standard directory structure.
+- Let Grails infer configurations where possible.
+
+### Performance
+- Use `@GrailsCompileStatic` on controllers and services.
+- Enable query caching for read-heavy operations.
+- Use pagination for large result sets.
+- Avoid N+1 queries with eager fetching or batch size.
+
+### Security
+- Use CSRF tokens in forms: `<g:form useToken="true">`.
+- Apply Spring Security for authentication/authorization.
+- Use parameterized queries (GORM handles this automatically).
+- Encode output to prevent XSS.
+
+### Testing
+- Write unit tests for domain constraints.
+- Test controllers with `ControllerUnitTest`.
+- Use integration tests for service/database interactions.
+- Use Geb for critical user workflows.
+
+### Code Style
+- Use `@GrailsCompileStatic` for type safety and performance.
+- Prefer services for business logic over controllers.
+- Use command objects for complex form handling.
+- Keep controllers thin, services fat.
+
+## Resources
+
+- **Grails 7 User Guide**: https://docs.grails.org/latest/guide/single.html

Review Comment:
   https://grails.apache.org/docs/latest/guide/single.html



##########
.agents/skills/grails-developer/SKILL.md:
##########
@@ -0,0 +1,883 @@
+<!--
+SPDX-License-Identifier: Apache-2.0
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+---
+name: grails-developer
+description: Comprehensive guide for Grails 7 development, covering web applications, REST APIs, GORM, controllers, services, views, plugins, and testing with Spock and Geb
+license: Apache-2.0
+compatibility: opencode, claude, grok, gemini, copilot, cursor, windsurf
+metadata:
+  audience: developers
+  frameworks: grails
+  versions: 7
+---
+
+## What I Do
+
+- Provide detailed guidance for building Grails 7 web applications and REST APIs.
+- Assist with GORM for data modeling, controllers for request handling, services for business logic, and views (GSP, JSON, Markup).
+- Support testing with Spock 2.3 (unit/integration tests) and Geb for browser automation.
+- Guide plugin usage and development, security implementation, and deployment strategies.
+- Help with configuration, internationalization, async programming, and performance optimization.
+
+## When to Use Me
+
+Activate this skill when developing with Grails 7, including:
+
+- Building CRUD applications, RESTful APIs, or full-stack web applications.
+- Working with GORM domain classes, constraints, and relationships.
+- Creating controllers, services, interceptors, or tag libraries.
+- Writing Spock specifications or Geb functional tests.
+- Configuring plugins, security, caching, or database migrations.
+- Deploying Grails applications to containers or cloud platforms.
+
+## Technology Stack
+
+Grails 7 is built on:
+- **Spring Boot**: 3.5.x
+- **Spring Framework**: 6.2.x
+- **Groovy**: 4.0.x
+- **Gradle**: 8.14.x
+- **Spock**: 2.3-groovy-4.0
+- **Jakarta EE**: 10 (migrated from javax.*)
+- **Micronaut**: Optional via `grails-micronaut` plugin
+
+## Project Structure
+
+```
+myapp/
+├── grails-app/
+│   ├── conf/                 # Configuration
+│   │   ├── application.yml   # Main config
+│   │   ├── logback.xml       # Logging config
+│   │   └── spring/           # Spring bean definitions
+│   ├── controllers/          # Request handlers
+│   ├── domain/               # GORM domain classes
+│   ├── i18n/                 # Message bundles
+│   ├── init/                 # Bootstrap classes
+│   ├── services/             # Business logic
+│   ├── taglib/               # Custom GSP tags
+│   ├── utils/                # Utility classes
+│   └── views/                # GSP templates
+├── src/
+│   ├── main/groovy/          # Additional Groovy classes
+│   ├── main/java/            # Java classes
+│   └── test/groovy/          # Test specifications
+├── build.gradle              # Build configuration
+└── gradle.properties         # Project properties
+```
+
+## Domain Classes (GORM)
+
+### Basic Domain Class
+```groovy
+class Book {
+    String title
+    String author
+    Date datePublished
+    Integer pages
+
+    static constraints = {
+        title blank: false, maxSize: 255
+        author blank: false
+        datePublished nullable: true
+        pages min: 1, nullable: true
+    }
+
+    static mapping = {
+        table 'books'
+        title column: 'book_title'
+        datePublished type: 'date'
+    }
+}
+```
+
+### Relationships
+```groovy
+class Author {
+    String name
+
+    static hasMany = [books: Book]
+
+    static mapping = {
+        books cascade: 'all-delete-orphan'
+    }
+}
+
+class Book {
+    String title
+
+    static belongsTo = [author: Author]
+}
+
+// Many-to-Many
+class Book {
+    static hasMany = [categories: Category]
+    static belongsTo = Category
+}
+
+class Category {
+    String name
+    static hasMany = [books: Book]
+}
+```
+
+### GORM Queries
+```groovy
+// Dynamic finders
+Book.findByTitle("Grails Guide")
+Book.findAllByAuthorLike("%Smith%")
+Book.findByTitleAndAuthor("Guide", "Smith")
+Book.countByPagesGreaterThan(100)
+
+// Where queries
+Book.where {
+    title =~ "%Grails%" && pages > 100
+}.list()
+
+// Criteria queries
+Book.withCriteria {
+    like('title', '%Grails%')
+    gt('pages', 100)
+    order('datePublished', 'desc')
+    maxResults(10)
+}
+
+// HQL queries
+Book.executeQuery(
+    "from Book b where b.author.name = :name",
+    [name: 'Smith']
+)
+
+// Detached criteria (reusable)
+def criteria = Book.where {
+    pages > 100
+}
+criteria.list()
+criteria.count()
+```
+
+### Transactions
+```groovy
+// In services (default transactional)
+@Transactional
+class BookService {
+    def saveBook(Book book) {
+        book.save(failOnError: true)
+    }
+}
+
+// Manual transaction control
+Book.withTransaction { status ->
+    def book = new Book(title: "Test")
+    book.save()
+    if (someCondition) {
+        status.setRollbackOnly()
+    }
+}
+```
+
+## Controllers
+
+### Basic Controller
+```groovy
+class BookController {
+
+    BookService bookService
+
+    static allowedMethods = [save: 'POST', update: 'PUT', delete: 'DELETE']
+
+    def index() {
+        respond Book.list(), model: [bookCount: Book.count()]
+    }
+
+    def show(Long id) {
+        respond Book.get(id)
+    }
+
+    def create() {
+        respond new Book(params)
+    }
+
+    def save(Book book) {
+        if (book.hasErrors()) {
+            respond book.errors, view: 'create'
+            return
+        }
+        bookService.save(book)
+        redirect action: 'show', id: book.id
+    }
+
+    def edit(Long id) {
+        respond Book.get(id)
+    }
+
+    def update(Book book) {
+        if (book.hasErrors()) {
+            respond book.errors, view: 'edit'
+            return
+        }
+        bookService.save(book)
+        redirect action: 'show', id: book.id
+    }
+
+    def delete(Long id) {
+        bookService.delete(id)
+        redirect action: 'index'
+    }
+}
+```
+
+### REST Controller
+```groovy
+import grails.rest.RestfulController
+
+class BookController extends RestfulController<Book> {
+
+    static responseFormats = ['json', 'xml']
+
+    BookController() {
+        super(Book)
+    }
+
+    // Override to customize
+    @Override
+    protected Book queryForResource(Serializable id) {
+        Book.where { id == id && active == true }.find()
+    }
+}
+```
+
+### Command Objects
+```groovy
+class BookCommand implements Validateable {
+    String title
+    String author
+    Integer pages
+
+    static constraints = {
+        title blank: false
+        author blank: false
+        pages min: 1, nullable: true
+    }
+}
+
+class BookController {
+    def save(BookCommand cmd) {
+        if (cmd.hasErrors()) {
+            respond cmd.errors
+            return
+        }
+        // Process valid command
+    }
+}
+```
+
+### Content Negotiation
+```groovy
+class BookController {
+    def show(Long id) {
+        def book = Book.get(id)
+        respond book  // Auto-negotiates based on Accept header
+    }
+}
+
+// Or explicit
+def show(Long id) {
+    def book = Book.get(id)
+    withFormat {
+        html { render view: 'show', model: [book: book] }
+        json { render book as JSON }
+        xml { render book as XML }
+    }
+}
+```
+
+## Services
+
+### Basic Service
+```groovy
+import grails.gorm.transactions.Transactional
+
+@Transactional
+class BookService {
+
+    def findByTitle(String title) {
+        Book.findByTitle(title)
+    }
+
+    def save(Book book) {
+        book.save(failOnError: true)
+    }
+
+    @Transactional(readOnly = true)
+    def list(Map params) {
+        Book.list(params)
+    }
+
+    def delete(Long id) {
+        Book.get(id)?.delete()
+    }
+}
+```
+
+### Service with Events
+```groovy
+import grails.events.annotation.Publisher
+import grails.events.annotation.Subscriber
+
+class BookService {
+
+    @Publisher
+    def save(Book book) {
+        book.save()
+        // Automatically publishes 'book.saved' event
+    }
+}
+
+class NotificationService {
+
+    @Subscriber('book.saved')
+    def onBookSaved(Book book) {
+        // Handle event
+        log.info "Book saved: ${book.title}"
+    }
+}
+```
+
+### Async Service
+```groovy
+import grails.async.Promise
+import static grails.async.Promises.*
+
+class BookService {
+
+    Promise<Book> findAsync(Long id) {
+        task {
+            Book.get(id)
+        }
+    }
+
+    def processBooks() {
+        def p1 = task { Book.findAllByActive(true) }
+        def p2 = task { Author.list() }
+
+        waitAll(p1, p2)
+        // Both complete
+    }
+}
+```
+
+## Views
+
+### GSP (Groovy Server Pages)
+```html
+<!-- grails-app/views/book/list.gsp -->
+<!DOCTYPE html>
+<html>
+<head>
+    <title>Books</title>
+    <asset:stylesheet src="application.css"/>
+</head>
+<body>
+    <h1>Books (${bookCount})</h1>
+
+    <g:each in="${bookList}" var="book">
+        <div class="book">
+            <h2>${book.title}</h2>
+            <p>By ${book.author}</p>
+            <g:link action="show" id="${book.id}">View</g:link>
+        </div>
+    </g:each>
+
+    <g:if test="${bookList.empty}">
+        <p>No books found.</p>
+    </g:if>
+
+    <g:paginate total="${bookCount}"/>
+
+    <asset:javascript src="application.js"/>
+</body>
+</html>
+```
+
+### Common GSP Tags
+```html
+<!-- Links -->
+<g:link controller="book" action="show" id="${book.id}">View</g:link>
+<g:createLink action="list"/>
+
+<!-- Forms -->
+<g:form action="save">
+    <g:textField name="title" value="${book?.title}"/>
+    <g:textArea name="description" value="${book?.description}"/>
+    <g:select name="category" from="${categories}" optionKey="id" optionValue="name"/>
+    <g:checkBox name="active" value="${book?.active}"/>
+    <g:submitButton name="submit" value="Save"/>
+</g:form>
+
+<!-- Conditionals -->
+<g:if test="${condition}">...</g:if>
+<g:elseif test="${other}">...</g:elseif>
+<g:else>...</g:else>
+
+<!-- Iteration -->
+<g:each in="${items}" var="item" status="i">
+    ${i}: ${item.name}
+</g:each>
+
+<!-- Rendering -->
+<g:render template="bookRow" model="[book: book]"/>
+<g:render template="bookRow" collection="${books}" var="book"/>
+
+<!-- Security (with Spring Security plugin) -->
+<sec:ifLoggedIn>Welcome, ${sec.username()}</sec:ifLoggedIn>
+<sec:ifNotLoggedIn><g:link controller="login">Login</g:link></sec:ifNotLoggedIn>
+```
+
+### JSON Views
+```groovy
+// grails-app/views/book/show.gson
+import myapp.Book
+
+model {
+    Book book
+}
+
+json {
+    id book.id
+    title book.title
+    author book.author
+    datePublished book.datePublished?.format('yyyy-MM-dd')
+    _links {
+        self {
+            href "/books/${book.id}"
+        }
+    }
+}
+```
+
+### Layouts
+```html
+<!-- grails-app/views/layouts/main.gsp -->
+<!DOCTYPE html>
+<html>
+<head>
+    <title><g:layoutTitle default="My App"/></title>
+    <asset:stylesheet src="application.css"/>
+    <g:layoutHead/>
+</head>
+<body>
+    <nav><!-- Navigation --></nav>
+    <main>
+        <g:layoutBody/>
+    </main>
+    <footer><!-- Footer --></footer>
+    <asset:javascript src="application.js"/>
+</body>
+</html>
+
+<!-- Use in views -->
+<html>
+<head>
+    <meta name="layout" content="main"/>
+    <title>Books</title>
+</head>
+<body>
+    <!-- Page content -->
+</body>
+</html>
+```
+
+## Interceptors
+
+```groovy
+class AuthInterceptor {
+
+    AuthInterceptor() {
+        matchAll()
+            .excludes(controller: 'login')
+            .excludes(controller: 'error')
+    }
+
+    boolean before() {
+        if (!session.user) {
+            redirect(controller: 'login')
+            return false
+        }
+        true
+    }
+
+    boolean after() {
+        // After action executes
+        true
+    }
+
+    void afterView() {
+        // After view renders
+    }
+}
+```
+
+## Tag Libraries
+
+```groovy
+class BookTagLib {
+
+    static namespace = 'book'
+    static defaultEncodeAs = [taglib: 'html']
+
+    def formatTitle = { attrs, body ->
+        def title = attrs.title ?: body()
+        out << "<span class='book-title'>${title}</span>"
+    }
+
+    def ifHasBooks = { attrs, body ->
+        if (Book.count() > 0) {
+            out << body()
+        }
+    }
+}
+
+// Usage in GSP
+<book:formatTitle title="${book.title}"/>
+<book:ifHasBooks>
+    <p>We have books!</p>
+</book:ifHasBooks>
+```
+
+## Configuration
+
+### application.yml
+```yaml
+grails:
+    profile: web
+    codegen:
+        defaultPackage: myapp
+    gorm:
+        reactor:
+            events: false
+    mime:
+        types:
+            json: ['application/json', 'text/json']
+            xml: ['text/xml', 'application/xml']
+
+environments:
+    development:
+        dataSource:
+            dbCreate: create-drop
+            url: jdbc:h2:mem:devDb
+    test:
+        dataSource:
+            dbCreate: update
+            url: jdbc:h2:mem:testDb
+    production:
+        dataSource:
+            dbCreate: none
+            url: jdbc:postgresql://localhost/myapp
+            driverClassName: org.postgresql.Driver
+            dialect: org.hibernate.dialect.PostgreSQLDialect
+            properties:
+                jmxEnabled: true
+                initialSize: 5
+                maxActive: 50
+
+server:
+    port: 8080
+    servlet:
+        context-path: /myapp
+```
+
+### URL Mappings
+```groovy
+// grails-app/controllers/myapp/UrlMappings.groovy
+class UrlMappings {
+
+    static mappings = {
+        // Default
+        "/$controller/$action?/$id?(.$format)?" {
+            constraints {
+                // apply constraints here
+            }
+        }
+
+        // REST resources
+        "/api/books"(resources: 'book')
+
+        // Custom mappings
+        "/books/$id"(controller: 'book', action: 'show')
+        "/search"(controller: 'book', action: 'search')
+
+        // Named URL mappings
+        name bookShow: "/books/$id" {
+            controller = 'book'
+            action = 'show'
+        }
+
+        // Error pages
+        "500"(view: '/error')
+        "404"(view: '/notFound')
+    }
+}
+```
+
+## Testing with Spock
+
+### Unit Test - Controller
+```groovy
+import grails.testing.web.controllers.ControllerUnitTest
+import spock.lang.Specification
+
+class BookControllerSpec extends Specification
+        implements ControllerUnitTest<BookController> {
+
+    def setup() {
+        controller.bookService = Mock(BookService)
+    }
+
+    void "index returns list of books"() {
+        given:
+        def books = [new Book(title: "Test")]
+        controller.bookService.list(_) >> books
+
+        when:
+        controller.index()
+
+        then:
+        model.bookList == books
+        view == '/book/index'
+    }
+
+    void "show returns 404 for missing book"() {
+        when:
+        controller.show(999)
+
+        then:
+        response.status == 404
+    }
+}
+```
+
+### Unit Test - Service
+```groovy
+import grails.testing.services.ServiceUnitTest
+import spock.lang.Specification
+
+class BookServiceSpec extends Specification
+        implements ServiceUnitTest<BookService> {
+
+    void "save persists book"() {
+        given:
+        def book = new Book(title: "Test", author: "Author")
+
+        when:
+        def result = service.save(book)
+
+        then:
+        result.id != null
+        Book.count() == 1
+    }
+}
+```
+
+### Unit Test - Domain
+```groovy
+import grails.testing.gorm.DomainUnitTest
+import spock.lang.Specification
+
+class BookSpec extends Specification
+        implements DomainUnitTest<Book> {
+
+    void "title cannot be blank"() {
+        when:
+        domain.title = ""
+        domain.author = "Test"
+
+        then:
+        !domain.validate(['title'])
+        domain.errors['title'].code == 'blank'
+    }
+
+    void "valid book passes validation"() {
+        when:
+        domain.title = "Valid Title"
+        domain.author = "Author"
+
+        then:
+        domain.validate()
+    }
+}
+```
+
+### Integration Test
+```groovy
+import grails.testing.mixin.integration.Integration
+import grails.gorm.transactions.Rollback
+import spock.lang.Specification
+
+@Integration
+@Rollback
+class BookServiceIntegrationSpec extends Specification {
+
+    BookService bookService
+
+    void "save and retrieve book"() {
+        given:
+        def book = new Book(title: "Integration Test", author: "Tester")
+
+        when:
+        bookService.save(book)
+        def found = Book.findByTitle("Integration Test")
+
+        then:
+        found != null
+        found.author == "Tester"
+    }
+}
+```
+
+### Functional Test with Geb
+```groovy
+import geb.spock.GebSpec
+import grails.testing.mixin.integration.Integration
+
+@Integration
+class BookFunctionalSpec extends GebSpec {
+
+    void "can view book list"() {
+        when:
+        go '/book/index'
+
+        then:
+        title == 'Book List'
+        $('h1').text() == 'Books'
+    }
+
+    void "can create new book"() {
+        when:
+        go '/book/create'
+        $('form').title = 'New Book'
+        $('form').author = 'Test Author'
+        $('input[type=submit]').click()
+
+        then:
+        $('h1').text().contains('New Book')
+    }
+}
+```
+
+## Plugins
+
+### Common Plugins
+```groovy
+// build.gradle
+
+// Spring Security
+implementation 'org.grails.plugins:spring-security-core:6.0.0'
+
+// Database Migration (Liquibase)
+implementation 'org.grails.plugins:database-migration:4.2.0'
+
+// Caching
+implementation 'org.grails.plugins:cache:6.0.0'
+
+// Async support
+implementation 'org.grails.plugins:async:5.0.0'
+
+// Fields plugin for form rendering
+implementation 'org.grails.plugins:fields:5.0.0'
+
+// Asset Pipeline
+runtimeOnly 'org.grails.plugins:asset-pipeline:5.0.0'
+```
+
+### Spring Security Configuration
+```groovy
+// grails-app/conf/application.groovy
+grails.plugin.springsecurity.userLookup.userDomainClassName = 'myapp.User'
+grails.plugin.springsecurity.userLookup.authorityJoinClassName = 'myapp.UserRole'
+grails.plugin.springsecurity.authority.className = 'myapp.Role'
+
+grails.plugin.springsecurity.controllerAnnotations.staticRules = [
+    [pattern: '/',               access: ['permitAll']],
+    [pattern: '/error',          access: ['permitAll']],
+    [pattern: '/index',          access: ['permitAll']],
+    [pattern: '/admin/**',       access: ['ROLE_ADMIN']],
+    [pattern: '/api/**',         access: ['isAuthenticated()']],
+]
+```
+
+## Build Commands
+
+```bash
+# Run application
+./gradlew bootRun
+
+# Run tests
+./gradlew test                                    # All tests
+./gradlew test --tests "BookServiceSpec"          # Single spec
+./gradlew test --tests "*Spec.save*"              # Pattern match
+./gradlew integrationTest                         # Integration tests
+
+# Build
+./gradlew build -PskipTests                       # Build without tests

Review Comment:
   The `skipTests` property is specific to Grails Core repository?



##########
.agents/skills/groovy-developer/SKILL.md:
##########
@@ -0,0 +1,520 @@
+<!--
+SPDX-License-Identifier: Apache-2.0
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+---
+name: groovy-developer
+description: Expert guide for Groovy 4 development, covering concise syntax, closures, DSLs, metaprogramming, static compilation, and integration with Java 17 and Grails
+license: Apache-2.0
+compatibility: opencode, claude, grok, gemini, copilot, cursor, windsurf
+metadata:
+  audience: developers
+  languages: groovy, java
+  versions: 4.0
+  paradigms: dynamic, static, functional, object-oriented, DSL-oriented
+---
+
+## What I Do
+
+- Provide deep expertise in Groovy 4.0, including core language features: syntax, closures, traits, GStrings, operators, and Groovy Truth.
+- Guide metaprogramming techniques: runtime (categories, ExpandoMetaClass, extension modules) and compile-time (AST transformations like @Immutable, @Builder, @Delegate, @Singleton, @Log, @Memoized).
+- Assist with DSL creation and usage (MarkupBuilder, JsonBuilder, builders for configuration).
+- Support testing with Spock Framework (BDD, data-driven tests, mocking) and built-in power assertions.
+- Help integrate Groovy with Java 17: joint compilation, Gradle builds, Grails, and Spring Boot.
+- Cover data handling: JSON/XML parsing and building, Groovy SQL, collection processing.
+- Advise on performance: @CompileStatic, @TypeChecked, @GrailsCompileStatic for optimal execution.
+
+## When to Use Me
+
+Activate this skill for any Groovy-related task, including:
+
+- Writing or debugging Groovy classes in Grails domain, controllers, services, or taglibs.
+- Building or enhancing Gradle build scripts (build.gradle).
+- Creating DSLs for configuration, testing, or business rules.
+- Writing Spock specifications for unit and integration tests.
+- Migrating from older Groovy versions (2.x/3.x) to 4.0.
+- Performance optimization with static compilation.
+- Working with JSON/XML data, GORM criteria queries, or builders.
+
+## Groovy 4 Key Features
+
+### Concise Syntax
+```groovy
+// No semicolons required
+def name = "Grails"
+
+// Optional parentheses for method calls
+println "Hello World"
+list.each { println it }
+
+// Optional return keyword
+String greet(String name) {
+    "Hello, $name"  // Last expression is returned
+}
+```
+
+### GStrings (String Interpolation)
+```groovy
+def user = "Alice"
+def count = 42
+
+// Simple interpolation
+println "User: $user"
+
+// Expression interpolation
+println "Items: ${count * 2}"
+
+// Lazy GStrings (evaluated when accessed)
+def lazy = "Count is ${ -> counter }"
+
+// Multi-line strings
+def sql = """
+    SELECT * FROM users
+    WHERE name = '$user'
+    ORDER BY created_at
+"""
+```
+
+### Closures
+```groovy
+// Basic closure
+def greet = { name -> "Hello, $name" }
+println greet("World")
+
+// Implicit 'it' parameter
+def double = { it * 2 }
+println [1, 2, 3].collect(double)
+
+// Closure with delegate (for DSLs)
+def configure = {
+    name = "MyApp"
+    version = "1.0"
+}
+configure.delegate = new Config()
+configure.resolveStrategy = Closure.DELEGATE_FIRST
+configure()
+
+// Method references
+def upper = String.&toUpperCase
+println ["a", "b"].collect(upper)
+```
+
+### Safe Navigation and Elvis Operator
+```groovy
+// Safe navigation - returns null if any part is null
+def city = user?.address?.city
+
+// Elvis operator - default value if null
+def name = user?.name ?: "Anonymous"
+
+// Safe method calls
+def length = text?.length() ?: 0
+
+// Combine with collections
+def firstTitle = books?.first()?.title ?: "No books"
+```
+
+### Spread Operator
+```groovy
+// Spread operator for collections
+def names = users*.name  // Same as users.collect { it.name }
+
+// Spread for method arguments
+def args = [1, 2, 3]
+someMethod(*args)
+
+// Spread in list literals
+def combined = [*list1, *list2]
+```
+
+### Collection Literals and Methods
+```groovy
+// List literal
+def list = [1, 2, 3, 4, 5]
+
+// Map literal
+def map = [name: "Grails", version: 7]
+
+// Range
+def range = 1..10
+def exclusive = 1..<10
+
+// Powerful collection methods
+list.find { it > 3 }           // First match: 4
+list.findAll { it > 3 }        // All matches: [4, 5]
+list.any { it > 3 }            // true
+list.every { it > 0 }          // true
+list.groupBy { it % 2 }        // [0:[2,4], 1:[1,3,5]]
+list.collectEntries { [it, it * 2] }  // [1:2, 2:4, ...]
+
+// Sorting
+list.sort { a, b -> b <=> a }  // Descending
+list.sort { -it }              // Descending (numeric)
+```
+
+### Groovy Truth
+```groovy
+// Falsy values: null, empty string, empty collection, 0, false
+if (list) { }      // True if not null and not empty
+if (string) { }    // True if not null and not blank
+if (number) { }    // True if not 0
+
+// Useful in conditionals
+def items = getItems() ?: []  // Default to empty list
+```
+
+### Records (Incubating)
+```groovy
+// Immutable data class
+record Point(int x, int y) {}
+
+def p = new Point(10, 20)
+println p.x()  // 10
+println p      // Point[x=10, y=20]
+```
+
+### Traits
+```groovy
+trait Auditable {
+    Date dateCreated
+    Date lastUpdated
+
+    def beforeInsert() {
+        dateCreated = new Date()
+    }
+
+    def beforeUpdate() {
+        lastUpdated = new Date()
+    }
+}
+
+class Book implements Auditable {
+    String title
+}
+```
+
+## Static Compilation
+
+### @CompileStatic
+Enables static type checking and compilation for better performance:
+```groovy
+import groovy.transform.CompileStatic
+
+@CompileStatic
+class BookService {
+    List<Book> findByAuthor(String author) {
+        Book.findAllByAuthor(author)
+    }
+
+    int calculateTotal(List<Integer> prices) {
+        prices.sum() as int
+    }
+}
+```
+
+### @TypeChecked
+Type checking without full static compilation:
+```groovy
+import groovy.transform.TypeChecked
+
+@TypeChecked
+void process(String input) {
+    println input.toUppercase()  // Compile error: method not found
+}
+```
+
+### @GrailsCompileStatic
+Grails-aware static compilation that understands dynamic finders:
+```groovy
+import grails.compiler.GrailsCompileStatic
+
+@GrailsCompileStatic
+class BookController {
+    def show(Long id) {
+        respond Book.get(id)  // Works with static compilation

Review Comment:
   This example would also work with `@CompileStatic`. It does not use a dynimic finder.



##########
.agents/skills/grails-developer/SKILL.md:
##########
@@ -0,0 +1,883 @@
+<!--
+SPDX-License-Identifier: Apache-2.0
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+---
+name: grails-developer
+description: Comprehensive guide for Grails 7 development, covering web applications, REST APIs, GORM, controllers, services, views, plugins, and testing with Spock and Geb
+license: Apache-2.0
+compatibility: opencode, claude, grok, gemini, copilot, cursor, windsurf
+metadata:
+  audience: developers
+  frameworks: grails
+  versions: 7
+---
+
+## What I Do
+
+- Provide detailed guidance for building Grails 7 web applications and REST APIs.
+- Assist with GORM for data modeling, controllers for request handling, services for business logic, and views (GSP, JSON, Markup).
+- Support testing with Spock 2.3 (unit/integration tests) and Geb for browser automation.
+- Guide plugin usage and development, security implementation, and deployment strategies.
+- Help with configuration, internationalization, async programming, and performance optimization.
+
+## When to Use Me
+
+Activate this skill when developing with Grails 7, including:
+
+- Building CRUD applications, RESTful APIs, or full-stack web applications.
+- Working with GORM domain classes, constraints, and relationships.
+- Creating controllers, services, interceptors, or tag libraries.
+- Writing Spock specifications or Geb functional tests.
+- Configuring plugins, security, caching, or database migrations.
+- Deploying Grails applications to containers or cloud platforms.
+
+## Technology Stack
+
+Grails 7 is built on:
+- **Spring Boot**: 3.5.x
+- **Spring Framework**: 6.2.x
+- **Groovy**: 4.0.x
+- **Gradle**: 8.14.x
+- **Spock**: 2.3-groovy-4.0
+- **Jakarta EE**: 10 (migrated from javax.*)
+- **Micronaut**: Optional via `grails-micronaut` plugin
+
+## Project Structure
+
+```
+myapp/
+├── grails-app/
+│   ├── conf/                 # Configuration
+│   │   ├── application.yml   # Main config
+│   │   ├── logback.xml       # Logging config
+│   │   └── spring/           # Spring bean definitions
+│   ├── controllers/          # Request handlers
+│   ├── domain/               # GORM domain classes
+│   ├── i18n/                 # Message bundles
+│   ├── init/                 # Bootstrap classes
+│   ├── services/             # Business logic
+│   ├── taglib/               # Custom GSP tags
+│   ├── utils/                # Utility classes
+│   └── views/                # GSP templates
+├── src/
+│   ├── main/groovy/          # Additional Groovy classes
+│   ├── main/java/            # Java classes
+│   └── test/groovy/          # Test specifications
+├── build.gradle              # Build configuration
+└── gradle.properties         # Project properties
+```
+
+## Domain Classes (GORM)
+
+### Basic Domain Class
+```groovy
+class Book {
+    String title
+    String author
+    Date datePublished
+    Integer pages
+
+    static constraints = {
+        title blank: false, maxSize: 255
+        author blank: false
+        datePublished nullable: true
+        pages min: 1, nullable: true
+    }
+
+    static mapping = {
+        table 'books'
+        title column: 'book_title'
+        datePublished type: 'date'
+    }
+}
+```
+
+### Relationships
+```groovy
+class Author {
+    String name
+
+    static hasMany = [books: Book]
+
+    static mapping = {
+        books cascade: 'all-delete-orphan'
+    }
+}
+
+class Book {
+    String title
+
+    static belongsTo = [author: Author]
+}
+
+// Many-to-Many
+class Book {
+    static hasMany = [categories: Category]
+    static belongsTo = Category
+}
+
+class Category {
+    String name
+    static hasMany = [books: Book]
+}
+```
+
+### GORM Queries
+```groovy
+// Dynamic finders
+Book.findByTitle("Grails Guide")
+Book.findAllByAuthorLike("%Smith%")
+Book.findByTitleAndAuthor("Guide", "Smith")
+Book.countByPagesGreaterThan(100)
+
+// Where queries
+Book.where {
+    title =~ "%Grails%" && pages > 100
+}.list()
+
+// Criteria queries
+Book.withCriteria {
+    like('title', '%Grails%')
+    gt('pages', 100)
+    order('datePublished', 'desc')
+    maxResults(10)
+}
+
+// HQL queries
+Book.executeQuery(
+    "from Book b where b.author.name = :name",
+    [name: 'Smith']
+)
+
+// Detached criteria (reusable)
+def criteria = Book.where {
+    pages > 100
+}
+criteria.list()
+criteria.count()
+```
+
+### Transactions
+```groovy
+// In services (default transactional)
+@Transactional
+class BookService {
+    def saveBook(Book book) {
+        book.save(failOnError: true)
+    }
+}
+
+// Manual transaction control
+Book.withTransaction { status ->
+    def book = new Book(title: "Test")
+    book.save()
+    if (someCondition) {
+        status.setRollbackOnly()
+    }
+}
+```
+
+## Controllers
+
+### Basic Controller
+```groovy
+class BookController {
+
+    BookService bookService
+
+    static allowedMethods = [save: 'POST', update: 'PUT', delete: 'DELETE']
+
+    def index() {
+        respond Book.list(), model: [bookCount: Book.count()]
+    }
+
+    def show(Long id) {
+        respond Book.get(id)
+    }
+
+    def create() {
+        respond new Book(params)
+    }
+
+    def save(Book book) {
+        if (book.hasErrors()) {
+            respond book.errors, view: 'create'
+            return
+        }
+        bookService.save(book)
+        redirect action: 'show', id: book.id
+    }
+
+    def edit(Long id) {
+        respond Book.get(id)
+    }
+
+    def update(Book book) {
+        if (book.hasErrors()) {
+            respond book.errors, view: 'edit'
+            return
+        }
+        bookService.save(book)
+        redirect action: 'show', id: book.id
+    }
+
+    def delete(Long id) {
+        bookService.delete(id)
+        redirect action: 'index'
+    }
+}
+```
+
+### REST Controller
+```groovy
+import grails.rest.RestfulController
+
+class BookController extends RestfulController<Book> {
+
+    static responseFormats = ['json', 'xml']
+
+    BookController() {
+        super(Book)
+    }
+
+    // Override to customize
+    @Override
+    protected Book queryForResource(Serializable id) {
+        Book.where { id == id && active == true }.find()
+    }
+}
+```
+
+### Command Objects
+```groovy
+class BookCommand implements Validateable {
+    String title
+    String author
+    Integer pages
+
+    static constraints = {
+        title blank: false
+        author blank: false
+        pages min: 1, nullable: true
+    }
+}
+
+class BookController {
+    def save(BookCommand cmd) {
+        if (cmd.hasErrors()) {
+            respond cmd.errors
+            return
+        }
+        // Process valid command
+    }
+}
+```
+
+### Content Negotiation
+```groovy
+class BookController {
+    def show(Long id) {
+        def book = Book.get(id)
+        respond book  // Auto-negotiates based on Accept header
+    }
+}
+
+// Or explicit
+def show(Long id) {
+    def book = Book.get(id)
+    withFormat {
+        html { render view: 'show', model: [book: book] }
+        json { render book as JSON }
+        xml { render book as XML }
+    }
+}
+```
+
+## Services
+
+### Basic Service
+```groovy
+import grails.gorm.transactions.Transactional
+
+@Transactional
+class BookService {
+
+    def findByTitle(String title) {
+        Book.findByTitle(title)
+    }
+
+    def save(Book book) {
+        book.save(failOnError: true)
+    }
+
+    @Transactional(readOnly = true)
+    def list(Map params) {
+        Book.list(params)
+    }
+
+    def delete(Long id) {
+        Book.get(id)?.delete()
+    }
+}
+```
+
+### Service with Events
+```groovy
+import grails.events.annotation.Publisher
+import grails.events.annotation.Subscriber
+
+class BookService {
+
+    @Publisher
+    def save(Book book) {
+        book.save()
+        // Automatically publishes 'book.saved' event
+    }
+}
+
+class NotificationService {
+
+    @Subscriber('book.saved')
+    def onBookSaved(Book book) {
+        // Handle event
+        log.info "Book saved: ${book.title}"
+    }
+}
+```
+
+### Async Service
+```groovy
+import grails.async.Promise
+import static grails.async.Promises.*
+
+class BookService {
+
+    Promise<Book> findAsync(Long id) {
+        task {
+            Book.get(id)
+        }
+    }
+
+    def processBooks() {
+        def p1 = task { Book.findAllByActive(true) }
+        def p2 = task { Author.list() }
+
+        waitAll(p1, p2)
+        // Both complete
+    }
+}
+```
+
+## Views
+
+### GSP (Groovy Server Pages)
+```html
+<!-- grails-app/views/book/list.gsp -->
+<!DOCTYPE html>
+<html>
+<head>
+    <title>Books</title>
+    <asset:stylesheet src="application.css"/>
+</head>
+<body>
+    <h1>Books (${bookCount})</h1>
+
+    <g:each in="${bookList}" var="book">
+        <div class="book">
+            <h2>${book.title}</h2>
+            <p>By ${book.author}</p>
+            <g:link action="show" id="${book.id}">View</g:link>
+        </div>
+    </g:each>
+
+    <g:if test="${bookList.empty}">
+        <p>No books found.</p>
+    </g:if>
+
+    <g:paginate total="${bookCount}"/>
+
+    <asset:javascript src="application.js"/>
+</body>
+</html>
+```
+
+### Common GSP Tags
+```html
+<!-- Links -->
+<g:link controller="book" action="show" id="${book.id}">View</g:link>
+<g:createLink action="list"/>
+
+<!-- Forms -->
+<g:form action="save">
+    <g:textField name="title" value="${book?.title}"/>
+    <g:textArea name="description" value="${book?.description}"/>
+    <g:select name="category" from="${categories}" optionKey="id" optionValue="name"/>
+    <g:checkBox name="active" value="${book?.active}"/>
+    <g:submitButton name="submit" value="Save"/>
+</g:form>
+
+<!-- Conditionals -->
+<g:if test="${condition}">...</g:if>
+<g:elseif test="${other}">...</g:elseif>
+<g:else>...</g:else>
+
+<!-- Iteration -->
+<g:each in="${items}" var="item" status="i">
+    ${i}: ${item.name}
+</g:each>
+
+<!-- Rendering -->
+<g:render template="bookRow" model="[book: book]"/>
+<g:render template="bookRow" collection="${books}" var="book"/>
+
+<!-- Security (with Spring Security plugin) -->
+<sec:ifLoggedIn>Welcome, ${sec.username()}</sec:ifLoggedIn>
+<sec:ifNotLoggedIn><g:link controller="login">Login</g:link></sec:ifNotLoggedIn>
+```
+
+### JSON Views
+```groovy
+// grails-app/views/book/show.gson
+import myapp.Book
+
+model {
+    Book book
+}
+
+json {
+    id book.id
+    title book.title
+    author book.author
+    datePublished book.datePublished?.format('yyyy-MM-dd')
+    _links {
+        self {
+            href "/books/${book.id}"
+        }
+    }
+}
+```
+
+### Layouts
+```html
+<!-- grails-app/views/layouts/main.gsp -->
+<!DOCTYPE html>
+<html>
+<head>
+    <title><g:layoutTitle default="My App"/></title>
+    <asset:stylesheet src="application.css"/>
+    <g:layoutHead/>
+</head>
+<body>
+    <nav><!-- Navigation --></nav>
+    <main>
+        <g:layoutBody/>
+    </main>
+    <footer><!-- Footer --></footer>
+    <asset:javascript src="application.js"/>
+</body>
+</html>
+
+<!-- Use in views -->
+<html>
+<head>
+    <meta name="layout" content="main"/>
+    <title>Books</title>
+</head>
+<body>
+    <!-- Page content -->
+</body>
+</html>
+```
+
+## Interceptors
+
+```groovy
+class AuthInterceptor {
+
+    AuthInterceptor() {
+        matchAll()
+            .excludes(controller: 'login')
+            .excludes(controller: 'error')
+    }
+
+    boolean before() {
+        if (!session.user) {
+            redirect(controller: 'login')
+            return false
+        }
+        true
+    }
+
+    boolean after() {
+        // After action executes
+        true
+    }
+
+    void afterView() {
+        // After view renders
+    }
+}
+```
+
+## Tag Libraries
+
+```groovy
+class BookTagLib {
+
+    static namespace = 'book'
+    static defaultEncodeAs = [taglib: 'html']
+
+    def formatTitle = { attrs, body ->
+        def title = attrs.title ?: body()
+        out << "<span class='book-title'>${title}</span>"
+    }
+
+    def ifHasBooks = { attrs, body ->
+        if (Book.count() > 0) {
+            out << body()
+        }
+    }
+}
+
+// Usage in GSP
+<book:formatTitle title="${book.title}"/>
+<book:ifHasBooks>
+    <p>We have books!</p>
+</book:ifHasBooks>
+```
+
+## Configuration
+
+### application.yml
+```yaml
+grails:
+    profile: web
+    codegen:
+        defaultPackage: myapp
+    gorm:
+        reactor:
+            events: false
+    mime:
+        types:
+            json: ['application/json', 'text/json']
+            xml: ['text/xml', 'application/xml']
+
+environments:
+    development:
+        dataSource:
+            dbCreate: create-drop
+            url: jdbc:h2:mem:devDb
+    test:
+        dataSource:
+            dbCreate: update
+            url: jdbc:h2:mem:testDb
+    production:
+        dataSource:
+            dbCreate: none
+            url: jdbc:postgresql://localhost/myapp
+            driverClassName: org.postgresql.Driver
+            dialect: org.hibernate.dialect.PostgreSQLDialect
+            properties:
+                jmxEnabled: true
+                initialSize: 5
+                maxActive: 50
+
+server:
+    port: 8080
+    servlet:
+        context-path: /myapp
+```
+
+### URL Mappings
+```groovy
+// grails-app/controllers/myapp/UrlMappings.groovy
+class UrlMappings {
+
+    static mappings = {
+        // Default
+        "/$controller/$action?/$id?(.$format)?" {
+            constraints {
+                // apply constraints here
+            }
+        }
+
+        // REST resources
+        "/api/books"(resources: 'book')
+
+        // Custom mappings
+        "/books/$id"(controller: 'book', action: 'show')
+        "/search"(controller: 'book', action: 'search')
+
+        // Named URL mappings
+        name bookShow: "/books/$id" {
+            controller = 'book'
+            action = 'show'
+        }
+
+        // Error pages
+        "500"(view: '/error')
+        "404"(view: '/notFound')
+    }
+}
+```
+
+## Testing with Spock
+
+### Unit Test - Controller
+```groovy
+import grails.testing.web.controllers.ControllerUnitTest
+import spock.lang.Specification
+
+class BookControllerSpec extends Specification
+        implements ControllerUnitTest<BookController> {
+
+    def setup() {
+        controller.bookService = Mock(BookService)
+    }
+
+    void "index returns list of books"() {
+        given:
+        def books = [new Book(title: "Test")]
+        controller.bookService.list(_) >> books
+
+        when:
+        controller.index()
+
+        then:
+        model.bookList == books
+        view == '/book/index'
+    }
+
+    void "show returns 404 for missing book"() {
+        when:
+        controller.show(999)
+
+        then:
+        response.status == 404
+    }
+}
+```
+
+### Unit Test - Service
+```groovy
+import grails.testing.services.ServiceUnitTest
+import spock.lang.Specification
+
+class BookServiceSpec extends Specification
+        implements ServiceUnitTest<BookService> {
+
+    void "save persists book"() {
+        given:
+        def book = new Book(title: "Test", author: "Author")
+
+        when:
+        def result = service.save(book)
+
+        then:
+        result.id != null
+        Book.count() == 1
+    }
+}
+```
+
+### Unit Test - Domain
+```groovy
+import grails.testing.gorm.DomainUnitTest
+import spock.lang.Specification
+
+class BookSpec extends Specification
+        implements DomainUnitTest<Book> {
+
+    void "title cannot be blank"() {
+        when:
+        domain.title = ""
+        domain.author = "Test"
+
+        then:
+        !domain.validate(['title'])
+        domain.errors['title'].code == 'blank'
+    }
+
+    void "valid book passes validation"() {
+        when:
+        domain.title = "Valid Title"
+        domain.author = "Author"
+
+        then:
+        domain.validate()
+    }
+}
+```
+
+### Integration Test
+```groovy
+import grails.testing.mixin.integration.Integration
+import grails.gorm.transactions.Rollback
+import spock.lang.Specification
+
+@Integration
+@Rollback
+class BookServiceIntegrationSpec extends Specification {
+
+    BookService bookService
+
+    void "save and retrieve book"() {
+        given:
+        def book = new Book(title: "Integration Test", author: "Tester")
+
+        when:
+        bookService.save(book)
+        def found = Book.findByTitle("Integration Test")
+
+        then:
+        found != null
+        found.author == "Tester"
+    }
+}
+```
+
+### Functional Test with Geb
+```groovy
+import geb.spock.GebSpec
+import grails.testing.mixin.integration.Integration
+
+@Integration
+class BookFunctionalSpec extends GebSpec {
+
+    void "can view book list"() {
+        when:
+        go '/book/index'
+
+        then:
+        title == 'Book List'
+        $('h1').text() == 'Books'
+    }
+
+    void "can create new book"() {
+        when:
+        go '/book/create'
+        $('form').title = 'New Book'
+        $('form').author = 'Test Author'
+        $('input[type=submit]').click()
+
+        then:
+        $('h1').text().contains('New Book')
+    }
+}
+```
+
+## Plugins
+
+### Common Plugins
+```groovy
+// build.gradle
+
+// Spring Security
+implementation 'org.grails.plugins:spring-security-core:6.0.0'
+
+// Database Migration (Liquibase)
+implementation 'org.grails.plugins:database-migration:4.2.0'
+
+// Caching
+implementation 'org.grails.plugins:cache:6.0.0'
+
+// Async support
+implementation 'org.grails.plugins:async:5.0.0'
+
+// Fields plugin for form rendering
+implementation 'org.grails.plugins:fields:5.0.0'
+
+// Asset Pipeline
+runtimeOnly 'org.grails.plugins:asset-pipeline:5.0.0'
+```
+
+### Spring Security Configuration
+```groovy
+// grails-app/conf/application.groovy
+grails.plugin.springsecurity.userLookup.userDomainClassName = 'myapp.User'
+grails.plugin.springsecurity.userLookup.authorityJoinClassName = 'myapp.UserRole'
+grails.plugin.springsecurity.authority.className = 'myapp.Role'
+
+grails.plugin.springsecurity.controllerAnnotations.staticRules = [
+    [pattern: '/',               access: ['permitAll']],
+    [pattern: '/error',          access: ['permitAll']],
+    [pattern: '/index',          access: ['permitAll']],
+    [pattern: '/admin/**',       access: ['ROLE_ADMIN']],
+    [pattern: '/api/**',         access: ['isAuthenticated()']],
+]
+```
+
+## Build Commands
+
+```bash
+# Run application
+./gradlew bootRun
+
+# Run tests
+./gradlew test                                    # All tests
+./gradlew test --tests "BookServiceSpec"          # Single spec
+./gradlew test --tests "*Spec.save*"              # Pattern match
+./gradlew integrationTest                         # Integration tests
+
+# Build
+./gradlew build -PskipTests                       # Build without tests
+./gradlew bootJar                                 # Executable JAR
+./gradlew bootWar                                 # WAR file
+
+# Code quality
+./gradlew codeStyle                               # Check style
+
+# Clean
+./gradlew clean
+```
+
+## Best Practices
+
+### Convention Over Configuration
+- Follow Grails naming conventions for automatic wiring.
+- Use standard directory structure.
+- Let Grails infer configurations where possible.
+
+### Performance
+- Use `@GrailsCompileStatic` on controllers and services.
+- Enable query caching for read-heavy operations.
+- Use pagination for large result sets.
+- Avoid N+1 queries with eager fetching or batch size.
+
+### Security
+- Use CSRF tokens in forms: `<g:form useToken="true">`.
+- Apply Spring Security for authentication/authorization.
+- Use parameterized queries (GORM handles this automatically).
+- Encode output to prevent XSS.
+
+### Testing
+- Write unit tests for domain constraints.
+- Test controllers with `ControllerUnitTest`.
+- Use integration tests for service/database interactions.
+- Use Geb for critical user workflows.
+
+### Code Style
+- Use `@GrailsCompileStatic` for type safety and performance.

Review Comment:
   "... or @CompileStatic for..."?



##########
.agents/skills/groovy-developer/SKILL.md:
##########
@@ -0,0 +1,520 @@
+<!--
+SPDX-License-Identifier: Apache-2.0
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+---
+name: groovy-developer
+description: Expert guide for Groovy 4 development, covering concise syntax, closures, DSLs, metaprogramming, static compilation, and integration with Java 17 and Grails
+license: Apache-2.0
+compatibility: opencode, claude, grok, gemini, copilot, cursor, windsurf
+metadata:
+  audience: developers
+  languages: groovy, java
+  versions: 4.0
+  paradigms: dynamic, static, functional, object-oriented, DSL-oriented
+---
+
+## What I Do
+
+- Provide deep expertise in Groovy 4.0, including core language features: syntax, closures, traits, GStrings, operators, and Groovy Truth.
+- Guide metaprogramming techniques: runtime (categories, ExpandoMetaClass, extension modules) and compile-time (AST transformations like @Immutable, @Builder, @Delegate, @Singleton, @Log, @Memoized).
+- Assist with DSL creation and usage (MarkupBuilder, JsonBuilder, builders for configuration).
+- Support testing with Spock Framework (BDD, data-driven tests, mocking) and built-in power assertions.
+- Help integrate Groovy with Java 17: joint compilation, Gradle builds, Grails, and Spring Boot.
+- Cover data handling: JSON/XML parsing and building, Groovy SQL, collection processing.
+- Advise on performance: @CompileStatic, @TypeChecked, @GrailsCompileStatic for optimal execution.
+
+## When to Use Me
+
+Activate this skill for any Groovy-related task, including:
+
+- Writing or debugging Groovy classes in Grails domain, controllers, services, or taglibs.
+- Building or enhancing Gradle build scripts (build.gradle).
+- Creating DSLs for configuration, testing, or business rules.
+- Writing Spock specifications for unit and integration tests.
+- Migrating from older Groovy versions (2.x/3.x) to 4.0.
+- Performance optimization with static compilation.
+- Working with JSON/XML data, GORM criteria queries, or builders.
+
+## Groovy 4 Key Features
+
+### Concise Syntax
+```groovy
+// No semicolons required
+def name = "Grails"
+
+// Optional parentheses for method calls
+println "Hello World"
+list.each { println it }
+
+// Optional return keyword
+String greet(String name) {
+    "Hello, $name"  // Last expression is returned
+}
+```
+
+### GStrings (String Interpolation)
+```groovy
+def user = "Alice"
+def count = 42
+
+// Simple interpolation
+println "User: $user"
+
+// Expression interpolation
+println "Items: ${count * 2}"
+
+// Lazy GStrings (evaluated when accessed)
+def lazy = "Count is ${ -> counter }"
+
+// Multi-line strings
+def sql = """
+    SELECT * FROM users
+    WHERE name = '$user'
+    ORDER BY created_at
+"""
+```
+
+### Closures
+```groovy
+// Basic closure
+def greet = { name -> "Hello, $name" }
+println greet("World")
+
+// Implicit 'it' parameter
+def double = { it * 2 }
+println [1, 2, 3].collect(double)
+
+// Closure with delegate (for DSLs)
+def configure = {
+    name = "MyApp"
+    version = "1.0"
+}
+configure.delegate = new Config()
+configure.resolveStrategy = Closure.DELEGATE_FIRST
+configure()
+
+// Method references
+def upper = String.&toUpperCase
+println ["a", "b"].collect(upper)
+```
+
+### Safe Navigation and Elvis Operator
+```groovy
+// Safe navigation - returns null if any part is null
+def city = user?.address?.city
+
+// Elvis operator - default value if null
+def name = user?.name ?: "Anonymous"
+
+// Safe method calls
+def length = text?.length() ?: 0
+
+// Combine with collections
+def firstTitle = books?.first()?.title ?: "No books"
+```
+
+### Spread Operator
+```groovy
+// Spread operator for collections
+def names = users*.name  // Same as users.collect { it.name }
+
+// Spread for method arguments
+def args = [1, 2, 3]
+someMethod(*args)
+
+// Spread in list literals
+def combined = [*list1, *list2]
+```
+
+### Collection Literals and Methods
+```groovy
+// List literal
+def list = [1, 2, 3, 4, 5]
+
+// Map literal
+def map = [name: "Grails", version: 7]
+
+// Range
+def range = 1..10
+def exclusive = 1..<10
+
+// Powerful collection methods
+list.find { it > 3 }           // First match: 4
+list.findAll { it > 3 }        // All matches: [4, 5]
+list.any { it > 3 }            // true
+list.every { it > 0 }          // true
+list.groupBy { it % 2 }        // [0:[2,4], 1:[1,3,5]]
+list.collectEntries { [it, it * 2] }  // [1:2, 2:4, ...]
+
+// Sorting
+list.sort { a, b -> b <=> a }  // Descending
+list.sort { -it }              // Descending (numeric)
+```
+
+### Groovy Truth
+```groovy
+// Falsy values: null, empty string, empty collection, 0, false
+if (list) { }      // True if not null and not empty
+if (string) { }    // True if not null and not blank
+if (number) { }    // True if not 0
+
+// Useful in conditionals
+def items = getItems() ?: []  // Default to empty list
+```
+
+### Records (Incubating)
+```groovy
+// Immutable data class
+record Point(int x, int y) {}
+
+def p = new Point(10, 20)
+println p.x()  // 10
+println p      // Point[x=10, y=20]
+```
+
+### Traits
+```groovy
+trait Auditable {
+    Date dateCreated
+    Date lastUpdated
+
+    def beforeInsert() {
+        dateCreated = new Date()
+    }
+
+    def beforeUpdate() {
+        lastUpdated = new Date()
+    }
+}
+
+class Book implements Auditable {
+    String title
+}
+```
+
+## Static Compilation
+
+### @CompileStatic
+Enables static type checking and compilation for better performance:
+```groovy
+import groovy.transform.CompileStatic
+
+@CompileStatic
+class BookService {
+    List<Book> findByAuthor(String author) {
+        Book.findAllByAuthor(author)
+    }
+
+    int calculateTotal(List<Integer> prices) {
+        prices.sum() as int
+    }
+}
+```
+
+### @TypeChecked
+Type checking without full static compilation:
+```groovy
+import groovy.transform.TypeChecked
+
+@TypeChecked
+void process(String input) {
+    println input.toUppercase()  // Compile error: method not found
+}
+```
+
+### @GrailsCompileStatic
+Grails-aware static compilation that understands dynamic finders:
+```groovy
+import grails.compiler.GrailsCompileStatic
+
+@GrailsCompileStatic
+class BookController {
+    def show(Long id) {
+        respond Book.get(id)  // Works with static compilation
+    }
+}
+```
+
+## AST Transformations
+
+### @Immutable
+```groovy
+import groovy.transform.Immutable
+
+@Immutable
+class Person {
+    String name
+    int age
+}
+
+def p = new Person(name: "Alice", age: 30)
+// p.name = "Bob"  // Error: read-only
+```
+
+### @Builder
+```groovy
+import groovy.transform.builder.Builder
+
+@Builder
+class Email {
+    String to
+    String subject
+    String body
+}
+
+def email = Email.builder()
+    .to("user@example.com")
+    .subject("Hello")
+    .body("Content here")
+    .build()
+```
+
+### @Delegate
+```groovy
+import groovy.transform.Delegate
+
+class EnhancedList<T> {
+    @Delegate List<T> list = []
+
+    T secondLast() {
+        list[-2]
+    }
+}
+
+def enhanced = new EnhancedList<String>()
+enhanced.add("a")  // Delegated to list
+enhanced.add("b")
+println enhanced.secondLast()  // "a"
+```
+
+### @Singleton
+```groovy
+import groovy.transform.Singleton
+
+@Singleton
+class ConfigManager {
+    Map settings = [:]
+}
+
+ConfigManager.instance.settings['key'] = 'value'
+```
+
+### @Memoized
+```groovy
+import groovy.transform.Memoized
+
+class Calculator {
+    @Memoized
+    BigInteger fibonacci(int n) {
+        if (n <= 1) return n
+        fibonacci(n - 1) + fibonacci(n - 2)
+    }
+}
+```
+
+### @Log Variants
+```groovy
+import groovy.util.logging.Slf4j
+
+@Slf4j
+class BookService {
+    def save(Book book) {
+        log.info "Saving book: ${book.title}"
+        // ...
+    }
+}
+```
+
+## Builders and DSLs
+
+### JsonBuilder
+```groovy
+import groovy.json.JsonBuilder
+
+def builder = new JsonBuilder()
+builder {
+    name "Grails"
+    version 7
+    features(["GORM", "GSP", "Plugins"])
+    metadata {
+        author "Grails Team"
+        license "Apache 2.0"
+    }
+}
+println builder.toPrettyString()
+```
+
+### JsonSlurper
+```groovy
+import groovy.json.JsonSlurper
+
+def json = '{"name": "Grails", "version": 7}'
+def data = new JsonSlurper().parseText(json)
+println data.name  // Grails
+```
+
+### MarkupBuilder (XML/HTML)
+```groovy
+import groovy.xml.MarkupBuilder
+
+def writer = new StringWriter()
+def xml = new MarkupBuilder(writer)
+xml.books {
+    book(id: 1) {
+        title "Grails Guide"
+        author "Team"
+    }
+}
+println writer.toString()
+```
+
+### Custom DSL Example
+```groovy
+class HtmlBuilder {
+    def html(@DelegatesTo(HtmlBuilder) Closure c) {
+        c.delegate = this
+        c.resolveStrategy = Closure.DELEGATE_FIRST
+        "<html>${c()}</html>"
+    }
+
+    def body(String content) {
+        "<body>$content</body>"
+    }
+}
+
+def builder = new HtmlBuilder()
+def result = builder.html {
+    body "Hello World"
+}
+```
+
+## Testing with Spock
+
+### Basic Specification
+```groovy
+class BookServiceSpec extends Specification {
+
+    def service = new BookService()
+
+    def "should find book by title"() {
+        given: "a book title"
+        def title = "Grails Guide"
+
+        when: "searching for the book"
+        def book = service.findByTitle(title)
+
+        then: "the book is found"
+        book != null
+        book.title == title
+    }
+}
+```
+
+### Data-Driven Tests
+```groovy
+@Unroll
+def "max of #a and #b is #expected"() {
+    expect:
+    Math.max(a, b) == expected
+
+    where:
+    a | b || expected
+    1 | 3 || 3
+    7 | 4 || 7
+    0 | 0 || 0
+}
+```
+
+### Mocking
+```groovy
+def "should call repository when saving"() {
+    given:
+    def repo = Mock(BookRepository)
+    def service = new BookService(repo)
+    def book = new Book(title: "Test")
+
+    when:
+    service.save(book)
+
+    then:
+    1 * repo.save(book)
+}
+```
+
+### Exception Testing
+```groovy
+def "should throw exception for invalid input"() {
+    when:
+    service.process(null)
+
+    then:
+    thrown(IllegalArgumentException)
+}
+```
+
+## Groovy SQL
+```groovy
+import groovy.sql.Sql
+
+def sql = Sql.newInstance(dataSource)
+
+// Query
+sql.eachRow("SELECT * FROM books WHERE author = ?", [authorName]) { row ->
+    println "${row.title} by ${row.author}"
+}
+
+// Insert
+sql.execute("INSERT INTO books (title, author) VALUES (?, ?)",
+            [title, author])
+
+// With GString (auto-parameterized)
+sql.execute("INSERT INTO books (title) VALUES ($title)")
+```
+
+## Best Practices
+
+### Performance
+- Use `@CompileStatic` or `@GrailsCompileStatic` in production code.
+- Avoid runtime metaprogramming in hot paths.
+- Prefer `collect`/`findAll` over manual loops.
+- Use `@Memoized` for expensive computations.
+
+### Code Style
+- Use safe navigation (`?.`) instead of null checks.
+- Prefer Elvis operator (`?:`) for default values.
+- Use GStrings for string interpolation.
+- Prefer traits over inheritance for mixins.
+- Use explicit types for public APIs, `def` for local variables.
+
+### Grails-Specific
+- Use `@GrailsCompileStatic` instead of `@CompileStatic` in Grails classes.

Review Comment:
   ...if needed



##########
.agents/skills/groovy-developer/SKILL.md:
##########
@@ -0,0 +1,520 @@
+<!--
+SPDX-License-Identifier: Apache-2.0
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+---
+name: groovy-developer
+description: Expert guide for Groovy 4 development, covering concise syntax, closures, DSLs, metaprogramming, static compilation, and integration with Java 17 and Grails
+license: Apache-2.0
+compatibility: opencode, claude, grok, gemini, copilot, cursor, windsurf
+metadata:
+  audience: developers
+  languages: groovy, java
+  versions: 4.0
+  paradigms: dynamic, static, functional, object-oriented, DSL-oriented
+---
+
+## What I Do
+
+- Provide deep expertise in Groovy 4.0, including core language features: syntax, closures, traits, GStrings, operators, and Groovy Truth.
+- Guide metaprogramming techniques: runtime (categories, ExpandoMetaClass, extension modules) and compile-time (AST transformations like @Immutable, @Builder, @Delegate, @Singleton, @Log, @Memoized).
+- Assist with DSL creation and usage (MarkupBuilder, JsonBuilder, builders for configuration).
+- Support testing with Spock Framework (BDD, data-driven tests, mocking) and built-in power assertions.
+- Help integrate Groovy with Java 17: joint compilation, Gradle builds, Grails, and Spring Boot.
+- Cover data handling: JSON/XML parsing and building, Groovy SQL, collection processing.
+- Advise on performance: @CompileStatic, @TypeChecked, @GrailsCompileStatic for optimal execution.
+
+## When to Use Me
+
+Activate this skill for any Groovy-related task, including:
+
+- Writing or debugging Groovy classes in Grails domain, controllers, services, or taglibs.
+- Building or enhancing Gradle build scripts (build.gradle).
+- Creating DSLs for configuration, testing, or business rules.
+- Writing Spock specifications for unit and integration tests.
+- Migrating from older Groovy versions (2.x/3.x) to 4.0.
+- Performance optimization with static compilation.
+- Working with JSON/XML data, GORM criteria queries, or builders.
+
+## Groovy 4 Key Features
+
+### Concise Syntax
+```groovy
+// No semicolons required
+def name = "Grails"
+
+// Optional parentheses for method calls
+println "Hello World"
+list.each { println it }
+
+// Optional return keyword
+String greet(String name) {
+    "Hello, $name"  // Last expression is returned
+}
+```
+
+### GStrings (String Interpolation)
+```groovy
+def user = "Alice"
+def count = 42
+
+// Simple interpolation
+println "User: $user"
+
+// Expression interpolation
+println "Items: ${count * 2}"
+
+// Lazy GStrings (evaluated when accessed)
+def lazy = "Count is ${ -> counter }"
+
+// Multi-line strings
+def sql = """
+    SELECT * FROM users
+    WHERE name = '$user'
+    ORDER BY created_at
+"""
+```
+
+### Closures
+```groovy
+// Basic closure
+def greet = { name -> "Hello, $name" }
+println greet("World")
+
+// Implicit 'it' parameter
+def double = { it * 2 }
+println [1, 2, 3].collect(double)
+
+// Closure with delegate (for DSLs)
+def configure = {
+    name = "MyApp"
+    version = "1.0"
+}
+configure.delegate = new Config()
+configure.resolveStrategy = Closure.DELEGATE_FIRST
+configure()
+
+// Method references
+def upper = String.&toUpperCase
+println ["a", "b"].collect(upper)
+```
+
+### Safe Navigation and Elvis Operator
+```groovy
+// Safe navigation - returns null if any part is null
+def city = user?.address?.city
+
+// Elvis operator - default value if null
+def name = user?.name ?: "Anonymous"
+
+// Safe method calls
+def length = text?.length() ?: 0
+
+// Combine with collections
+def firstTitle = books?.first()?.title ?: "No books"
+```
+
+### Spread Operator
+```groovy
+// Spread operator for collections
+def names = users*.name  // Same as users.collect { it.name }
+
+// Spread for method arguments
+def args = [1, 2, 3]
+someMethod(*args)
+
+// Spread in list literals
+def combined = [*list1, *list2]
+```
+
+### Collection Literals and Methods
+```groovy
+// List literal
+def list = [1, 2, 3, 4, 5]
+
+// Map literal
+def map = [name: "Grails", version: 7]
+
+// Range
+def range = 1..10
+def exclusive = 1..<10
+
+// Powerful collection methods
+list.find { it > 3 }           // First match: 4
+list.findAll { it > 3 }        // All matches: [4, 5]
+list.any { it > 3 }            // true
+list.every { it > 0 }          // true
+list.groupBy { it % 2 }        // [0:[2,4], 1:[1,3,5]]
+list.collectEntries { [it, it * 2] }  // [1:2, 2:4, ...]
+
+// Sorting
+list.sort { a, b -> b <=> a }  // Descending
+list.sort { -it }              // Descending (numeric)
+```
+
+### Groovy Truth
+```groovy
+// Falsy values: null, empty string, empty collection, 0, false
+if (list) { }      // True if not null and not empty
+if (string) { }    // True if not null and not blank
+if (number) { }    // True if not 0
+
+// Useful in conditionals
+def items = getItems() ?: []  // Default to empty list
+```
+
+### Records (Incubating)
+```groovy
+// Immutable data class
+record Point(int x, int y) {}
+
+def p = new Point(10, 20)
+println p.x()  // 10
+println p      // Point[x=10, y=20]
+```
+
+### Traits
+```groovy
+trait Auditable {
+    Date dateCreated
+    Date lastUpdated
+
+    def beforeInsert() {
+        dateCreated = new Date()
+    }
+
+    def beforeUpdate() {
+        lastUpdated = new Date()
+    }
+}
+
+class Book implements Auditable {
+    String title
+}
+```
+
+## Static Compilation
+
+### @CompileStatic
+Enables static type checking and compilation for better performance:
+```groovy
+import groovy.transform.CompileStatic
+
+@CompileStatic
+class BookService {
+    List<Book> findByAuthor(String author) {
+        Book.findAllByAuthor(author)
+    }
+
+    int calculateTotal(List<Integer> prices) {
+        prices.sum() as int
+    }
+}
+```
+
+### @TypeChecked
+Type checking without full static compilation:
+```groovy
+import groovy.transform.TypeChecked
+
+@TypeChecked
+void process(String input) {
+    println input.toUppercase()  // Compile error: method not found
+}
+```
+
+### @GrailsCompileStatic
+Grails-aware static compilation that understands dynamic finders:
+```groovy
+import grails.compiler.GrailsCompileStatic
+
+@GrailsCompileStatic
+class BookController {
+    def show(Long id) {
+        respond Book.get(id)  // Works with static compilation
+    }
+}
+```
+
+## AST Transformations
+
+### @Immutable
+```groovy
+import groovy.transform.Immutable
+
+@Immutable
+class Person {
+    String name
+    int age
+}
+
+def p = new Person(name: "Alice", age: 30)
+// p.name = "Bob"  // Error: read-only
+```
+
+### @Builder
+```groovy
+import groovy.transform.builder.Builder
+
+@Builder
+class Email {
+    String to
+    String subject
+    String body
+}
+
+def email = Email.builder()
+    .to("user@example.com")
+    .subject("Hello")
+    .body("Content here")
+    .build()
+```
+
+### @Delegate
+```groovy
+import groovy.transform.Delegate

Review Comment:
   `groovy.lang.Delegate`?



##########
.agents/skills/grails-developer/SKILL.md:
##########
@@ -0,0 +1,883 @@
+<!--
+SPDX-License-Identifier: Apache-2.0
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+---
+name: grails-developer
+description: Comprehensive guide for Grails 7 development, covering web applications, REST APIs, GORM, controllers, services, views, plugins, and testing with Spock and Geb
+license: Apache-2.0
+compatibility: opencode, claude, grok, gemini, copilot, cursor, windsurf
+metadata:
+  audience: developers
+  frameworks: grails
+  versions: 7
+---
+
+## What I Do
+
+- Provide detailed guidance for building Grails 7 web applications and REST APIs.
+- Assist with GORM for data modeling, controllers for request handling, services for business logic, and views (GSP, JSON, Markup).
+- Support testing with Spock 2.3 (unit/integration tests) and Geb for browser automation.
+- Guide plugin usage and development, security implementation, and deployment strategies.
+- Help with configuration, internationalization, async programming, and performance optimization.
+
+## When to Use Me
+
+Activate this skill when developing with Grails 7, including:
+
+- Building CRUD applications, RESTful APIs, or full-stack web applications.
+- Working with GORM domain classes, constraints, and relationships.
+- Creating controllers, services, interceptors, or tag libraries.
+- Writing Spock specifications or Geb functional tests.
+- Configuring plugins, security, caching, or database migrations.
+- Deploying Grails applications to containers or cloud platforms.
+
+## Technology Stack
+
+Grails 7 is built on:
+- **Spring Boot**: 3.5.x
+- **Spring Framework**: 6.2.x
+- **Groovy**: 4.0.x
+- **Gradle**: 8.14.x
+- **Spock**: 2.3-groovy-4.0
+- **Jakarta EE**: 10 (migrated from javax.*)
+- **Micronaut**: Optional via `grails-micronaut` plugin
+
+## Project Structure
+
+```
+myapp/
+├── grails-app/
+│   ├── conf/                 # Configuration
+│   │   ├── application.yml   # Main config
+│   │   ├── logback.xml       # Logging config
+│   │   └── spring/           # Spring bean definitions
+│   ├── controllers/          # Request handlers
+│   ├── domain/               # GORM domain classes
+│   ├── i18n/                 # Message bundles
+│   ├── init/                 # Bootstrap classes
+│   ├── services/             # Business logic
+│   ├── taglib/               # Custom GSP tags
+│   ├── utils/                # Utility classes
+│   └── views/                # GSP templates
+├── src/
+│   ├── main/groovy/          # Additional Groovy classes
+│   ├── main/java/            # Java classes
+│   └── test/groovy/          # Test specifications
+├── build.gradle              # Build configuration
+└── gradle.properties         # Project properties
+```
+
+## Domain Classes (GORM)
+
+### Basic Domain Class
+```groovy
+class Book {
+    String title
+    String author
+    Date datePublished
+    Integer pages
+
+    static constraints = {
+        title blank: false, maxSize: 255
+        author blank: false
+        datePublished nullable: true
+        pages min: 1, nullable: true
+    }
+
+    static mapping = {
+        table 'books'
+        title column: 'book_title'
+        datePublished type: 'date'
+    }
+}
+```
+
+### Relationships
+```groovy
+class Author {
+    String name
+
+    static hasMany = [books: Book]
+
+    static mapping = {
+        books cascade: 'all-delete-orphan'
+    }
+}
+
+class Book {
+    String title
+
+    static belongsTo = [author: Author]
+}
+
+// Many-to-Many
+class Book {
+    static hasMany = [categories: Category]
+    static belongsTo = Category
+}
+
+class Category {
+    String name
+    static hasMany = [books: Book]
+}
+```
+
+### GORM Queries
+```groovy
+// Dynamic finders
+Book.findByTitle("Grails Guide")
+Book.findAllByAuthorLike("%Smith%")
+Book.findByTitleAndAuthor("Guide", "Smith")
+Book.countByPagesGreaterThan(100)
+
+// Where queries
+Book.where {
+    title =~ "%Grails%" && pages > 100
+}.list()
+
+// Criteria queries
+Book.withCriteria {
+    like('title', '%Grails%')
+    gt('pages', 100)
+    order('datePublished', 'desc')
+    maxResults(10)
+}
+
+// HQL queries
+Book.executeQuery(
+    "from Book b where b.author.name = :name",
+    [name: 'Smith']
+)
+
+// Detached criteria (reusable)
+def criteria = Book.where {
+    pages > 100
+}
+criteria.list()
+criteria.count()
+```
+
+### Transactions
+```groovy
+// In services (default transactional)
+@Transactional
+class BookService {
+    def saveBook(Book book) {
+        book.save(failOnError: true)
+    }
+}
+
+// Manual transaction control
+Book.withTransaction { status ->
+    def book = new Book(title: "Test")
+    book.save()
+    if (someCondition) {
+        status.setRollbackOnly()
+    }
+}
+```
+
+## Controllers
+
+### Basic Controller
+```groovy
+class BookController {
+
+    BookService bookService
+
+    static allowedMethods = [save: 'POST', update: 'PUT', delete: 'DELETE']
+
+    def index() {
+        respond Book.list(), model: [bookCount: Book.count()]
+    }
+
+    def show(Long id) {
+        respond Book.get(id)
+    }
+
+    def create() {
+        respond new Book(params)
+    }
+
+    def save(Book book) {
+        if (book.hasErrors()) {
+            respond book.errors, view: 'create'
+            return
+        }
+        bookService.save(book)
+        redirect action: 'show', id: book.id
+    }
+
+    def edit(Long id) {
+        respond Book.get(id)
+    }
+
+    def update(Book book) {
+        if (book.hasErrors()) {
+            respond book.errors, view: 'edit'
+            return
+        }
+        bookService.save(book)
+        redirect action: 'show', id: book.id
+    }
+
+    def delete(Long id) {
+        bookService.delete(id)
+        redirect action: 'index'
+    }
+}
+```
+
+### REST Controller
+```groovy
+import grails.rest.RestfulController
+
+class BookController extends RestfulController<Book> {
+
+    static responseFormats = ['json', 'xml']
+
+    BookController() {
+        super(Book)
+    }
+
+    // Override to customize
+    @Override
+    protected Book queryForResource(Serializable id) {
+        Book.where { id == id && active == true }.find()
+    }
+}
+```
+
+### Command Objects
+```groovy
+class BookCommand implements Validateable {
+    String title
+    String author
+    Integer pages
+
+    static constraints = {
+        title blank: false
+        author blank: false
+        pages min: 1, nullable: true
+    }
+}
+
+class BookController {
+    def save(BookCommand cmd) {
+        if (cmd.hasErrors()) {
+            respond cmd.errors
+            return
+        }
+        // Process valid command
+    }
+}
+```
+
+### Content Negotiation
+```groovy
+class BookController {
+    def show(Long id) {
+        def book = Book.get(id)
+        respond book  // Auto-negotiates based on Accept header
+    }
+}
+
+// Or explicit
+def show(Long id) {
+    def book = Book.get(id)
+    withFormat {
+        html { render view: 'show', model: [book: book] }
+        json { render book as JSON }
+        xml { render book as XML }
+    }
+}
+```
+
+## Services
+
+### Basic Service
+```groovy
+import grails.gorm.transactions.Transactional
+
+@Transactional
+class BookService {
+
+    def findByTitle(String title) {
+        Book.findByTitle(title)
+    }
+
+    def save(Book book) {
+        book.save(failOnError: true)
+    }
+
+    @Transactional(readOnly = true)
+    def list(Map params) {
+        Book.list(params)
+    }
+
+    def delete(Long id) {
+        Book.get(id)?.delete()
+    }
+}
+```
+
+### Service with Events
+```groovy
+import grails.events.annotation.Publisher
+import grails.events.annotation.Subscriber
+
+class BookService {
+
+    @Publisher
+    def save(Book book) {
+        book.save()
+        // Automatically publishes 'book.saved' event
+    }
+}
+
+class NotificationService {
+
+    @Subscriber('book.saved')
+    def onBookSaved(Book book) {
+        // Handle event
+        log.info "Book saved: ${book.title}"
+    }
+}
+```
+
+### Async Service
+```groovy
+import grails.async.Promise
+import static grails.async.Promises.*
+
+class BookService {
+
+    Promise<Book> findAsync(Long id) {
+        task {
+            Book.get(id)
+        }
+    }
+
+    def processBooks() {
+        def p1 = task { Book.findAllByActive(true) }
+        def p2 = task { Author.list() }
+
+        waitAll(p1, p2)
+        // Both complete
+    }
+}
+```
+
+## Views
+
+### GSP (Groovy Server Pages)
+```html
+<!-- grails-app/views/book/list.gsp -->
+<!DOCTYPE html>
+<html>
+<head>
+    <title>Books</title>
+    <asset:stylesheet src="application.css"/>
+</head>
+<body>
+    <h1>Books (${bookCount})</h1>
+
+    <g:each in="${bookList}" var="book">
+        <div class="book">
+            <h2>${book.title}</h2>
+            <p>By ${book.author}</p>
+            <g:link action="show" id="${book.id}">View</g:link>
+        </div>
+    </g:each>
+
+    <g:if test="${bookList.empty}">
+        <p>No books found.</p>
+    </g:if>
+
+    <g:paginate total="${bookCount}"/>
+
+    <asset:javascript src="application.js"/>
+</body>
+</html>
+```
+
+### Common GSP Tags
+```html
+<!-- Links -->
+<g:link controller="book" action="show" id="${book.id}">View</g:link>
+<g:createLink action="list"/>
+
+<!-- Forms -->
+<g:form action="save">
+    <g:textField name="title" value="${book?.title}"/>
+    <g:textArea name="description" value="${book?.description}"/>
+    <g:select name="category" from="${categories}" optionKey="id" optionValue="name"/>
+    <g:checkBox name="active" value="${book?.active}"/>
+    <g:submitButton name="submit" value="Save"/>
+</g:form>
+
+<!-- Conditionals -->
+<g:if test="${condition}">...</g:if>
+<g:elseif test="${other}">...</g:elseif>
+<g:else>...</g:else>
+
+<!-- Iteration -->
+<g:each in="${items}" var="item" status="i">
+    ${i}: ${item.name}
+</g:each>
+
+<!-- Rendering -->
+<g:render template="bookRow" model="[book: book]"/>
+<g:render template="bookRow" collection="${books}" var="book"/>
+
+<!-- Security (with Spring Security plugin) -->
+<sec:ifLoggedIn>Welcome, ${sec.username()}</sec:ifLoggedIn>
+<sec:ifNotLoggedIn><g:link controller="login">Login</g:link></sec:ifNotLoggedIn>
+```
+
+### JSON Views
+```groovy
+// grails-app/views/book/show.gson
+import myapp.Book
+
+model {
+    Book book
+}
+
+json {
+    id book.id
+    title book.title
+    author book.author
+    datePublished book.datePublished?.format('yyyy-MM-dd')
+    _links {
+        self {
+            href "/books/${book.id}"
+        }
+    }
+}
+```
+
+### Layouts
+```html
+<!-- grails-app/views/layouts/main.gsp -->
+<!DOCTYPE html>
+<html>
+<head>
+    <title><g:layoutTitle default="My App"/></title>
+    <asset:stylesheet src="application.css"/>
+    <g:layoutHead/>
+</head>
+<body>
+    <nav><!-- Navigation --></nav>
+    <main>
+        <g:layoutBody/>
+    </main>
+    <footer><!-- Footer --></footer>
+    <asset:javascript src="application.js"/>
+</body>
+</html>
+
+<!-- Use in views -->
+<html>
+<head>
+    <meta name="layout" content="main"/>
+    <title>Books</title>
+</head>
+<body>
+    <!-- Page content -->
+</body>
+</html>
+```
+
+## Interceptors
+
+```groovy
+class AuthInterceptor {
+
+    AuthInterceptor() {
+        matchAll()
+            .excludes(controller: 'login')
+            .excludes(controller: 'error')
+    }
+
+    boolean before() {
+        if (!session.user) {
+            redirect(controller: 'login')
+            return false
+        }
+        true
+    }
+
+    boolean after() {
+        // After action executes
+        true
+    }
+
+    void afterView() {
+        // After view renders
+    }
+}
+```
+
+## Tag Libraries
+
+```groovy
+class BookTagLib {
+
+    static namespace = 'book'
+    static defaultEncodeAs = [taglib: 'html']
+
+    def formatTitle = { attrs, body ->
+        def title = attrs.title ?: body()
+        out << "<span class='book-title'>${title}</span>"
+    }
+
+    def ifHasBooks = { attrs, body ->
+        if (Book.count() > 0) {
+            out << body()
+        }
+    }
+}
+
+// Usage in GSP
+<book:formatTitle title="${book.title}"/>
+<book:ifHasBooks>
+    <p>We have books!</p>
+</book:ifHasBooks>
+```
+
+## Configuration
+
+### application.yml
+```yaml
+grails:
+    profile: web
+    codegen:
+        defaultPackage: myapp
+    gorm:
+        reactor:
+            events: false
+    mime:
+        types:
+            json: ['application/json', 'text/json']
+            xml: ['text/xml', 'application/xml']
+
+environments:
+    development:
+        dataSource:
+            dbCreate: create-drop
+            url: jdbc:h2:mem:devDb
+    test:
+        dataSource:
+            dbCreate: update
+            url: jdbc:h2:mem:testDb
+    production:
+        dataSource:
+            dbCreate: none
+            url: jdbc:postgresql://localhost/myapp
+            driverClassName: org.postgresql.Driver
+            dialect: org.hibernate.dialect.PostgreSQLDialect
+            properties:
+                jmxEnabled: true
+                initialSize: 5
+                maxActive: 50
+
+server:
+    port: 8080
+    servlet:
+        context-path: /myapp
+```
+
+### URL Mappings
+```groovy
+// grails-app/controllers/myapp/UrlMappings.groovy
+class UrlMappings {
+
+    static mappings = {
+        // Default
+        "/$controller/$action?/$id?(.$format)?" {
+            constraints {
+                // apply constraints here
+            }
+        }
+
+        // REST resources
+        "/api/books"(resources: 'book')
+
+        // Custom mappings
+        "/books/$id"(controller: 'book', action: 'show')
+        "/search"(controller: 'book', action: 'search')
+
+        // Named URL mappings
+        name bookShow: "/books/$id" {
+            controller = 'book'
+            action = 'show'
+        }
+
+        // Error pages
+        "500"(view: '/error')
+        "404"(view: '/notFound')
+    }
+}
+```
+
+## Testing with Spock
+
+### Unit Test - Controller
+```groovy
+import grails.testing.web.controllers.ControllerUnitTest
+import spock.lang.Specification
+
+class BookControllerSpec extends Specification
+        implements ControllerUnitTest<BookController> {
+
+    def setup() {
+        controller.bookService = Mock(BookService)
+    }
+
+    void "index returns list of books"() {
+        given:
+        def books = [new Book(title: "Test")]
+        controller.bookService.list(_) >> books
+
+        when:
+        controller.index()
+
+        then:
+        model.bookList == books
+        view == '/book/index'
+    }
+
+    void "show returns 404 for missing book"() {
+        when:
+        controller.show(999)
+
+        then:
+        response.status == 404
+    }
+}
+```
+
+### Unit Test - Service
+```groovy
+import grails.testing.services.ServiceUnitTest
+import spock.lang.Specification
+
+class BookServiceSpec extends Specification
+        implements ServiceUnitTest<BookService> {
+
+    void "save persists book"() {
+        given:
+        def book = new Book(title: "Test", author: "Author")
+
+        when:
+        def result = service.save(book)
+
+        then:
+        result.id != null
+        Book.count() == 1
+    }
+}
+```
+
+### Unit Test - Domain
+```groovy
+import grails.testing.gorm.DomainUnitTest
+import spock.lang.Specification
+
+class BookSpec extends Specification
+        implements DomainUnitTest<Book> {
+
+    void "title cannot be blank"() {
+        when:
+        domain.title = ""
+        domain.author = "Test"
+
+        then:
+        !domain.validate(['title'])
+        domain.errors['title'].code == 'blank'
+    }
+
+    void "valid book passes validation"() {
+        when:
+        domain.title = "Valid Title"
+        domain.author = "Author"
+
+        then:
+        domain.validate()
+    }
+}
+```
+
+### Integration Test
+```groovy
+import grails.testing.mixin.integration.Integration
+import grails.gorm.transactions.Rollback
+import spock.lang.Specification
+
+@Integration
+@Rollback
+class BookServiceIntegrationSpec extends Specification {
+
+    BookService bookService
+
+    void "save and retrieve book"() {
+        given:
+        def book = new Book(title: "Integration Test", author: "Tester")
+
+        when:
+        bookService.save(book)
+        def found = Book.findByTitle("Integration Test")
+
+        then:
+        found != null
+        found.author == "Tester"
+    }
+}
+```
+
+### Functional Test with Geb
+```groovy
+import geb.spock.GebSpec
+import grails.testing.mixin.integration.Integration
+
+@Integration
+class BookFunctionalSpec extends GebSpec {
+
+    void "can view book list"() {
+        when:
+        go '/book/index'
+
+        then:
+        title == 'Book List'
+        $('h1').text() == 'Books'
+    }
+
+    void "can create new book"() {
+        when:
+        go '/book/create'
+        $('form').title = 'New Book'
+        $('form').author = 'Test Author'
+        $('input[type=submit]').click()
+
+        then:
+        $('h1').text().contains('New Book')
+    }
+}
+```
+
+## Plugins
+
+### Common Plugins

Review Comment:
   Old coordinates and versions below



##########
.agents/skills/grails-developer/SKILL.md:
##########
@@ -0,0 +1,883 @@
+<!--
+SPDX-License-Identifier: Apache-2.0
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+---
+name: grails-developer
+description: Comprehensive guide for Grails 7 development, covering web applications, REST APIs, GORM, controllers, services, views, plugins, and testing with Spock and Geb
+license: Apache-2.0
+compatibility: opencode, claude, grok, gemini, copilot, cursor, windsurf
+metadata:
+  audience: developers
+  frameworks: grails
+  versions: 7
+---
+
+## What I Do
+
+- Provide detailed guidance for building Grails 7 web applications and REST APIs.
+- Assist with GORM for data modeling, controllers for request handling, services for business logic, and views (GSP, JSON, Markup).
+- Support testing with Spock 2.3 (unit/integration tests) and Geb for browser automation.
+- Guide plugin usage and development, security implementation, and deployment strategies.
+- Help with configuration, internationalization, async programming, and performance optimization.
+
+## When to Use Me
+
+Activate this skill when developing with Grails 7, including:
+
+- Building CRUD applications, RESTful APIs, or full-stack web applications.
+- Working with GORM domain classes, constraints, and relationships.
+- Creating controllers, services, interceptors, or tag libraries.
+- Writing Spock specifications or Geb functional tests.
+- Configuring plugins, security, caching, or database migrations.
+- Deploying Grails applications to containers or cloud platforms.
+
+## Technology Stack
+
+Grails 7 is built on:
+- **Spring Boot**: 3.5.x
+- **Spring Framework**: 6.2.x
+- **Groovy**: 4.0.x
+- **Gradle**: 8.14.x
+- **Spock**: 2.3-groovy-4.0
+- **Jakarta EE**: 10 (migrated from javax.*)
+- **Micronaut**: Optional via `grails-micronaut` plugin
+
+## Project Structure
+
+```
+myapp/
+├── grails-app/
+│   ├── conf/                 # Configuration
+│   │   ├── application.yml   # Main config
+│   │   ├── logback.xml       # Logging config
+│   │   └── spring/           # Spring bean definitions
+│   ├── controllers/          # Request handlers
+│   ├── domain/               # GORM domain classes
+│   ├── i18n/                 # Message bundles
+│   ├── init/                 # Bootstrap classes
+│   ├── services/             # Business logic
+│   ├── taglib/               # Custom GSP tags
+│   ├── utils/                # Utility classes
+│   └── views/                # GSP templates
+├── src/
+│   ├── main/groovy/          # Additional Groovy classes
+│   ├── main/java/            # Java classes
+│   └── test/groovy/          # Test specifications
+├── build.gradle              # Build configuration
+└── gradle.properties         # Project properties
+```
+
+## Domain Classes (GORM)
+
+### Basic Domain Class
+```groovy
+class Book {
+    String title
+    String author
+    Date datePublished
+    Integer pages
+
+    static constraints = {
+        title blank: false, maxSize: 255
+        author blank: false
+        datePublished nullable: true
+        pages min: 1, nullable: true
+    }
+
+    static mapping = {
+        table 'books'
+        title column: 'book_title'
+        datePublished type: 'date'
+    }
+}
+```
+
+### Relationships
+```groovy
+class Author {
+    String name
+
+    static hasMany = [books: Book]
+
+    static mapping = {
+        books cascade: 'all-delete-orphan'
+    }
+}
+
+class Book {
+    String title
+
+    static belongsTo = [author: Author]
+}
+
+// Many-to-Many
+class Book {
+    static hasMany = [categories: Category]
+    static belongsTo = Category
+}
+
+class Category {
+    String name
+    static hasMany = [books: Book]
+}
+```
+
+### GORM Queries
+```groovy
+// Dynamic finders
+Book.findByTitle("Grails Guide")
+Book.findAllByAuthorLike("%Smith%")
+Book.findByTitleAndAuthor("Guide", "Smith")
+Book.countByPagesGreaterThan(100)
+
+// Where queries
+Book.where {
+    title =~ "%Grails%" && pages > 100
+}.list()
+
+// Criteria queries
+Book.withCriteria {
+    like('title', '%Grails%')
+    gt('pages', 100)
+    order('datePublished', 'desc')
+    maxResults(10)
+}
+
+// HQL queries
+Book.executeQuery(
+    "from Book b where b.author.name = :name",
+    [name: 'Smith']
+)
+
+// Detached criteria (reusable)
+def criteria = Book.where {
+    pages > 100
+}
+criteria.list()
+criteria.count()
+```
+
+### Transactions
+```groovy
+// In services (default transactional)
+@Transactional
+class BookService {
+    def saveBook(Book book) {
+        book.save(failOnError: true)
+    }
+}
+
+// Manual transaction control
+Book.withTransaction { status ->
+    def book = new Book(title: "Test")
+    book.save()
+    if (someCondition) {
+        status.setRollbackOnly()
+    }
+}
+```
+
+## Controllers
+
+### Basic Controller
+```groovy
+class BookController {
+
+    BookService bookService
+
+    static allowedMethods = [save: 'POST', update: 'PUT', delete: 'DELETE']
+
+    def index() {
+        respond Book.list(), model: [bookCount: Book.count()]
+    }
+
+    def show(Long id) {
+        respond Book.get(id)
+    }
+
+    def create() {
+        respond new Book(params)
+    }
+
+    def save(Book book) {
+        if (book.hasErrors()) {
+            respond book.errors, view: 'create'
+            return
+        }
+        bookService.save(book)
+        redirect action: 'show', id: book.id
+    }
+
+    def edit(Long id) {
+        respond Book.get(id)
+    }
+
+    def update(Book book) {
+        if (book.hasErrors()) {
+            respond book.errors, view: 'edit'
+            return
+        }
+        bookService.save(book)
+        redirect action: 'show', id: book.id
+    }
+
+    def delete(Long id) {
+        bookService.delete(id)
+        redirect action: 'index'
+    }
+}
+```
+
+### REST Controller
+```groovy
+import grails.rest.RestfulController
+
+class BookController extends RestfulController<Book> {
+
+    static responseFormats = ['json', 'xml']
+
+    BookController() {
+        super(Book)
+    }
+
+    // Override to customize
+    @Override
+    protected Book queryForResource(Serializable id) {
+        Book.where { id == id && active == true }.find()
+    }
+}
+```
+
+### Command Objects
+```groovy
+class BookCommand implements Validateable {
+    String title
+    String author
+    Integer pages
+
+    static constraints = {
+        title blank: false
+        author blank: false
+        pages min: 1, nullable: true
+    }
+}
+
+class BookController {
+    def save(BookCommand cmd) {
+        if (cmd.hasErrors()) {
+            respond cmd.errors
+            return
+        }
+        // Process valid command
+    }
+}
+```
+
+### Content Negotiation
+```groovy
+class BookController {
+    def show(Long id) {
+        def book = Book.get(id)
+        respond book  // Auto-negotiates based on Accept header
+    }
+}
+
+// Or explicit
+def show(Long id) {
+    def book = Book.get(id)
+    withFormat {
+        html { render view: 'show', model: [book: book] }
+        json { render book as JSON }
+        xml { render book as XML }
+    }
+}
+```
+
+## Services
+
+### Basic Service
+```groovy
+import grails.gorm.transactions.Transactional
+
+@Transactional
+class BookService {
+
+    def findByTitle(String title) {
+        Book.findByTitle(title)
+    }
+
+    def save(Book book) {
+        book.save(failOnError: true)
+    }
+
+    @Transactional(readOnly = true)
+    def list(Map params) {
+        Book.list(params)
+    }
+
+    def delete(Long id) {
+        Book.get(id)?.delete()
+    }
+}
+```
+
+### Service with Events
+```groovy
+import grails.events.annotation.Publisher
+import grails.events.annotation.Subscriber
+
+class BookService {
+
+    @Publisher
+    def save(Book book) {
+        book.save()
+        // Automatically publishes 'book.saved' event
+    }
+}
+
+class NotificationService {
+
+    @Subscriber('book.saved')
+    def onBookSaved(Book book) {
+        // Handle event
+        log.info "Book saved: ${book.title}"
+    }
+}
+```
+
+### Async Service
+```groovy
+import grails.async.Promise
+import static grails.async.Promises.*
+
+class BookService {
+
+    Promise<Book> findAsync(Long id) {
+        task {
+            Book.get(id)
+        }
+    }
+
+    def processBooks() {
+        def p1 = task { Book.findAllByActive(true) }
+        def p2 = task { Author.list() }
+
+        waitAll(p1, p2)
+        // Both complete
+    }
+}
+```
+
+## Views
+
+### GSP (Groovy Server Pages)
+```html
+<!-- grails-app/views/book/list.gsp -->
+<!DOCTYPE html>
+<html>
+<head>
+    <title>Books</title>
+    <asset:stylesheet src="application.css"/>
+</head>
+<body>
+    <h1>Books (${bookCount})</h1>
+
+    <g:each in="${bookList}" var="book">
+        <div class="book">
+            <h2>${book.title}</h2>
+            <p>By ${book.author}</p>
+            <g:link action="show" id="${book.id}">View</g:link>
+        </div>
+    </g:each>
+
+    <g:if test="${bookList.empty}">
+        <p>No books found.</p>
+    </g:if>
+
+    <g:paginate total="${bookCount}"/>
+
+    <asset:javascript src="application.js"/>
+</body>
+</html>
+```
+
+### Common GSP Tags
+```html
+<!-- Links -->
+<g:link controller="book" action="show" id="${book.id}">View</g:link>
+<g:createLink action="list"/>
+
+<!-- Forms -->
+<g:form action="save">
+    <g:textField name="title" value="${book?.title}"/>
+    <g:textArea name="description" value="${book?.description}"/>
+    <g:select name="category" from="${categories}" optionKey="id" optionValue="name"/>
+    <g:checkBox name="active" value="${book?.active}"/>
+    <g:submitButton name="submit" value="Save"/>
+</g:form>
+
+<!-- Conditionals -->
+<g:if test="${condition}">...</g:if>
+<g:elseif test="${other}">...</g:elseif>
+<g:else>...</g:else>
+
+<!-- Iteration -->
+<g:each in="${items}" var="item" status="i">
+    ${i}: ${item.name}
+</g:each>
+
+<!-- Rendering -->
+<g:render template="bookRow" model="[book: book]"/>
+<g:render template="bookRow" collection="${books}" var="book"/>
+
+<!-- Security (with Spring Security plugin) -->
+<sec:ifLoggedIn>Welcome, ${sec.username()}</sec:ifLoggedIn>
+<sec:ifNotLoggedIn><g:link controller="login">Login</g:link></sec:ifNotLoggedIn>
+```
+
+### JSON Views
+```groovy
+// grails-app/views/book/show.gson
+import myapp.Book
+
+model {
+    Book book
+}
+
+json {
+    id book.id
+    title book.title
+    author book.author
+    datePublished book.datePublished?.format('yyyy-MM-dd')
+    _links {
+        self {
+            href "/books/${book.id}"
+        }
+    }
+}
+```
+
+### Layouts
+```html
+<!-- grails-app/views/layouts/main.gsp -->
+<!DOCTYPE html>
+<html>
+<head>
+    <title><g:layoutTitle default="My App"/></title>
+    <asset:stylesheet src="application.css"/>
+    <g:layoutHead/>
+</head>
+<body>
+    <nav><!-- Navigation --></nav>
+    <main>
+        <g:layoutBody/>
+    </main>
+    <footer><!-- Footer --></footer>
+    <asset:javascript src="application.js"/>
+</body>
+</html>
+
+<!-- Use in views -->
+<html>
+<head>
+    <meta name="layout" content="main"/>
+    <title>Books</title>
+</head>
+<body>
+    <!-- Page content -->
+</body>
+</html>
+```
+
+## Interceptors
+
+```groovy
+class AuthInterceptor {
+
+    AuthInterceptor() {
+        matchAll()
+            .excludes(controller: 'login')
+            .excludes(controller: 'error')
+    }
+
+    boolean before() {
+        if (!session.user) {
+            redirect(controller: 'login')
+            return false
+        }
+        true
+    }
+
+    boolean after() {
+        // After action executes
+        true
+    }
+
+    void afterView() {
+        // After view renders
+    }
+}
+```
+
+## Tag Libraries
+
+```groovy
+class BookTagLib {
+
+    static namespace = 'book'
+    static defaultEncodeAs = [taglib: 'html']
+
+    def formatTitle = { attrs, body ->
+        def title = attrs.title ?: body()
+        out << "<span class='book-title'>${title}</span>"
+    }
+
+    def ifHasBooks = { attrs, body ->
+        if (Book.count() > 0) {
+            out << body()
+        }
+    }
+}
+
+// Usage in GSP
+<book:formatTitle title="${book.title}"/>
+<book:ifHasBooks>
+    <p>We have books!</p>
+</book:ifHasBooks>
+```
+
+## Configuration
+
+### application.yml
+```yaml
+grails:
+    profile: web
+    codegen:
+        defaultPackage: myapp
+    gorm:
+        reactor:
+            events: false
+    mime:
+        types:
+            json: ['application/json', 'text/json']
+            xml: ['text/xml', 'application/xml']
+
+environments:
+    development:
+        dataSource:
+            dbCreate: create-drop
+            url: jdbc:h2:mem:devDb
+    test:
+        dataSource:
+            dbCreate: update
+            url: jdbc:h2:mem:testDb
+    production:
+        dataSource:
+            dbCreate: none
+            url: jdbc:postgresql://localhost/myapp
+            driverClassName: org.postgresql.Driver
+            dialect: org.hibernate.dialect.PostgreSQLDialect
+            properties:
+                jmxEnabled: true
+                initialSize: 5
+                maxActive: 50
+
+server:
+    port: 8080
+    servlet:
+        context-path: /myapp
+```
+
+### URL Mappings
+```groovy
+// grails-app/controllers/myapp/UrlMappings.groovy
+class UrlMappings {
+
+    static mappings = {
+        // Default
+        "/$controller/$action?/$id?(.$format)?" {
+            constraints {
+                // apply constraints here
+            }
+        }
+
+        // REST resources
+        "/api/books"(resources: 'book')
+
+        // Custom mappings
+        "/books/$id"(controller: 'book', action: 'show')
+        "/search"(controller: 'book', action: 'search')
+
+        // Named URL mappings
+        name bookShow: "/books/$id" {
+            controller = 'book'
+            action = 'show'
+        }
+
+        // Error pages
+        "500"(view: '/error')
+        "404"(view: '/notFound')
+    }
+}
+```
+
+## Testing with Spock
+
+### Unit Test - Controller
+```groovy
+import grails.testing.web.controllers.ControllerUnitTest
+import spock.lang.Specification
+
+class BookControllerSpec extends Specification
+        implements ControllerUnitTest<BookController> {
+
+    def setup() {
+        controller.bookService = Mock(BookService)
+    }
+
+    void "index returns list of books"() {
+        given:
+        def books = [new Book(title: "Test")]
+        controller.bookService.list(_) >> books
+
+        when:
+        controller.index()
+
+        then:
+        model.bookList == books
+        view == '/book/index'
+    }
+
+    void "show returns 404 for missing book"() {
+        when:
+        controller.show(999)
+
+        then:
+        response.status == 404
+    }
+}
+```
+
+### Unit Test - Service
+```groovy
+import grails.testing.services.ServiceUnitTest
+import spock.lang.Specification
+
+class BookServiceSpec extends Specification
+        implements ServiceUnitTest<BookService> {
+
+    void "save persists book"() {
+        given:
+        def book = new Book(title: "Test", author: "Author")
+
+        when:
+        def result = service.save(book)
+
+        then:
+        result.id != null
+        Book.count() == 1
+    }
+}
+```
+
+### Unit Test - Domain
+```groovy
+import grails.testing.gorm.DomainUnitTest
+import spock.lang.Specification
+
+class BookSpec extends Specification
+        implements DomainUnitTest<Book> {
+
+    void "title cannot be blank"() {
+        when:
+        domain.title = ""
+        domain.author = "Test"
+
+        then:
+        !domain.validate(['title'])
+        domain.errors['title'].code == 'blank'
+    }
+
+    void "valid book passes validation"() {
+        when:
+        domain.title = "Valid Title"
+        domain.author = "Author"
+
+        then:
+        domain.validate()
+    }
+}
+```
+
+### Integration Test
+```groovy
+import grails.testing.mixin.integration.Integration
+import grails.gorm.transactions.Rollback
+import spock.lang.Specification
+
+@Integration
+@Rollback
+class BookServiceIntegrationSpec extends Specification {
+
+    BookService bookService
+
+    void "save and retrieve book"() {
+        given:
+        def book = new Book(title: "Integration Test", author: "Tester")
+
+        when:
+        bookService.save(book)
+        def found = Book.findByTitle("Integration Test")
+
+        then:
+        found != null
+        found.author == "Tester"
+    }
+}
+```
+
+### Functional Test with Geb
+```groovy
+import geb.spock.GebSpec
+import grails.testing.mixin.integration.Integration
+
+@Integration
+class BookFunctionalSpec extends GebSpec {
+
+    void "can view book list"() {
+        when:
+        go '/book/index'
+
+        then:
+        title == 'Book List'
+        $('h1').text() == 'Books'
+    }
+
+    void "can create new book"() {
+        when:
+        go '/book/create'
+        $('form').title = 'New Book'
+        $('form').author = 'Test Author'
+        $('input[type=submit]').click()
+
+        then:
+        $('h1').text().contains('New Book')
+    }
+}
+```
+
+## Plugins
+
+### Common Plugins
+```groovy
+// build.gradle
+
+// Spring Security
+implementation 'org.grails.plugins:spring-security-core:6.0.0'
+
+// Database Migration (Liquibase)
+implementation 'org.grails.plugins:database-migration:4.2.0'
+
+// Caching
+implementation 'org.grails.plugins:cache:6.0.0'
+
+// Async support
+implementation 'org.grails.plugins:async:5.0.0'
+
+// Fields plugin for form rendering
+implementation 'org.grails.plugins:fields:5.0.0'
+
+// Asset Pipeline
+runtimeOnly 'org.grails.plugins:asset-pipeline:5.0.0'
+```
+
+### Spring Security Configuration
+```groovy
+// grails-app/conf/application.groovy
+grails.plugin.springsecurity.userLookup.userDomainClassName = 'myapp.User'
+grails.plugin.springsecurity.userLookup.authorityJoinClassName = 'myapp.UserRole'
+grails.plugin.springsecurity.authority.className = 'myapp.Role'
+
+grails.plugin.springsecurity.controllerAnnotations.staticRules = [
+    [pattern: '/',               access: ['permitAll']],
+    [pattern: '/error',          access: ['permitAll']],
+    [pattern: '/index',          access: ['permitAll']],
+    [pattern: '/admin/**',       access: ['ROLE_ADMIN']],
+    [pattern: '/api/**',         access: ['isAuthenticated()']],
+]
+```
+
+## Build Commands
+
+```bash
+# Run application
+./gradlew bootRun
+
+# Run tests
+./gradlew test                                    # All tests
+./gradlew test --tests "BookServiceSpec"          # Single spec
+./gradlew test --tests "*Spec.save*"              # Pattern match
+./gradlew integrationTest                         # Integration tests
+
+# Build
+./gradlew build -PskipTests                       # Build without tests
+./gradlew bootJar                                 # Executable JAR
+./gradlew bootWar                                 # WAR file
+
+# Code quality
+./gradlew codeStyle                               # Check style
+
+# Clean
+./gradlew clean
+```
+
+## Best Practices
+
+### Convention Over Configuration
+- Follow Grails naming conventions for automatic wiring.
+- Use standard directory structure.
+- Let Grails infer configurations where possible.
+
+### Performance
+- Use `@GrailsCompileStatic` on controllers and services.
+- Enable query caching for read-heavy operations.
+- Use pagination for large result sets.
+- Avoid N+1 queries with eager fetching or batch size.
+
+### Security
+- Use CSRF tokens in forms: `<g:form useToken="true">`.
+- Apply Spring Security for authentication/authorization.
+- Use parameterized queries (GORM handles this automatically).
+- Encode output to prevent XSS.
+
+### Testing
+- Write unit tests for domain constraints.
+- Test controllers with `ControllerUnitTest`.
+- Use integration tests for service/database interactions.
+- Use Geb for critical user workflows.
+
+### Code Style
+- Use `@GrailsCompileStatic` for type safety and performance.
+- Prefer services for business logic over controllers.
+- Use command objects for complex form handling.
+- Keep controllers thin, services fat.
+
+## Resources
+
+- **Grails 7 User Guide**: https://docs.grails.org/latest/guide/single.html
+- **GORM Documentation**: https://gorm.grails.org/latest/
+- **Grails Plugins**: https://plugins.grails.org/
+- **Spock Framework**: https://spockframework.org/spock/docs/2.3/all_in_one.html
+- **Geb Manual**: https://gebish.org/manual/current/

Review Comment:
   https://groovy.apache.org/geb/manual/current/



##########
.agents/skills/groovy-developer/SKILL.md:
##########
@@ -0,0 +1,520 @@
+<!--
+SPDX-License-Identifier: Apache-2.0
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+---
+name: groovy-developer
+description: Expert guide for Groovy 4 development, covering concise syntax, closures, DSLs, metaprogramming, static compilation, and integration with Java 17 and Grails
+license: Apache-2.0
+compatibility: opencode, claude, grok, gemini, copilot, cursor, windsurf
+metadata:
+  audience: developers
+  languages: groovy, java
+  versions: 4.0
+  paradigms: dynamic, static, functional, object-oriented, DSL-oriented
+---
+
+## What I Do
+
+- Provide deep expertise in Groovy 4.0, including core language features: syntax, closures, traits, GStrings, operators, and Groovy Truth.
+- Guide metaprogramming techniques: runtime (categories, ExpandoMetaClass, extension modules) and compile-time (AST transformations like @Immutable, @Builder, @Delegate, @Singleton, @Log, @Memoized).
+- Assist with DSL creation and usage (MarkupBuilder, JsonBuilder, builders for configuration).
+- Support testing with Spock Framework (BDD, data-driven tests, mocking) and built-in power assertions.
+- Help integrate Groovy with Java 17: joint compilation, Gradle builds, Grails, and Spring Boot.
+- Cover data handling: JSON/XML parsing and building, Groovy SQL, collection processing.
+- Advise on performance: @CompileStatic, @TypeChecked, @GrailsCompileStatic for optimal execution.
+
+## When to Use Me
+
+Activate this skill for any Groovy-related task, including:
+
+- Writing or debugging Groovy classes in Grails domain, controllers, services, or taglibs.
+- Building or enhancing Gradle build scripts (build.gradle).
+- Creating DSLs for configuration, testing, or business rules.
+- Writing Spock specifications for unit and integration tests.
+- Migrating from older Groovy versions (2.x/3.x) to 4.0.
+- Performance optimization with static compilation.
+- Working with JSON/XML data, GORM criteria queries, or builders.
+
+## Groovy 4 Key Features
+
+### Concise Syntax
+```groovy
+// No semicolons required
+def name = "Grails"
+
+// Optional parentheses for method calls
+println "Hello World"
+list.each { println it }
+
+// Optional return keyword
+String greet(String name) {
+    "Hello, $name"  // Last expression is returned
+}
+```
+
+### GStrings (String Interpolation)
+```groovy
+def user = "Alice"
+def count = 42
+
+// Simple interpolation
+println "User: $user"
+
+// Expression interpolation
+println "Items: ${count * 2}"
+
+// Lazy GStrings (evaluated when accessed)
+def lazy = "Count is ${ -> counter }"
+
+// Multi-line strings
+def sql = """
+    SELECT * FROM users
+    WHERE name = '$user'
+    ORDER BY created_at
+"""
+```
+
+### Closures
+```groovy
+// Basic closure
+def greet = { name -> "Hello, $name" }
+println greet("World")
+
+// Implicit 'it' parameter
+def double = { it * 2 }
+println [1, 2, 3].collect(double)
+
+// Closure with delegate (for DSLs)
+def configure = {
+    name = "MyApp"
+    version = "1.0"
+}
+configure.delegate = new Config()
+configure.resolveStrategy = Closure.DELEGATE_FIRST
+configure()
+
+// Method references
+def upper = String.&toUpperCase
+println ["a", "b"].collect(upper)
+```
+
+### Safe Navigation and Elvis Operator
+```groovy
+// Safe navigation - returns null if any part is null
+def city = user?.address?.city
+
+// Elvis operator - default value if null
+def name = user?.name ?: "Anonymous"
+
+// Safe method calls
+def length = text?.length() ?: 0
+
+// Combine with collections
+def firstTitle = books?.first()?.title ?: "No books"
+```
+
+### Spread Operator
+```groovy
+// Spread operator for collections
+def names = users*.name  // Same as users.collect { it.name }
+
+// Spread for method arguments
+def args = [1, 2, 3]
+someMethod(*args)
+
+// Spread in list literals
+def combined = [*list1, *list2]
+```
+
+### Collection Literals and Methods
+```groovy
+// List literal
+def list = [1, 2, 3, 4, 5]
+
+// Map literal
+def map = [name: "Grails", version: 7]
+
+// Range
+def range = 1..10
+def exclusive = 1..<10
+
+// Powerful collection methods
+list.find { it > 3 }           // First match: 4
+list.findAll { it > 3 }        // All matches: [4, 5]
+list.any { it > 3 }            // true
+list.every { it > 0 }          // true
+list.groupBy { it % 2 }        // [0:[2,4], 1:[1,3,5]]
+list.collectEntries { [it, it * 2] }  // [1:2, 2:4, ...]
+
+// Sorting
+list.sort { a, b -> b <=> a }  // Descending
+list.sort { -it }              // Descending (numeric)
+```
+
+### Groovy Truth
+```groovy
+// Falsy values: null, empty string, empty collection, 0, false
+if (list) { }      // True if not null and not empty
+if (string) { }    // True if not null and not blank
+if (number) { }    // True if not 0
+
+// Useful in conditionals
+def items = getItems() ?: []  // Default to empty list
+```
+
+### Records (Incubating)
+```groovy
+// Immutable data class
+record Point(int x, int y) {}
+
+def p = new Point(10, 20)
+println p.x()  // 10
+println p      // Point[x=10, y=20]
+```
+
+### Traits
+```groovy
+trait Auditable {
+    Date dateCreated
+    Date lastUpdated
+
+    def beforeInsert() {
+        dateCreated = new Date()
+    }
+
+    def beforeUpdate() {
+        lastUpdated = new Date()
+    }
+}
+
+class Book implements Auditable {
+    String title
+}
+```
+
+## Static Compilation
+
+### @CompileStatic
+Enables static type checking and compilation for better performance:
+```groovy
+import groovy.transform.CompileStatic
+
+@CompileStatic
+class BookService {
+    List<Book> findByAuthor(String author) {
+        Book.findAllByAuthor(author)
+    }
+
+    int calculateTotal(List<Integer> prices) {
+        prices.sum() as int
+    }
+}
+```
+
+### @TypeChecked
+Type checking without full static compilation:
+```groovy
+import groovy.transform.TypeChecked
+
+@TypeChecked
+void process(String input) {
+    println input.toUppercase()  // Compile error: method not found
+}
+```
+
+### @GrailsCompileStatic
+Grails-aware static compilation that understands dynamic finders:
+```groovy
+import grails.compiler.GrailsCompileStatic
+
+@GrailsCompileStatic
+class BookController {
+    def show(Long id) {
+        respond Book.get(id)  // Works with static compilation
+    }
+}
+```
+
+## AST Transformations
+
+### @Immutable
+```groovy
+import groovy.transform.Immutable
+
+@Immutable
+class Person {
+    String name
+    int age
+}
+
+def p = new Person(name: "Alice", age: 30)
+// p.name = "Bob"  // Error: read-only
+```
+
+### @Builder
+```groovy
+import groovy.transform.builder.Builder
+
+@Builder
+class Email {
+    String to
+    String subject
+    String body
+}
+
+def email = Email.builder()
+    .to("user@example.com")
+    .subject("Hello")
+    .body("Content here")
+    .build()
+```
+
+### @Delegate
+```groovy
+import groovy.transform.Delegate
+
+class EnhancedList<T> {
+    @Delegate List<T> list = []
+
+    T secondLast() {
+        list[-2]
+    }
+}
+
+def enhanced = new EnhancedList<String>()
+enhanced.add("a")  // Delegated to list
+enhanced.add("b")
+println enhanced.secondLast()  // "a"
+```
+
+### @Singleton
+```groovy
+import groovy.transform.Singleton

Review Comment:
   `groovy.lang.Singleton`?



##########
.agents/skills/groovy-developer/SKILL.md:
##########
@@ -0,0 +1,520 @@
+<!--
+SPDX-License-Identifier: Apache-2.0
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+---
+name: groovy-developer
+description: Expert guide for Groovy 4 development, covering concise syntax, closures, DSLs, metaprogramming, static compilation, and integration with Java 17 and Grails
+license: Apache-2.0
+compatibility: opencode, claude, grok, gemini, copilot, cursor, windsurf
+metadata:
+  audience: developers
+  languages: groovy, java
+  versions: 4.0
+  paradigms: dynamic, static, functional, object-oriented, DSL-oriented
+---
+
+## What I Do
+
+- Provide deep expertise in Groovy 4.0, including core language features: syntax, closures, traits, GStrings, operators, and Groovy Truth.
+- Guide metaprogramming techniques: runtime (categories, ExpandoMetaClass, extension modules) and compile-time (AST transformations like @Immutable, @Builder, @Delegate, @Singleton, @Log, @Memoized).
+- Assist with DSL creation and usage (MarkupBuilder, JsonBuilder, builders for configuration).
+- Support testing with Spock Framework (BDD, data-driven tests, mocking) and built-in power assertions.
+- Help integrate Groovy with Java 17: joint compilation, Gradle builds, Grails, and Spring Boot.
+- Cover data handling: JSON/XML parsing and building, Groovy SQL, collection processing.
+- Advise on performance: @CompileStatic, @TypeChecked, @GrailsCompileStatic for optimal execution.
+
+## When to Use Me
+
+Activate this skill for any Groovy-related task, including:
+
+- Writing or debugging Groovy classes in Grails domain, controllers, services, or taglibs.
+- Building or enhancing Gradle build scripts (build.gradle).
+- Creating DSLs for configuration, testing, or business rules.
+- Writing Spock specifications for unit and integration tests.
+- Migrating from older Groovy versions (2.x/3.x) to 4.0.
+- Performance optimization with static compilation.
+- Working with JSON/XML data, GORM criteria queries, or builders.
+
+## Groovy 4 Key Features
+
+### Concise Syntax

Review Comment:
   Single quotes for strings 🙏?



##########
.agents/skills/grails-developer/SKILL.md:
##########
@@ -0,0 +1,883 @@
+<!--
+SPDX-License-Identifier: Apache-2.0
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+---
+name: grails-developer
+description: Comprehensive guide for Grails 7 development, covering web applications, REST APIs, GORM, controllers, services, views, plugins, and testing with Spock and Geb
+license: Apache-2.0
+compatibility: opencode, claude, grok, gemini, copilot, cursor, windsurf
+metadata:
+  audience: developers
+  frameworks: grails
+  versions: 7
+---
+
+## What I Do
+
+- Provide detailed guidance for building Grails 7 web applications and REST APIs.
+- Assist with GORM for data modeling, controllers for request handling, services for business logic, and views (GSP, JSON, Markup).
+- Support testing with Spock 2.3 (unit/integration tests) and Geb for browser automation.
+- Guide plugin usage and development, security implementation, and deployment strategies.
+- Help with configuration, internationalization, async programming, and performance optimization.
+
+## When to Use Me
+
+Activate this skill when developing with Grails 7, including:
+
+- Building CRUD applications, RESTful APIs, or full-stack web applications.
+- Working with GORM domain classes, constraints, and relationships.
+- Creating controllers, services, interceptors, or tag libraries.
+- Writing Spock specifications or Geb functional tests.
+- Configuring plugins, security, caching, or database migrations.
+- Deploying Grails applications to containers or cloud platforms.
+
+## Technology Stack
+
+Grails 7 is built on:
+- **Spring Boot**: 3.5.x
+- **Spring Framework**: 6.2.x
+- **Groovy**: 4.0.x
+- **Gradle**: 8.14.x
+- **Spock**: 2.3-groovy-4.0
+- **Jakarta EE**: 10 (migrated from javax.*)
+- **Micronaut**: Optional via `grails-micronaut` plugin
+
+## Project Structure
+
+```
+myapp/
+├── grails-app/
+│   ├── conf/                 # Configuration
+│   │   ├── application.yml   # Main config
+│   │   ├── logback.xml       # Logging config
+│   │   └── spring/           # Spring bean definitions
+│   ├── controllers/          # Request handlers
+│   ├── domain/               # GORM domain classes
+│   ├── i18n/                 # Message bundles
+│   ├── init/                 # Bootstrap classes
+│   ├── services/             # Business logic
+│   ├── taglib/               # Custom GSP tags
+│   ├── utils/                # Utility classes
+│   └── views/                # GSP templates
+├── src/
+│   ├── main/groovy/          # Additional Groovy classes
+│   ├── main/java/            # Java classes
+│   └── test/groovy/          # Test specifications
+├── build.gradle              # Build configuration
+└── gradle.properties         # Project properties
+```
+
+## Domain Classes (GORM)
+
+### Basic Domain Class
+```groovy
+class Book {
+    String title
+    String author
+    Date datePublished
+    Integer pages
+
+    static constraints = {
+        title blank: false, maxSize: 255
+        author blank: false
+        datePublished nullable: true
+        pages min: 1, nullable: true
+    }
+
+    static mapping = {
+        table 'books'
+        title column: 'book_title'
+        datePublished type: 'date'
+    }
+}
+```
+
+### Relationships
+```groovy
+class Author {
+    String name
+
+    static hasMany = [books: Book]
+
+    static mapping = {
+        books cascade: 'all-delete-orphan'
+    }
+}
+
+class Book {
+    String title
+
+    static belongsTo = [author: Author]
+}
+
+// Many-to-Many
+class Book {
+    static hasMany = [categories: Category]
+    static belongsTo = Category
+}
+
+class Category {
+    String name
+    static hasMany = [books: Book]
+}
+```
+
+### GORM Queries
+```groovy
+// Dynamic finders
+Book.findByTitle("Grails Guide")
+Book.findAllByAuthorLike("%Smith%")
+Book.findByTitleAndAuthor("Guide", "Smith")
+Book.countByPagesGreaterThan(100)
+
+// Where queries
+Book.where {
+    title =~ "%Grails%" && pages > 100
+}.list()
+
+// Criteria queries
+Book.withCriteria {
+    like('title', '%Grails%')
+    gt('pages', 100)
+    order('datePublished', 'desc')
+    maxResults(10)
+}
+
+// HQL queries
+Book.executeQuery(
+    "from Book b where b.author.name = :name",
+    [name: 'Smith']
+)
+
+// Detached criteria (reusable)
+def criteria = Book.where {
+    pages > 100
+}
+criteria.list()
+criteria.count()
+```
+
+### Transactions
+```groovy
+// In services (default transactional)
+@Transactional
+class BookService {
+    def saveBook(Book book) {
+        book.save(failOnError: true)
+    }
+}
+
+// Manual transaction control
+Book.withTransaction { status ->
+    def book = new Book(title: "Test")
+    book.save()
+    if (someCondition) {
+        status.setRollbackOnly()
+    }
+}
+```
+
+## Controllers
+
+### Basic Controller
+```groovy
+class BookController {
+
+    BookService bookService
+
+    static allowedMethods = [save: 'POST', update: 'PUT', delete: 'DELETE']
+
+    def index() {
+        respond Book.list(), model: [bookCount: Book.count()]
+    }
+
+    def show(Long id) {
+        respond Book.get(id)
+    }
+
+    def create() {
+        respond new Book(params)
+    }
+
+    def save(Book book) {
+        if (book.hasErrors()) {
+            respond book.errors, view: 'create'
+            return
+        }
+        bookService.save(book)
+        redirect action: 'show', id: book.id
+    }
+
+    def edit(Long id) {
+        respond Book.get(id)
+    }
+
+    def update(Book book) {
+        if (book.hasErrors()) {
+            respond book.errors, view: 'edit'
+            return
+        }
+        bookService.save(book)
+        redirect action: 'show', id: book.id
+    }
+
+    def delete(Long id) {
+        bookService.delete(id)
+        redirect action: 'index'
+    }
+}
+```
+
+### REST Controller
+```groovy
+import grails.rest.RestfulController
+
+class BookController extends RestfulController<Book> {
+
+    static responseFormats = ['json', 'xml']
+
+    BookController() {
+        super(Book)
+    }
+
+    // Override to customize
+    @Override
+    protected Book queryForResource(Serializable id) {
+        Book.where { id == id && active == true }.find()
+    }
+}
+```
+
+### Command Objects
+```groovy
+class BookCommand implements Validateable {
+    String title
+    String author
+    Integer pages
+
+    static constraints = {
+        title blank: false
+        author blank: false
+        pages min: 1, nullable: true
+    }
+}
+
+class BookController {
+    def save(BookCommand cmd) {
+        if (cmd.hasErrors()) {
+            respond cmd.errors
+            return
+        }
+        // Process valid command
+    }
+}
+```
+
+### Content Negotiation
+```groovy
+class BookController {
+    def show(Long id) {
+        def book = Book.get(id)
+        respond book  // Auto-negotiates based on Accept header
+    }
+}
+
+// Or explicit
+def show(Long id) {
+    def book = Book.get(id)
+    withFormat {
+        html { render view: 'show', model: [book: book] }
+        json { render book as JSON }
+        xml { render book as XML }
+    }
+}
+```
+
+## Services
+
+### Basic Service
+```groovy
+import grails.gorm.transactions.Transactional
+
+@Transactional
+class BookService {
+
+    def findByTitle(String title) {
+        Book.findByTitle(title)
+    }
+
+    def save(Book book) {
+        book.save(failOnError: true)
+    }
+
+    @Transactional(readOnly = true)
+    def list(Map params) {
+        Book.list(params)
+    }
+
+    def delete(Long id) {
+        Book.get(id)?.delete()
+    }
+}
+```
+
+### Service with Events
+```groovy
+import grails.events.annotation.Publisher
+import grails.events.annotation.Subscriber
+
+class BookService {
+
+    @Publisher
+    def save(Book book) {
+        book.save()
+        // Automatically publishes 'book.saved' event
+    }
+}
+
+class NotificationService {
+
+    @Subscriber('book.saved')
+    def onBookSaved(Book book) {
+        // Handle event
+        log.info "Book saved: ${book.title}"
+    }
+}
+```
+
+### Async Service
+```groovy
+import grails.async.Promise
+import static grails.async.Promises.*
+
+class BookService {
+
+    Promise<Book> findAsync(Long id) {
+        task {
+            Book.get(id)
+        }
+    }
+
+    def processBooks() {
+        def p1 = task { Book.findAllByActive(true) }
+        def p2 = task { Author.list() }
+
+        waitAll(p1, p2)
+        // Both complete
+    }
+}
+```
+
+## Views
+
+### GSP (Groovy Server Pages)
+```html
+<!-- grails-app/views/book/list.gsp -->
+<!DOCTYPE html>
+<html>
+<head>
+    <title>Books</title>
+    <asset:stylesheet src="application.css"/>
+</head>
+<body>
+    <h1>Books (${bookCount})</h1>
+
+    <g:each in="${bookList}" var="book">
+        <div class="book">
+            <h2>${book.title}</h2>
+            <p>By ${book.author}</p>
+            <g:link action="show" id="${book.id}">View</g:link>
+        </div>
+    </g:each>
+
+    <g:if test="${bookList.empty}">
+        <p>No books found.</p>
+    </g:if>
+
+    <g:paginate total="${bookCount}"/>
+
+    <asset:javascript src="application.js"/>
+</body>
+</html>
+```
+
+### Common GSP Tags
+```html
+<!-- Links -->
+<g:link controller="book" action="show" id="${book.id}">View</g:link>
+<g:createLink action="list"/>
+
+<!-- Forms -->
+<g:form action="save">
+    <g:textField name="title" value="${book?.title}"/>
+    <g:textArea name="description" value="${book?.description}"/>
+    <g:select name="category" from="${categories}" optionKey="id" optionValue="name"/>
+    <g:checkBox name="active" value="${book?.active}"/>
+    <g:submitButton name="submit" value="Save"/>
+</g:form>
+
+<!-- Conditionals -->
+<g:if test="${condition}">...</g:if>
+<g:elseif test="${other}">...</g:elseif>
+<g:else>...</g:else>
+
+<!-- Iteration -->
+<g:each in="${items}" var="item" status="i">
+    ${i}: ${item.name}
+</g:each>
+
+<!-- Rendering -->
+<g:render template="bookRow" model="[book: book]"/>
+<g:render template="bookRow" collection="${books}" var="book"/>
+
+<!-- Security (with Spring Security plugin) -->
+<sec:ifLoggedIn>Welcome, ${sec.username()}</sec:ifLoggedIn>
+<sec:ifNotLoggedIn><g:link controller="login">Login</g:link></sec:ifNotLoggedIn>
+```
+
+### JSON Views
+```groovy
+// grails-app/views/book/show.gson
+import myapp.Book
+
+model {
+    Book book
+}
+
+json {
+    id book.id
+    title book.title
+    author book.author
+    datePublished book.datePublished?.format('yyyy-MM-dd')
+    _links {
+        self {
+            href "/books/${book.id}"
+        }
+    }
+}
+```
+
+### Layouts
+```html
+<!-- grails-app/views/layouts/main.gsp -->
+<!DOCTYPE html>
+<html>
+<head>
+    <title><g:layoutTitle default="My App"/></title>
+    <asset:stylesheet src="application.css"/>
+    <g:layoutHead/>
+</head>
+<body>
+    <nav><!-- Navigation --></nav>
+    <main>
+        <g:layoutBody/>
+    </main>
+    <footer><!-- Footer --></footer>
+    <asset:javascript src="application.js"/>
+</body>
+</html>
+
+<!-- Use in views -->
+<html>
+<head>
+    <meta name="layout" content="main"/>
+    <title>Books</title>
+</head>
+<body>
+    <!-- Page content -->
+</body>
+</html>
+```
+
+## Interceptors
+
+```groovy
+class AuthInterceptor {
+
+    AuthInterceptor() {
+        matchAll()
+            .excludes(controller: 'login')
+            .excludes(controller: 'error')
+    }
+
+    boolean before() {
+        if (!session.user) {
+            redirect(controller: 'login')
+            return false
+        }
+        true
+    }
+
+    boolean after() {
+        // After action executes
+        true
+    }
+
+    void afterView() {
+        // After view renders
+    }
+}
+```
+
+## Tag Libraries
+
+```groovy
+class BookTagLib {
+
+    static namespace = 'book'
+    static defaultEncodeAs = [taglib: 'html']
+
+    def formatTitle = { attrs, body ->
+        def title = attrs.title ?: body()
+        out << "<span class='book-title'>${title}</span>"
+    }
+
+    def ifHasBooks = { attrs, body ->
+        if (Book.count() > 0) {
+            out << body()
+        }
+    }
+}
+
+// Usage in GSP
+<book:formatTitle title="${book.title}"/>
+<book:ifHasBooks>
+    <p>We have books!</p>
+</book:ifHasBooks>
+```
+
+## Configuration
+
+### application.yml
+```yaml
+grails:
+    profile: web
+    codegen:
+        defaultPackage: myapp
+    gorm:
+        reactor:
+            events: false
+    mime:
+        types:
+            json: ['application/json', 'text/json']
+            xml: ['text/xml', 'application/xml']
+
+environments:
+    development:
+        dataSource:
+            dbCreate: create-drop
+            url: jdbc:h2:mem:devDb
+    test:
+        dataSource:
+            dbCreate: update
+            url: jdbc:h2:mem:testDb
+    production:
+        dataSource:
+            dbCreate: none
+            url: jdbc:postgresql://localhost/myapp
+            driverClassName: org.postgresql.Driver
+            dialect: org.hibernate.dialect.PostgreSQLDialect
+            properties:
+                jmxEnabled: true
+                initialSize: 5
+                maxActive: 50
+
+server:
+    port: 8080
+    servlet:
+        context-path: /myapp
+```
+
+### URL Mappings
+```groovy
+// grails-app/controllers/myapp/UrlMappings.groovy
+class UrlMappings {
+
+    static mappings = {
+        // Default
+        "/$controller/$action?/$id?(.$format)?" {
+            constraints {
+                // apply constraints here
+            }
+        }
+
+        // REST resources
+        "/api/books"(resources: 'book')
+
+        // Custom mappings
+        "/books/$id"(controller: 'book', action: 'show')
+        "/search"(controller: 'book', action: 'search')
+
+        // Named URL mappings
+        name bookShow: "/books/$id" {
+            controller = 'book'
+            action = 'show'
+        }
+
+        // Error pages
+        "500"(view: '/error')
+        "404"(view: '/notFound')
+    }
+}
+```
+
+## Testing with Spock
+
+### Unit Test - Controller
+```groovy
+import grails.testing.web.controllers.ControllerUnitTest
+import spock.lang.Specification
+
+class BookControllerSpec extends Specification
+        implements ControllerUnitTest<BookController> {
+
+    def setup() {
+        controller.bookService = Mock(BookService)
+    }
+
+    void "index returns list of books"() {
+        given:
+        def books = [new Book(title: "Test")]
+        controller.bookService.list(_) >> books
+
+        when:
+        controller.index()
+
+        then:
+        model.bookList == books
+        view == '/book/index'
+    }
+
+    void "show returns 404 for missing book"() {
+        when:
+        controller.show(999)
+
+        then:
+        response.status == 404
+    }
+}
+```
+
+### Unit Test - Service
+```groovy
+import grails.testing.services.ServiceUnitTest
+import spock.lang.Specification
+
+class BookServiceSpec extends Specification
+        implements ServiceUnitTest<BookService> {
+
+    void "save persists book"() {
+        given:
+        def book = new Book(title: "Test", author: "Author")
+
+        when:
+        def result = service.save(book)
+
+        then:
+        result.id != null
+        Book.count() == 1
+    }
+}
+```
+
+### Unit Test - Domain
+```groovy
+import grails.testing.gorm.DomainUnitTest
+import spock.lang.Specification
+
+class BookSpec extends Specification
+        implements DomainUnitTest<Book> {
+
+    void "title cannot be blank"() {
+        when:
+        domain.title = ""
+        domain.author = "Test"
+
+        then:
+        !domain.validate(['title'])
+        domain.errors['title'].code == 'blank'
+    }
+
+    void "valid book passes validation"() {
+        when:
+        domain.title = "Valid Title"
+        domain.author = "Author"
+
+        then:
+        domain.validate()
+    }
+}
+```
+
+### Integration Test
+```groovy
+import grails.testing.mixin.integration.Integration
+import grails.gorm.transactions.Rollback
+import spock.lang.Specification
+
+@Integration
+@Rollback
+class BookServiceIntegrationSpec extends Specification {
+
+    BookService bookService
+
+    void "save and retrieve book"() {
+        given:
+        def book = new Book(title: "Integration Test", author: "Tester")
+
+        when:
+        bookService.save(book)
+        def found = Book.findByTitle("Integration Test")
+
+        then:
+        found != null
+        found.author == "Tester"
+    }
+}
+```
+
+### Functional Test with Geb
+```groovy
+import geb.spock.GebSpec
+import grails.testing.mixin.integration.Integration
+
+@Integration
+class BookFunctionalSpec extends GebSpec {

Review Comment:
   `ContainerGebSpec`?



##########
.agents/skills/grails-developer/SKILL.md:
##########
@@ -0,0 +1,883 @@
+<!--
+SPDX-License-Identifier: Apache-2.0
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+---
+name: grails-developer
+description: Comprehensive guide for Grails 7 development, covering web applications, REST APIs, GORM, controllers, services, views, plugins, and testing with Spock and Geb
+license: Apache-2.0
+compatibility: opencode, claude, grok, gemini, copilot, cursor, windsurf
+metadata:
+  audience: developers
+  frameworks: grails
+  versions: 7
+---
+
+## What I Do
+
+- Provide detailed guidance for building Grails 7 web applications and REST APIs.
+- Assist with GORM for data modeling, controllers for request handling, services for business logic, and views (GSP, JSON, Markup).
+- Support testing with Spock 2.3 (unit/integration tests) and Geb for browser automation.
+- Guide plugin usage and development, security implementation, and deployment strategies.
+- Help with configuration, internationalization, async programming, and performance optimization.
+
+## When to Use Me
+
+Activate this skill when developing with Grails 7, including:
+
+- Building CRUD applications, RESTful APIs, or full-stack web applications.
+- Working with GORM domain classes, constraints, and relationships.
+- Creating controllers, services, interceptors, or tag libraries.
+- Writing Spock specifications or Geb functional tests.
+- Configuring plugins, security, caching, or database migrations.
+- Deploying Grails applications to containers or cloud platforms.
+
+## Technology Stack
+
+Grails 7 is built on:
+- **Spring Boot**: 3.5.x
+- **Spring Framework**: 6.2.x
+- **Groovy**: 4.0.x
+- **Gradle**: 8.14.x
+- **Spock**: 2.3-groovy-4.0
+- **Jakarta EE**: 10 (migrated from javax.*)
+- **Micronaut**: Optional via `grails-micronaut` plugin
+
+## Project Structure
+
+```
+myapp/
+├── grails-app/
+│   ├── conf/                 # Configuration
+│   │   ├── application.yml   # Main config
+│   │   ├── logback.xml       # Logging config
+│   │   └── spring/           # Spring bean definitions
+│   ├── controllers/          # Request handlers
+│   ├── domain/               # GORM domain classes
+│   ├── i18n/                 # Message bundles
+│   ├── init/                 # Bootstrap classes
+│   ├── services/             # Business logic
+│   ├── taglib/               # Custom GSP tags
+│   ├── utils/                # Utility classes
+│   └── views/                # GSP templates
+├── src/
+│   ├── main/groovy/          # Additional Groovy classes
+│   ├── main/java/            # Java classes
+│   └── test/groovy/          # Test specifications
+├── build.gradle              # Build configuration
+└── gradle.properties         # Project properties
+```
+
+## Domain Classes (GORM)
+
+### Basic Domain Class
+```groovy
+class Book {
+    String title
+    String author
+    Date datePublished
+    Integer pages
+
+    static constraints = {
+        title blank: false, maxSize: 255
+        author blank: false
+        datePublished nullable: true
+        pages min: 1, nullable: true
+    }
+
+    static mapping = {
+        table 'books'
+        title column: 'book_title'
+        datePublished type: 'date'
+    }
+}
+```
+
+### Relationships
+```groovy
+class Author {
+    String name
+
+    static hasMany = [books: Book]
+
+    static mapping = {
+        books cascade: 'all-delete-orphan'
+    }
+}
+
+class Book {
+    String title
+
+    static belongsTo = [author: Author]
+}
+
+// Many-to-Many
+class Book {
+    static hasMany = [categories: Category]
+    static belongsTo = Category
+}
+
+class Category {
+    String name
+    static hasMany = [books: Book]
+}
+```
+
+### GORM Queries
+```groovy
+// Dynamic finders
+Book.findByTitle("Grails Guide")
+Book.findAllByAuthorLike("%Smith%")
+Book.findByTitleAndAuthor("Guide", "Smith")
+Book.countByPagesGreaterThan(100)
+
+// Where queries
+Book.where {
+    title =~ "%Grails%" && pages > 100
+}.list()
+
+// Criteria queries
+Book.withCriteria {
+    like('title', '%Grails%')
+    gt('pages', 100)
+    order('datePublished', 'desc')
+    maxResults(10)
+}
+
+// HQL queries
+Book.executeQuery(
+    "from Book b where b.author.name = :name",
+    [name: 'Smith']
+)
+
+// Detached criteria (reusable)
+def criteria = Book.where {
+    pages > 100
+}
+criteria.list()
+criteria.count()
+```
+
+### Transactions
+```groovy
+// In services (default transactional)
+@Transactional
+class BookService {
+    def saveBook(Book book) {
+        book.save(failOnError: true)
+    }
+}
+
+// Manual transaction control
+Book.withTransaction { status ->
+    def book = new Book(title: "Test")
+    book.save()
+    if (someCondition) {
+        status.setRollbackOnly()
+    }
+}
+```
+
+## Controllers
+
+### Basic Controller
+```groovy
+class BookController {
+
+    BookService bookService
+
+    static allowedMethods = [save: 'POST', update: 'PUT', delete: 'DELETE']
+
+    def index() {
+        respond Book.list(), model: [bookCount: Book.count()]
+    }
+
+    def show(Long id) {
+        respond Book.get(id)
+    }
+
+    def create() {
+        respond new Book(params)
+    }
+
+    def save(Book book) {
+        if (book.hasErrors()) {
+            respond book.errors, view: 'create'
+            return
+        }
+        bookService.save(book)
+        redirect action: 'show', id: book.id
+    }
+
+    def edit(Long id) {
+        respond Book.get(id)
+    }
+
+    def update(Book book) {
+        if (book.hasErrors()) {
+            respond book.errors, view: 'edit'
+            return
+        }
+        bookService.save(book)
+        redirect action: 'show', id: book.id
+    }
+
+    def delete(Long id) {
+        bookService.delete(id)
+        redirect action: 'index'
+    }
+}
+```
+
+### REST Controller
+```groovy
+import grails.rest.RestfulController
+
+class BookController extends RestfulController<Book> {
+
+    static responseFormats = ['json', 'xml']
+
+    BookController() {
+        super(Book)
+    }
+
+    // Override to customize
+    @Override
+    protected Book queryForResource(Serializable id) {
+        Book.where { id == id && active == true }.find()
+    }
+}
+```
+
+### Command Objects
+```groovy
+class BookCommand implements Validateable {
+    String title
+    String author
+    Integer pages
+
+    static constraints = {
+        title blank: false
+        author blank: false
+        pages min: 1, nullable: true
+    }
+}
+
+class BookController {
+    def save(BookCommand cmd) {
+        if (cmd.hasErrors()) {
+            respond cmd.errors
+            return
+        }
+        // Process valid command
+    }
+}
+```
+
+### Content Negotiation
+```groovy
+class BookController {
+    def show(Long id) {
+        def book = Book.get(id)
+        respond book  // Auto-negotiates based on Accept header
+    }
+}
+
+// Or explicit
+def show(Long id) {
+    def book = Book.get(id)
+    withFormat {
+        html { render view: 'show', model: [book: book] }
+        json { render book as JSON }
+        xml { render book as XML }
+    }
+}
+```
+
+## Services
+
+### Basic Service
+```groovy
+import grails.gorm.transactions.Transactional
+
+@Transactional
+class BookService {
+
+    def findByTitle(String title) {
+        Book.findByTitle(title)
+    }
+
+    def save(Book book) {
+        book.save(failOnError: true)
+    }
+
+    @Transactional(readOnly = true)
+    def list(Map params) {
+        Book.list(params)
+    }
+
+    def delete(Long id) {
+        Book.get(id)?.delete()
+    }
+}
+```
+
+### Service with Events
+```groovy
+import grails.events.annotation.Publisher
+import grails.events.annotation.Subscriber
+
+class BookService {
+
+    @Publisher
+    def save(Book book) {
+        book.save()
+        // Automatically publishes 'book.saved' event
+    }
+}
+
+class NotificationService {
+
+    @Subscriber('book.saved')
+    def onBookSaved(Book book) {
+        // Handle event
+        log.info "Book saved: ${book.title}"
+    }
+}
+```
+
+### Async Service
+```groovy
+import grails.async.Promise
+import static grails.async.Promises.*
+
+class BookService {
+
+    Promise<Book> findAsync(Long id) {
+        task {
+            Book.get(id)
+        }
+    }
+
+    def processBooks() {
+        def p1 = task { Book.findAllByActive(true) }
+        def p2 = task { Author.list() }
+
+        waitAll(p1, p2)
+        // Both complete
+    }
+}
+```
+
+## Views
+
+### GSP (Groovy Server Pages)
+```html
+<!-- grails-app/views/book/list.gsp -->
+<!DOCTYPE html>
+<html>
+<head>
+    <title>Books</title>
+    <asset:stylesheet src="application.css"/>
+</head>
+<body>
+    <h1>Books (${bookCount})</h1>
+
+    <g:each in="${bookList}" var="book">
+        <div class="book">
+            <h2>${book.title}</h2>
+            <p>By ${book.author}</p>
+            <g:link action="show" id="${book.id}">View</g:link>
+        </div>
+    </g:each>
+
+    <g:if test="${bookList.empty}">
+        <p>No books found.</p>
+    </g:if>
+
+    <g:paginate total="${bookCount}"/>
+
+    <asset:javascript src="application.js"/>
+</body>
+</html>
+```
+
+### Common GSP Tags
+```html
+<!-- Links -->
+<g:link controller="book" action="show" id="${book.id}">View</g:link>
+<g:createLink action="list"/>
+
+<!-- Forms -->
+<g:form action="save">
+    <g:textField name="title" value="${book?.title}"/>
+    <g:textArea name="description" value="${book?.description}"/>
+    <g:select name="category" from="${categories}" optionKey="id" optionValue="name"/>
+    <g:checkBox name="active" value="${book?.active}"/>
+    <g:submitButton name="submit" value="Save"/>
+</g:form>
+
+<!-- Conditionals -->
+<g:if test="${condition}">...</g:if>
+<g:elseif test="${other}">...</g:elseif>
+<g:else>...</g:else>
+
+<!-- Iteration -->
+<g:each in="${items}" var="item" status="i">
+    ${i}: ${item.name}
+</g:each>
+
+<!-- Rendering -->
+<g:render template="bookRow" model="[book: book]"/>
+<g:render template="bookRow" collection="${books}" var="book"/>
+
+<!-- Security (with Spring Security plugin) -->
+<sec:ifLoggedIn>Welcome, ${sec.username()}</sec:ifLoggedIn>
+<sec:ifNotLoggedIn><g:link controller="login">Login</g:link></sec:ifNotLoggedIn>
+```
+
+### JSON Views
+```groovy
+// grails-app/views/book/show.gson
+import myapp.Book
+
+model {
+    Book book
+}
+
+json {
+    id book.id
+    title book.title
+    author book.author
+    datePublished book.datePublished?.format('yyyy-MM-dd')
+    _links {
+        self {
+            href "/books/${book.id}"
+        }
+    }
+}
+```
+
+### Layouts
+```html
+<!-- grails-app/views/layouts/main.gsp -->
+<!DOCTYPE html>
+<html>
+<head>
+    <title><g:layoutTitle default="My App"/></title>
+    <asset:stylesheet src="application.css"/>
+    <g:layoutHead/>
+</head>
+<body>
+    <nav><!-- Navigation --></nav>
+    <main>
+        <g:layoutBody/>
+    </main>
+    <footer><!-- Footer --></footer>
+    <asset:javascript src="application.js"/>
+</body>
+</html>
+
+<!-- Use in views -->
+<html>
+<head>
+    <meta name="layout" content="main"/>
+    <title>Books</title>
+</head>
+<body>
+    <!-- Page content -->
+</body>
+</html>
+```
+
+## Interceptors
+
+```groovy
+class AuthInterceptor {
+
+    AuthInterceptor() {
+        matchAll()
+            .excludes(controller: 'login')
+            .excludes(controller: 'error')
+    }
+
+    boolean before() {
+        if (!session.user) {
+            redirect(controller: 'login')
+            return false
+        }
+        true
+    }
+
+    boolean after() {
+        // After action executes
+        true
+    }
+
+    void afterView() {
+        // After view renders
+    }
+}
+```
+
+## Tag Libraries
+
+```groovy
+class BookTagLib {
+
+    static namespace = 'book'
+    static defaultEncodeAs = [taglib: 'html']
+
+    def formatTitle = { attrs, body ->
+        def title = attrs.title ?: body()
+        out << "<span class='book-title'>${title}</span>"
+    }
+
+    def ifHasBooks = { attrs, body ->
+        if (Book.count() > 0) {
+            out << body()
+        }
+    }
+}
+
+// Usage in GSP
+<book:formatTitle title="${book.title}"/>
+<book:ifHasBooks>
+    <p>We have books!</p>
+</book:ifHasBooks>
+```
+
+## Configuration
+
+### application.yml
+```yaml
+grails:
+    profile: web
+    codegen:
+        defaultPackage: myapp
+    gorm:
+        reactor:
+            events: false
+    mime:
+        types:
+            json: ['application/json', 'text/json']
+            xml: ['text/xml', 'application/xml']
+
+environments:
+    development:
+        dataSource:
+            dbCreate: create-drop
+            url: jdbc:h2:mem:devDb
+    test:
+        dataSource:
+            dbCreate: update
+            url: jdbc:h2:mem:testDb
+    production:
+        dataSource:
+            dbCreate: none
+            url: jdbc:postgresql://localhost/myapp
+            driverClassName: org.postgresql.Driver
+            dialect: org.hibernate.dialect.PostgreSQLDialect
+            properties:
+                jmxEnabled: true
+                initialSize: 5
+                maxActive: 50
+
+server:
+    port: 8080
+    servlet:
+        context-path: /myapp
+```
+
+### URL Mappings
+```groovy
+// grails-app/controllers/myapp/UrlMappings.groovy
+class UrlMappings {
+
+    static mappings = {
+        // Default
+        "/$controller/$action?/$id?(.$format)?" {
+            constraints {
+                // apply constraints here
+            }
+        }
+
+        // REST resources
+        "/api/books"(resources: 'book')
+
+        // Custom mappings
+        "/books/$id"(controller: 'book', action: 'show')
+        "/search"(controller: 'book', action: 'search')
+
+        // Named URL mappings
+        name bookShow: "/books/$id" {
+            controller = 'book'
+            action = 'show'
+        }
+
+        // Error pages
+        "500"(view: '/error')
+        "404"(view: '/notFound')
+    }
+}
+```
+
+## Testing with Spock
+
+### Unit Test - Controller
+```groovy
+import grails.testing.web.controllers.ControllerUnitTest
+import spock.lang.Specification
+
+class BookControllerSpec extends Specification
+        implements ControllerUnitTest<BookController> {
+
+    def setup() {
+        controller.bookService = Mock(BookService)
+    }
+
+    void "index returns list of books"() {
+        given:
+        def books = [new Book(title: "Test")]
+        controller.bookService.list(_) >> books
+
+        when:
+        controller.index()
+
+        then:
+        model.bookList == books
+        view == '/book/index'
+    }
+
+    void "show returns 404 for missing book"() {
+        when:
+        controller.show(999)
+
+        then:
+        response.status == 404
+    }
+}
+```
+
+### Unit Test - Service
+```groovy
+import grails.testing.services.ServiceUnitTest
+import spock.lang.Specification
+
+class BookServiceSpec extends Specification
+        implements ServiceUnitTest<BookService> {
+
+    void "save persists book"() {
+        given:
+        def book = new Book(title: "Test", author: "Author")
+
+        when:
+        def result = service.save(book)
+
+        then:
+        result.id != null
+        Book.count() == 1
+    }
+}
+```
+
+### Unit Test - Domain
+```groovy
+import grails.testing.gorm.DomainUnitTest
+import spock.lang.Specification
+
+class BookSpec extends Specification
+        implements DomainUnitTest<Book> {
+
+    void "title cannot be blank"() {
+        when:
+        domain.title = ""
+        domain.author = "Test"
+
+        then:
+        !domain.validate(['title'])
+        domain.errors['title'].code == 'blank'
+    }
+
+    void "valid book passes validation"() {
+        when:
+        domain.title = "Valid Title"
+        domain.author = "Author"
+
+        then:
+        domain.validate()
+    }
+}
+```
+
+### Integration Test
+```groovy
+import grails.testing.mixin.integration.Integration
+import grails.gorm.transactions.Rollback
+import spock.lang.Specification
+
+@Integration
+@Rollback
+class BookServiceIntegrationSpec extends Specification {
+
+    BookService bookService
+
+    void "save and retrieve book"() {
+        given:
+        def book = new Book(title: "Integration Test", author: "Tester")
+
+        when:
+        bookService.save(book)
+        def found = Book.findByTitle("Integration Test")
+
+        then:
+        found != null
+        found.author == "Tester"
+    }
+}
+```
+
+### Functional Test with Geb
+```groovy
+import geb.spock.GebSpec
+import grails.testing.mixin.integration.Integration
+
+@Integration
+class BookFunctionalSpec extends GebSpec {
+
+    void "can view book list"() {
+        when:
+        go '/book/index'
+
+        then:
+        title == 'Book List'
+        $('h1').text() == 'Books'
+    }
+
+    void "can create new book"() {
+        when:
+        go '/book/create'
+        $('form').title = 'New Book'
+        $('form').author = 'Test Author'
+        $('input[type=submit]').click()
+
+        then:
+        $('h1').text().contains('New Book')
+    }
+}
+```
+
+## Plugins
+
+### Common Plugins
+```groovy
+// build.gradle
+
+// Spring Security
+implementation 'org.grails.plugins:spring-security-core:6.0.0'
+
+// Database Migration (Liquibase)
+implementation 'org.grails.plugins:database-migration:4.2.0'
+
+// Caching
+implementation 'org.grails.plugins:cache:6.0.0'
+
+// Async support
+implementation 'org.grails.plugins:async:5.0.0'
+
+// Fields plugin for form rendering
+implementation 'org.grails.plugins:fields:5.0.0'
+
+// Asset Pipeline
+runtimeOnly 'org.grails.plugins:asset-pipeline:5.0.0'
+```
+
+### Spring Security Configuration
+```groovy
+// grails-app/conf/application.groovy
+grails.plugin.springsecurity.userLookup.userDomainClassName = 'myapp.User'
+grails.plugin.springsecurity.userLookup.authorityJoinClassName = 'myapp.UserRole'
+grails.plugin.springsecurity.authority.className = 'myapp.Role'
+
+grails.plugin.springsecurity.controllerAnnotations.staticRules = [
+    [pattern: '/',               access: ['permitAll']],
+    [pattern: '/error',          access: ['permitAll']],
+    [pattern: '/index',          access: ['permitAll']],
+    [pattern: '/admin/**',       access: ['ROLE_ADMIN']],
+    [pattern: '/api/**',         access: ['isAuthenticated()']],
+]
+```
+
+## Build Commands
+
+```bash
+# Run application
+./gradlew bootRun
+
+# Run tests
+./gradlew test                                    # All tests
+./gradlew test --tests "BookServiceSpec"          # Single spec
+./gradlew test --tests "*Spec.save*"              # Pattern match
+./gradlew integrationTest                         # Integration tests
+
+# Build
+./gradlew build -PskipTests                       # Build without tests
+./gradlew bootJar                                 # Executable JAR
+./gradlew bootWar                                 # WAR file
+
+# Code quality
+./gradlew codeStyle                               # Check style
+
+# Clean
+./gradlew clean
+```
+
+## Best Practices
+
+### Convention Over Configuration
+- Follow Grails naming conventions for automatic wiring.
+- Use standard directory structure.
+- Let Grails infer configurations where possible.
+
+### Performance
+- Use `@GrailsCompileStatic` on controllers and services.
+- Enable query caching for read-heavy operations.
+- Use pagination for large result sets.
+- Avoid N+1 queries with eager fetching or batch size.
+
+### Security
+- Use CSRF tokens in forms: `<g:form useToken="true">`.
+- Apply Spring Security for authentication/authorization.
+- Use parameterized queries (GORM handles this automatically).
+- Encode output to prevent XSS.
+
+### Testing
+- Write unit tests for domain constraints.
+- Test controllers with `ControllerUnitTest`.
+- Use integration tests for service/database interactions.
+- Use Geb for critical user workflows.
+
+### Code Style
+- Use `@GrailsCompileStatic` for type safety and performance.
+- Prefer services for business logic over controllers.
+- Use command objects for complex form handling.
+- Keep controllers thin, services fat.
+
+## Resources
+
+- **Grails 7 User Guide**: https://docs.grails.org/latest/guide/single.html
+- **GORM Documentation**: https://gorm.grails.org/latest/
+- **Grails Plugins**: https://plugins.grails.org/

Review Comment:
   https://grails.apache.org/plugins.html



##########
.agents/skills/grails-developer/SKILL.md:
##########
@@ -0,0 +1,883 @@
+<!--
+SPDX-License-Identifier: Apache-2.0
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+---
+name: grails-developer
+description: Comprehensive guide for Grails 7 development, covering web applications, REST APIs, GORM, controllers, services, views, plugins, and testing with Spock and Geb
+license: Apache-2.0
+compatibility: opencode, claude, grok, gemini, copilot, cursor, windsurf
+metadata:
+  audience: developers
+  frameworks: grails
+  versions: 7
+---
+
+## What I Do
+
+- Provide detailed guidance for building Grails 7 web applications and REST APIs.
+- Assist with GORM for data modeling, controllers for request handling, services for business logic, and views (GSP, JSON, Markup).
+- Support testing with Spock 2.3 (unit/integration tests) and Geb for browser automation.
+- Guide plugin usage and development, security implementation, and deployment strategies.
+- Help with configuration, internationalization, async programming, and performance optimization.
+
+## When to Use Me
+
+Activate this skill when developing with Grails 7, including:
+
+- Building CRUD applications, RESTful APIs, or full-stack web applications.
+- Working with GORM domain classes, constraints, and relationships.
+- Creating controllers, services, interceptors, or tag libraries.
+- Writing Spock specifications or Geb functional tests.
+- Configuring plugins, security, caching, or database migrations.
+- Deploying Grails applications to containers or cloud platforms.
+
+## Technology Stack
+
+Grails 7 is built on:
+- **Spring Boot**: 3.5.x
+- **Spring Framework**: 6.2.x
+- **Groovy**: 4.0.x
+- **Gradle**: 8.14.x
+- **Spock**: 2.3-groovy-4.0
+- **Jakarta EE**: 10 (migrated from javax.*)
+- **Micronaut**: Optional via `grails-micronaut` plugin
+
+## Project Structure
+
+```
+myapp/
+├── grails-app/
+│   ├── conf/                 # Configuration
+│   │   ├── application.yml   # Main config
+│   │   ├── logback.xml       # Logging config
+│   │   └── spring/           # Spring bean definitions
+│   ├── controllers/          # Request handlers
+│   ├── domain/               # GORM domain classes
+│   ├── i18n/                 # Message bundles
+│   ├── init/                 # Bootstrap classes
+│   ├── services/             # Business logic
+│   ├── taglib/               # Custom GSP tags
+│   ├── utils/                # Utility classes
+│   └── views/                # GSP templates
+├── src/
+│   ├── main/groovy/          # Additional Groovy classes
+│   ├── main/java/            # Java classes
+│   └── test/groovy/          # Test specifications
+├── build.gradle              # Build configuration
+└── gradle.properties         # Project properties
+```
+
+## Domain Classes (GORM)
+
+### Basic Domain Class
+```groovy
+class Book {
+    String title
+    String author
+    Date datePublished
+    Integer pages
+
+    static constraints = {
+        title blank: false, maxSize: 255
+        author blank: false
+        datePublished nullable: true
+        pages min: 1, nullable: true
+    }
+
+    static mapping = {
+        table 'books'
+        title column: 'book_title'
+        datePublished type: 'date'
+    }
+}
+```
+
+### Relationships
+```groovy
+class Author {
+    String name
+
+    static hasMany = [books: Book]
+
+    static mapping = {
+        books cascade: 'all-delete-orphan'
+    }
+}
+
+class Book {
+    String title
+
+    static belongsTo = [author: Author]
+}
+
+// Many-to-Many
+class Book {
+    static hasMany = [categories: Category]
+    static belongsTo = Category
+}
+
+class Category {
+    String name
+    static hasMany = [books: Book]
+}
+```
+
+### GORM Queries
+```groovy
+// Dynamic finders
+Book.findByTitle("Grails Guide")
+Book.findAllByAuthorLike("%Smith%")
+Book.findByTitleAndAuthor("Guide", "Smith")
+Book.countByPagesGreaterThan(100)
+
+// Where queries
+Book.where {
+    title =~ "%Grails%" && pages > 100
+}.list()
+
+// Criteria queries
+Book.withCriteria {
+    like('title', '%Grails%')
+    gt('pages', 100)
+    order('datePublished', 'desc')
+    maxResults(10)
+}
+
+// HQL queries
+Book.executeQuery(
+    "from Book b where b.author.name = :name",
+    [name: 'Smith']
+)
+
+// Detached criteria (reusable)
+def criteria = Book.where {
+    pages > 100
+}
+criteria.list()
+criteria.count()
+```
+
+### Transactions
+```groovy
+// In services (default transactional)
+@Transactional
+class BookService {
+    def saveBook(Book book) {
+        book.save(failOnError: true)
+    }
+}
+
+// Manual transaction control
+Book.withTransaction { status ->
+    def book = new Book(title: "Test")
+    book.save()
+    if (someCondition) {
+        status.setRollbackOnly()
+    }
+}
+```
+
+## Controllers
+
+### Basic Controller
+```groovy
+class BookController {
+
+    BookService bookService
+
+    static allowedMethods = [save: 'POST', update: 'PUT', delete: 'DELETE']
+
+    def index() {
+        respond Book.list(), model: [bookCount: Book.count()]
+    }
+
+    def show(Long id) {
+        respond Book.get(id)
+    }
+
+    def create() {
+        respond new Book(params)
+    }
+
+    def save(Book book) {
+        if (book.hasErrors()) {
+            respond book.errors, view: 'create'
+            return
+        }
+        bookService.save(book)
+        redirect action: 'show', id: book.id
+    }
+
+    def edit(Long id) {
+        respond Book.get(id)
+    }
+
+    def update(Book book) {
+        if (book.hasErrors()) {
+            respond book.errors, view: 'edit'
+            return
+        }
+        bookService.save(book)
+        redirect action: 'show', id: book.id
+    }
+
+    def delete(Long id) {
+        bookService.delete(id)
+        redirect action: 'index'
+    }
+}
+```
+
+### REST Controller
+```groovy
+import grails.rest.RestfulController
+
+class BookController extends RestfulController<Book> {
+
+    static responseFormats = ['json', 'xml']
+
+    BookController() {
+        super(Book)
+    }
+
+    // Override to customize
+    @Override
+    protected Book queryForResource(Serializable id) {
+        Book.where { id == id && active == true }.find()
+    }
+}
+```
+
+### Command Objects
+```groovy
+class BookCommand implements Validateable {
+    String title
+    String author
+    Integer pages
+
+    static constraints = {
+        title blank: false
+        author blank: false
+        pages min: 1, nullable: true
+    }
+}
+
+class BookController {
+    def save(BookCommand cmd) {
+        if (cmd.hasErrors()) {
+            respond cmd.errors
+            return
+        }
+        // Process valid command
+    }
+}
+```
+
+### Content Negotiation
+```groovy
+class BookController {
+    def show(Long id) {
+        def book = Book.get(id)
+        respond book  // Auto-negotiates based on Accept header
+    }
+}
+
+// Or explicit
+def show(Long id) {
+    def book = Book.get(id)
+    withFormat {
+        html { render view: 'show', model: [book: book] }
+        json { render book as JSON }
+        xml { render book as XML }
+    }
+}
+```
+
+## Services
+
+### Basic Service
+```groovy
+import grails.gorm.transactions.Transactional
+
+@Transactional
+class BookService {
+
+    def findByTitle(String title) {
+        Book.findByTitle(title)
+    }
+
+    def save(Book book) {
+        book.save(failOnError: true)
+    }
+
+    @Transactional(readOnly = true)
+    def list(Map params) {
+        Book.list(params)
+    }
+
+    def delete(Long id) {
+        Book.get(id)?.delete()
+    }
+}
+```
+
+### Service with Events
+```groovy
+import grails.events.annotation.Publisher
+import grails.events.annotation.Subscriber
+
+class BookService {
+
+    @Publisher
+    def save(Book book) {
+        book.save()
+        // Automatically publishes 'book.saved' event
+    }
+}
+
+class NotificationService {
+
+    @Subscriber('book.saved')
+    def onBookSaved(Book book) {
+        // Handle event
+        log.info "Book saved: ${book.title}"
+    }
+}
+```
+
+### Async Service
+```groovy
+import grails.async.Promise
+import static grails.async.Promises.*
+
+class BookService {
+
+    Promise<Book> findAsync(Long id) {
+        task {
+            Book.get(id)
+        }
+    }
+
+    def processBooks() {
+        def p1 = task { Book.findAllByActive(true) }
+        def p2 = task { Author.list() }
+
+        waitAll(p1, p2)
+        // Both complete
+    }
+}
+```
+
+## Views
+
+### GSP (Groovy Server Pages)
+```html
+<!-- grails-app/views/book/list.gsp -->
+<!DOCTYPE html>
+<html>
+<head>
+    <title>Books</title>
+    <asset:stylesheet src="application.css"/>
+</head>
+<body>
+    <h1>Books (${bookCount})</h1>
+
+    <g:each in="${bookList}" var="book">
+        <div class="book">
+            <h2>${book.title}</h2>
+            <p>By ${book.author}</p>
+            <g:link action="show" id="${book.id}">View</g:link>
+        </div>
+    </g:each>
+
+    <g:if test="${bookList.empty}">
+        <p>No books found.</p>
+    </g:if>
+
+    <g:paginate total="${bookCount}"/>
+
+    <asset:javascript src="application.js"/>
+</body>
+</html>
+```
+
+### Common GSP Tags
+```html
+<!-- Links -->
+<g:link controller="book" action="show" id="${book.id}">View</g:link>
+<g:createLink action="list"/>
+
+<!-- Forms -->
+<g:form action="save">
+    <g:textField name="title" value="${book?.title}"/>
+    <g:textArea name="description" value="${book?.description}"/>
+    <g:select name="category" from="${categories}" optionKey="id" optionValue="name"/>
+    <g:checkBox name="active" value="${book?.active}"/>
+    <g:submitButton name="submit" value="Save"/>
+</g:form>
+
+<!-- Conditionals -->
+<g:if test="${condition}">...</g:if>
+<g:elseif test="${other}">...</g:elseif>
+<g:else>...</g:else>
+
+<!-- Iteration -->
+<g:each in="${items}" var="item" status="i">
+    ${i}: ${item.name}
+</g:each>
+
+<!-- Rendering -->
+<g:render template="bookRow" model="[book: book]"/>
+<g:render template="bookRow" collection="${books}" var="book"/>
+
+<!-- Security (with Spring Security plugin) -->
+<sec:ifLoggedIn>Welcome, ${sec.username()}</sec:ifLoggedIn>
+<sec:ifNotLoggedIn><g:link controller="login">Login</g:link></sec:ifNotLoggedIn>
+```
+
+### JSON Views
+```groovy
+// grails-app/views/book/show.gson
+import myapp.Book
+
+model {
+    Book book
+}
+
+json {
+    id book.id
+    title book.title
+    author book.author
+    datePublished book.datePublished?.format('yyyy-MM-dd')
+    _links {
+        self {
+            href "/books/${book.id}"
+        }
+    }
+}
+```
+
+### Layouts
+```html
+<!-- grails-app/views/layouts/main.gsp -->
+<!DOCTYPE html>
+<html>
+<head>
+    <title><g:layoutTitle default="My App"/></title>
+    <asset:stylesheet src="application.css"/>
+    <g:layoutHead/>
+</head>
+<body>
+    <nav><!-- Navigation --></nav>
+    <main>
+        <g:layoutBody/>
+    </main>
+    <footer><!-- Footer --></footer>
+    <asset:javascript src="application.js"/>
+</body>
+</html>
+
+<!-- Use in views -->
+<html>
+<head>
+    <meta name="layout" content="main"/>
+    <title>Books</title>
+</head>
+<body>
+    <!-- Page content -->
+</body>
+</html>
+```
+
+## Interceptors
+
+```groovy
+class AuthInterceptor {
+
+    AuthInterceptor() {
+        matchAll()
+            .excludes(controller: 'login')
+            .excludes(controller: 'error')
+    }
+
+    boolean before() {
+        if (!session.user) {
+            redirect(controller: 'login')
+            return false
+        }
+        true
+    }
+
+    boolean after() {
+        // After action executes
+        true
+    }
+
+    void afterView() {
+        // After view renders
+    }
+}
+```
+
+## Tag Libraries
+
+```groovy
+class BookTagLib {
+
+    static namespace = 'book'
+    static defaultEncodeAs = [taglib: 'html']
+
+    def formatTitle = { attrs, body ->
+        def title = attrs.title ?: body()
+        out << "<span class='book-title'>${title}</span>"
+    }
+
+    def ifHasBooks = { attrs, body ->
+        if (Book.count() > 0) {
+            out << body()
+        }
+    }
+}
+
+// Usage in GSP
+<book:formatTitle title="${book.title}"/>
+<book:ifHasBooks>
+    <p>We have books!</p>
+</book:ifHasBooks>
+```
+
+## Configuration
+
+### application.yml
+```yaml
+grails:
+    profile: web
+    codegen:
+        defaultPackage: myapp
+    gorm:
+        reactor:
+            events: false
+    mime:
+        types:
+            json: ['application/json', 'text/json']
+            xml: ['text/xml', 'application/xml']
+
+environments:
+    development:
+        dataSource:
+            dbCreate: create-drop
+            url: jdbc:h2:mem:devDb
+    test:
+        dataSource:
+            dbCreate: update
+            url: jdbc:h2:mem:testDb
+    production:
+        dataSource:
+            dbCreate: none
+            url: jdbc:postgresql://localhost/myapp
+            driverClassName: org.postgresql.Driver
+            dialect: org.hibernate.dialect.PostgreSQLDialect
+            properties:
+                jmxEnabled: true
+                initialSize: 5
+                maxActive: 50
+
+server:
+    port: 8080
+    servlet:
+        context-path: /myapp
+```
+
+### URL Mappings
+```groovy
+// grails-app/controllers/myapp/UrlMappings.groovy
+class UrlMappings {
+
+    static mappings = {
+        // Default
+        "/$controller/$action?/$id?(.$format)?" {
+            constraints {
+                // apply constraints here
+            }
+        }
+
+        // REST resources
+        "/api/books"(resources: 'book')
+
+        // Custom mappings
+        "/books/$id"(controller: 'book', action: 'show')
+        "/search"(controller: 'book', action: 'search')
+
+        // Named URL mappings
+        name bookShow: "/books/$id" {
+            controller = 'book'
+            action = 'show'
+        }
+
+        // Error pages
+        "500"(view: '/error')
+        "404"(view: '/notFound')
+    }
+}
+```
+
+## Testing with Spock
+
+### Unit Test - Controller
+```groovy
+import grails.testing.web.controllers.ControllerUnitTest
+import spock.lang.Specification
+
+class BookControllerSpec extends Specification
+        implements ControllerUnitTest<BookController> {
+
+    def setup() {
+        controller.bookService = Mock(BookService)
+    }
+
+    void "index returns list of books"() {
+        given:
+        def books = [new Book(title: "Test")]
+        controller.bookService.list(_) >> books
+
+        when:
+        controller.index()
+
+        then:
+        model.bookList == books
+        view == '/book/index'
+    }
+
+    void "show returns 404 for missing book"() {
+        when:
+        controller.show(999)
+
+        then:
+        response.status == 404
+    }
+}
+```
+
+### Unit Test - Service
+```groovy
+import grails.testing.services.ServiceUnitTest
+import spock.lang.Specification
+
+class BookServiceSpec extends Specification
+        implements ServiceUnitTest<BookService> {
+
+    void "save persists book"() {
+        given:
+        def book = new Book(title: "Test", author: "Author")
+
+        when:
+        def result = service.save(book)
+
+        then:
+        result.id != null
+        Book.count() == 1
+    }
+}
+```
+
+### Unit Test - Domain
+```groovy
+import grails.testing.gorm.DomainUnitTest
+import spock.lang.Specification
+
+class BookSpec extends Specification
+        implements DomainUnitTest<Book> {
+
+    void "title cannot be blank"() {
+        when:
+        domain.title = ""
+        domain.author = "Test"
+
+        then:
+        !domain.validate(['title'])
+        domain.errors['title'].code == 'blank'
+    }
+
+    void "valid book passes validation"() {
+        when:
+        domain.title = "Valid Title"
+        domain.author = "Author"
+
+        then:
+        domain.validate()
+    }
+}
+```
+
+### Integration Test
+```groovy
+import grails.testing.mixin.integration.Integration
+import grails.gorm.transactions.Rollback
+import spock.lang.Specification
+
+@Integration
+@Rollback
+class BookServiceIntegrationSpec extends Specification {
+
+    BookService bookService
+
+    void "save and retrieve book"() {
+        given:
+        def book = new Book(title: "Integration Test", author: "Tester")
+
+        when:
+        bookService.save(book)
+        def found = Book.findByTitle("Integration Test")
+
+        then:
+        found != null
+        found.author == "Tester"
+    }
+}
+```
+
+### Functional Test with Geb
+```groovy
+import geb.spock.GebSpec
+import grails.testing.mixin.integration.Integration
+
+@Integration
+class BookFunctionalSpec extends GebSpec {
+
+    void "can view book list"() {
+        when:
+        go '/book/index'
+
+        then:
+        title == 'Book List'
+        $('h1').text() == 'Books'
+    }
+
+    void "can create new book"() {
+        when:
+        go '/book/create'
+        $('form').title = 'New Book'
+        $('form').author = 'Test Author'
+        $('input[type=submit]').click()
+
+        then:
+        $('h1').text().contains('New Book')
+    }
+}
+```
+
+## Plugins
+
+### Common Plugins
+```groovy
+// build.gradle
+
+// Spring Security
+implementation 'org.grails.plugins:spring-security-core:6.0.0'
+
+// Database Migration (Liquibase)
+implementation 'org.grails.plugins:database-migration:4.2.0'
+
+// Caching
+implementation 'org.grails.plugins:cache:6.0.0'
+
+// Async support
+implementation 'org.grails.plugins:async:5.0.0'
+
+// Fields plugin for form rendering
+implementation 'org.grails.plugins:fields:5.0.0'
+
+// Asset Pipeline
+runtimeOnly 'org.grails.plugins:asset-pipeline:5.0.0'
+```
+
+### Spring Security Configuration
+```groovy
+// grails-app/conf/application.groovy
+grails.plugin.springsecurity.userLookup.userDomainClassName = 'myapp.User'
+grails.plugin.springsecurity.userLookup.authorityJoinClassName = 'myapp.UserRole'
+grails.plugin.springsecurity.authority.className = 'myapp.Role'
+
+grails.plugin.springsecurity.controllerAnnotations.staticRules = [
+    [pattern: '/',               access: ['permitAll']],
+    [pattern: '/error',          access: ['permitAll']],
+    [pattern: '/index',          access: ['permitAll']],
+    [pattern: '/admin/**',       access: ['ROLE_ADMIN']],
+    [pattern: '/api/**',         access: ['isAuthenticated()']],
+]
+```
+
+## Build Commands
+
+```bash
+# Run application
+./gradlew bootRun
+
+# Run tests
+./gradlew test                                    # All tests
+./gradlew test --tests "BookServiceSpec"          # Single spec
+./gradlew test --tests "*Spec.save*"              # Pattern match
+./gradlew integrationTest                         # Integration tests
+
+# Build
+./gradlew build -PskipTests                       # Build without tests
+./gradlew bootJar                                 # Executable JAR
+./gradlew bootWar                                 # WAR file
+
+# Code quality
+./gradlew codeStyle                               # Check style
+
+# Clean
+./gradlew clean
+```
+
+## Best Practices
+
+### Convention Over Configuration
+- Follow Grails naming conventions for automatic wiring.
+- Use standard directory structure.
+- Let Grails infer configurations where possible.
+
+### Performance
+- Use `@GrailsCompileStatic` on controllers and services.
+- Enable query caching for read-heavy operations.
+- Use pagination for large result sets.
+- Avoid N+1 queries with eager fetching or batch size.
+
+### Security
+- Use CSRF tokens in forms: `<g:form useToken="true">`.
+- Apply Spring Security for authentication/authorization.
+- Use parameterized queries (GORM handles this automatically).
+- Encode output to prevent XSS.
+
+### Testing
+- Write unit tests for domain constraints.
+- Test controllers with `ControllerUnitTest`.
+- Use integration tests for service/database interactions.
+- Use Geb for critical user workflows.
+
+### Code Style
+- Use `@GrailsCompileStatic` for type safety and performance.
+- Prefer services for business logic over controllers.
+- Use command objects for complex form handling.
+- Keep controllers thin, services fat.
+
+## Resources

Review Comment:
   Also add Groovy single page documentation? 



##########
.agents/skills/groovy-developer/SKILL.md:
##########
@@ -0,0 +1,520 @@
+<!--
+SPDX-License-Identifier: Apache-2.0
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+---
+name: groovy-developer
+description: Expert guide for Groovy 4 development, covering concise syntax, closures, DSLs, metaprogramming, static compilation, and integration with Java 17 and Grails
+license: Apache-2.0
+compatibility: opencode, claude, grok, gemini, copilot, cursor, windsurf
+metadata:
+  audience: developers
+  languages: groovy, java
+  versions: 4.0
+  paradigms: dynamic, static, functional, object-oriented, DSL-oriented
+---
+
+## What I Do
+
+- Provide deep expertise in Groovy 4.0, including core language features: syntax, closures, traits, GStrings, operators, and Groovy Truth.
+- Guide metaprogramming techniques: runtime (categories, ExpandoMetaClass, extension modules) and compile-time (AST transformations like @Immutable, @Builder, @Delegate, @Singleton, @Log, @Memoized).
+- Assist with DSL creation and usage (MarkupBuilder, JsonBuilder, builders for configuration).
+- Support testing with Spock Framework (BDD, data-driven tests, mocking) and built-in power assertions.
+- Help integrate Groovy with Java 17: joint compilation, Gradle builds, Grails, and Spring Boot.
+- Cover data handling: JSON/XML parsing and building, Groovy SQL, collection processing.
+- Advise on performance: @CompileStatic, @TypeChecked, @GrailsCompileStatic for optimal execution.
+
+## When to Use Me
+
+Activate this skill for any Groovy-related task, including:
+
+- Writing or debugging Groovy classes in Grails domain, controllers, services, or taglibs.
+- Building or enhancing Gradle build scripts (build.gradle).
+- Creating DSLs for configuration, testing, or business rules.
+- Writing Spock specifications for unit and integration tests.
+- Migrating from older Groovy versions (2.x/3.x) to 4.0.
+- Performance optimization with static compilation.
+- Working with JSON/XML data, GORM criteria queries, or builders.
+
+## Groovy 4 Key Features
+
+### Concise Syntax
+```groovy
+// No semicolons required
+def name = "Grails"
+
+// Optional parentheses for method calls
+println "Hello World"
+list.each { println it }
+
+// Optional return keyword
+String greet(String name) {
+    "Hello, $name"  // Last expression is returned
+}
+```
+
+### GStrings (String Interpolation)
+```groovy
+def user = "Alice"
+def count = 42
+
+// Simple interpolation
+println "User: $user"
+
+// Expression interpolation
+println "Items: ${count * 2}"
+
+// Lazy GStrings (evaluated when accessed)
+def lazy = "Count is ${ -> counter }"
+
+// Multi-line strings
+def sql = """
+    SELECT * FROM users
+    WHERE name = '$user'
+    ORDER BY created_at
+"""
+```
+
+### Closures
+```groovy
+// Basic closure
+def greet = { name -> "Hello, $name" }
+println greet("World")
+
+// Implicit 'it' parameter
+def double = { it * 2 }
+println [1, 2, 3].collect(double)
+
+// Closure with delegate (for DSLs)
+def configure = {
+    name = "MyApp"
+    version = "1.0"
+}
+configure.delegate = new Config()
+configure.resolveStrategy = Closure.DELEGATE_FIRST
+configure()
+
+// Method references
+def upper = String.&toUpperCase
+println ["a", "b"].collect(upper)
+```
+
+### Safe Navigation and Elvis Operator
+```groovy
+// Safe navigation - returns null if any part is null
+def city = user?.address?.city
+
+// Elvis operator - default value if null
+def name = user?.name ?: "Anonymous"
+
+// Safe method calls
+def length = text?.length() ?: 0
+
+// Combine with collections
+def firstTitle = books?.first()?.title ?: "No books"
+```
+
+### Spread Operator
+```groovy
+// Spread operator for collections
+def names = users*.name  // Same as users.collect { it.name }
+
+// Spread for method arguments
+def args = [1, 2, 3]
+someMethod(*args)
+
+// Spread in list literals
+def combined = [*list1, *list2]
+```
+
+### Collection Literals and Methods
+```groovy
+// List literal
+def list = [1, 2, 3, 4, 5]
+
+// Map literal
+def map = [name: "Grails", version: 7]
+
+// Range
+def range = 1..10
+def exclusive = 1..<10
+
+// Powerful collection methods
+list.find { it > 3 }           // First match: 4
+list.findAll { it > 3 }        // All matches: [4, 5]
+list.any { it > 3 }            // true
+list.every { it > 0 }          // true
+list.groupBy { it % 2 }        // [0:[2,4], 1:[1,3,5]]
+list.collectEntries { [it, it * 2] }  // [1:2, 2:4, ...]
+
+// Sorting
+list.sort { a, b -> b <=> a }  // Descending
+list.sort { -it }              // Descending (numeric)
+```
+
+### Groovy Truth
+```groovy
+// Falsy values: null, empty string, empty collection, 0, false
+if (list) { }      // True if not null and not empty
+if (string) { }    // True if not null and not blank
+if (number) { }    // True if not 0
+
+// Useful in conditionals
+def items = getItems() ?: []  // Default to empty list
+```
+
+### Records (Incubating)
+```groovy
+// Immutable data class
+record Point(int x, int y) {}
+
+def p = new Point(10, 20)
+println p.x()  // 10
+println p      // Point[x=10, y=20]
+```
+
+### Traits
+```groovy
+trait Auditable {
+    Date dateCreated
+    Date lastUpdated
+
+    def beforeInsert() {
+        dateCreated = new Date()
+    }
+
+    def beforeUpdate() {
+        lastUpdated = new Date()
+    }
+}
+
+class Book implements Auditable {
+    String title
+}
+```
+
+## Static Compilation
+
+### @CompileStatic
+Enables static type checking and compilation for better performance:
+```groovy
+import groovy.transform.CompileStatic
+
+@CompileStatic
+class BookService {
+    List<Book> findByAuthor(String author) {
+        Book.findAllByAuthor(author)
+    }
+
+    int calculateTotal(List<Integer> prices) {
+        prices.sum() as int
+    }
+}
+```
+
+### @TypeChecked
+Type checking without full static compilation:
+```groovy
+import groovy.transform.TypeChecked
+
+@TypeChecked
+void process(String input) {
+    println input.toUppercase()  // Compile error: method not found
+}
+```
+
+### @GrailsCompileStatic
+Grails-aware static compilation that understands dynamic finders:
+```groovy
+import grails.compiler.GrailsCompileStatic
+
+@GrailsCompileStatic
+class BookController {
+    def show(Long id) {
+        respond Book.get(id)  // Works with static compilation
+    }
+}
+```
+
+## AST Transformations
+
+### @Immutable
+```groovy
+import groovy.transform.Immutable
+
+@Immutable
+class Person {
+    String name
+    int age
+}
+
+def p = new Person(name: "Alice", age: 30)
+// p.name = "Bob"  // Error: read-only
+```
+
+### @Builder
+```groovy
+import groovy.transform.builder.Builder
+
+@Builder
+class Email {
+    String to
+    String subject
+    String body
+}
+
+def email = Email.builder()
+    .to("user@example.com")
+    .subject("Hello")
+    .body("Content here")
+    .build()
+```
+
+### @Delegate
+```groovy
+import groovy.transform.Delegate
+
+class EnhancedList<T> {
+    @Delegate List<T> list = []
+
+    T secondLast() {
+        list[-2]
+    }
+}
+
+def enhanced = new EnhancedList<String>()
+enhanced.add("a")  // Delegated to list
+enhanced.add("b")
+println enhanced.secondLast()  // "a"
+```
+
+### @Singleton
+```groovy
+import groovy.transform.Singleton
+
+@Singleton
+class ConfigManager {
+    Map settings = [:]
+}
+
+ConfigManager.instance.settings['key'] = 'value'
+```
+
+### @Memoized
+```groovy
+import groovy.transform.Memoized
+
+class Calculator {
+    @Memoized
+    BigInteger fibonacci(int n) {
+        if (n <= 1) return n
+        fibonacci(n - 1) + fibonacci(n - 2)
+    }
+}
+```
+
+### @Log Variants
+```groovy
+import groovy.util.logging.Slf4j
+
+@Slf4j
+class BookService {
+    def save(Book book) {
+        log.info "Saving book: ${book.title}"
+        // ...
+    }
+}
+```
+
+## Builders and DSLs
+
+### JsonBuilder
+```groovy
+import groovy.json.JsonBuilder
+
+def builder = new JsonBuilder()
+builder {
+    name "Grails"
+    version 7
+    features(["GORM", "GSP", "Plugins"])
+    metadata {
+        author "Grails Team"
+        license "Apache 2.0"
+    }
+}
+println builder.toPrettyString()
+```
+
+### JsonSlurper
+```groovy
+import groovy.json.JsonSlurper
+
+def json = '{"name": "Grails", "version": 7}'
+def data = new JsonSlurper().parseText(json)
+println data.name  // Grails
+```
+
+### MarkupBuilder (XML/HTML)
+```groovy
+import groovy.xml.MarkupBuilder
+
+def writer = new StringWriter()
+def xml = new MarkupBuilder(writer)
+xml.books {
+    book(id: 1) {
+        title "Grails Guide"
+        author "Team"
+    }
+}
+println writer.toString()
+```
+
+### Custom DSL Example
+```groovy
+class HtmlBuilder {
+    def html(@DelegatesTo(HtmlBuilder) Closure c) {
+        c.delegate = this
+        c.resolveStrategy = Closure.DELEGATE_FIRST
+        "<html>${c()}</html>"
+    }
+
+    def body(String content) {
+        "<body>$content</body>"
+    }
+}
+
+def builder = new HtmlBuilder()
+def result = builder.html {
+    body "Hello World"
+}
+```
+
+## Testing with Spock
+
+### Basic Specification
+```groovy
+class BookServiceSpec extends Specification {
+
+    def service = new BookService()
+
+    def "should find book by title"() {
+        given: "a book title"
+        def title = "Grails Guide"
+
+        when: "searching for the book"
+        def book = service.findByTitle(title)
+
+        then: "the book is found"
+        book != null
+        book.title == title
+    }
+}
+```
+
+### Data-Driven Tests
+```groovy
+@Unroll
+def "max of #a and #b is #expected"() {
+    expect:
+    Math.max(a, b) == expected
+
+    where:
+    a | b || expected
+    1 | 3 || 3
+    7 | 4 || 7
+    0 | 0 || 0
+}
+```
+
+### Mocking
+```groovy
+def "should call repository when saving"() {
+    given:
+    def repo = Mock(BookRepository)
+    def service = new BookService(repo)
+    def book = new Book(title: "Test")
+
+    when:
+    service.save(book)
+
+    then:
+    1 * repo.save(book)
+}
+```
+
+### Exception Testing
+```groovy
+def "should throw exception for invalid input"() {
+    when:
+    service.process(null)
+
+    then:
+    thrown(IllegalArgumentException)
+}
+```
+
+## Groovy SQL
+```groovy
+import groovy.sql.Sql
+
+def sql = Sql.newInstance(dataSource)
+
+// Query
+sql.eachRow("SELECT * FROM books WHERE author = ?", [authorName]) { row ->
+    println "${row.title} by ${row.author}"
+}
+
+// Insert
+sql.execute("INSERT INTO books (title, author) VALUES (?, ?)",
+            [title, author])
+
+// With GString (auto-parameterized)
+sql.execute("INSERT INTO books (title) VALUES ($title)")
+```
+
+## Best Practices
+
+### Performance
+- Use `@CompileStatic` or `@GrailsCompileStatic` in production code.
+- Avoid runtime metaprogramming in hot paths.
+- Prefer `collect`/`findAll` over manual loops.
+- Use `@Memoized` for expensive computations.
+
+### Code Style
+- Use safe navigation (`?.`) instead of null checks.
+- Prefer Elvis operator (`?:`) for default values.
+- Use GStrings for string interpolation.
+- Prefer traits over inheritance for mixins.
+- Use explicit types for public APIs, `def` for local variables.
+
+### Grails-Specific
+- Use `@GrailsCompileStatic` instead of `@CompileStatic` in Grails classes.
+- Leverage GORM dynamic finders and where queries.
+- Use command objects for form binding and validation.
+- Follow convention over configuration.
+
+## Common Pitfalls
+
+- **`==` vs `is`**: `==` calls `equals()`, use `is` for identity comparison.
+- **GString in maps**: Use `"key".toString()` as map keys if needed.

Review Comment:
   Example should use GString, for example `"key$idx".toString()`



##########
.agents/skills/groovy-developer/SKILL.md:
##########
@@ -0,0 +1,520 @@
+<!--
+SPDX-License-Identifier: Apache-2.0
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+---
+name: groovy-developer
+description: Expert guide for Groovy 4 development, covering concise syntax, closures, DSLs, metaprogramming, static compilation, and integration with Java 17 and Grails
+license: Apache-2.0
+compatibility: opencode, claude, grok, gemini, copilot, cursor, windsurf
+metadata:
+  audience: developers
+  languages: groovy, java
+  versions: 4.0
+  paradigms: dynamic, static, functional, object-oriented, DSL-oriented
+---
+
+## What I Do
+
+- Provide deep expertise in Groovy 4.0, including core language features: syntax, closures, traits, GStrings, operators, and Groovy Truth.
+- Guide metaprogramming techniques: runtime (categories, ExpandoMetaClass, extension modules) and compile-time (AST transformations like @Immutable, @Builder, @Delegate, @Singleton, @Log, @Memoized).
+- Assist with DSL creation and usage (MarkupBuilder, JsonBuilder, builders for configuration).
+- Support testing with Spock Framework (BDD, data-driven tests, mocking) and built-in power assertions.
+- Help integrate Groovy with Java 17: joint compilation, Gradle builds, Grails, and Spring Boot.
+- Cover data handling: JSON/XML parsing and building, Groovy SQL, collection processing.
+- Advise on performance: @CompileStatic, @TypeChecked, @GrailsCompileStatic for optimal execution.
+
+## When to Use Me
+
+Activate this skill for any Groovy-related task, including:
+
+- Writing or debugging Groovy classes in Grails domain, controllers, services, or taglibs.
+- Building or enhancing Gradle build scripts (build.gradle).
+- Creating DSLs for configuration, testing, or business rules.
+- Writing Spock specifications for unit and integration tests.
+- Migrating from older Groovy versions (2.x/3.x) to 4.0.
+- Performance optimization with static compilation.
+- Working with JSON/XML data, GORM criteria queries, or builders.
+
+## Groovy 4 Key Features
+
+### Concise Syntax
+```groovy
+// No semicolons required
+def name = "Grails"
+
+// Optional parentheses for method calls
+println "Hello World"
+list.each { println it }
+
+// Optional return keyword
+String greet(String name) {
+    "Hello, $name"  // Last expression is returned
+}
+```
+
+### GStrings (String Interpolation)
+```groovy
+def user = "Alice"
+def count = 42
+
+// Simple interpolation
+println "User: $user"
+
+// Expression interpolation
+println "Items: ${count * 2}"
+
+// Lazy GStrings (evaluated when accessed)
+def lazy = "Count is ${ -> counter }"
+
+// Multi-line strings
+def sql = """
+    SELECT * FROM users
+    WHERE name = '$user'
+    ORDER BY created_at
+"""
+```
+
+### Closures
+```groovy
+// Basic closure
+def greet = { name -> "Hello, $name" }
+println greet("World")
+
+// Implicit 'it' parameter
+def double = { it * 2 }
+println [1, 2, 3].collect(double)
+
+// Closure with delegate (for DSLs)
+def configure = {
+    name = "MyApp"
+    version = "1.0"
+}
+configure.delegate = new Config()
+configure.resolveStrategy = Closure.DELEGATE_FIRST
+configure()
+
+// Method references
+def upper = String.&toUpperCase
+println ["a", "b"].collect(upper)
+```
+
+### Safe Navigation and Elvis Operator
+```groovy
+// Safe navigation - returns null if any part is null
+def city = user?.address?.city
+
+// Elvis operator - default value if null
+def name = user?.name ?: "Anonymous"
+
+// Safe method calls
+def length = text?.length() ?: 0
+
+// Combine with collections
+def firstTitle = books?.first()?.title ?: "No books"
+```
+
+### Spread Operator
+```groovy
+// Spread operator for collections
+def names = users*.name  // Same as users.collect { it.name }
+
+// Spread for method arguments
+def args = [1, 2, 3]
+someMethod(*args)
+
+// Spread in list literals
+def combined = [*list1, *list2]
+```
+
+### Collection Literals and Methods
+```groovy
+// List literal
+def list = [1, 2, 3, 4, 5]
+
+// Map literal
+def map = [name: "Grails", version: 7]
+
+// Range
+def range = 1..10
+def exclusive = 1..<10
+
+// Powerful collection methods
+list.find { it > 3 }           // First match: 4
+list.findAll { it > 3 }        // All matches: [4, 5]
+list.any { it > 3 }            // true
+list.every { it > 0 }          // true
+list.groupBy { it % 2 }        // [0:[2,4], 1:[1,3,5]]
+list.collectEntries { [it, it * 2] }  // [1:2, 2:4, ...]
+
+// Sorting
+list.sort { a, b -> b <=> a }  // Descending
+list.sort { -it }              // Descending (numeric)
+```
+
+### Groovy Truth
+```groovy
+// Falsy values: null, empty string, empty collection, 0, false
+if (list) { }      // True if not null and not empty
+if (string) { }    // True if not null and not blank
+if (number) { }    // True if not 0
+
+// Useful in conditionals
+def items = getItems() ?: []  // Default to empty list
+```
+
+### Records (Incubating)
+```groovy
+// Immutable data class
+record Point(int x, int y) {}
+
+def p = new Point(10, 20)
+println p.x()  // 10
+println p      // Point[x=10, y=20]
+```
+
+### Traits
+```groovy
+trait Auditable {
+    Date dateCreated
+    Date lastUpdated
+
+    def beforeInsert() {
+        dateCreated = new Date()
+    }
+
+    def beforeUpdate() {
+        lastUpdated = new Date()
+    }
+}
+
+class Book implements Auditable {
+    String title
+}
+```
+
+## Static Compilation
+
+### @CompileStatic
+Enables static type checking and compilation for better performance:
+```groovy
+import groovy.transform.CompileStatic
+
+@CompileStatic
+class BookService {
+    List<Book> findByAuthor(String author) {
+        Book.findAllByAuthor(author)
+    }
+
+    int calculateTotal(List<Integer> prices) {
+        prices.sum() as int
+    }
+}
+```
+
+### @TypeChecked
+Type checking without full static compilation:
+```groovy
+import groovy.transform.TypeChecked
+
+@TypeChecked
+void process(String input) {
+    println input.toUppercase()  // Compile error: method not found
+}
+```
+
+### @GrailsCompileStatic
+Grails-aware static compilation that understands dynamic finders:
+```groovy
+import grails.compiler.GrailsCompileStatic
+
+@GrailsCompileStatic
+class BookController {
+    def show(Long id) {
+        respond Book.get(id)  // Works with static compilation
+    }
+}
+```
+
+## AST Transformations
+
+### @Immutable
+```groovy
+import groovy.transform.Immutable
+
+@Immutable
+class Person {
+    String name
+    int age
+}
+
+def p = new Person(name: "Alice", age: 30)
+// p.name = "Bob"  // Error: read-only
+```
+
+### @Builder
+```groovy
+import groovy.transform.builder.Builder
+
+@Builder
+class Email {
+    String to
+    String subject
+    String body
+}
+
+def email = Email.builder()
+    .to("user@example.com")
+    .subject("Hello")
+    .body("Content here")
+    .build()
+```
+
+### @Delegate
+```groovy
+import groovy.transform.Delegate
+
+class EnhancedList<T> {
+    @Delegate List<T> list = []
+
+    T secondLast() {
+        list[-2]
+    }
+}
+
+def enhanced = new EnhancedList<String>()
+enhanced.add("a")  // Delegated to list
+enhanced.add("b")
+println enhanced.secondLast()  // "a"
+```
+
+### @Singleton
+```groovy
+import groovy.transform.Singleton
+
+@Singleton
+class ConfigManager {
+    Map settings = [:]
+}
+
+ConfigManager.instance.settings['key'] = 'value'
+```
+
+### @Memoized
+```groovy
+import groovy.transform.Memoized
+
+class Calculator {
+    @Memoized
+    BigInteger fibonacci(int n) {
+        if (n <= 1) return n
+        fibonacci(n - 1) + fibonacci(n - 2)
+    }
+}
+```
+
+### @Log Variants
+```groovy
+import groovy.util.logging.Slf4j
+
+@Slf4j
+class BookService {
+    def save(Book book) {
+        log.info "Saving book: ${book.title}"
+        // ...
+    }
+}
+```
+
+## Builders and DSLs
+
+### JsonBuilder
+```groovy
+import groovy.json.JsonBuilder
+
+def builder = new JsonBuilder()
+builder {
+    name "Grails"
+    version 7
+    features(["GORM", "GSP", "Plugins"])
+    metadata {
+        author "Grails Team"
+        license "Apache 2.0"
+    }
+}
+println builder.toPrettyString()
+```
+
+### JsonSlurper
+```groovy
+import groovy.json.JsonSlurper
+
+def json = '{"name": "Grails", "version": 7}'
+def data = new JsonSlurper().parseText(json)
+println data.name  // Grails
+```
+
+### MarkupBuilder (XML/HTML)
+```groovy
+import groovy.xml.MarkupBuilder
+
+def writer = new StringWriter()
+def xml = new MarkupBuilder(writer)
+xml.books {
+    book(id: 1) {
+        title "Grails Guide"
+        author "Team"
+    }
+}
+println writer.toString()
+```
+
+### Custom DSL Example
+```groovy
+class HtmlBuilder {
+    def html(@DelegatesTo(HtmlBuilder) Closure c) {
+        c.delegate = this
+        c.resolveStrategy = Closure.DELEGATE_FIRST
+        "<html>${c()}</html>"
+    }
+
+    def body(String content) {
+        "<body>$content</body>"
+    }
+}
+
+def builder = new HtmlBuilder()
+def result = builder.html {
+    body "Hello World"
+}
+```
+
+## Testing with Spock
+
+### Basic Specification
+```groovy
+class BookServiceSpec extends Specification {
+
+    def service = new BookService()
+
+    def "should find book by title"() {
+        given: "a book title"
+        def title = "Grails Guide"
+
+        when: "searching for the book"
+        def book = service.findByTitle(title)
+
+        then: "the book is found"
+        book != null
+        book.title == title
+    }
+}
+```
+
+### Data-Driven Tests
+```groovy
+@Unroll
+def "max of #a and #b is #expected"() {
+    expect:
+    Math.max(a, b) == expected
+
+    where:
+    a | b || expected
+    1 | 3 || 3
+    7 | 4 || 7
+    0 | 0 || 0
+}
+```
+
+### Mocking
+```groovy
+def "should call repository when saving"() {
+    given:
+    def repo = Mock(BookRepository)
+    def service = new BookService(repo)
+    def book = new Book(title: "Test")
+
+    when:
+    service.save(book)
+
+    then:
+    1 * repo.save(book)
+}
+```
+
+### Exception Testing
+```groovy
+def "should throw exception for invalid input"() {
+    when:
+    service.process(null)
+
+    then:
+    thrown(IllegalArgumentException)
+}
+```
+
+## Groovy SQL
+```groovy
+import groovy.sql.Sql
+
+def sql = Sql.newInstance(dataSource)
+
+// Query
+sql.eachRow("SELECT * FROM books WHERE author = ?", [authorName]) { row ->
+    println "${row.title} by ${row.author}"
+}
+
+// Insert
+sql.execute("INSERT INTO books (title, author) VALUES (?, ?)",
+            [title, author])
+
+// With GString (auto-parameterized)
+sql.execute("INSERT INTO books (title) VALUES ($title)")
+```
+
+## Best Practices
+
+### Performance
+- Use `@CompileStatic` or `@GrailsCompileStatic` in production code.
+- Avoid runtime metaprogramming in hot paths.
+- Prefer `collect`/`findAll` over manual loops.
+- Use `@Memoized` for expensive computations.
+
+### Code Style
+- Use safe navigation (`?.`) instead of null checks.
+- Prefer Elvis operator (`?:`) for default values.
+- Use GStrings for string interpolation.
+- Prefer traits over inheritance for mixins.
+- Use explicit types for public APIs, `def` for local variables.
+
+### Grails-Specific
+- Use `@GrailsCompileStatic` instead of `@CompileStatic` in Grails classes.
+- Leverage GORM dynamic finders and where queries.
+- Use command objects for form binding and validation.
+- Follow convention over configuration.
+
+## Common Pitfalls
+
+- **`==` vs `is`**: `==` calls `equals()`, use `is` for identity comparison.
+- **GString in maps**: Use `"key".toString()` as map keys if needed.
+- **Closure scope**: Understand `delegate`, `owner`, and `this` in closures.
+- **Optional parentheses**: Can cause ambiguity; use parentheses when unclear.

Review Comment:
   ⭐ (I would say, always use parentheses, much clearer and easier to read)



-- 
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

To unsubscribe, e-mail: notifications-unsubscribe@grails.apache.org

For queries about this service, please contact Infrastructure at:
users@infra.apache.org

Re: [PR] Add AGENTS.md and AI coding assistant support [grails-core]

["jamesfredley (via GitHub)" <gi...@apache.org>]

jamesfredley commented on PR #15340:
URL: https://github.com/apache/grails-core/pull/15340#issuecomment-3825200028

   @matrei I pushed a couple commits with requested changes.


-- 
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

To unsubscribe, e-mail: notifications-unsubscribe@grails.apache.org

For queries about this service, please contact Infrastructure at:
users@infra.apache.org

Re: [PR] Add AGENTS.md and AI coding assistant support [grails-core]

["jamesfredley (via GitHub)" <gi...@apache.org>]

jamesfredley commented on code in PR #15340:
URL: https://github.com/apache/grails-core/pull/15340#discussion_r2738725110


##########
.cursorrules:
##########
@@ -0,0 +1 @@
+AGENTS.md

Review Comment:
   CLAUDE.md is required for Claude Code, not sure on the others.  The main agents are starting to move towards agents.md, but are not all there yet.  
   
   



-- 
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

To unsubscribe, e-mail: notifications-unsubscribe@grails.apache.org

For queries about this service, please contact Infrastructure at:
users@infra.apache.org

Re: [PR] docs: create AGENTS.md for AI LLM crawlers [grails-core]

["jamesfredley (via GitHub)" <gi...@apache.org>]

jamesfredley commented on PR #15340:
URL: https://github.com/apache/grails-core/pull/15340#issuecomment-3797099519

   [AGENTS.md](https://github.com/user-attachments/files/24848369/AGENTS.md) - some items we might want to include
   


-- 
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

To unsubscribe, e-mail: notifications-unsubscribe@grails.apache.org

For queries about this service, please contact Infrastructure at:
users@infra.apache.org

Re: [PR] Add AGENTS.md and AI coding assistant support [grails-core]

["jdaugherty (via GitHub)" <gi...@apache.org>]

jdaugherty commented on PR #15340:
URL: https://github.com/apache/grails-core/pull/15340#issuecomment-3814009646

   @sanjana2505006 Let's let @jamesfredley implement the feedback in this PR and we'll merge once @matrei also reviews.


-- 
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

To unsubscribe, e-mail: notifications-unsubscribe@grails.apache.org

For queries about this service, please contact Infrastructure at:
users@infra.apache.org

Re: [PR] docs: create AGENTS.md for AI LLM crawlers [grails-core]

["jamesfredley (via GitHub)" <gi...@apache.org>]

jamesfredley commented on PR #15340:
URL: https://github.com/apache/grails-core/pull/15340#issuecomment-3812814543

   @sanjana2505006 I am going to push some additional changes to this PR based on https://github.com/apache/superset/ and the conversation in our weekly Grails planning meeting.  
   


-- 
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

To unsubscribe, e-mail: notifications-unsubscribe@grails.apache.org

For queries about this service, please contact Infrastructure at:
users@infra.apache.org

Re: [PR] Add AGENTS.md and AI coding assistant support [grails-core]

["jamesfredley (via GitHub)" <gi...@apache.org>]

jamesfredley commented on code in PR #15340:
URL: https://github.com/apache/grails-core/pull/15340#discussion_r2738693881


##########
.agents/skills/grails-developer/SKILL.md:
##########
@@ -0,0 +1,883 @@
+<!--
+SPDX-License-Identifier: Apache-2.0
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+---
+name: grails-developer
+description: Comprehensive guide for Grails 7 development, covering web applications, REST APIs, GORM, controllers, services, views, plugins, and testing with Spock and Geb
+license: Apache-2.0
+compatibility: opencode, claude, grok, gemini, copilot, cursor, windsurf
+metadata:
+  audience: developers
+  frameworks: grails
+  versions: 7
+---
+
+## What I Do
+
+- Provide detailed guidance for building Grails 7 web applications and REST APIs.
+- Assist with GORM for data modeling, controllers for request handling, services for business logic, and views (GSP, JSON, Markup).
+- Support testing with Spock 2.3 (unit/integration tests) and Geb for browser automation.
+- Guide plugin usage and development, security implementation, and deployment strategies.
+- Help with configuration, internationalization, async programming, and performance optimization.
+
+## When to Use Me
+
+Activate this skill when developing with Grails 7, including:
+
+- Building CRUD applications, RESTful APIs, or full-stack web applications.
+- Working with GORM domain classes, constraints, and relationships.
+- Creating controllers, services, interceptors, or tag libraries.
+- Writing Spock specifications or Geb functional tests.
+- Configuring plugins, security, caching, or database migrations.
+- Deploying Grails applications to containers or cloud platforms.
+
+## Technology Stack
+
+Grails 7 is built on:
+- **Spring Boot**: 3.5.x
+- **Spring Framework**: 6.2.x
+- **Groovy**: 4.0.x
+- **Gradle**: 8.14.x
+- **Spock**: 2.3-groovy-4.0
+- **Jakarta EE**: 10 (migrated from javax.*)
+- **Micronaut**: Optional via `grails-micronaut` plugin
+
+## Project Structure
+
+```
+myapp/
+├── grails-app/
+│   ├── conf/                 # Configuration
+│   │   ├── application.yml   # Main config
+│   │   ├── logback.xml       # Logging config
+│   │   └── spring/           # Spring bean definitions
+│   ├── controllers/          # Request handlers
+│   ├── domain/               # GORM domain classes
+│   ├── i18n/                 # Message bundles
+│   ├── init/                 # Bootstrap classes
+│   ├── services/             # Business logic
+│   ├── taglib/               # Custom GSP tags
+│   ├── utils/                # Utility classes
+│   └── views/                # GSP templates
+├── src/
+│   ├── main/groovy/          # Additional Groovy classes
+│   ├── main/java/            # Java classes
+│   └── test/groovy/          # Test specifications
+├── build.gradle              # Build configuration
+└── gradle.properties         # Project properties
+```
+
+## Domain Classes (GORM)
+
+### Basic Domain Class
+```groovy
+class Book {
+    String title
+    String author
+    Date datePublished
+    Integer pages
+
+    static constraints = {
+        title blank: false, maxSize: 255
+        author blank: false
+        datePublished nullable: true
+        pages min: 1, nullable: true
+    }
+
+    static mapping = {
+        table 'books'
+        title column: 'book_title'
+        datePublished type: 'date'
+    }
+}
+```
+
+### Relationships
+```groovy
+class Author {
+    String name
+
+    static hasMany = [books: Book]
+
+    static mapping = {
+        books cascade: 'all-delete-orphan'
+    }
+}
+
+class Book {
+    String title
+
+    static belongsTo = [author: Author]
+}
+
+// Many-to-Many
+class Book {
+    static hasMany = [categories: Category]
+    static belongsTo = Category
+}
+
+class Category {
+    String name
+    static hasMany = [books: Book]
+}
+```
+
+### GORM Queries
+```groovy
+// Dynamic finders
+Book.findByTitle("Grails Guide")
+Book.findAllByAuthorLike("%Smith%")
+Book.findByTitleAndAuthor("Guide", "Smith")
+Book.countByPagesGreaterThan(100)
+
+// Where queries
+Book.where {
+    title =~ "%Grails%" && pages > 100
+}.list()
+
+// Criteria queries
+Book.withCriteria {
+    like('title', '%Grails%')
+    gt('pages', 100)
+    order('datePublished', 'desc')
+    maxResults(10)
+}
+
+// HQL queries
+Book.executeQuery(
+    "from Book b where b.author.name = :name",
+    [name: 'Smith']
+)
+
+// Detached criteria (reusable)
+def criteria = Book.where {
+    pages > 100
+}
+criteria.list()
+criteria.count()
+```
+
+### Transactions
+```groovy
+// In services (default transactional)
+@Transactional
+class BookService {
+    def saveBook(Book book) {
+        book.save(failOnError: true)
+    }
+}
+
+// Manual transaction control
+Book.withTransaction { status ->
+    def book = new Book(title: "Test")
+    book.save()
+    if (someCondition) {
+        status.setRollbackOnly()
+    }
+}
+```
+
+## Controllers
+
+### Basic Controller
+```groovy
+class BookController {
+
+    BookService bookService
+
+    static allowedMethods = [save: 'POST', update: 'PUT', delete: 'DELETE']
+
+    def index() {
+        respond Book.list(), model: [bookCount: Book.count()]
+    }
+
+    def show(Long id) {
+        respond Book.get(id)
+    }
+
+    def create() {
+        respond new Book(params)
+    }
+
+    def save(Book book) {
+        if (book.hasErrors()) {
+            respond book.errors, view: 'create'
+            return
+        }
+        bookService.save(book)
+        redirect action: 'show', id: book.id
+    }
+
+    def edit(Long id) {
+        respond Book.get(id)
+    }
+
+    def update(Book book) {
+        if (book.hasErrors()) {
+            respond book.errors, view: 'edit'
+            return
+        }
+        bookService.save(book)
+        redirect action: 'show', id: book.id
+    }
+
+    def delete(Long id) {
+        bookService.delete(id)
+        redirect action: 'index'
+    }
+}
+```
+
+### REST Controller
+```groovy
+import grails.rest.RestfulController
+
+class BookController extends RestfulController<Book> {
+
+    static responseFormats = ['json', 'xml']
+
+    BookController() {
+        super(Book)
+    }
+
+    // Override to customize
+    @Override
+    protected Book queryForResource(Serializable id) {
+        Book.where { id == id && active == true }.find()
+    }
+}
+```
+
+### Command Objects
+```groovy
+class BookCommand implements Validateable {
+    String title
+    String author
+    Integer pages
+
+    static constraints = {
+        title blank: false
+        author blank: false
+        pages min: 1, nullable: true
+    }
+}
+
+class BookController {
+    def save(BookCommand cmd) {
+        if (cmd.hasErrors()) {
+            respond cmd.errors
+            return
+        }
+        // Process valid command
+    }
+}
+```
+
+### Content Negotiation
+```groovy
+class BookController {
+    def show(Long id) {
+        def book = Book.get(id)
+        respond book  // Auto-negotiates based on Accept header
+    }
+}
+
+// Or explicit
+def show(Long id) {
+    def book = Book.get(id)
+    withFormat {
+        html { render view: 'show', model: [book: book] }
+        json { render book as JSON }
+        xml { render book as XML }
+    }
+}
+```
+
+## Services
+
+### Basic Service
+```groovy
+import grails.gorm.transactions.Transactional
+
+@Transactional
+class BookService {
+
+    def findByTitle(String title) {
+        Book.findByTitle(title)
+    }
+
+    def save(Book book) {
+        book.save(failOnError: true)
+    }
+
+    @Transactional(readOnly = true)
+    def list(Map params) {
+        Book.list(params)
+    }
+
+    def delete(Long id) {
+        Book.get(id)?.delete()
+    }
+}
+```
+
+### Service with Events
+```groovy
+import grails.events.annotation.Publisher
+import grails.events.annotation.Subscriber
+
+class BookService {
+
+    @Publisher
+    def save(Book book) {
+        book.save()
+        // Automatically publishes 'book.saved' event
+    }
+}
+
+class NotificationService {
+
+    @Subscriber('book.saved')
+    def onBookSaved(Book book) {
+        // Handle event
+        log.info "Book saved: ${book.title}"
+    }
+}
+```
+
+### Async Service
+```groovy
+import grails.async.Promise
+import static grails.async.Promises.*
+
+class BookService {
+
+    Promise<Book> findAsync(Long id) {
+        task {
+            Book.get(id)
+        }
+    }
+
+    def processBooks() {
+        def p1 = task { Book.findAllByActive(true) }
+        def p2 = task { Author.list() }
+
+        waitAll(p1, p2)
+        // Both complete
+    }
+}
+```
+
+## Views
+
+### GSP (Groovy Server Pages)
+```html
+<!-- grails-app/views/book/list.gsp -->
+<!DOCTYPE html>
+<html>
+<head>
+    <title>Books</title>
+    <asset:stylesheet src="application.css"/>
+</head>
+<body>
+    <h1>Books (${bookCount})</h1>
+
+    <g:each in="${bookList}" var="book">
+        <div class="book">
+            <h2>${book.title}</h2>
+            <p>By ${book.author}</p>
+            <g:link action="show" id="${book.id}">View</g:link>
+        </div>
+    </g:each>
+
+    <g:if test="${bookList.empty}">
+        <p>No books found.</p>
+    </g:if>
+
+    <g:paginate total="${bookCount}"/>
+
+    <asset:javascript src="application.js"/>
+</body>
+</html>
+```
+
+### Common GSP Tags
+```html
+<!-- Links -->
+<g:link controller="book" action="show" id="${book.id}">View</g:link>
+<g:createLink action="list"/>
+
+<!-- Forms -->
+<g:form action="save">
+    <g:textField name="title" value="${book?.title}"/>
+    <g:textArea name="description" value="${book?.description}"/>
+    <g:select name="category" from="${categories}" optionKey="id" optionValue="name"/>
+    <g:checkBox name="active" value="${book?.active}"/>
+    <g:submitButton name="submit" value="Save"/>
+</g:form>
+
+<!-- Conditionals -->
+<g:if test="${condition}">...</g:if>
+<g:elseif test="${other}">...</g:elseif>
+<g:else>...</g:else>
+
+<!-- Iteration -->
+<g:each in="${items}" var="item" status="i">
+    ${i}: ${item.name}
+</g:each>
+
+<!-- Rendering -->
+<g:render template="bookRow" model="[book: book]"/>
+<g:render template="bookRow" collection="${books}" var="book"/>
+
+<!-- Security (with Spring Security plugin) -->
+<sec:ifLoggedIn>Welcome, ${sec.username()}</sec:ifLoggedIn>
+<sec:ifNotLoggedIn><g:link controller="login">Login</g:link></sec:ifNotLoggedIn>
+```
+
+### JSON Views
+```groovy
+// grails-app/views/book/show.gson
+import myapp.Book
+
+model {
+    Book book
+}
+
+json {
+    id book.id
+    title book.title
+    author book.author
+    datePublished book.datePublished?.format('yyyy-MM-dd')
+    _links {
+        self {
+            href "/books/${book.id}"
+        }
+    }
+}
+```
+
+### Layouts
+```html
+<!-- grails-app/views/layouts/main.gsp -->
+<!DOCTYPE html>
+<html>
+<head>
+    <title><g:layoutTitle default="My App"/></title>
+    <asset:stylesheet src="application.css"/>
+    <g:layoutHead/>
+</head>
+<body>
+    <nav><!-- Navigation --></nav>
+    <main>
+        <g:layoutBody/>
+    </main>
+    <footer><!-- Footer --></footer>
+    <asset:javascript src="application.js"/>
+</body>
+</html>
+
+<!-- Use in views -->
+<html>
+<head>
+    <meta name="layout" content="main"/>
+    <title>Books</title>
+</head>
+<body>
+    <!-- Page content -->
+</body>
+</html>
+```
+
+## Interceptors
+
+```groovy
+class AuthInterceptor {
+
+    AuthInterceptor() {
+        matchAll()
+            .excludes(controller: 'login')
+            .excludes(controller: 'error')
+    }
+
+    boolean before() {
+        if (!session.user) {
+            redirect(controller: 'login')
+            return false
+        }
+        true
+    }
+
+    boolean after() {
+        // After action executes
+        true
+    }
+
+    void afterView() {
+        // After view renders
+    }
+}
+```
+
+## Tag Libraries
+
+```groovy
+class BookTagLib {
+
+    static namespace = 'book'
+    static defaultEncodeAs = [taglib: 'html']
+
+    def formatTitle = { attrs, body ->
+        def title = attrs.title ?: body()
+        out << "<span class='book-title'>${title}</span>"
+    }
+
+    def ifHasBooks = { attrs, body ->
+        if (Book.count() > 0) {
+            out << body()
+        }
+    }
+}
+
+// Usage in GSP
+<book:formatTitle title="${book.title}"/>
+<book:ifHasBooks>
+    <p>We have books!</p>
+</book:ifHasBooks>
+```
+
+## Configuration
+
+### application.yml
+```yaml
+grails:
+    profile: web
+    codegen:
+        defaultPackage: myapp
+    gorm:
+        reactor:
+            events: false
+    mime:
+        types:
+            json: ['application/json', 'text/json']
+            xml: ['text/xml', 'application/xml']
+
+environments:
+    development:
+        dataSource:
+            dbCreate: create-drop
+            url: jdbc:h2:mem:devDb
+    test:
+        dataSource:
+            dbCreate: update
+            url: jdbc:h2:mem:testDb
+    production:
+        dataSource:
+            dbCreate: none
+            url: jdbc:postgresql://localhost/myapp
+            driverClassName: org.postgresql.Driver
+            dialect: org.hibernate.dialect.PostgreSQLDialect
+            properties:
+                jmxEnabled: true
+                initialSize: 5
+                maxActive: 50
+
+server:
+    port: 8080
+    servlet:
+        context-path: /myapp
+```
+
+### URL Mappings
+```groovy
+// grails-app/controllers/myapp/UrlMappings.groovy
+class UrlMappings {
+
+    static mappings = {
+        // Default
+        "/$controller/$action?/$id?(.$format)?" {
+            constraints {
+                // apply constraints here
+            }
+        }
+
+        // REST resources
+        "/api/books"(resources: 'book')
+
+        // Custom mappings
+        "/books/$id"(controller: 'book', action: 'show')
+        "/search"(controller: 'book', action: 'search')
+
+        // Named URL mappings
+        name bookShow: "/books/$id" {
+            controller = 'book'
+            action = 'show'
+        }
+
+        // Error pages
+        "500"(view: '/error')
+        "404"(view: '/notFound')
+    }
+}
+```
+
+## Testing with Spock
+
+### Unit Test - Controller
+```groovy
+import grails.testing.web.controllers.ControllerUnitTest
+import spock.lang.Specification
+
+class BookControllerSpec extends Specification
+        implements ControllerUnitTest<BookController> {
+
+    def setup() {
+        controller.bookService = Mock(BookService)
+    }
+
+    void "index returns list of books"() {
+        given:
+        def books = [new Book(title: "Test")]
+        controller.bookService.list(_) >> books
+
+        when:
+        controller.index()
+
+        then:
+        model.bookList == books
+        view == '/book/index'
+    }
+
+    void "show returns 404 for missing book"() {
+        when:
+        controller.show(999)
+
+        then:
+        response.status == 404
+    }
+}
+```
+
+### Unit Test - Service
+```groovy
+import grails.testing.services.ServiceUnitTest
+import spock.lang.Specification
+
+class BookServiceSpec extends Specification
+        implements ServiceUnitTest<BookService> {
+
+    void "save persists book"() {
+        given:
+        def book = new Book(title: "Test", author: "Author")
+
+        when:
+        def result = service.save(book)
+
+        then:
+        result.id != null
+        Book.count() == 1
+    }
+}
+```
+
+### Unit Test - Domain
+```groovy
+import grails.testing.gorm.DomainUnitTest
+import spock.lang.Specification
+
+class BookSpec extends Specification
+        implements DomainUnitTest<Book> {
+
+    void "title cannot be blank"() {
+        when:
+        domain.title = ""
+        domain.author = "Test"
+
+        then:
+        !domain.validate(['title'])
+        domain.errors['title'].code == 'blank'
+    }
+
+    void "valid book passes validation"() {
+        when:
+        domain.title = "Valid Title"
+        domain.author = "Author"
+
+        then:
+        domain.validate()
+    }
+}
+```
+
+### Integration Test
+```groovy
+import grails.testing.mixin.integration.Integration
+import grails.gorm.transactions.Rollback
+import spock.lang.Specification
+
+@Integration
+@Rollback
+class BookServiceIntegrationSpec extends Specification {
+
+    BookService bookService
+
+    void "save and retrieve book"() {
+        given:
+        def book = new Book(title: "Integration Test", author: "Tester")
+
+        when:
+        bookService.save(book)
+        def found = Book.findByTitle("Integration Test")
+
+        then:
+        found != null
+        found.author == "Tester"
+    }
+}
+```
+
+### Functional Test with Geb
+```groovy
+import geb.spock.GebSpec
+import grails.testing.mixin.integration.Integration
+
+@Integration
+class BookFunctionalSpec extends GebSpec {
+
+    void "can view book list"() {
+        when:
+        go '/book/index'
+
+        then:
+        title == 'Book List'
+        $('h1').text() == 'Books'
+    }
+
+    void "can create new book"() {
+        when:
+        go '/book/create'
+        $('form').title = 'New Book'
+        $('form').author = 'Test Author'
+        $('input[type=submit]').click()
+
+        then:
+        $('h1').text().contains('New Book')
+    }
+}
+```
+
+## Plugins
+
+### Common Plugins
+```groovy
+// build.gradle
+
+// Spring Security
+implementation 'org.grails.plugins:spring-security-core:6.0.0'
+
+// Database Migration (Liquibase)
+implementation 'org.grails.plugins:database-migration:4.2.0'
+
+// Caching
+implementation 'org.grails.plugins:cache:6.0.0'
+
+// Async support
+implementation 'org.grails.plugins:async:5.0.0'
+
+// Fields plugin for form rendering
+implementation 'org.grails.plugins:fields:5.0.0'
+
+// Asset Pipeline
+runtimeOnly 'org.grails.plugins:asset-pipeline:5.0.0'
+```
+
+### Spring Security Configuration
+```groovy
+// grails-app/conf/application.groovy
+grails.plugin.springsecurity.userLookup.userDomainClassName = 'myapp.User'
+grails.plugin.springsecurity.userLookup.authorityJoinClassName = 'myapp.UserRole'
+grails.plugin.springsecurity.authority.className = 'myapp.Role'
+
+grails.plugin.springsecurity.controllerAnnotations.staticRules = [
+    [pattern: '/',               access: ['permitAll']],
+    [pattern: '/error',          access: ['permitAll']],
+    [pattern: '/index',          access: ['permitAll']],
+    [pattern: '/admin/**',       access: ['ROLE_ADMIN']],
+    [pattern: '/api/**',         access: ['isAuthenticated()']],
+]
+```
+
+## Build Commands
+
+```bash
+# Run application
+./gradlew bootRun
+
+# Run tests
+./gradlew test                                    # All tests

Review Comment:
   I do not have a strong opinion. 



-- 
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

To unsubscribe, e-mail: notifications-unsubscribe@grails.apache.org

For queries about this service, please contact Infrastructure at:
users@infra.apache.org

Re: [PR] Add AGENTS.md and AI coding assistant support [grails-core]

["jamesfredley (via GitHub)" <gi...@apache.org>]

jamesfredley commented on PR #15340:
URL: https://github.com/apache/grails-core/pull/15340#issuecomment-3813195708

   We will likely want to copy this over to grails-spring-security, grails-cache and grails-quartz.


-- 
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

To unsubscribe, e-mail: notifications-unsubscribe@grails.apache.org

For queries about this service, please contact Infrastructure at:
users@infra.apache.org

Re: [PR] Add AGENTS.md and AI coding assistant support [grails-core]

["jamesfredley (via GitHub)" <gi...@apache.org>]

jamesfredley commented on code in PR #15340:
URL: https://github.com/apache/grails-core/pull/15340#discussion_r2738735343


##########
.github/copilot-instructions.md:
##########
@@ -0,0 +1 @@
+../AGENTS.md

Review Comment:
   Removed since that one should work without it.



-- 
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

To unsubscribe, e-mail: notifications-unsubscribe@grails.apache.org

For queries about this service, please contact Infrastructure at:
users@infra.apache.org

Re: [PR] Add AGENTS.md and AI coding assistant support [grails-core]

["jdaugherty (via GitHub)" <gi...@apache.org>]

jdaugherty merged PR #15340:
URL: https://github.com/apache/grails-core/pull/15340


-- 
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

To unsubscribe, e-mail: notifications-unsubscribe@grails.apache.org

For queries about this service, please contact Infrastructure at:
users@infra.apache.org

Re: [PR] docs: create AGENTS.md for AI LLM crawlers [grails-core]

["jamesfredley (via GitHub)" <gi...@apache.org>]

jamesfredley commented on PR #15340:
URL: https://github.com/apache/grails-core/pull/15340#issuecomment-3797098073

   [AGENTS.md](https://github.com/user-attachments/files/24848362/AGENTS.md) - some items for consideration
   


-- 
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

To unsubscribe, e-mail: notifications-unsubscribe@grails.apache.org

For queries about this service, please contact Infrastructure at:
users@infra.apache.org

Re: [PR] Add AGENTS.md and AI coding assistant support [grails-core]

["jdaugherty (via GitHub)" <gi...@apache.org>]

jdaugherty commented on code in PR #15340:
URL: https://github.com/apache/grails-core/pull/15340#discussion_r2738665036


##########
.github/copilot-instructions.md:
##########
@@ -0,0 +1 @@
+../AGENTS.md

Review Comment:
   I don't think this is necessary - copilot will find the closest AGENTS.md file in your repo per this: https://docs.github.com/en/copilot/how-tos/configure-custom-instructions/add-repository-instructions 



##########
.agents/skills/grails-developer/SKILL.md:
##########
@@ -0,0 +1,883 @@
+<!--
+SPDX-License-Identifier: Apache-2.0
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+---
+name: grails-developer
+description: Comprehensive guide for Grails 7 development, covering web applications, REST APIs, GORM, controllers, services, views, plugins, and testing with Spock and Geb
+license: Apache-2.0
+compatibility: opencode, claude, grok, gemini, copilot, cursor, windsurf
+metadata:
+  audience: developers
+  frameworks: grails
+  versions: 7
+---
+
+## What I Do
+
+- Provide detailed guidance for building Grails 7 web applications and REST APIs.
+- Assist with GORM for data modeling, controllers for request handling, services for business logic, and views (GSP, JSON, Markup).
+- Support testing with Spock 2.3 (unit/integration tests) and Geb for browser automation.
+- Guide plugin usage and development, security implementation, and deployment strategies.
+- Help with configuration, internationalization, async programming, and performance optimization.
+
+## When to Use Me
+
+Activate this skill when developing with Grails 7, including:
+
+- Building CRUD applications, RESTful APIs, or full-stack web applications.
+- Working with GORM domain classes, constraints, and relationships.
+- Creating controllers, services, interceptors, or tag libraries.
+- Writing Spock specifications or Geb functional tests.
+- Configuring plugins, security, caching, or database migrations.
+- Deploying Grails applications to containers or cloud platforms.
+
+## Technology Stack
+
+Grails 7 is built on:
+- **Spring Boot**: 3.5.x
+- **Spring Framework**: 6.2.x
+- **Groovy**: 4.0.x
+- **Gradle**: 8.14.x
+- **Spock**: 2.3-groovy-4.0
+- **Jakarta EE**: 10 (migrated from javax.*)
+- **Micronaut**: Optional via `grails-micronaut` plugin
+
+## Project Structure
+
+```
+myapp/
+├── grails-app/
+│   ├── conf/                 # Configuration
+│   │   ├── application.yml   # Main config
+│   │   ├── logback.xml       # Logging config
+│   │   └── spring/           # Spring bean definitions
+│   ├── controllers/          # Request handlers
+│   ├── domain/               # GORM domain classes
+│   ├── i18n/                 # Message bundles
+│   ├── init/                 # Bootstrap classes
+│   ├── services/             # Business logic
+│   ├── taglib/               # Custom GSP tags
+│   ├── utils/                # Utility classes
+│   └── views/                # GSP templates
+├── src/
+│   ├── main/groovy/          # Additional Groovy classes
+│   ├── main/java/            # Java classes
+│   └── test/groovy/          # Test specifications
+├── build.gradle              # Build configuration
+└── gradle.properties         # Project properties
+```
+
+## Domain Classes (GORM)
+
+### Basic Domain Class
+```groovy
+class Book {
+    String title
+    String author
+    Date datePublished
+    Integer pages
+
+    static constraints = {
+        title blank: false, maxSize: 255
+        author blank: false
+        datePublished nullable: true
+        pages min: 1, nullable: true
+    }
+
+    static mapping = {
+        table 'books'
+        title column: 'book_title'
+        datePublished type: 'date'
+    }
+}
+```
+
+### Relationships
+```groovy
+class Author {
+    String name
+
+    static hasMany = [books: Book]
+
+    static mapping = {
+        books cascade: 'all-delete-orphan'
+    }
+}
+
+class Book {
+    String title
+
+    static belongsTo = [author: Author]
+}
+
+// Many-to-Many
+class Book {
+    static hasMany = [categories: Category]
+    static belongsTo = Category
+}
+
+class Category {
+    String name
+    static hasMany = [books: Book]
+}
+```
+
+### GORM Queries
+```groovy
+// Dynamic finders
+Book.findByTitle("Grails Guide")
+Book.findAllByAuthorLike("%Smith%")
+Book.findByTitleAndAuthor("Guide", "Smith")
+Book.countByPagesGreaterThan(100)
+
+// Where queries
+Book.where {
+    title =~ "%Grails%" && pages > 100
+}.list()
+
+// Criteria queries
+Book.withCriteria {
+    like('title', '%Grails%')
+    gt('pages', 100)
+    order('datePublished', 'desc')
+    maxResults(10)
+}
+
+// HQL queries
+Book.executeQuery(
+    "from Book b where b.author.name = :name",
+    [name: 'Smith']
+)
+
+// Detached criteria (reusable)
+def criteria = Book.where {
+    pages > 100
+}
+criteria.list()
+criteria.count()
+```
+
+### Transactions
+```groovy
+// In services (default transactional)
+@Transactional
+class BookService {
+    def saveBook(Book book) {
+        book.save(failOnError: true)
+    }
+}
+
+// Manual transaction control
+Book.withTransaction { status ->
+    def book = new Book(title: "Test")
+    book.save()
+    if (someCondition) {
+        status.setRollbackOnly()
+    }
+}
+```
+
+## Controllers
+
+### Basic Controller
+```groovy
+class BookController {
+
+    BookService bookService
+
+    static allowedMethods = [save: 'POST', update: 'PUT', delete: 'DELETE']
+
+    def index() {
+        respond Book.list(), model: [bookCount: Book.count()]
+    }
+
+    def show(Long id) {
+        respond Book.get(id)
+    }
+
+    def create() {
+        respond new Book(params)
+    }
+
+    def save(Book book) {
+        if (book.hasErrors()) {
+            respond book.errors, view: 'create'
+            return
+        }
+        bookService.save(book)
+        redirect action: 'show', id: book.id
+    }
+
+    def edit(Long id) {
+        respond Book.get(id)
+    }
+
+    def update(Book book) {
+        if (book.hasErrors()) {
+            respond book.errors, view: 'edit'
+            return
+        }
+        bookService.save(book)
+        redirect action: 'show', id: book.id
+    }
+
+    def delete(Long id) {
+        bookService.delete(id)
+        redirect action: 'index'
+    }
+}
+```
+
+### REST Controller
+```groovy
+import grails.rest.RestfulController
+
+class BookController extends RestfulController<Book> {
+
+    static responseFormats = ['json', 'xml']
+
+    BookController() {
+        super(Book)
+    }
+
+    // Override to customize
+    @Override
+    protected Book queryForResource(Serializable id) {
+        Book.where { id == id && active == true }.find()
+    }
+}
+```
+
+### Command Objects
+```groovy
+class BookCommand implements Validateable {
+    String title
+    String author
+    Integer pages
+
+    static constraints = {
+        title blank: false
+        author blank: false
+        pages min: 1, nullable: true
+    }
+}
+
+class BookController {
+    def save(BookCommand cmd) {
+        if (cmd.hasErrors()) {
+            respond cmd.errors
+            return
+        }
+        // Process valid command
+    }
+}
+```
+
+### Content Negotiation
+```groovy
+class BookController {
+    def show(Long id) {
+        def book = Book.get(id)
+        respond book  // Auto-negotiates based on Accept header
+    }
+}
+
+// Or explicit
+def show(Long id) {
+    def book = Book.get(id)
+    withFormat {
+        html { render view: 'show', model: [book: book] }
+        json { render book as JSON }
+        xml { render book as XML }
+    }
+}
+```
+
+## Services
+
+### Basic Service
+```groovy
+import grails.gorm.transactions.Transactional
+
+@Transactional
+class BookService {
+
+    def findByTitle(String title) {
+        Book.findByTitle(title)
+    }
+
+    def save(Book book) {
+        book.save(failOnError: true)
+    }
+
+    @Transactional(readOnly = true)
+    def list(Map params) {
+        Book.list(params)
+    }
+
+    def delete(Long id) {
+        Book.get(id)?.delete()
+    }
+}
+```
+
+### Service with Events
+```groovy
+import grails.events.annotation.Publisher
+import grails.events.annotation.Subscriber
+
+class BookService {
+
+    @Publisher
+    def save(Book book) {
+        book.save()
+        // Automatically publishes 'book.saved' event
+    }
+}
+
+class NotificationService {
+
+    @Subscriber('book.saved')
+    def onBookSaved(Book book) {
+        // Handle event
+        log.info "Book saved: ${book.title}"
+    }
+}
+```
+
+### Async Service
+```groovy
+import grails.async.Promise
+import static grails.async.Promises.*
+
+class BookService {
+
+    Promise<Book> findAsync(Long id) {
+        task {
+            Book.get(id)
+        }
+    }
+
+    def processBooks() {
+        def p1 = task { Book.findAllByActive(true) }
+        def p2 = task { Author.list() }
+
+        waitAll(p1, p2)
+        // Both complete
+    }
+}
+```
+
+## Views
+
+### GSP (Groovy Server Pages)
+```html
+<!-- grails-app/views/book/list.gsp -->
+<!DOCTYPE html>
+<html>
+<head>
+    <title>Books</title>
+    <asset:stylesheet src="application.css"/>
+</head>
+<body>
+    <h1>Books (${bookCount})</h1>
+
+    <g:each in="${bookList}" var="book">
+        <div class="book">
+            <h2>${book.title}</h2>
+            <p>By ${book.author}</p>
+            <g:link action="show" id="${book.id}">View</g:link>
+        </div>
+    </g:each>
+
+    <g:if test="${bookList.empty}">
+        <p>No books found.</p>
+    </g:if>
+
+    <g:paginate total="${bookCount}"/>
+
+    <asset:javascript src="application.js"/>
+</body>
+</html>
+```
+
+### Common GSP Tags
+```html
+<!-- Links -->
+<g:link controller="book" action="show" id="${book.id}">View</g:link>
+<g:createLink action="list"/>
+
+<!-- Forms -->
+<g:form action="save">
+    <g:textField name="title" value="${book?.title}"/>
+    <g:textArea name="description" value="${book?.description}"/>
+    <g:select name="category" from="${categories}" optionKey="id" optionValue="name"/>
+    <g:checkBox name="active" value="${book?.active}"/>
+    <g:submitButton name="submit" value="Save"/>
+</g:form>
+
+<!-- Conditionals -->
+<g:if test="${condition}">...</g:if>
+<g:elseif test="${other}">...</g:elseif>
+<g:else>...</g:else>
+
+<!-- Iteration -->
+<g:each in="${items}" var="item" status="i">
+    ${i}: ${item.name}
+</g:each>
+
+<!-- Rendering -->
+<g:render template="bookRow" model="[book: book]"/>
+<g:render template="bookRow" collection="${books}" var="book"/>
+
+<!-- Security (with Spring Security plugin) -->
+<sec:ifLoggedIn>Welcome, ${sec.username()}</sec:ifLoggedIn>
+<sec:ifNotLoggedIn><g:link controller="login">Login</g:link></sec:ifNotLoggedIn>
+```
+
+### JSON Views
+```groovy
+// grails-app/views/book/show.gson
+import myapp.Book
+
+model {
+    Book book
+}
+
+json {
+    id book.id
+    title book.title
+    author book.author
+    datePublished book.datePublished?.format('yyyy-MM-dd')
+    _links {
+        self {
+            href "/books/${book.id}"
+        }
+    }
+}
+```
+
+### Layouts
+```html
+<!-- grails-app/views/layouts/main.gsp -->
+<!DOCTYPE html>
+<html>
+<head>
+    <title><g:layoutTitle default="My App"/></title>
+    <asset:stylesheet src="application.css"/>
+    <g:layoutHead/>
+</head>
+<body>
+    <nav><!-- Navigation --></nav>
+    <main>
+        <g:layoutBody/>
+    </main>
+    <footer><!-- Footer --></footer>
+    <asset:javascript src="application.js"/>
+</body>
+</html>
+
+<!-- Use in views -->
+<html>
+<head>
+    <meta name="layout" content="main"/>
+    <title>Books</title>
+</head>
+<body>
+    <!-- Page content -->
+</body>
+</html>
+```
+
+## Interceptors
+
+```groovy
+class AuthInterceptor {
+
+    AuthInterceptor() {
+        matchAll()
+            .excludes(controller: 'login')
+            .excludes(controller: 'error')
+    }
+
+    boolean before() {
+        if (!session.user) {
+            redirect(controller: 'login')
+            return false
+        }
+        true
+    }
+
+    boolean after() {
+        // After action executes
+        true
+    }
+
+    void afterView() {
+        // After view renders
+    }
+}
+```
+
+## Tag Libraries
+
+```groovy
+class BookTagLib {
+
+    static namespace = 'book'
+    static defaultEncodeAs = [taglib: 'html']
+
+    def formatTitle = { attrs, body ->
+        def title = attrs.title ?: body()
+        out << "<span class='book-title'>${title}</span>"
+    }
+
+    def ifHasBooks = { attrs, body ->
+        if (Book.count() > 0) {
+            out << body()
+        }
+    }
+}
+
+// Usage in GSP
+<book:formatTitle title="${book.title}"/>
+<book:ifHasBooks>
+    <p>We have books!</p>
+</book:ifHasBooks>
+```
+
+## Configuration
+
+### application.yml
+```yaml
+grails:
+    profile: web
+    codegen:
+        defaultPackage: myapp
+    gorm:
+        reactor:
+            events: false
+    mime:
+        types:
+            json: ['application/json', 'text/json']
+            xml: ['text/xml', 'application/xml']
+
+environments:
+    development:
+        dataSource:
+            dbCreate: create-drop
+            url: jdbc:h2:mem:devDb
+    test:
+        dataSource:
+            dbCreate: update
+            url: jdbc:h2:mem:testDb
+    production:
+        dataSource:
+            dbCreate: none
+            url: jdbc:postgresql://localhost/myapp
+            driverClassName: org.postgresql.Driver
+            dialect: org.hibernate.dialect.PostgreSQLDialect
+            properties:
+                jmxEnabled: true
+                initialSize: 5
+                maxActive: 50
+
+server:
+    port: 8080
+    servlet:
+        context-path: /myapp
+```
+
+### URL Mappings
+```groovy
+// grails-app/controllers/myapp/UrlMappings.groovy
+class UrlMappings {
+
+    static mappings = {
+        // Default
+        "/$controller/$action?/$id?(.$format)?" {
+            constraints {
+                // apply constraints here
+            }
+        }
+
+        // REST resources
+        "/api/books"(resources: 'book')
+
+        // Custom mappings
+        "/books/$id"(controller: 'book', action: 'show')
+        "/search"(controller: 'book', action: 'search')
+
+        // Named URL mappings
+        name bookShow: "/books/$id" {
+            controller = 'book'
+            action = 'show'
+        }
+
+        // Error pages
+        "500"(view: '/error')
+        "404"(view: '/notFound')
+    }
+}
+```
+
+## Testing with Spock
+
+### Unit Test - Controller
+```groovy
+import grails.testing.web.controllers.ControllerUnitTest
+import spock.lang.Specification
+
+class BookControllerSpec extends Specification
+        implements ControllerUnitTest<BookController> {
+
+    def setup() {
+        controller.bookService = Mock(BookService)
+    }
+
+    void "index returns list of books"() {
+        given:
+        def books = [new Book(title: "Test")]
+        controller.bookService.list(_) >> books
+
+        when:
+        controller.index()
+
+        then:
+        model.bookList == books
+        view == '/book/index'
+    }
+
+    void "show returns 404 for missing book"() {
+        when:
+        controller.show(999)
+
+        then:
+        response.status == 404
+    }
+}
+```
+
+### Unit Test - Service
+```groovy
+import grails.testing.services.ServiceUnitTest
+import spock.lang.Specification
+
+class BookServiceSpec extends Specification
+        implements ServiceUnitTest<BookService> {
+
+    void "save persists book"() {
+        given:
+        def book = new Book(title: "Test", author: "Author")
+
+        when:
+        def result = service.save(book)
+
+        then:
+        result.id != null
+        Book.count() == 1
+    }
+}
+```
+
+### Unit Test - Domain
+```groovy
+import grails.testing.gorm.DomainUnitTest
+import spock.lang.Specification
+
+class BookSpec extends Specification
+        implements DomainUnitTest<Book> {
+
+    void "title cannot be blank"() {
+        when:
+        domain.title = ""
+        domain.author = "Test"
+
+        then:
+        !domain.validate(['title'])
+        domain.errors['title'].code == 'blank'
+    }
+
+    void "valid book passes validation"() {
+        when:
+        domain.title = "Valid Title"
+        domain.author = "Author"
+
+        then:
+        domain.validate()
+    }
+}
+```
+
+### Integration Test
+```groovy
+import grails.testing.mixin.integration.Integration
+import grails.gorm.transactions.Rollback
+import spock.lang.Specification
+
+@Integration
+@Rollback
+class BookServiceIntegrationSpec extends Specification {
+
+    BookService bookService
+
+    void "save and retrieve book"() {
+        given:
+        def book = new Book(title: "Integration Test", author: "Tester")
+
+        when:
+        bookService.save(book)
+        def found = Book.findByTitle("Integration Test")
+
+        then:
+        found != null
+        found.author == "Tester"
+    }
+}
+```
+
+### Functional Test with Geb
+```groovy
+import geb.spock.GebSpec
+import grails.testing.mixin.integration.Integration
+
+@Integration
+class BookFunctionalSpec extends GebSpec {
+
+    void "can view book list"() {
+        when:
+        go '/book/index'
+
+        then:
+        title == 'Book List'
+        $('h1').text() == 'Books'
+    }
+
+    void "can create new book"() {
+        when:
+        go '/book/create'
+        $('form').title = 'New Book'
+        $('form').author = 'Test Author'
+        $('input[type=submit]').click()
+
+        then:
+        $('h1').text().contains('New Book')
+    }
+}
+```
+
+## Plugins
+
+### Common Plugins
+```groovy
+// build.gradle
+
+// Spring Security
+implementation 'org.grails.plugins:spring-security-core:6.0.0'
+
+// Database Migration (Liquibase)
+implementation 'org.grails.plugins:database-migration:4.2.0'
+
+// Caching
+implementation 'org.grails.plugins:cache:6.0.0'
+
+// Async support
+implementation 'org.grails.plugins:async:5.0.0'
+
+// Fields plugin for form rendering
+implementation 'org.grails.plugins:fields:5.0.0'
+
+// Asset Pipeline
+runtimeOnly 'org.grails.plugins:asset-pipeline:5.0.0'
+```
+
+### Spring Security Configuration
+```groovy
+// grails-app/conf/application.groovy
+grails.plugin.springsecurity.userLookup.userDomainClassName = 'myapp.User'
+grails.plugin.springsecurity.userLookup.authorityJoinClassName = 'myapp.UserRole'
+grails.plugin.springsecurity.authority.className = 'myapp.Role'
+
+grails.plugin.springsecurity.controllerAnnotations.staticRules = [
+    [pattern: '/',               access: ['permitAll']],
+    [pattern: '/error',          access: ['permitAll']],
+    [pattern: '/index',          access: ['permitAll']],
+    [pattern: '/admin/**',       access: ['ROLE_ADMIN']],
+    [pattern: '/api/**',         access: ['isAuthenticated()']],
+]
+```
+
+## Build Commands
+
+```bash
+# Run application
+./gradlew bootRun
+
+# Run tests
+./gradlew test                                    # All tests

Review Comment:
   why not make this `./gradlew check` instead?  I know that unit & integration tests both extend the test type, but check is meant to run everything I thought.



##########
.cursorrules:
##########
@@ -0,0 +1 @@
+AGENTS.md

Review Comment:
   Do you think it's beneficial to add these other editor links? 



##########
AGENTS.md:
##########
@@ -0,0 +1,227 @@
+<!--
+SPDX-License-Identifier: Apache-2.0
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+
+# Agent Guide for grails-core
+
+> **IMPORTANT**: This is the Grails Framework source repository (60+ modules), NOT a Grails application.
+> For building Grails apps, see `.agents/skills/grails-developer/SKILL.md`.
+
+## Quick Reference
+
+```bash
+# Build (no tests)
+./gradlew build -PskipTests
+
+# Build single module
+./gradlew :grails-core:build
+
+# Run tests
+./gradlew :<module>:test
+./gradlew :<module>:test --tests "com.example.SomeSpec"
+
+# Style check
+./gradlew codeStyle
+
+# Out of memory? Set:
+export GRADLE_OPTS="-Xms2G -Xmx5G"
+```
+
+## Critical Rules
+
+1. **Use `jakarta.*` NOT `javax.*`** - All packages migrated to Jakarta EE 10
+2. **Use `@GrailsCompileStatic`** - Not plain `@CompileStatic` in Grails classes
+3. **Use `GrailsWebRequest.lookup()`** - For thread-safe request context in tests
+4. **No wildcard imports** - Use explicit imports
+5. **4 spaces, no tabs** - See `.editorconfig`
+6. **Apache license header** - Required on all new source files
+
+## Available Skills
+
+> **AI AGENTS - MANDATORY**: Before writing or modifying any code, you **MUST** read the relevant skill file(s) below. Do not write Groovy/Grails code without first loading these instructions:
+> - Writing Grails code → Read `.agents/skills/grails-developer/SKILL.md`
+> - Writing Groovy code → Read `.agents/skills/groovy-developer/SKILL.md`
+> - Writing Java code → Read `.agents/skills/java-developer/SKILL.md`
+>
+> Use your file reading capability to load the skill content before proceeding with any code changes.
+
+| Skill | Path | Use For |
+|-------|------|---------|
+| **grails-developer** | `.agents/skills/grails-developer/SKILL.md` | Grails 7 apps, GORM, controllers, views |
+| **groovy-developer** | `.agents/skills/groovy-developer/SKILL.md` | Groovy 4 syntax, closures, DSLs, Spock |
+| **java-developer** | `.agents/skills/java-developer/SKILL.md` | Java 17 features, Groovy interop |
+
+## Technology Stack
+
+| Component | Version |
+|-----------|---------|
+| JDK | 17+ (baseline 17) |
+| Groovy | 4.0.x |
+| Spring Boot | 3.5.x |
+| Spring Framework | 6.2.x |
+| Spock | 2.3-groovy-4.0 |
+| Gradle | 8.14.x |
+| Jakarta EE | 10 |
+
+## Key Modules
+
+**Core**: `grails-core`, `grails-bootstrap`, `grails-spring`, `grails-common`
+
+**Web**: `grails-web-core`, `grails-web-mvc`, `grails-controllers`, `grails-url-mappings`, `grails-interceptors`
+
+**GORM**: `grails-datastore-core`, `grails-datamapping-core`, `grails-domain-class`, `grails-validation`, `grails-databinding`
+
+**Views**: `grails-views-core`, `grails-views-gson`, `grails-views-markup`
+
+**Testing**: `grails-testing-support-core`, `grails-testing-support-web`, `grails-geb`
+
+**Other**: `grails-bom` (dependency management), `grails-doc`, `grails-shell-cli`, `grails-forge`
+
+## Artefact Types
+
+| Type | Pattern | Handler |
+|------|---------|---------|
+| Domain | `**/domain/**/*.groovy` | `DomainClassArtefactHandler` |
+| Controller | `**/*Controller.groovy` | `ControllerArtefactHandler` |
+| Service | `**/*Service.groovy` | `ServiceArtefactHandler` |
+| TagLib | `**/*TagLib.groovy` | `TagLibArtefactHandler` |
+| Interceptor | `**/*Interceptor.groovy` | `InterceptorArtefactHandler` |
+
+## Code Patterns
+
+### Spock Test Structure
+```groovy
+class MyServiceSpec extends Specification implements ServiceUnitTest<MyService> {
+    def "feature description"() {
+        given: "preconditions"
+        def input = "test"
+
+        when: "action"
+        def result = service.process(input)
+
+        then: "assertions"
+        result != null
+        result.status == "OK"
+    }
+}
+```
+
+### Mocking
+```groovy
+def repo = Mock(BookRepository)
+1 * repo.save(_) >> savedBook  // expect 1 call, return savedBook
+```
+
+### Data-Driven Tests
+```groovy
+@Unroll
+def "#a + #b == #c"() {
+    expect: a + b == c
+    where:
+    a | b || c
+    1 | 2 || 3
+    4 | 5 || 9
+}
+```
+
+### Framework Access
+```groovy
+// Thread-safe request context
+GrailsWebRequest webRequest = GrailsWebRequest.lookup()
+
+// Artefact registry
+grailsApplication.getArtefacts(DomainClassArtefactHandler.TYPE)
+```
+
+## Groovy Style
+
+```groovy
+// DO: Safe navigation
+book?.author?.name
+
+// DO: Elvis operator
+name ?: 'Unknown'
+
+// DO: GStrings
+"Hello ${user.name}"
+
+// DO: Spread operator
+books*.title
+
+// DO: Static compilation
+@GrailsCompileStatic
+class MyService { }
+
+// DON'T: Wildcard imports
+// import java.util.*  ❌
+
+// DON'T: javax packages
+// import javax.servlet.*  ❌ → use jakarta.servlet.*
+```
+
+## Test Isolation
+
+> **WARNING**: Tests run in parallel (`maxParallelForks > 1`). Static state causes flaky tests.
+
+- Use `GrailsWebRequest.lookup()` for thread-local context
+- Clear artefacts: `grailsApplication.artefactInfo.clear()`
+- Use `@ResourceLock` for shared resources
+
+## Build Commands
+
+| Task | Command |
+|------|---------|
+| Build (no tests) | `./gradlew build -PskipTests` |
+| Build module | `./gradlew :grails-core:build` |
+| Test module | `./gradlew :grails-core:test` |
+| Single test | `./gradlew :module:test --tests "pkg.MySpec"` |
+| Single feature | `./gradlew :module:test --tests "pkg.MySpec.feature name"` |
+| Force rerun | `./gradlew :module:test --rerun-tasks` |
+| Style check | `./gradlew codeStyle` |
+| Build docs | `./gradlew :grails-doc:publishGuide -x aggregateGroovydoc` |
+| Debug | `./gradlew bootRun --debug-jvm` |
+
+## Branch Naming (Auto-Labels PRs)
+
+| Prefix | Label |
+|--------|-------|
+| `fix/` | bug |
+| `feat/`, `feature/` | feature |
+| `docs/` | documentation |
+| `chore/`, `refactor/`, `test/`, `ci/`, `perf/`, `build/` | maintenance |
+| `deps/` | deps |
+
+## Common Issues
+
+| Problem | Solution |
+|---------|----------|
+| Out of memory | `export GRADLE_OPTS="-Xms2G -Xmx5G"` |
+| Container missing | Use `-PskipTests` or install Docker/Podman |
+| Flaky tests | Check static state pollution, use `@ResourceLock` |
+| Cache issues | `./gradlew --rerun-tasks` |
+| Deprecation details | `./gradlew <task> --warning-mode all` |
+
+## Security
+
+Report vulnerabilities to: `security@grails.org` (NOT public issues)
+

Review Comment:
   https://github.com/agentsmd/agents.md suggests the following additional sections: 
   * Testing instructions 
   * Dev environment tips - since we have a multiple project build should we call out the multiproject structure?  i.e. build-logic vs grails-gradle vs grails-core vs grails-forge? 
   * PR instructions



-- 
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

To unsubscribe, e-mail: notifications-unsubscribe@grails.apache.org

For queries about this service, please contact Infrastructure at:
users@infra.apache.org

Re: [PR] Add AGENTS.md and AI coding assistant support [grails-core]

["jdaugherty (via GitHub)" <gi...@apache.org>]

jdaugherty commented on PR #15340:
URL: https://github.com/apache/grails-core/pull/15340#issuecomment-3830070673

   @matrei I'd like to take advantage of this initial work and since this is only documentation at this time, I think it's safe to merge given that @jamesfredley has attempted to address all of the issues you raised.  I'm going to go ahead and merge this and then we can open subsequent PR's to further refine these files.


-- 
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

To unsubscribe, e-mail: notifications-unsubscribe@grails.apache.org

For queries about this service, please contact Infrastructure at:
users@infra.apache.org