@mmerterden/multi-agent-pipeline 20.2.1 → 20.3.0

package/pipeline/skills/shared/external/android-architecture/SKILL.md

@@ -115,17 +115,17 @@ lives in `:core:model` (models) and feature modules (use cases).
 
 ```kotlin
 // :core:model
-data class Flight(
+data class Order(
     val id: String,
-    val origin: Airport,
-    val destination: Airport,
-    val departureTime: Instant,
-    val arrivalTime: Instant,
+    val store: Location,
+    val region: Location,
+    val placedAt: Instant,
+    val deliveredAt: Instant,
     val price: Price,
-    val status: FlightStatus,
+    val status: OrderStatus,
 )
 
-enum class FlightStatus { SCHEDULED, DELAYED, CANCELLED, LANDED }
+enum class OrderStatus { PLACED, SHIPPED, CANCELLED, DELIVERED }
 
 data class Price(val amount: Double, val currency: String)
 ```
@@ -136,22 +136,22 @@ Each use case has a single responsibility. Use `operator fun invoke` so call
 sites read like function calls.
 
 ```kotlin
-class GetFlightsUseCase @Inject constructor(
-    private val flightRepository: FlightRepository,
+class GetOrdersUseCase @Inject constructor(
+    private val orderRepository: OrderRepository,
 ) {
-    operator fun invoke(origin: String, destination: String): Flow<List<Flight>> =
-        flightRepository.getFlights(origin, destination)
+    operator fun invoke(store: String, region: String): Flow<List<Order>> =
+        orderRepository.getOrders(store, region)
 }
 ```
 
 For use cases with parameters, define a data class or use function parameters:
 
 ```kotlin
-class SearchFlightsUseCase @Inject constructor(
-    private val repository: FlightRepository,
+class SearchOrdersUseCase @Inject constructor(
+    private val repository: OrderRepository,
 ) {
-    operator fun invoke(params: Params): Flow<Result<List<Flight>>> =
-        repository.searchFlights(params.query, params.date)
+    operator fun invoke(params: Params): Flow<Result<List<Order>>> =
+        repository.searchOrders(params.query, params.date)
             .map { Result.success(it) }
             .catch { emit(Result.failure(it)) }
 
@@ -163,10 +163,10 @@ class SearchFlightsUseCase @Inject constructor(
 
 ```kotlin
 // :core:data
-interface FlightRepository {
-    fun getFlights(origin: String, destination: String): Flow<List<Flight>>
-    fun searchFlights(query: String, date: LocalDate): Flow<List<Flight>>
-    suspend fun bookFlight(flightId: String): Result<Booking>
+interface OrderRepository {
+    fun getOrders(store: String, region: String): Flow<List<Order>>
+    fun searchOrders(query: String, date: LocalDate): Flow<List<Order>>
+    suspend fun payOrder(orderId: String): Result<Payment>
 }
 ```
 
@@ -178,28 +178,28 @@ The data layer implements repository interfaces. It coordinates between remote
 ### Repository Implementation
 
 ```kotlin
-class FlightRepositoryImpl @Inject constructor(
-    private val remoteDataSource: FlightRemoteDataSource,
-    private val localDataSource: FlightLocalDataSource,
-    private val flightMapper: FlightMapper,
-) : FlightRepository {
-
-    override fun getFlights(origin: String, destination: String): Flow<List<Flight>> =
-        localDataSource.getFlights(origin, destination)
-            .map { entities -> entities.map(flightMapper::toDomain) }
-
-    override fun searchFlights(query: String, date: LocalDate): Flow<List<Flight>> = flow {
-        val dtos = remoteDataSource.searchFlights(query, date.toString())
-        localDataSource.insertFlights(dtos.map(flightMapper::toEntity))
+class OrderRepositoryImpl @Inject constructor(
+    private val remoteDataSource: OrderRemoteDataSource,
+    private val localDataSource: OrderLocalDataSource,
+    private val orderMapper: OrderMapper,
+) : OrderRepository {
+
+    override fun getOrders(store: String, region: String): Flow<List<Order>> =
+        localDataSource.getOrders(store, region)
+            .map { entities -> entities.map(orderMapper::toDomain) }
+
+    override fun searchOrders(query: String, date: LocalDate): Flow<List<Order>> = flow {
+        val dtos = remoteDataSource.searchOrders(query, date.toString())
+        localDataSource.insertOrders(dtos.map(orderMapper::toEntity))
         emitAll(
-            localDataSource.getFlights(query, query)
-                .map { entities -> entities.map(flightMapper::toDomain) }
+            localDataSource.getOrders(query, query)
+                .map { entities -> entities.map(orderMapper::toDomain) }
         )
     }
 
-    override suspend fun bookFlight(flightId: String): Result<Booking> = runCatching {
-        val response = remoteDataSource.bookFlight(flightId)
-        flightMapper.toBookingDomain(response)
+    override suspend fun payOrder(orderId: String): Result<Payment> = runCatching {
+        val response = remoteDataSource.payOrder(orderId)
+        orderMapper.toPaymentDomain(response)
     }
 }
 ```
@@ -208,25 +208,25 @@ class FlightRepositoryImpl @Inject constructor(
 
 ```kotlin
 // Remote
-class FlightRemoteDataSource @Inject constructor(
-    private val api: FlightApiService,
+class OrderRemoteDataSource @Inject constructor(
+    private val api: OrderApiService,
 ) {
-    suspend fun searchFlights(query: String, date: String): List<FlightDto> =
-        api.searchFlights(query, date)
+    suspend fun searchOrders(query: String, date: String): List<OrderDto> =
+        api.searchOrders(query, date)
 
-    suspend fun bookFlight(flightId: String): BookingResponse =
-        api.bookFlight(BookingRequest(flightId))
+    suspend fun payOrder(orderId: String): PaymentResponse =
+        api.payOrder(PaymentRequest(orderId))
 }
 
 // Local
-class FlightLocalDataSource @Inject constructor(
-    private val dao: FlightDao,
+class OrderLocalDataSource @Inject constructor(
+    private val dao: OrderDao,
 ) {
-    fun getFlights(origin: String, destination: String): Flow<List<FlightEntity>> =
-        dao.getFlights(origin, destination)
+    fun getOrders(store: String, region: String): Flow<List<OrderEntity>> =
+        dao.getOrders(store, region)
 
-    suspend fun insertFlights(entities: List<FlightEntity>) =
-        dao.upsertFlights(entities)
+    suspend fun insertOrders(entities: List<OrderEntity>) =
+        dao.upsertOrders(entities)
 }
 ```
 
@@ -237,16 +237,16 @@ ViewModels expose UI state as `StateFlow` and handle user actions.
 ```kotlin
 @HiltViewModel
 class HomeViewModel @Inject constructor(
-    private val getFlightsUseCase: GetFlightsUseCase,
+    private val getOrdersUseCase: GetOrdersUseCase,
 ) : ViewModel() {
 
     private val _uiState = MutableStateFlow<HomeUiState>(HomeUiState.Loading)
     val uiState: StateFlow<HomeUiState> = _uiState.asStateFlow()
 
-    fun loadFlights(origin: String, destination: String) {
+    fun loadOrders(store: String, region: String) {
         viewModelScope.launch {
-            getFlightsUseCase(origin, destination)
-                .map<List<Flight>, HomeUiState> { HomeUiState.Success(it) }
+            getOrdersUseCase(store, region)
+                .map<List<Order>, HomeUiState> { HomeUiState.Success(it) }
                 .catch { emit(HomeUiState.Error(it.message ?: "Unknown error")) }
                 .collect { _uiState.value = it }
         }
@@ -255,7 +255,7 @@ class HomeViewModel @Inject constructor(
 
 sealed interface HomeUiState {
     data object Loading : HomeUiState
-    data class Success(val flights: List<Flight>) : HomeUiState
+    data class Success(val orders: List<Order>) : HomeUiState
     data class Error(val message: String) : HomeUiState
 }
 ```
@@ -293,9 +293,9 @@ abstract class RepositoryModule {
 
     @Binds
     @Singleton
-    abstract fun bindFlightRepository(
-        impl: FlightRepositoryImpl,
-    ): FlightRepository
+    abstract fun bindOrderRepository(
+        impl: OrderRepositoryImpl,
+    ): OrderRepository
 }
 ```
 
@@ -328,8 +328,8 @@ object NetworkModule {
 
     @Provides
     @Singleton
-    fun provideFlightApiService(retrofit: Retrofit): FlightApiService =
-        retrofit.create(FlightApiService::class.java)
+    fun provideOrderApiService(retrofit: Retrofit): OrderApiService =
+        retrofit.create(OrderApiService::class.java)
 }
 ```
 
@@ -393,35 +393,35 @@ depending on every `impl`. Full host injection and per-feature contribution:
 Mappers isolate layer boundaries. Each layer has its own model type.
 
 ```kotlin
-class FlightMapper @Inject constructor() {
+class OrderMapper @Inject constructor() {
 
-    fun toDomain(entity: FlightEntity): Flight = Flight(
+    fun toDomain(entity: OrderEntity): Order = Order(
         id = entity.id,
-        origin = Airport(entity.originCode, entity.originName),
-        destination = Airport(entity.destinationCode, entity.destinationName),
-        departureTime = Instant.parse(entity.departureTime),
-        arrivalTime = Instant.parse(entity.arrivalTime),
+        store = Location(entity.storeCode, entity.storeName),
+        region = Location(entity.regionCode, entity.regionName),
+        placedAt = Instant.parse(entity.placedAt),
+        deliveredAt = Instant.parse(entity.deliveredAt),
         price = Price(entity.priceAmount, entity.priceCurrency),
-        status = FlightStatus.valueOf(entity.status),
+        status = OrderStatus.valueOf(entity.status),
     )
 
-    fun toEntity(dto: FlightDto): FlightEntity = FlightEntity(
+    fun toEntity(dto: OrderDto): OrderEntity = OrderEntity(
         id = dto.id,
-        originCode = dto.origin.code,
-        originName = dto.origin.name,
-        destinationCode = dto.destination.code,
-        destinationName = dto.destination.name,
-        departureTime = dto.departureTime,
-        arrivalTime = dto.arrivalTime,
+        storeCode = dto.store.code,
+        storeName = dto.store.name,
+        regionCode = dto.region.code,
+        regionName = dto.region.name,
+        placedAt = dto.placedAt,
+        deliveredAt = dto.deliveredAt,
         priceAmount = dto.price.amount,
         priceCurrency = dto.price.currency,
         status = dto.status,
     )
 
-    fun toBookingDomain(response: BookingResponse): Booking = Booking(
-        id = response.bookingId,
+    fun toPaymentDomain(response: PaymentResponse): Payment = Payment(
+        id = response.paymentId,
         confirmationCode = response.confirmationCode,
-        status = BookingStatus.valueOf(response.status),
+        status = PaymentStatus.valueOf(response.status),
     )
 }
 ```
@@ -438,6 +438,10 @@ class FlightMapper @Inject constructor() {
 - Use `sealed interface` for UI state to guarantee exhaustive `when` handling
 - Split each feature into `:api` (routes + entry params) and `:impl` (screens, ViewModels, DI)
 - Aggregate feature nav graphs into the host with Hilt `@IntoSet` multibinding
+- Let a repository implementation depend on data sources only; the remote data source owns the Retrofit service and unwraps the response envelope
+- Run remote calls through one shared request helper (IO dispatcher, error mapping); leave local and in-memory calls unwrapped
+- Map domain models to feature-local `@Immutable` UI models in the ViewModel (a domain class from another module is unstable in Compose)
+- Default feature and data classes to `internal`; only routes and domain contracts are public
 
 ### Don'ts
 - Do not let feature modules depend on each other directly
@@ -449,6 +453,8 @@ class FlightMapper @Inject constructor() {
 - Do not use `GlobalScope` -- always use `viewModelScope` or a structured scope
 - Do not put business logic in ViewModels -- delegate to use cases
 - Do not use `LiveData` for new Compose-first projects
+- Do not inject a Retrofit `*ApiService` into a repository implementation, or let a DTO or `Response` type leave the data layer
+- Do not call a use case outside the ViewModel's executor; that bypasses shared loading and error routing
 
 ## Troubleshooting
 
@@ -474,5 +480,8 @@ class FlightMapper @Inject constructor() {
 - [ ] Feature `impl` modules depend only on other features' `api`, never their `impl`
 - [ ] Feature nav graphs aggregate into the host via Hilt `@IntoSet` multibinding
 - [ ] Mappers separate DTO/Entity/Domain models
+- [ ] Repository implementations depend on data sources, never on the API service
+- [ ] No DTO, `Response` or domain entity reaches a composable; UI models are feature-local
+- [ ] Feature and data internals are `internal`
 - [ ] Coroutine dispatchers are injectable via `DispatcherProvider`
 - [ ] No `GlobalScope` usage; all coroutines use structured concurrency

package/pipeline/skills/shared/external/android-build-quality-gates/SKILL.md

@@ -1,9 +1,10 @@
 ---
 name: android-build-quality-gates
 description: "Encode Android module and quality rules as build-failing Gradle tasks: layer-dependency checks, coverage floors, a Compose-stability gate, lint-on-diff and screenshot validation. Use when a multi-module app needs enforceable boundaries and quality gates in the build, not in review."
-risk: safe
-source: multi-agent-pipeline
-date_added: "2026-09-21"
+metadata:
+  risk: safe
+  source: multi-agent-pipeline
+  date_added: "2026-09-21"
 ---
 
 # Android Build Quality Gates
@@ -25,6 +26,7 @@ carries the decisions and short snippets.
 - [Coverage floor with Kover](#coverage-floor-with-kover)
 - [Compose-stability gate](#compose-stability-gate)
 - [Lint on diff](#lint-on-diff)
+- [Custom architecture rules](#custom-architecture-rules)
 - [Screenshot validation task](#screenshot-validation-task)
 - [Ratchet, do not wall](#ratchet-do-not-wall)
 - [Wiring gates into check](#wiring-gates-into-check)
@@ -203,6 +205,51 @@ Keep the two consistent: the same ruleset and the same baseline file drive both
 the diff run and the full run, so a commit that passes the hook does not surprise
 the author in CI.
 
+## Custom architecture rules
+
+A convention written only in a doc is enforced by whoever reviews that day. The
+rules a reviewer keeps repeating belong in a custom detekt rule set, run by the
+same diff hook and CI job as the rest of static analysis. Good candidates are
+rules a single file shows the violation of:
+
+- route arguments read with a plain `toRoute()` instead of the project's typed
+  helper that carries the type map
+- a `*RepositoryImpl` that injects a Retrofit `*ApiService` instead of a data
+  source, skips the shared base class, or makes a remote call outside the shared
+  request helper
+- a raw `dp` / `sp` / `Color(...)` literal inside the design-system module
+- an import from the Material 2 `androidx.compose.material.*` package
+
+Put the rules in a small JVM module and register it with `detektPlugins`
+(detekt 1.23 API shown):
+
+```kotlin
+class TypedRouteRequired(config: Config) : Rule(config) {
+    override val issue = Issue(javaClass.simpleName, Severity.Defect,
+        "Read route arguments through the typed helper", Debt.FIVE_MINS)
+
+    override fun visitCallExpression(expression: KtCallExpression) {
+        super.visitCallExpression(expression)
+        if (expression.calleeExpression?.text == "toRoute") {
+            report(CodeSmell(issue, Entity.from(expression), issue.description))
+        }
+    }
+}
+
+class ArchitectureRuleSetProvider : RuleSetProvider {
+    override val ruleSetId = "architecture"
+    override fun instance(config: Config) = RuleSet(ruleSetId, listOf(TypedRouteRequired(config)))
+}
+// META-INF/services/io.gitlab.arturbosch.detekt.api.RuleSetProvider names the provider;
+// modules apply it with detektPlugins(project(":lint-rules")).
+```
+
+Run the rule set with `warningsAsErrors: true` and `maxIssues: 0`, so a
+violation fails the commit hook instead of adding to a report. Give each rule a
+narrow, suppressible scope (`@Suppress("NoRawValues")` on one private constants
+object is a reviewed exception, not a loophole). Tell the reviewers (human or
+automated) which rules exist, so review time goes to what no rule can see.
+
 ## Screenshot validation task
 
 Screenshot tests are only a gate when a mismatch fails the build. Author the
@@ -308,6 +355,7 @@ This skill owns build-failing quality-gate tasks. It does not re-explain:
 - [ ] Compose stability report points at a build dir, check is `finalizedBy` the
       compile, ignore-list holds accepted exceptions only.
 - [ ] Lint runs on the diff at commit time, full with baseline in CI.
+- [ ] Repeated review findings encoded as custom detekt rules, zero-tolerance, and listed for reviewers.
 - [ ] Screenshot `verify` fails on missing/changed goldens, never records.
 - [ ] Every gate is reachable from `check`; expensive ones sit behind `-P` flags.
 - [ ] Floors seeded at current state; ignore-lists/baselines only ratchet down.

package/pipeline/skills/shared/external/android-build-quality-gates/references/patterns.md

@@ -4,6 +4,15 @@ Full, copy-ready code for the gates summarized in
 [../SKILL.md](../SKILL.md). Each section mirrors a heading there. Adapt names to
 the project's module conventions; nothing here hardcodes a product.
 
+## Contents
+
+- [Layer-dependency gate](#layer-dependency-gate)
+- [Coverage floor with Kover](#coverage-floor-with-kover)
+- [Compose-stability gate](#compose-stability-gate)
+- [Lint on diff](#lint-on-diff)
+- [Screenshot validation task](#screenshot-validation-task)
+- [Wiring gates into check](#wiring-gates-into-check)
+
 ## Layer-dependency gate
 
 Convention plugin `build-logic/convention/src/main/kotlin/quality/LayerGate.kt`.

package/pipeline/skills/shared/external/android-datastore/SKILL.md

@@ -1,9 +1,10 @@
 ---
 name: android-datastore
 description: "Typed Jetpack DataStore as the modern SharedPreferences replacement: Preferences and typed stores, serializer-layer encryption, and migration. Use when persisting settings, session or tokens, encrypting key-value state, or migrating off EncryptedSharedPreferences."
-risk: safe
-source: multi-agent-pipeline
-date_added: "2026-09-21"
+metadata:
+  risk: safe
+  source: multi-agent-pipeline
+  date_added: "2026-09-21"
 ---
 
 # Android DataStore

package/pipeline/skills/shared/external/android-design-tokens-codegen/SKILL.md

@@ -1,9 +1,10 @@
 ---
 name: android-design-tokens-codegen
 description: "A single-source JSON to typed-Kotlin codegen pipeline for design tokens, UI-test ids, analytics events and deeplink manifests, run as Gradle tasks with a --check CI freshness gate. Use when a design system or cross-platform app needs one source of truth that generates typed code."
-risk: safe
-source: multi-agent-pipeline
-date_added: "2026-09-21"
+metadata:
+  risk: safe
+  source: multi-agent-pipeline
+  date_added: "2026-09-21"
 ---
 
 # Android Design Tokens Codegen