geneseed 4.9.4 → 4.10.0

package/src/skills/spring-boot/web.md

@@ -0,0 +1,112 @@
+# {{SKILL}}: spring-boot — web layer
+
+{{CREDIT:piomin-spring-boot:skills/spring-boot/references/web.md}}
+
+Controllers, validation, error handling and outbound HTTP for a Spring MVC service.
+
+## Controller
+Thin: bind, validate, delegate, shape the response. Create returns `201` with a `Location` header; delete returns `204`.
+
+```java
+@RestController
+@RequestMapping("/api/v1/users")
+class UserController {
+    private final UserService service;
+
+    UserController(UserService service) { this.service = service; }
+
+    @GetMapping
+    PagedModel<UserResponse> list(@PageableDefault(size = 20, sort = "createdAt") Pageable pageable) {
+        return new PagedModel<>(service.findAll(pageable));
+    }
+
+    @PostMapping
+    ResponseEntity<UserResponse> create(@Valid @RequestBody UserCreateRequest request) {
+        UserResponse user = service.create(request);
+        URI location = ServletUriComponentsBuilder.fromCurrentRequest()
+                .path("/{id}").buildAndExpand(user.id()).toUri();
+        return ResponseEntity.created(location).body(user);
+    }
+
+    @DeleteMapping("/{id}")
+    @ResponseStatus(HttpStatus.NO_CONTENT)
+    void delete(@PathVariable Long id) { service.delete(id); }
+}
+```
+
+Version the path (`/api/v1`). Use GET for reads, POST/PUT/PATCH/DELETE for state changes; never change state on GET.
+
+## DTOs and validation
+Records for request and response. Constraints sit on the record components (`jakarta.validation.constraints`); `@Valid` on the controller parameter triggers them. Put the entity-to-DTO mapping in a static factory or a mapper, not in the controller.
+
+```java
+public record UserCreateRequest(
+        @NotBlank @Email String email,
+        @NotBlank @Size(min = 8, max = 100) String password,
+        @Min(18) Integer age) {}
+```
+
+A custom constraint is an annotation with `@Constraint(validatedBy = ...)` plus a `ConstraintValidator`; the validator may be a Spring bean and inject a repository. A uniqueness check in a validator is advisory only; the database constraint is the truth, so also handle `DataIntegrityViolationException` (409).
+
+## Errors: Problem Details
+Enable RFC 9457 responses for Spring's own exceptions:
+
+```yaml
+spring:
+  mvc:
+    problemdetails:
+      enabled: true
+```
+
+Return `ProblemDetail` from your own handlers so every error shares one shape. Extending `ResponseEntityExceptionHandler` keeps the framework exceptions on that shape too.
+
+```java
+@RestControllerAdvice
+class ApiExceptionHandler extends ResponseEntityExceptionHandler {
+
+    @ExceptionHandler(ResourceNotFoundException.class)
+    ProblemDetail notFound(ResourceNotFoundException ex) {
+        return ProblemDetail.forStatusAndDetail(HttpStatus.NOT_FOUND, ex.getMessage());
+    }
+
+    @ExceptionHandler(DataIntegrityViolationException.class)
+    ProblemDetail conflict(DataIntegrityViolationException ex) {
+        return ProblemDetail.forStatusAndDetail(HttpStatus.CONFLICT, "Resource already exists");
+    }
+}
+```
+
+A domain exception can carry its own problem by extending `ErrorResponseException`. Never put stack traces or SQL text in `detail`; log the exception server-side and return a generic message for the catch-all 500.
+
+## Outbound HTTP
+Blocking calls use `RestClient`; build it from the injected `RestClient.Builder` so Boot's customizers (timeouts, SSL, observability) apply.
+
+```java
+@Bean
+RestClient pricingClient(RestClient.Builder builder) {
+    return builder.baseUrl("https://api.example.com").build();
+}
+
+Quote fetch(String id) {
+    return pricingClient.get().uri("/quotes/{id}", id)
+            .retrieve()
+            .onStatus(status -> status.value() == 404, (req, res) -> {
+                throw new ResourceNotFoundException("Quote " + id);
+            })
+            .body(Quote.class);
+}
+```
+
+Prefer an `@HttpExchange` interface when the remote API has several operations (see [spring-boot/cloud.md](cloud.md)). `WebClient` is for reactive or streaming code only.
+
+## CORS
+Prefer one bean over scattered annotations. With Spring Security on the classpath configure CORS in the security chain ([spring-boot/security.md](security.md)); otherwise `WebMvcConfigurer.addCorsMappings`. List explicit origins; `allowedOrigins("*")` cannot be combined with credentials.
+
+## Quick reference
+| Need | Use |
+|------|-----|
+| Page and sort | `Pageable` + `@PageableDefault` |
+| Bad input | `@Valid` -> 400 Problem Details |
+| Missing resource | 404 via your exception handler |
+| Duplicate | 409 from the DB constraint |
+| Slow upstream | `spring.http.clients.connect-timeout` / `read-timeout` |

package/src/skills/spring-boot.md

@@ -0,0 +1,57 @@
+# {{SKILL}}: spring-boot
+
+> {{DESC_SPRING_BOOT}}
+
+{{CREDIT:piomin-spring-boot:skills/spring-boot/SKILL.md}}
+
+{{CREDIT:piomin-spring-boot:skills/conventions/SKILL.md}}
+
+**Trigger:** writing or changing a Spring Boot application (Spring Boot 4, Spring Framework 7, Java 21+) — controllers, services, configuration, security, HTTP clients, logging, cloud-native deployment. Load it for any Spring Boot task, then read the side file the task needs. It does not replace the core review or refactor skills; for a Spring review or refactor, load those and use this one for the framework facts.
+
+Target stack: Spring Boot 4 / Spring Framework 7 / Spring Security 7 / Hibernate 7 / Jakarta EE 11 / Java 21+. Check the project's actual versions first (`pom.xml` or `build.gradle`); if it is still on Boot 3, say so and do not apply the Boot 4 rows below blindly.
+
+## Working loop
+1. Read the build file, `application.yml` and the existing package layout. Match what the project already does (Maven or Gradle, its CI, its test style) before adding anything.
+2. Confirm the design for anything beyond a small change: endpoints, DTOs, transaction boundaries, who authenticates.
+3. Implement in layers, then run the project's own test command and read the output.
+
+## Conventions
+- Layering: controller (HTTP, validation) -> service (business logic, transactions) -> repository. Keep the package layout the project already has; for a new app a flat feature-or-layer split under one root package is fine (`com.example.<app>`).
+- Constructor injection only; one constructor needs no `@Autowired`. Lombok is allowed where the project uses it.
+- DTOs are records. JPA entities are not records. Never return an entity from a controller.
+- `@Valid` on every request body; `@Transactional(readOnly = true)` on read services, `@Transactional` on mutating methods.
+- Typed config: `@ConfigurationProperties` records instead of scattered `@Value`.
+- Errors: one `@RestControllerAdvice`, Problem Details responses.
+- Blocking outbound HTTP: `RestClient`, or an `@HttpExchange` interface. `WebClient` only for reactive or streaming code. Do not mix blocking and reactive in one call path.
+- Jakarta namespaces only (`jakarta.persistence`, `jakarta.validation`, `jakarta.servlet`).
+- Secrets from the environment or mounted files, never committed config.
+- Tests: positive and negative cases; Testcontainers with `@ServiceConnection`; `@MockitoBean` for slice-test collaborators.
+- Baseline properties worth enabling: `spring.threads.virtual.enabled: true`, `spring.mvc.problemdetails.enabled: true`, `server.shutdown: graceful`.
+
+## Boot 4 pitfalls
+Removed or renamed in Boot 4 (do not write them): `@MockBean` and `@SpyBean`, `ClientHttpRequestFactories`, `javax.persistence` (now `jakarta.persistence`), Spring Security 6 idioms such as `authorizeRequests` and `.and()` chains. <!-- banned: ok -->
+
+| Old habit | Boot 4 / Framework 7 reality |
+|-----------|------------------------------|
+| Mock beans in slice tests | `@MockitoBean`, `@MockitoSpyBean` (`org.springframework.test.context.bean.override.mockito`) |
+| Hand-built request factories | `ClientHttpRequestFactoryBuilder` with `HttpClientSettings` |
+| Security configuration | Spring Security 7: lambda DSL, `authorizeHttpRequests` |
+| `org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest` | `org.springframework.boot.webmvc.test.autoconfigure.WebMvcTest`: slices moved to per-technology modules; import from the new packages |
+| Jackson 2 (`com.fasterxml.jackson`) | Jackson 3 is the default (`tools.jackson`); Jackson 2 support is deprecated, `spring.jackson.use-jackson2-defaults` eases migration |
+| `@DynamicPropertySource` for container URLs | `@ServiceConnection` on the container |
+| MockMvc status assertions via Hamcrest | `MockMvcTester` (AssertJ) or `RestTestClient` with `@AutoConfigureRestTestClient` |
+| OpenFeign for declarative clients | `@HttpExchange` interfaces, registered with `@ImportHttpServices` |
+| Zipkin-only tracing setup | `spring-boot-starter-opentelemetry`, `management.opentelemetry.tracing.export.otlp.*` |
+| Starters assumed to pull everything | Boot 4 starters are modular; add the matching starter or test starter for each technology, and read the migration guide when a class vanishes |
+
+## Side files
+- **Web/REST** -> read [spring-boot/web.md](spring-boot/web.md) and follow it.
+- **Security (OAuth2 resource server, method security, SSL bundles)** -> read [spring-boot/security.md](spring-boot/security.md) and follow it.
+- **Cloud-native (config, gateway, resilience, tracing, Kubernetes, images)** -> read [spring-boot/cloud.md](spring-boot/cloud.md) and follow it.
+- **Modern Java in Spring code (records, sealed types, pattern matching, null safety)** -> read [spring-boot/java-modern.md](spring-boot/java-modern.md) and follow it.
+- **Logging and structured logs** -> read [spring-boot/logging.md](spring-boot/logging.md) and follow it.
+
+## Done when
+- The project's build and tests pass, read from real output; no deprecated Boot 2/3 idiom was introduced; every new endpoint validates input and has a negative test.
+
+<!-- INCLUDE: skills/_self-improvement.md -->

package/src/skills/spring-data-jpa/patterns.md

@@ -0,0 +1,68 @@
+# {{SKILL}}: spring-data-jpa — outbox, saga, CQRS
+
+{{CREDIT:piomin-spring-boot:skills/design-patterns/SKILL.md}}
+
+Use when a write must also publish an event, a business process spans services, or reads and writes need separate models. If a plain `@Transactional` method does the job, do not add these.
+
+## Transactional outbox
+
+Dual write (save, then publish to a broker) can lose or duplicate the event. Write the event row in the same transaction as the state change; a separate relay publishes it.
+
+```java
+@Entity
+public class OutboxEvent {
+    @Id @GeneratedValue(strategy = GenerationType.UUID) UUID id;
+    String aggregateId;
+    String type;
+    @Column(columnDefinition = "text") String payload;
+    boolean published;
+    // constructor, getters
+}
+
+@Service
+class OrderService {
+    @Transactional
+    public Order place(OrderRequest req) {
+        Order order = orders.save(Order.from(req));
+        outbox.save(new OutboxEvent(order.getId().toString(), "OrderPlaced", json(order)));
+        return order;                         // both rows commit or neither does
+    }
+}
+
+@Component
+class OutboxRelay {
+    @Scheduled(fixedDelay = 1000)             // needs @EnableScheduling on a config class
+    @Transactional
+    void relay() {
+        for (OutboxEvent e : outbox.findTop100ByPublishedFalseOrderByIdAsc()) {
+            publisher.send(e);                // broker client; may throw, row stays unpublished
+            e.setPublished(true);
+        }
+    }
+}
+```
+
+- Delivery is at-least-once: consumers dedupe on the event id.
+- Several relay instances will pick the same rows. Use a single relay, or a row-claiming query verified for your database (not covered here), or a lock.
+- Delete or archive published rows on a schedule.
+- In-process alternative: publish a Spring `ApplicationEvent` and handle it with `@TransactionalEventListener` (default phase `AFTER_COMMIT`). The handler runs only if the transaction commits, and it is not durable: a crash after commit loses the event. Use it for in-JVM side effects, the outbox table for anything that must survive a crash. If the listener must write to the database again, annotate it `@Transactional(propagation = Propagation.REQUIRES_NEW)`.
+
+## Saga
+
+| Style | Mechanism | Pick when |
+|-------|-----------|-----------|
+| Choreography | each service reacts to the previous service's event and emits its own (events through the outbox) | few steps, no central owner |
+| Orchestration | one `OrderSaga` component sends commands, tracks state in its own table, issues compensations | many steps, branching, need to see where a flow is stuck |
+
+- Every step has a compensating action (cancel, refund, release); compensations must be idempotent.
+- Persist saga state (`STARTED`, `PAYMENT_DONE`, `FAILED`, ...) with `@Version` so concurrent events cannot both advance it.
+- Timeouts are events too: a scheduled job moves stale sagas to compensation.
+- Messaging infrastructure (Spring Cloud Stream, plain Kafka or AMQP clients) is project-specific and not verified here; keep the saga logic behind a small publisher interface.
+
+## CQRS
+
+Split only when read and write shapes diverge. Smallest useful form, same database:
+
+- Write side: aggregate entities and `@Transactional` command services.
+- Read side: projection or DTO-record repository methods (or a view) behind a `@Transactional(readOnly = true)` query service; never return entities.
+- A separate read store fed by outbox events adds eventual consistency: show it in the API (version or timestamp) and accept stale reads.

package/src/skills/spring-data-jpa.md

@@ -0,0 +1,81 @@
+# {{SKILL}}: spring-data-jpa
+
+> {{DESC_SPRING_DATA_JPA}}
+
+{{CREDIT:piomin-spring-boot:skills/jpa-patterns/SKILL.md}}
+
+{{CREDIT:piomin-spring-boot:skills/spring-boot/references/data.md}}
+
+**Trigger:** a Spring Data JPA / Hibernate task in a Spring Boot project: entities, repositories, N+1 queries, `LazyInitializationException`, transactions, locking, projections, Flyway or Liquibase migrations, soft delete, or a transactional outbox. Spring-specific; for generic query or schema work outside Spring, do not load it.
+
+Target stack: Spring Boot 4, Hibernate 7, Jakarta Persistence (`jakarta.persistence.*` only).
+
+## Symptom to fix
+
+| Symptom | Fix |
+|---------|-----|
+| N+1 SELECTs | `@EntityGraph(attributePaths = "books")` or `JOIN FETCH`; as a mitigation only, `hibernate.default_batch_fetch_size` (batch fetching mitigates N+1, it does not solve it) |
+| `LazyInitializationException` | fetch what the use case needs inside the transaction (graph / `JOIN FETCH`) or return a DTO; do not flip associations to `EAGER` |
+| Slow list endpoints | `Pageable` (`Slice` when no total is needed), interface or record projections, indexes |
+| Lost updates | `@Version` (optimistic); `@Lock(LockModeType.PESSIMISTIC_WRITE)` only for hot rows |
+| Slow read-only service | `@Transactional(readOnly = true)` on the class, override on writes |
+| Transaction ignored | self-invocation bypasses the proxy: call through another bean |
+
+## Entities
+
+```java
+@Entity
+@SoftDelete                       // Hibernate: adds a deleted-flag column, filters reads
+public class Author {
+    @Id @GeneratedValue(strategy = GenerationType.UUID)
+    private UUID id;
+    @Version private long version;
+    @OneToMany(mappedBy = "author", fetch = FetchType.LAZY)
+    private List<Book> books = new ArrayList<>();
+    // getters/setters, or Lombok if the project uses it
+}
+```
+
+- Every to-one and to-many is `LAZY`; decide fetching per query, not on the mapping.
+- `@SoftDelete(strategy = ...)` takes `ACTIVE`, `DELETED`, or `TIMESTAMP`; the default stores a deleted flag.
+- `GenerationType.UUID` generates the id in Java; `IDENTITY` and `SEQUENCE` need the database.
+- Equality on entities: id-based with a stable hash, or business key. Never include lazy collections in `equals`/`toString`.
+
+## Repositories and projections
+
+```java
+public interface AuthorRepository extends JpaRepository<Author, UUID> {
+    @EntityGraph(attributePaths = "books")
+    List<Author> findByNameStartingWith(String prefix);
+
+    record AuthorName(UUID id, String name) {}
+    List<AuthorName> findAllBy(Pageable pageable);          // DTO projection
+
+    @Modifying(clearAutomatically = true)
+    @Query("update Author a set a.name = :name where a.id = :id")
+    int rename(UUID id, String name);
+}
+```
+
+- Interface projections are built from tuple queries; DTO records need an all-args constructor and no column aliases in `@Query` JPQL.
+- Bulk `@Modifying` queries bypass the persistence context: `clearAutomatically = true` or reload.
+- Return DTOs from the web layer, never entities.
+
+## Transactions and open-in-view
+
+- Put `@Transactional` on service methods, not repositories or controllers.
+- `spring.jpa.open-in-view` defaults to `true` in a web app (the EntityManager stays open through view rendering). Set it to `false` and fetch explicitly; it hides N+1 otherwise.
+- Detect N+1: `spring.jpa.show-sql=true` is enough for a quick look; assert query counts in a `@DataJpaTest` for regressions.
+
+## Migrations
+
+Schema is owned by migrations, not `ddl-auto`: `spring.jpa.hibernate.ddl-auto=validate` (or `none`) with Flyway or Liquibase, whichever the project already uses. In Boot 4 add the starter (`spring-boot-starter-flyway`), not just the Flyway core jar, or auto-configuration does not apply; Postgres and MySQL also need `flyway-database-postgresql` / `flyway-mysql`. Migration files are immutable once merged; add a new one.
+
+## Outbox, saga, CQRS
+
+Event-publishing alongside a DB write (dual-write problem), distributed workflows, read/write model split: read [spring-data-jpa/patterns.md](spring-data-jpa/patterns.md).
+
+## Done when
+- No lazy collection is touched outside a transaction; hot queries show one SELECT per use case in the SQL log; schema changes ship as a migration; imports are `jakarta.persistence`.
+
+<!-- INCLUDE: skills/_self-improvement.md -->

package/src/skills/spring-testing.md

@@ -0,0 +1,93 @@
+# {{SKILL}}: spring-testing
+
+> {{DESC_SPRING_TESTING}}
+
+{{CREDIT:piomin-spring-boot:skills/testing-patterns/SKILL.md}}
+
+{{CREDIT:piomin-spring-boot:skills/spring-boot/references/testing.md}}
+
+**Trigger:** writing or fixing tests in a Spring Boot project: unit tests of services, `@WebMvcTest` / `@DataJpaTest` slices, `@SpringBootTest` integration tests, Testcontainers, mocking beans. Spring-specific; core test discipline lives in the test-gates and develop skills.
+
+Target stack: Spring Boot 4, JUnit 5, Mockito, AssertJ.
+
+## Pick the narrowest test
+
+| Goal | Tool |
+|------|------|
+| Service logic | plain JUnit + `@ExtendWith(MockitoExtension.class)`, no Spring context |
+| Controller mapping, validation, serialization | `@WebMvcTest(X.class)` + `MockMvcTester` + `@MockitoBean` |
+| Repository queries, mappings | `@DataJpaTest` against the real database engine |
+| Whole app over HTTP | `@SpringBootTest(webEnvironment = RANDOM_PORT)` + `@AutoConfigureRestTestClient` |
+| Whole app, no server | `@SpringBootTest` + `@AutoConfigureMockMvc` |
+
+Boot 4 split the test support into modules: slice annotations live in `org.springframework.boot.<module>.test.autoconfigure` (e.g. `org.springframework.boot.data.jpa.test.autoconfigure.DataJpaTest`); `@AutoConfigureTestDatabase` is in `org.springframework.boot.jdbc.test.autoconfigure`. Let the IDE import them. Use the matching test starter (`spring-boot-starter-data-jpa-test`, and so on) so each slice is on the classpath.
+
+## Mocking beans
+
+The Boot-era mock-bean annotations are gone in Boot 4. Use `@MockitoBean` and `@MockitoSpyBean` (from `org.springframework.test.context.bean.override.mockito`).
+
+```java
+@WebMvcTest(UserController.class)
+class UserControllerTests {
+    @Autowired MockMvcTester mvc;
+    @MockitoBean UserService users;
+
+    @Test
+    void unknownUserIs404() {
+        given(users.find("x")).willThrow(new UserNotFoundException("x"));
+        assertThat(mvc.get().uri("/users/x")).hasStatus(HttpStatus.NOT_FOUND);
+    }
+}
+```
+
+`MockMvcTester` is AssertJ-based (`assertThat(mvc.get().uri(...)).hasStatusOk()`); do not mix it with the `expectStatus()` chain, which belongs to the other clients. Security: `@WithMockUser` still works on slices; `@Import` your security config.
+
+## Full-server test
+
+```java
+@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
+@AutoConfigureRestTestClient
+class UserApiTests {
+    @Autowired RestTestClient client;
+
+    @Test
+    void createReturns201() {
+        client.post().uri("/users").contentType(MediaType.APPLICATION_JSON)
+              .body(new UserRequest("a@example.com"))
+              .exchange()
+              .expectStatus().isCreated();
+    }
+}
+```
+
+`RestTestClient` resolves relative URIs against the running server; it also supports AssertJ-style assertions through its response type. Customize through a `RestTestClientBuilderCustomizer` bean.
+
+## Real dependencies with Testcontainers
+
+Prefer `@ServiceConnection`: Boot derives connection details, no property wiring.
+
+```java
+@TestConfiguration(proxyBeanMethods = false)
+class ContainersConfig {
+    @Bean @ServiceConnection
+    PostgreSQLContainer postgres() { return new PostgreSQLContainer("postgres:16"); }
+}
+
+@DataJpaTest
+@Import(ContainersConfig.class)
+class AuthorRepositoryTests { /* ... */ }
+```
+
+- Testcontainers 2 containers are non-generic and live in per-module packages (`org.testcontainers.postgresql.PostgreSQLContainer`, artifact `testcontainers-postgresql`).
+- The default `replace = NON_TEST` already keeps a `@ServiceConnection` data source; `replace = NONE` is only needed for a non-test `DataSource` you defined yourself.
+- Where `@ServiceConnection` has no support for the container, use `@Testcontainers` + `@Container static` + `@DynamicPropertySource` to register the properties.
+- Share one container configuration across tests so the context cache is reused.
+
+## Rules
+
+- Test behaviour through the public seam; do not assert on mock call counts unless the call is the behaviour.
+- Slice tests load only what they need; reaching for `@SpringBootTest` to test one controller is a smell.
+- Never replace the database engine with H2 when production runs another one; dialect differences hide bugs.
+- No `Thread.sleep`: wait on the condition with a bounded timeout.
+
+<!-- INCLUDE: skills/_self-improvement.md -->

package/src/skills/wayfinder.md

@@ -2,6 +2,8 @@
 
 > {{DESC_WAYFINDER}}
 
+{{CREDIT:mattpocock-skills:skills/engineering/wayfinder/SKILL.md}}
+
 **Trigger:** a piece of work too large for one session and still in the fog —
 the destination can be named but the route to it cannot; the user says
 "wayfinder" or asks to chart a big effort before building anything.

package/src/upstreams.json

@@ -0,0 +1,59 @@
+{
+  "daydream": {
+    "repo": "glebis/claude-skills",
+    "commit": "b8e34966661bd7b6834af6a0548ce3ccd371ee30",
+    "author": "Gleb Kalinin",
+    "license": "MIT",
+    "licenseFile": "skills/daydream/LICENSE"
+  },
+  "react-view-transitions": {
+    "repo": "vercel-labs/agent-skills",
+    "commit": "063bee94c3f4df8453406c830b0a7df0f2860278",
+    "author": "Vercel Engineering",
+    "license": "MIT",
+    "licenseFile": null
+  },
+  "mattpocock-skills": {
+    "repo": "mattpocock/skills",
+    "commit": "5beb35b040e3de97e54fa9e386d7e42d15c295c2",
+    "author": "Matt Pocock",
+    "license": "MIT",
+    "licenseFile": "licenses/mattpocock-skills.txt"
+  },
+  "superpowers": {
+    "repo": "obra/superpowers",
+    "commit": "bb92a77741419a4ab5f06e711a283343f1ada0c3",
+    "author": "Jesse Vincent",
+    "license": "MIT",
+    "licenseFile": "licenses/superpowers.txt"
+  },
+  "vibe-wise": {
+    "repo": "nykooi1/vibe-wise",
+    "commit": "eefb53df406ab89e31444684ff32c1df205221f8",
+    "author": "Noah Kim",
+    "license": "MIT",
+    "licenseFile": "licenses/vibe-wise.txt"
+  },
+  "mattpocock-skills-frozen": {
+    "repo": "mattpocock/skills",
+    "commit": "391a2701dd948f94f56a39f7533f8eea9a859c87",
+    "author": "Matt Pocock",
+    "license": "MIT",
+    "licenseFile": "licenses/mattpocock-skills.txt",
+    "frozen": true
+  },
+  "mattpocock-skills-2509": {
+    "repo": "mattpocock/skills",
+    "commit": "5beb35b040e3de97e54fa9e386d7e42d15c295c2",
+    "author": "Matt Pocock",
+    "license": "MIT",
+    "licenseFile": "licenses/mattpocock-skills.txt"
+  },
+  "piomin-spring-boot": {
+    "repo": "piomin/claude-ai-spring-boot",
+    "commit": "cf876a1041ac4692f32422261f6d67d7f12140d5",
+    "author": "Piotr Mińkowski",
+    "license": "Apache-2.0",
+    "licenseFile": "licenses/piomin-spring-boot.txt"
+  }
+}

package/themes/_TEMPLATE.json

@@ -34,6 +34,12 @@
   "DESC_EMPIRICIST": "<council seat: holds every claim to evidence, for and against>",
   "DESC_OPERATOR": "<council seat: speaks for running it in production — reliability, on-call>",
   "DESC_HISTORIAN": "<council seat: brings the precedent — what was tried before>",
+  "DESC_SPRING_BOOT_ENGINEER": "<one-line description: implements a Spring Boot feature or service end to end in a Java codebase>",
+  "DESC_SPRING_REVIEWER": "<one-line description: reviews a Spring Boot change with framework knowledge — layering, transactions, JPA, configuration, test slices>",
+  "DESC_SPRING_SECURITY": "<one-line description: security pass over a Spring Security change — filter chain, method security, OAuth2/JWT, CORS/CSRF>",
+  "DESC_KUBERNETES_SPECIALIST": "<one-line description: writes or reviews Kubernetes manifests, probes, resources and rollout for a Spring Boot service>",
+  "DESC_DOCKER_EXPERT": "<one-line description: writes or reviews the Dockerfile and image build (layered or native) of a Spring Boot service>",
+  "DESC_DEVOPS_ENGINEER": "<one-line description: reviews or improves the build and delivery pipeline of a Spring Boot service on the CI already in use>",
   "DESC_PLAN": "<one-line description: write a plan before a non-trivial task; track progress>",
   "DESC_DEPENDENCIES": "<one-line description: audit dependencies — outdated, vulnerable, abandoned, unused — into a risk-ordered plan, then upgrade one change at a time, tests green between>",
   "DESC_GIT_HISTORY": "<one-line description: learn from git history read-only — bisect, blame, pickaxe — or recover/rewrite it safely behind a backup branch>",
@@ -144,6 +150,9 @@
   "DESC_FRONTEND_DESIGN": "<one-line description: design a UI with intent — palette/type/layout chosen for the brief, not templated defaults; plan tokens, critique against the brief, keep one bold move>",
   "DESC_DECK": "<one-line description: build slides or a presentation as one self-contained offline HTML file — short interview, outline approved first, keys, URL hash, one slide per printed page>",
   "DESC_WORKFLOW": "<one-line description: run a saved, code-driven workflow that orchestrates subagents deterministically>",
+  "DESC_SPRING_BOOT": "<one-line description: build or change a Spring Boot service — controllers, configuration, REST clients, error handling, observability, packaging>",
+  "DESC_SPRING_DATA_JPA": "<one-line description: Spring Data JPA and Hibernate work — entities, repositories, queries, transactions, migrations, N+1 and fetch problems>",
+  "DESC_SPRING_TESTING": "<one-line description: write or fix Spring Boot tests — slices, MockMvc, Testcontainers with service connections, mocking beans>",
   "AGENT_COLORS": {
     "architect": "primary",
     "reviewer": "warning",

package/themes/biker.json

@@ -34,6 +34,12 @@
   "DESC_EMPIRICIST": "Wants the proof — holds every claim, for and against, to the odometer, trials, or precedent.",
   "DESC_OPERATOR": "Speaks for the bike on the road — how it holds under load, the watch, and the on-call burden of keeping it running.",
   "DESC_HISTORIAN": "Brings the old miles — what was tried before, how it went, and the lesson for this run.",
+  "DESC_SPRING_BOOT_ENGINEER": "Builds a Spring Boot feature or service end to end in a Java codebase, frame to finish.",
+  "DESC_SPRING_REVIEWER": "Walks a Spring Boot change over like a bike before a ride — layering, transactions, JPA, configuration, test slices.",
+  "DESC_SPRING_SECURITY": "Goes over Spring Security changes bolt by bolt — filter chain, method security, OAuth2/JWT, CORS/CSRF.",
+  "DESC_KUBERNETES_SPECIALIST": "Sets up the Kubernetes manifests for a Spring Boot service — probes, resources, rollout — so it holds on the highway.",
+  "DESC_DOCKER_EXPERT": "Packs the Docker image of a Spring Boot service lean, layered or native, ready to roll.",
+  "DESC_DEVOPS_ENGINEER": "Tunes the build and delivery pipeline of a Spring Boot service, on whatever CI the shop already runs.",
   "DESC_PLAN": "Map the route before a non-trivial run; mark your progress mile by mile.",
   "DESC_DEPENDENCIES": "Inspect every part on the bike — worn, recalled, discontinued, dead weight — into a risk-ordered replacement plan, then fit one part at a time, trials green between each.",
   "DESC_GIT_HISTORY": "Trace the roadbook to find when it broke or why a part was fitted — bisect, blame, the pickaxe, hands off the bike — or recover a wrecked run and rewrite the history safely, reflog and rebase behind a backup.",
@@ -144,6 +150,9 @@
   "DESC_FRONTEND_DESIGN": "Design a UI with real attitude — pick palette, type, and layout for this job, not the stock defaults, then trim it down to one bold move.",
   "DESC_DECK": "Build slides or a presentation as one offline HTML file — a quick interview, the outline signed off first, then a deck that rides on arrow keys and prints clean.",
   "DESC_WORKFLOW": "Run a saved route that sends your riders by script — many rolled out at once, their findings gathered and checked in one clean run.",
+  "DESC_SPRING_BOOT": "Build or change a Spring Boot service — controllers, configuration, REST clients, error handling, observability, packaging — and keep it on the road.",
+  "DESC_SPRING_DATA_JPA": "Wrench on Spring Data JPA and Hibernate — entities, repositories, queries, transactions, migrations, N+1 and fetch trouble.",
+  "DESC_SPRING_TESTING": "Write or fix Spring Boot tests — slices, MockMvc, Testcontainers with service connections, mocked beans — before the ride.",
   "AGENT_COLORS": {
     "architect": "primary",
     "reviewer": "warning",

package/themes/commentator.json

@@ -34,6 +34,12 @@
   "DESC_EMPIRICIST": "Demands the data — holds every claim, for and against, to telemetry, trials, or precedent.",
   "DESC_OPERATOR": "Speaks for the car at racing speed — its reliability under load, its watch, and the on-call burden of running it.",
   "DESC_HISTORIAN": "Brings the form book — what was tried in past races, how it went, and the lesson for this call.",
+  "DESC_SPRING_BOOT_ENGINEER": "Builds a Spring Boot feature or service end to end in a Java codebase — lights out and away it goes.",
+  "DESC_SPRING_REVIEWER": "Runs the scrutineering on a Spring Boot change with framework know-how — layering, transactions, JPA, configuration, test slices.",
+  "DESC_SPRING_SECURITY": "Checks the Spring Security barriers — filter chain, method security, OAuth2/JWT, CORS/CSRF — on any change that touches them.",
+  "DESC_KUBERNETES_SPECIALIST": "Sets the pit wall for a Spring Boot service on Kubernetes — manifests, probes, resources, rollout.",
+  "DESC_DOCKER_EXPERT": "Preps the Docker image of a Spring Boot service, layered or native, ready for the grid.",
+  "DESC_DEVOPS_ENGINEER": "Works the pit lane of build and delivery for a Spring Boot service, on whatever CI the team already runs.",
   "DESC_PLAN": "Plot the strategy before a non-trivial stint; call your progress lap by lap.",
   "DESC_DEPENDENCIES": "Survey every component — outdated, on recall, discontinued, dead weight — into a risk-ordered upgrade plan, then fit one change at a time, trials green between each.",
   "DESC_GIT_HISTORY": "Replay the data to find when the lap fell apart or why a line was driven — bisect, blame, the pickaxe, hands off the car — or recover a crashed session and rewrite the history safely, reflog and rebase behind a backup lap.",
@@ -144,6 +150,9 @@
   "DESC_FRONTEND_DESIGN": "Design a UI with a point of view — palette, type, and layout built for this brief, not the templated defaults, then critique and cut to one bold move.",
   "DESC_DECK": "Build slides or a presentation as one offline HTML file — a short interview, the outline approved first, then a deck that runs on arrow keys and prints one slide a page.",
   "DESC_WORKFLOW": "Run a saved race plan that drives your team by script — many sent out at once, their results gathered and checked in one clean grand prix.",
+  "DESC_SPRING_BOOT": "Build or change a Spring Boot service — controllers, configuration, REST clients, error handling, observability, packaging — lap after lap.",
+  "DESC_SPRING_DATA_JPA": "Work the Spring Data JPA and Hibernate setup — entities, repositories, queries, transactions, migrations, N+1 and fetch problems.",
+  "DESC_SPRING_TESTING": "Write or fix Spring Boot tests — slices, MockMvc, Testcontainers with service connections, mocked beans — before the lights go out.",
   "AGENT_COLORS": {
     "architect": "primary",
     "reviewer": "warning",

package/themes/cyberpunk.json

@@ -34,6 +34,12 @@
   "DESC_EMPIRICIST": "Demands proof — holds every claim, for and against, to data, tests, or precedent.",
   "DESC_OPERATOR": "Speaks for it live on the grid — uptime, telemetry, rollback, and the on-call burn.",
   "DESC_HISTORIAN": "Pulls the old logs — what was run before, how it crashed, and the lesson for this call.",
+  "DESC_SPRING_BOOT_ENGINEER": "Jacks into a Java codebase and ships a Spring Boot feature or service end to end.",
+  "DESC_SPRING_REVIEWER": "Scans a Spring Boot change with framework-aware eyes — layering, transactions, JPA, configuration, test slices.",
+  "DESC_SPRING_SECURITY": "Probes the ICE around Spring Security changes — filter chain, method security, OAuth2/JWT, CORS/CSRF.",
+  "DESC_KUBERNETES_SPECIALIST": "Deploys and audits the Kubernetes manifests of a Spring Boot service — probes, resources, rollout — across the grid.",
+  "DESC_DOCKER_EXPERT": "Packs the Docker image of a Spring Boot service, layered or native, lean for the net.",
+  "DESC_DEVOPS_ENGINEER": "Tunes the build and delivery pipeline of a Spring Boot service, on whatever CI the crew already runs.",
   "DESC_PLAN": "Map the run before a non-trivial job; track progress as it executes.",
   "DESC_DEPENDENCIES": "Scan every dependency on the rig — outdated, exploitable, abandoned, dead weight — into a risk-ordered plan, then jack in each upgrade one swap at a time, tests green between.",
   "DESC_GIT_HISTORY": "Trace the history read-only — bisect, blame, pickaxe — or recover a corrupted repo and rewrite it clean — reflog, undo, rebase behind a backup branch.",
@@ -144,6 +150,9 @@
   "DESC_FRONTEND_DESIGN": "Design a UI with edge — palette, type, and layout forged for this brief, not the stock defaults; plan, critique, and keep one bold move.",
   "DESC_DECK": "Build slides or a presentation as one self-contained offline HTML file — short interview, outline cleared first, keyboard-driven, no CDN, prints one slide per page.",
   "DESC_WORKFLOW": "Jack in a saved routine that drives your daemons on rails — parallel forks, staged pipelines, and verification, all in one deterministic run.",
+  "DESC_SPRING_BOOT": "Build or change a Spring Boot service — controllers, configuration, REST clients, error handling, observability, packaging — and push it live.",
+  "DESC_SPRING_DATA_JPA": "Run Spring Data JPA and Hibernate jobs — entities, repositories, queries, transactions, migrations, N+1 and fetch glitches.",
+  "DESC_SPRING_TESTING": "Write or fix Spring Boot tests — slices, MockMvc, Testcontainers with service connections, mocked beans — before the run.",
   "AGENT_COLORS": {
     "architect": "primary",
     "reviewer": "warning",

package/themes/gamer.json

@@ -34,6 +34,12 @@
   "DESC_EMPIRICIST": "Demands the receipts — holds every claim, for and against, to stats, tests, or precedent.",
   "DESC_OPERATOR": "Speaks for it live on the server — uptime, lag, rollback, and the on-call grind.",
   "DESC_HISTORIAN": "Reads the old runs — what was tried before, how it wiped, and the lesson for this call.",
+  "DESC_SPRING_BOOT_ENGINEER": "Builds a Spring Boot feature or service end to end in a Java codebase, full clear.",
+  "DESC_SPRING_REVIEWER": "Runs a framework-aware review of a Spring Boot change — layering, transactions, JPA, configuration, test slices.",
+  "DESC_SPRING_SECURITY": "Runs the anti-cheat pass on Spring Security changes — filter chain, method security, OAuth2/JWT, CORS/CSRF.",
+  "DESC_KUBERNETES_SPECIALIST": "Sets up the Kubernetes manifests for a Spring Boot service — probes, resources, rollout — so the raid does not wipe.",
+  "DESC_DOCKER_EXPERT": "Builds the Docker image of a Spring Boot service lean, layered or native, ready to spawn.",
+  "DESC_DEVOPS_ENGINEER": "Tunes the build and delivery pipeline of a Spring Boot service, on whatever CI the party already uses.",
   "DESC_PLAN": "Plot the route before a non-trivial run; track progress at each checkpoint.",
   "DESC_DEPENDENCIES": "Audit the loadout — outdated, exploitable, abandoned, dead weight — into a risk-ordered upgrade plan, then patch one change at a time, tests green between.",
   "DESC_GIT_HISTORY": "Replay the history read-only — bisect, blame, pickaxe — or recover a corrupted save and rewrite it clean — reflog, undo, rebase behind a backup branch.",
@@ -144,6 +150,9 @@
   "DESC_FRONTEND_DESIGN": "Design a UI with a real identity — palette, type, and layout picked for this brief, not the default skin, then cut it down to one bold move.",
   "DESC_DECK": "Build slides or a presentation as one offline HTML file — a quick setup interview, outline locked first, then a deck that plays on arrow keys and prints one slide a page.",
   "DESC_WORKFLOW": "Run a saved combo that scripts your party — fan out, chain the stages, and verify the clear, all in one deterministic rotation.",
+  "DESC_SPRING_BOOT": "Build or change a Spring Boot service — controllers, configuration, REST clients, error handling, observability, packaging — level by level.",
+  "DESC_SPRING_DATA_JPA": "Handle Spring Data JPA and Hibernate — entities, repositories, queries, transactions, migrations, N+1 and fetch bugs.",
+  "DESC_SPRING_TESTING": "Write or fix Spring Boot tests — slices, MockMvc, Testcontainers with service connections, mocked beans — before the boss fight.",
   "AGENT_COLORS": {
     "architect": "primary",
     "reviewer": "warning",

package/themes/imperial.json

@@ -34,6 +34,12 @@
   "DESC_EMPIRICIST": "Demands proof — holds every claim, for and against, to evidence, trial, or precedent.",
   "DESC_OPERATOR": "Speaks for the work in the field — its endurance under fire, its watch, and the cost borne by those who keep it.",
   "DESC_HISTORIAN": "Bears the chronicle — what was attempted before, how it fared, and the lesson for this decree.",
+  "DESC_SPRING_BOOT_ENGINEER": "Forges a Spring Boot feature or service end to end within a Java codex, from first rite to last.",
+  "DESC_SPRING_REVIEWER": "Sits in judgement of a Spring Boot change with knowledge of the framework — layering, transactions, JPA, configuration, test slices.",
+  "DESC_SPRING_SECURITY": "Wards the Spring Security gates — filter chain, method security, OAuth2/JWT, CORS/CSRF — and pronounces on any change that touches them.",
+  "DESC_KUBERNETES_SPECIALIST": "Inscribes and inspects the Kubernetes manifests of a Spring Boot service — probes, resources, rollout — so the cluster holds the line.",
+  "DESC_DOCKER_EXPERT": "Forges and inspects the Docker image of a Spring Boot service, layered or native, sealed for deployment.",
+  "DESC_DEVOPS_ENGINEER": "Tends the build and delivery pipeline of a Spring Boot service, upon whatever CI the project already keeps.",
   "DESC_PLAN": "Set down the campaign-plan before the non-trivial task; mark your progress as the battle turns.",
   "DESC_DEPENDENCIES": "Survey every dependency of the machine — outdated, corrupted, abandoned, dead weight — into a risk-ordered plan, then ascend one change at a time, the trials green between.",
   "DESC_GIT_HISTORY": "Interrogate the chronicle, touching nothing — bisect, blame, and pickaxe — or reclaim a ruined archive and rewrite it without ruin — by reflog and undo, every rite warded by a backup.",
@@ -144,6 +150,9 @@
   "DESC_FRONTEND_DESIGN": "Design an interface with intent — palette, type, and layout forged for this brief, not the common defaults; plan, scrutinise, and keep one bold stroke.",
   "DESC_DECK": "Forge slides or a presentation as one self-contained offline HTML scroll — a brief interrogation, the outline sanctioned first, arrow-key navigation, one slide per printed page.",
   "DESC_WORKFLOW": "Unleash a sealed battle-rite that marshals your Adepts by iron script — many loosed at once, their findings martialled and proven in one disciplined campaign.",
+  "DESC_SPRING_BOOT": "Raise or reshape a Spring Boot service — controllers, configuration, REST clients, error handling, observability, packaging — by the rites of Boot 4.",
+  "DESC_SPRING_DATA_JPA": "Conduct Spring Data JPA and Hibernate rites — entities, repositories, queries, transactions, migrations, the N+1 heresy and fetch ills.",
+  "DESC_SPRING_TESTING": "Forge and mend Spring Boot trials — slices, MockMvc, Testcontainers with service connections, mocked beans.",
   "AGENT_COLORS": {
     "architect": "primary",
     "reviewer": "warning",