From 3516c5912f30bf8f98e6afdf6f254142fb5fd8d8 Mon Sep 17 00:00:00 2001
From: Sebastian Fix <sebastian.fix@codebar.ch>
Date: Fri, 27 Feb 2026 22:45:40 +0100
Subject: [PATCH 1/9] Package transfomrer

---
 LICENSE.md                                    |  21 +
 README.md                                     |  92 ++-
 composer.json                                 |  41 ++
 guidelines.mdc                                |  15 +-
 resources/boost/skills/actions/SKILL.md       |  95 +++
 resources/boost/skills/blade/SKILL.md         |  74 +++
 resources/boost/skills/commands/SKILL.md      |  78 +++
 resources/boost/skills/controllers/SKILL.md   |  83 +++
 resources/boost/skills/dto/SKILL.md           |  63 ++
 resources/boost/skills/dusk/SKILL.md          | 100 +++
 resources/boost/skills/enums/SKILL.md         |  76 +++
 resources/boost/skills/events/SKILL.md        | 102 +++
 resources/boost/skills/exceptions/SKILL.md    |  90 +++
 resources/boost/skills/formrequests/SKILL.md  |  91 +++
 resources/boost/skills/general/SKILL.md       |  75 +++
 .../boost/skills/helperfunctions/SKILL.md     |  96 +++
 resources/boost/skills/helpers/SKILL.md       |  70 +++
 resources/boost/skills/interfaces/SKILL.md    |  94 +++
 resources/boost/skills/jobs/SKILL.md          |  85 +++
 resources/boost/skills/livewire/SKILL.md      | 117 ++++
 resources/boost/skills/middleware/SKILL.md    |  90 +++
 resources/boost/skills/migrations/SKILL.md    |  77 +++
 resources/boost/skills/models/SKILL.md        |  92 +++
 resources/boost/skills/observers/SKILL.md     |  87 +++
 resources/boost/skills/pesttesting/SKILL.md   | 120 ++++
 resources/boost/skills/php/SKILL.md           | 101 +++
 resources/boost/skills/phpstan/SKILL.md       |  86 +++
 resources/boost/skills/phpunit/SKILL.md       |  94 +++
 resources/boost/skills/policies/SKILL.md      |  90 +++
 resources/boost/skills/requests/SKILL.md      |  81 +++
 resources/boost/skills/resources/SKILL.md     |  75 +++
 resources/boost/skills/routing/SKILL.md       |  68 ++
 resources/boost/skills/saloon/SKILL.md        | 130 ++++
 resources/boost/skills/services/SKILL.md      |  95 +++
 resources/boost/skills/traits/SKILL.md        |  97 +++
 src/CodingGuidelinesServiceProvider.php       |  27 +
 vendor/autoload.php                           |  22 +
 vendor/composer/ClassLoader.php               | 579 ++++++++++++++++++
 vendor/composer/LICENSE                       |  21 +
 vendor/composer/autoload_classmap.php         |  10 +
 vendor/composer/autoload_namespaces.php       |   9 +
 vendor/composer/autoload_psr4.php             |  10 +
 vendor/composer/autoload_real.php             |  38 ++
 vendor/composer/autoload_static.php           |  36 ++
 vendor/composer/platform_check.php            |  25 +
 45 files changed, 3686 insertions(+), 32 deletions(-)
 create mode 100644 LICENSE.md
 create mode 100644 composer.json
 create mode 100644 resources/boost/skills/actions/SKILL.md
 create mode 100644 resources/boost/skills/blade/SKILL.md
 create mode 100644 resources/boost/skills/commands/SKILL.md
 create mode 100644 resources/boost/skills/controllers/SKILL.md
 create mode 100644 resources/boost/skills/dto/SKILL.md
 create mode 100644 resources/boost/skills/dusk/SKILL.md
 create mode 100644 resources/boost/skills/enums/SKILL.md
 create mode 100644 resources/boost/skills/events/SKILL.md
 create mode 100644 resources/boost/skills/exceptions/SKILL.md
 create mode 100644 resources/boost/skills/formrequests/SKILL.md
 create mode 100644 resources/boost/skills/general/SKILL.md
 create mode 100644 resources/boost/skills/helperfunctions/SKILL.md
 create mode 100644 resources/boost/skills/helpers/SKILL.md
 create mode 100644 resources/boost/skills/interfaces/SKILL.md
 create mode 100644 resources/boost/skills/jobs/SKILL.md
 create mode 100644 resources/boost/skills/livewire/SKILL.md
 create mode 100644 resources/boost/skills/middleware/SKILL.md
 create mode 100644 resources/boost/skills/migrations/SKILL.md
 create mode 100644 resources/boost/skills/models/SKILL.md
 create mode 100644 resources/boost/skills/observers/SKILL.md
 create mode 100644 resources/boost/skills/pesttesting/SKILL.md
 create mode 100644 resources/boost/skills/php/SKILL.md
 create mode 100644 resources/boost/skills/phpstan/SKILL.md
 create mode 100644 resources/boost/skills/phpunit/SKILL.md
 create mode 100644 resources/boost/skills/policies/SKILL.md
 create mode 100644 resources/boost/skills/requests/SKILL.md
 create mode 100644 resources/boost/skills/resources/SKILL.md
 create mode 100644 resources/boost/skills/routing/SKILL.md
 create mode 100644 resources/boost/skills/saloon/SKILL.md
 create mode 100644 resources/boost/skills/services/SKILL.md
 create mode 100644 resources/boost/skills/traits/SKILL.md
 create mode 100644 src/CodingGuidelinesServiceProvider.php
 create mode 100644 vendor/autoload.php
 create mode 100644 vendor/composer/ClassLoader.php
 create mode 100644 vendor/composer/LICENSE
 create mode 100644 vendor/composer/autoload_classmap.php
 create mode 100644 vendor/composer/autoload_namespaces.php
 create mode 100644 vendor/composer/autoload_psr4.php
 create mode 100644 vendor/composer/autoload_real.php
 create mode 100644 vendor/composer/autoload_static.php
 create mode 100644 vendor/composer/platform_check.php

diff --git a/LICENSE.md b/LICENSE.md
new file mode 100644
index 0000000..a5267d1
--- /dev/null
+++ b/LICENSE.md
@@ -0,0 +1,21 @@
+# The MIT License (MIT)
+
+Copyright (c) codebar-ag
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/README.md b/README.md
index af0bfae..0a05777 100644
--- a/README.md
+++ b/README.md
@@ -1,19 +1,33 @@
 # Coding Guidelines
 
-Shared Cursor AI rules and skills for codebar-ag Laravel projects. The AI uses these to follow consistent conventions for PHP, Laravel, testing, frontend, and services.
+Shared Laravel AI coding guidelines and skills for codebar-ag projects. A Boost-first Composer package that ships 30+ skills for consistent conventions across PHP, Laravel, testing, frontend, and services.
 
 **Rule index:** See [RULES.md](RULES.md) for the full rule structure and file reference.
 
 ---
 
-## Prerequisites
+## Skills Summary
 
-- A Laravel project where you want to use these guidelines
-- [Laravel Boost](https://github.com/laravel/boost) (for syncing rules/skills into your project)
+| Category | Skills | Description |
+|----------|--------|-------------|
+| **Laravel** | General, HelperFunctions, Models, Controllers, Migrations, Routing, FormRequests | Framework conventions, config/logging, Eloquent, routes, validation |
+| **Backend** | Actions, Commands, DTO, Enums, Events, Exceptions, Helpers, Interfaces, Jobs, Middleware, Observers, Policies, Requests, Resources, Services, Traits | PHP architecture, single-purpose classes, API resources, queue jobs |
+| **Frontend** | Blade, Livewire | Templates, components, reactive UI |
+| **Testing** | PHPUnit, PestTesting, PHPStan, Dusk | Unit/feature tests, static analysis, browser tests |
+| **Services** | Saloon | External API integrations (Saloon pattern) |
+
+**Total: 30 skills.** Each skill includes Rules, Examples, Anti-Patterns, and References.
 
 ---
 
-## 1. Install Laravel Boost (if not already)
+## Implementation Guide
+
+### Prerequisites
+
+- A Laravel project where you want to use these guidelines
+- [Laravel Boost](https://github.com/laravel/boost) (required for skill discovery)
+
+### Step 1: Install Laravel Boost
 
 In your Laravel project:
 
@@ -22,34 +36,70 @@ composer require laravel/boost --dev
 php artisan boost:install
 ```
 
----
+### Step 2: Add this package
+
+**Option A — Composer (recommended for version pinning):**
+
+```bash
+composer require codebar-ag/coding-guidelines --dev
+```
 
-## 2. Activate the MCP server
+**Option B — GitHub via Boost:**
 
-If your editor supports MCP (Model Context Protocol), configure it to use the Boost MCP server so the AI has full context. See the [Laravel Boost documentation](https://github.com/laravel/boost) for your editor’s setup.
+```bash
+php artisan boost:add-skill codebar-ag/coding-guidelines
+```
 
----
+### Step 3: Sync skills
 
-## 3. Add and sync the guidelines
+```bash
+php artisan boost:update
+```
 
-Choose one of the following depending on how you work with this repo.
+Boost automatically discovers skills from `vendor/codebar-ag/coding-guidelines/resources/boost/skills/` when the package is installed.
 
-### When you are **not** pulling from `main`
+### Step 4: Activate MCP (optional)
 
-1. Copy the **`skills`** folder from this repo into your AI config folder (e.g. `.cursor/skills` or your editor’s equivalent).
-2. In your Laravel project, run:
+If your editor supports MCP (Model Context Protocol), configure it to use the Boost MCP server for full context. See the [Laravel Boost documentation](https://laravel.com/docs/boost) for your editor’s setup.
 
-   ```bash
-   php artisan boost:update
-   ```
+### Step 5: Override skills locally (optional)
 
-### When you **are** pulling from the `main` branch (recommended)
+To customize a skill for your project, create a file at `.ai/skills/{skill-name}/SKILL.md`. Your local version takes precedence over the package default.
 
-In your Laravel project, add this repo as a Boost skill source and update:
+Example: override the Models skill:
+
+```
+your-project/
+├── .ai/
+│   └── skills/
+│       └── models/
+│           └── SKILL.md    ← Your custom version
+```
+
+---
+
+## How It Works
+
+This package places skills in `resources/boost/skills/{skill-name}/SKILL.md`. Laravel Boost v2.2+ automatically discovers skills from vendor packages when you run `boost:update`. No custom sync commands — Boost handles everything.
+
+| Source | Path |
+|--------|------|
+| This package | `vendor/codebar-ag/coding-guidelines/resources/boost/skills/` |
+| Project overrides | `.ai/skills/{skill-name}/SKILL.md` |
+
+---
+
+## Updating
+
+When using Composer:
 
 ```bash
-php artisan boost:add-skill codebar-ag/coding-guidelines
+composer update codebar-ag/coding-guidelines
 php artisan boost:update
 ```
 
-After this, the AI in your project will automatically use the rules and skills from this repository.
+When using `boost:add-skill`:
+
+```bash
+php artisan boost:update
+```
diff --git a/composer.json b/composer.json
new file mode 100644
index 0000000..08904c1
--- /dev/null
+++ b/composer.json
@@ -0,0 +1,41 @@
+{
+    "name": "codebar-ag/coding-guidelines",
+    "description": "Shared Laravel AI coding guidelines and skills for codebar-ag projects. Boost-first Composer package.",
+    "keywords": [
+        "laravel",
+        "boost",
+        "ai",
+        "cursor",
+        "coding-guidelines",
+        "skills"
+    ],
+    "license": "MIT",
+    "require": {
+        "php": "^8.2"
+    },
+    "suggest": {
+        "laravel/boost": "Required for skill discovery. Install in your Laravel project."
+    },
+    "autoload": {
+        "psr-4": {
+            "CodebarAg\\CodingGuidelines\\": "src/"
+        }
+    },
+    "autoload-dev": {
+        "psr-4": {
+            "CodebarAg\\CodingGuidelines\\Tests\\": "tests/"
+        }
+    },
+    "extra": {
+        "laravel": {
+            "providers": [
+                "CodebarAg\\CodingGuidelines\\CodingGuidelinesServiceProvider"
+            ]
+        }
+    },
+    "config": {
+        "sort-packages": true
+    },
+    "minimum-stability": "dev",
+    "prefer-stable": true
+}
diff --git a/guidelines.mdc b/guidelines.mdc
index 174d3ae..5f1c519 100644
--- a/guidelines.mdc
+++ b/guidelines.mdc
@@ -1,19 +1,12 @@
 ---
-description: References shared coding guidelines in the guidelines/ directory
+description: References codebar-ag coding guidelines (installed via Laravel Boost)
 alwaysApply: true
 ---
 
 # Shared Coding Guidelines
 
-This project has shared coding guidelines in the `guidelines/` directory
-(synced from the codebar-ag/coding-guidelines repo).
+This project uses **codebar-ag/coding-guidelines** — Laravel AI skills installed via [Laravel Boost](https://laravel.com/docs/boost).
 
-Before making any code change, read and follow the relevant rule files:
+Before making any code change, follow the relevant skills (PHP, Models, Actions, Livewire, etc.) that Boost has installed. Run `php artisan boost:update` to sync the latest skills.
 
-- `guidelines/rules/testing/` -- PHPUnit, PHPStan conventions
-- `guidelines/rules/frontend/` -- Blade, Livewire, Tailwind conventions
-- `guidelines/rules/backend/` -- PHP typing, enums, DTOs, jobs conventions
-- `guidelines/rules/laravel/` -- Models, controllers, migrations, routing conventions
-- `guidelines/rules/services/` -- Saloon, DocuWare, Albatros API conventions
-
-See `guidelines/RULES.md` for the full structure and index.
+See the [README](https://github.com/codebar-ag/coding-guidelines) for the full skills index.
diff --git a/resources/boost/skills/actions/SKILL.md b/resources/boost/skills/actions/SKILL.md
new file mode 100644
index 0000000..ab4ce2a
--- /dev/null
+++ b/resources/boost/skills/actions/SKILL.md
@@ -0,0 +1,95 @@
+---
+name: actions
+description: Single-purpose business logic classes that encapsulate one well-defined business operation. Actions are the primary location for business logic in Laravel applications, invoked from controllers, commands, or jobs.
+---
+
+**Name:** Actions
+**Description:** Single-purpose business logic classes that encapsulate one well-defined business operation. Actions are the primary location for business logic in Laravel applications, invoked from controllers, commands, or jobs.
+**Compatible Agents:** general-purpose, backend
+**Tags:** app/Actions/**/*.php, laravel, php, backend, business-logic, action
+
+## Rules
+
+- Action classes live in `app/Actions/`
+- Each action represents **one single business operation** — if you can't describe it in a single sentence, split it up
+- Use a clear verb-noun naming pattern: `CreateInvoice`, `SendPasswordResetEmail`, `ArchiveExpiredSubscriptions`
+- Never use vague names like `InvoiceAction` or `UserHandler`
+- Actions expose a single public `execute()` method
+- Keep the constructor for dependency injection only
+- Actions are resolved via the service container
+- Never include HTTP concerns (request, response, redirects) in an action
+- Never put multi-domain orchestration in an action — use a Service instead
+- Never put reusable formatting or utility logic in an action — use a Helper
+
+## Examples
+
+```php
+namespace App\Actions;
+
+use App\Models\Invoice;
+use App\Models\Order;
+use App\Notifications\InvoiceCreatedNotification;
+
+class CreateInvoice
+{
+    public function __construct(
+        private readonly GenerateInvoicePdf $generatePdf,
+    ) {}
+
+    public function execute(Order $order): Invoice
+    {
+        $invoice = Invoice::create([
+            'order_id' => $order->id,
+            'amount'   => $order->total,
+            'due_date' => now()->addDays(30),
+        ]);
+
+        $this->generatePdf->execute($invoice);
+
+        $order->user->notify(new InvoiceCreatedNotification($invoice));
+
+        return $invoice;
+    }
+}
+```
+
+```php
+// Controller usage
+class InvoiceController extends Controller
+{
+    public function store(StoreInvoiceRequest $request, CreateInvoice $action): JsonResponse
+    {
+        $order = Order::findOrFail($request->validated('order_id'));
+        $invoice = $action->execute($order);
+
+        return new JsonResponse(new InvoiceResource($invoice), 201);
+    }
+}
+
+// Command usage
+class GenerateInvoicesCommand extends Command
+{
+    public function handle(CreateInvoice $action): int
+    {
+        Order::pending()->each(fn ($order) => $action->execute($order));
+
+        return self::SUCCESS;
+    }
+}
+```
+
+## Anti-Patterns
+
+- Putting HTTP concerns (`Request`, `Response`, redirects) inside an action
+- Creating multi-step orchestration across domains in a single action (use a Service)
+- Naming an action vaguely: `InvoiceAction`, `UserHandler`, `DataProcessor`
+- Adding multiple `execute()` methods or public methods beyond the single operation
+- Adding business logic in a constructor — use `execute()` for that
+- Performing database queries unrelated to the action's single responsibility
+
+## References
+
+- [Laravel Service Container](https://laravel.com/docs/container)
+- Related: `Services/SKILL.md` — for multi-domain orchestration
+- Related: `Jobs/SKILL.md` — for deferring actions to the queue
+- Related: `Controllers/SKILL.md` — for how controllers delegate to actions
diff --git a/resources/boost/skills/blade/SKILL.md b/resources/boost/skills/blade/SKILL.md
new file mode 100644
index 0000000..8b8e0f1
--- /dev/null
+++ b/resources/boost/skills/blade/SKILL.md
@@ -0,0 +1,74 @@
+---
+name: blade
+description: Laravel Blade template conventions covering components, output escaping, security, structure, and formatting.
+---
+
+**Name:** Blade Templates
+**Description:** Laravel Blade template conventions covering components, output escaping, security, structure, and formatting.
+**Compatible Agents:** general-purpose, frontend
+**Tags:** resources/views/**/*.blade.php, laravel, php, frontend, blade, template, html
+
+## Rules
+
+- Use Blade components (`<x-component>`) for reusable UI pieces
+- Prefer anonymous components for simple, presentation-only elements
+- Use class-based components when logic is needed
+- Use `{{ }}` for escaped output (default) — never output raw user input unescaped
+- Use `{!! !!}` only when the content is explicitly safe (e.g., pre-sanitized HTML)
+- No inline `<style>` tags in Blade files
+- No inline `<script>` tags in Blade files — use Livewire or Alpine.js via Blade directives
+- Keep all user-facing text in English
+- Indent Blade directives consistently (4 spaces)
+- Use short attribute syntax where supported: `@class`, `@style`
+
+## Examples
+
+```blade
+{{-- Escaped output — always use {{ }} for user data --}}
+<h1>{{ $user->name }}</h1>
+<p>{{ $post->excerpt }}</p>
+
+{{-- Raw output — only for pre-sanitized content --}}
+{!! $article->sanitizedBody !!}
+
+{{-- Anonymous component --}}
+<x-card>
+    <x-slot:title>{{ $invoice->title }}</x-slot:title>
+    <p>{{ $invoice->amount }}</p>
+</x-card>
+```
+
+```blade
+{{-- @class directive for conditional classes --}}
+<div @class(['p-4 rounded', 'bg-green-100' => $active, 'bg-red-100' => $error])>
+    {{ $message }}
+</div>
+
+{{-- @style directive for conditional styles --}}
+<div @style(['color: green' => $success, 'color: red' => $failure])>
+    {{ $text }}
+</div>
+```
+
+```blade
+{{-- Alpine.js via directive — no inline script tags --}}
+<div x-data="{ open: false }">
+    <button @click="open = !open">Toggle</button>
+    <div x-show="open">Content</div>
+</div>
+```
+
+## Anti-Patterns
+
+- Using `{!! $user->input !!}` for user-provided data — XSS vulnerability
+- Adding `<style>` or `<script>` tags directly in Blade files
+- Putting complex PHP logic directly in Blade templates (use components or Livewire)
+- Using inconsistent indentation for `@if`, `@foreach`, `@while` blocks
+- Hardcoding non-English text directly in Blade (use translation helpers for user-facing strings)
+
+## References
+
+- [Laravel Blade Templates](https://laravel.com/docs/blade)
+- [Alpine.js](https://alpinejs.dev/)
+- Related: `Livewire/SKILL.md` — interactive UI in Blade templates
+- Related: `Design/SKILL.md` — component-first design system
diff --git a/resources/boost/skills/commands/SKILL.md b/resources/boost/skills/commands/SKILL.md
new file mode 100644
index 0000000..7359f4a
--- /dev/null
+++ b/resources/boost/skills/commands/SKILL.md
@@ -0,0 +1,78 @@
+---
+name: commands
+description: Artisan console command classes that serve as the CLI entry point for operations. Commands validate input and delegate all business logic to Actions or Services.
+---
+
+**Name:** Commands
+**Description:** Artisan console command classes that serve as the CLI entry point for operations. Commands validate input and delegate all business logic to Actions or Services.
+**Compatible Agents:** general-purpose, backend
+**Tags:** app/Console/Commands/**/*.php, laravel, php, backend, artisan, cli, console
+
+## Rules
+
+- Command classes live in `app/Console/Commands/`
+- Each command should have a single, clearly defined responsibility
+- Complex logic belongs in **Actions** or **Services**, not in the command itself — commands are the entry point only
+- Use descriptive verb-noun names: `SendInvoiceReminders`, `ImportProductCsv`, `PruneExpiredSessions`
+- Command signatures follow the `namespace:action` pattern: `invoices:send-reminders`, `products:import`
+- Every argument and option **must** have a clear description
+- Validate all input using the `Validator` class — never trust raw input
+- Use `--option` flags for optional behaviour; avoid positional ambiguity
+- Implement `PromptsForMissingInput` so users receive clear prompts instead of silent failures
+- Commands must **always** return either `self::SUCCESS` or `self::FAILURE` — never `void` or `null`
+
+## Examples
+
+```php
+class SendInvoiceReminders extends Command implements PromptsForMissingInput
+{
+    protected $signature = 'invoices:send-reminders
+                            {email : The email address to send the reminder to}
+                            {--dry-run : Simulate the command without persisting changes}';
+
+    protected $description = 'Send invoice payment reminders to a specific user.';
+
+    public function __construct(private readonly SendInvoiceReminderAction $action)
+    {
+        parent::__construct();
+    }
+
+    public function handle(): int
+    {
+        $validated = validator(
+            [
+                'email'   => $this->argument('email'),
+                'dry_run' => $this->option('dry-run'),
+            ],
+            [
+                'email'   => ['required', 'email'],
+                'dry_run' => ['boolean'],
+            ]
+        )->validate();
+
+        try {
+            $this->action->execute($validated['email']);
+            $this->info("Reminder sent to {$validated['email']}.");
+
+            return self::SUCCESS;
+        } catch (Throwable $e) {
+            $this->error("Failed: {$e->getMessage()}");
+
+            return self::FAILURE;
+        }
+    }
+}
+```
+
+## Anti-Patterns
+
+- Putting business logic directly inside `handle()` instead of delegating to an Action or Service
+- Not returning `self::SUCCESS` or `self::FAILURE` (e.g., returning `void` or `null`)
+- Trusting raw `$this->argument()` / `$this->option()` values without validation
+- Omitting descriptions from arguments and options in the signature
+- Not implementing `PromptsForMissingInput`, causing silent failures for missing arguments
+
+## References
+
+- [Laravel Artisan Console](https://laravel.com/docs/artisan)
+- Related: `Actions/SKILL.md` — for the business logic commands delegate to
diff --git a/resources/boost/skills/controllers/SKILL.md b/resources/boost/skills/controllers/SKILL.md
new file mode 100644
index 0000000..b6da9d0
--- /dev/null
+++ b/resources/boost/skills/controllers/SKILL.md
@@ -0,0 +1,83 @@
+---
+name: controllers
+description: Thin HTTP entry points that validate input, delegate to Actions or Services, and return a response. Controllers contain no business logic.
+---
+
+**Name:** Controllers
+**Description:** Thin HTTP entry points that validate input, delegate to Actions or Services, and return a response. Controllers contain no business logic.
+**Compatible Agents:** general-purpose, backend
+**Tags:** app/Http/Controllers/**/*.php, laravel, php, backend, controller, http, request-response
+
+## Rules
+
+- Keep controllers **thin** — delegate business logic to Services, Actions, or Jobs
+- Controllers handle: request validation, calling a service/job, returning a response
+- No direct database queries or complex logic in controller methods
+- Use dedicated `FormRequest` classes for all validation — never call `$request->validate()` or `Validator::make()` inside a controller
+- Use invokable controllers (`__invoke`) for single-action endpoints
+- Name invokable controllers after the action: `StoreInvoiceController`, `ProcessWebhookController`
+- Return JSON responses from API controllers
+- Return views from web controllers
+- Use appropriate HTTP status codes (200, 201, 422, 403, etc.)
+- Enforce authorization at the controller level using `$this->authorize()`, via Form Request `authorize()`, or route middleware
+
+## Examples
+
+```php
+// Invokable single-action controller
+class StoreInvoiceController extends Controller
+{
+    public function __invoke(StoreInvoiceRequest $request, CreateInvoice $action): JsonResponse
+    {
+        $order = Order::findOrFail($request->validated('order_id'));
+        $invoice = $action->execute($order);
+
+        return new JsonResponse(new InvoiceResource($invoice), 201);
+    }
+}
+```
+
+```php
+// Resource controller — thin, delegates to actions
+class InvoiceController extends Controller
+{
+    public function index(): JsonResponse
+    {
+        return new JsonResponse(InvoiceResource::collection(Invoice::paginate()));
+    }
+
+    public function store(StoreInvoiceRequest $request, CreateInvoice $action): JsonResponse
+    {
+        $this->authorize('create', Invoice::class);
+
+        $order = Order::findOrFail($request->validated('order_id'));
+        $invoice = $action->execute($order);
+
+        return new JsonResponse(new InvoiceResource($invoice), 201);
+    }
+
+    public function destroy(Invoice $invoice, DeleteInvoice $action): JsonResponse
+    {
+        $this->authorize('delete', $invoice);
+        $action->execute($invoice);
+
+        return new JsonResponse(null, 204);
+    }
+}
+```
+
+## Anti-Patterns
+
+- Calling `$request->validate()` directly in a controller (use a FormRequest)
+- Writing database queries directly in a controller
+- Putting business logic in a controller method
+- Using resource controllers with 7 methods when only 1-2 are needed (use invokable controllers)
+- Not using appropriate HTTP status codes in responses
+- Performing authorization inside Actions instead of at the controller level
+
+## References
+
+- [Laravel Controllers](https://laravel.com/docs/controllers)
+- Related: `FormRequests/SKILL.md` — all input validation
+- Related: `Actions/SKILL.md` — the business logic controllers delegate to
+- Related: `Policies/SKILL.md` — authorization enforced in controllers
diff --git a/resources/boost/skills/dto/SKILL.md b/resources/boost/skills/dto/SKILL.md
new file mode 100644
index 0000000..a645a91
--- /dev/null
+++ b/resources/boost/skills/dto/SKILL.md
@@ -0,0 +1,63 @@
+---
+name: dto
+description: Readonly data containers with a `fromArray` factory method used to pass structured data between application layers — especially for external API responses and service boundaries.
+---
+
+**Name:** DTO (Data Transfer Object)
+**Description:** Readonly data containers with a `fromArray` factory method used to pass structured data between application layers — especially for external API responses and service boundaries.
+**Compatible Agents:** general-purpose, backend
+**Tags:** DataObjects/**/*.php, laravel, php, backend, dto, data-object, readonly
+
+## Rules
+
+- Use `readonly class` with constructor promotion
+- Include a `static fromArray(array $data): static` factory method
+- Place DTOs in the relevant service's `DataObjects/` directory
+- DTOs are immutable — never add setters or mutable state
+- Handle API field name variations (PascalCase, camelCase, snake_case) in `fromArray()`
+- Use nullable types for optional fields
+- Keep DTOs free of business logic — they are data containers only
+- All properties must have explicit types — no untyped properties
+
+## Examples
+
+```php
+readonly class CustomerData
+{
+    public function __construct(
+        public string $id,
+        public ?string $name,
+        public ?string $email,
+    ) {}
+
+    public static function fromArray(array $data): static
+    {
+        return new static(
+            id: (string) ($data['ID'] ?? $data['id'] ?? ''),
+            name: $data['Name'] ?? $data['name'] ?? null,
+            email: $data['Email'] ?? $data['email'] ?? null,
+        );
+    }
+}
+```
+
+```php
+// Usage
+$customer = CustomerData::fromArray($apiResponse);
+echo $customer->name;
+```
+
+## Anti-Patterns
+
+- Adding setters or mutable state to a DTO
+- Including business logic inside a DTO
+- Using a DTO as a model replacement (DTOs don't persist to the database)
+- Not handling API field name variations (assuming a single naming convention)
+- Leaving properties untyped or using `mixed` without narrowing
+- Placing DTOs in a global `DataObjects/` folder instead of within the relevant service directory
+
+## References
+
+- [PHP Readonly Classes](https://www.php.net/manual/en/language.oop5.readonly-properties.php)
+- Related: `Services/SKILL.md` — DTOs are typically returned by service classes
+- Related: `Saloon/SKILL.md` — Saloon integrations return typed DTOs
diff --git a/resources/boost/skills/dusk/SKILL.md b/resources/boost/skills/dusk/SKILL.md
new file mode 100644
index 0000000..0265164
--- /dev/null
+++ b/resources/boost/skills/dusk/SKILL.md
@@ -0,0 +1,100 @@
+---
+name: dusk
+description: End-to-end browser testing with Laravel Dusk. Used exclusively for full user flows requiring a real Chrome browser — JavaScript interactions, multi-step forms, and visual assertions.
+---
+
+**Name:** Dusk (Browser Testing)
+**Description:** End-to-end browser testing with Laravel Dusk. Used exclusively for full user flows requiring a real Chrome browser — JavaScript interactions, multi-step forms, and visual assertions.
+**Compatible Agents:** general-purpose, testing
+**Tags:** tests/Browser/**/*.php, laravel, php, testing, dusk, browser, e2e, end-to-end
+
+## Rules
+
+- Browser tests live in `tests/Browser/`
+- Use Dusk only where a real browser interaction is required (JavaScript, multi-step flows)
+- Never use `RefreshDatabase` in Dusk tests — use `DatabaseTruncation` (preferred) or `DatabaseMigrations`
+- Always call `assertNoJavaScriptErrors()` after every `visit()`
+- Always use `dusk=""` HTML attributes as selectors — never CSS classes or IDs
+- Never use `pause()` — use `waitFor()`, `waitForText()`, or `waitUntilMissing()` instead
+- Use `loginAs()` to authenticate without going through the login form
+- Extract repeated navigation into **Page Objects**
+- Extract repeated interactive UI elements into **Dusk Components**
+- Create a dedicated `.env.dusk.local` file to use a separate test database
+
+## Examples
+
+```php
+uses(DatabaseTruncation::class);
+
+it('user can submit an invoice', function () {
+    // Arrange
+    $user = User::factory()->create();
+
+    // Act + Assert
+    $this->browse(function (Browser $browser) use ($user) {
+        $browser->loginAs($user)
+                ->visit('/invoices/create')
+                ->assertNoJavaScriptErrors()
+                ->type('@amount-input', '100')
+                ->press('@submit-button')
+                ->waitForText('Invoice created')
+                ->assertSee('Invoice created');
+    });
+});
+```
+
+```html
+<!-- Blade/HTML — use dusk attributes, not CSS classes -->
+<button dusk="submit-invoice">Submit</button>
+<input dusk="amount-input" type="number" name="amount">
+```
+
+```php
+// Page Object
+class InvoicePage extends Page
+{
+    public function __construct(private readonly int $invoiceId) {}
+
+    public function url(): string { return "/invoices/{$this->invoiceId}"; }
+
+    public function assert(Browser $browser): void
+    {
+        $browser->assertPathIs($this->url());
+    }
+
+    public function elements(): array
+    {
+        return [
+            '@mark-paid-button' => '[dusk="mark-paid-button"]',
+        ];
+    }
+
+    public function markAsPaid(Browser $browser): void
+    {
+        $browser->click('@mark-paid-button')
+                ->waitForText('Invoice marked as paid');
+    }
+}
+```
+
+```php
+// Waiting — never use pause()
+$browser->waitFor('@invoice-table');          // ❌ pause(3000)
+$browser->waitForText('Invoice created');     // ❌ pause(2000)
+$browser->waitUntilMissing('@loading-spinner'); // ❌ pause(5000)
+```
+
+## Anti-Patterns
+
+- Using `RefreshDatabase` in Dusk tests (transactions invisible across HTTP processes)
+- Using `pause(3000)` — arbitrary sleeps make tests slow and brittle
+- Using CSS classes or IDs as selectors instead of `dusk=""` attributes
+- Testing pure business logic or JSON API responses with Dusk (use feature tests instead)
+- Not calling `assertNoJavaScriptErrors()` after `visit()`
+- Repeating navigation and selector logic across test files instead of using Page Objects
+
+## References
+
+- [Laravel Dusk](https://laravel.com/docs/dusk)
+- Related: `PestTesting/SKILL.md` — Pest syntax used for Dusk tests
+- Related: `PHPUnit/SKILL.md` — feature tests for non-browser scenarios
diff --git a/resources/boost/skills/enums/SKILL.md b/resources/boost/skills/enums/SKILL.md
new file mode 100644
index 0000000..0e03d26
--- /dev/null
+++ b/resources/boost/skills/enums/SKILL.md
@@ -0,0 +1,76 @@
+---
+name: enums
+description: PHP backed string enums used instead of constants or magic strings. Enums include `label()` and `color()` helper methods and are cast on Eloquent models.
+---
+
+**Name:** Enums
+**Description:** PHP backed string enums used instead of constants or magic strings. Enums include `label()` and `color()` helper methods and are cast on Eloquent models.
+**Compatible Agents:** general-purpose, backend
+**Tags:** app/Enums/**/*.php, laravel, php, backend, enum, status
+
+## Rules
+
+- Use **backed string enums** — never use plain constants or magic strings for finite sets of values
+- Include `label(): string` and `color(): string` helper methods on every enum
+- Place all enums in `app/Enums/`
+- Always cast enum columns in model `casts()` methods
+- Use enum string values in migrations: `$table->string('status')->default('draft')`
+- Reference enum cases in code, never raw strings: `Status::Draft` not `'draft'`
+- Use `match` expressions in `label()` and `color()` — never if/else chains
+
+## Examples
+
+```php
+enum Status: string
+{
+    case Draft    = 'draft';
+    case Active   = 'active';
+    case Archived = 'archived';
+
+    public function label(): string
+    {
+        return match ($this) {
+            self::Draft    => 'Draft',
+            self::Active   => 'Active',
+            self::Archived => 'Archived',
+        };
+    }
+
+    public function color(): string
+    {
+        return match ($this) {
+            self::Draft    => 'gray',
+            self::Active   => 'green',
+            self::Archived => 'red',
+        };
+    }
+}
+```
+
+```php
+// Model cast
+protected function casts(): array
+{
+    return [
+        'status' => Status::class,
+    ];
+}
+
+// Usage
+if ($invoice->status === Status::Draft) { ... }
+echo $invoice->status->label(); // 'Draft'
+```
+
+## Anti-Patterns
+
+- Using raw strings instead of enum cases: `'draft'` instead of `Status::Draft`
+- Using integer-backed enums when string enums are more readable
+- Forgetting to cast enum columns in the model's `casts()` method
+- Using if/else chains instead of `match` expressions in `label()` or `color()`
+- Putting business logic inside enum methods (beyond label/color presentation helpers)
+
+## References
+
+- [PHP Enums](https://www.php.net/manual/en/language.enumerations.php)
+- [Laravel Enum Casting](https://laravel.com/docs/eloquent-mutators#enum-casting)
+- Related: `Models/SKILL.md` — for how enums are cast in Eloquent models
diff --git a/resources/boost/skills/events/SKILL.md b/resources/boost/skills/events/SKILL.md
new file mode 100644
index 0000000..a9e96a9
--- /dev/null
+++ b/resources/boost/skills/events/SKILL.md
@@ -0,0 +1,102 @@
+---
+name: events
+description: Decoupled communication between application layers. Events are plain data objects describing what happened; listeners react to those events with a single, specific side effect.
+---
+
+**Name:** Events & Listeners
+**Description:** Decoupled communication between application layers. Events are plain data objects describing what happened; listeners react to those events with a single, specific side effect.
+**Compatible Agents:** general-purpose, backend
+**Tags:** app/Events/**/*.php, app/Listeners/**/*.php, laravel, php, backend, event, listener, observer-pattern
+
+## Rules
+
+- Event classes live in `app/Events/`; listener classes live in `app/Listeners/`
+- Events are plain data containers — no logic inside events
+- Listeners handle one specific reaction each — never bundle multiple side effects
+- Events: past-tense noun phrase → `InvoicePaid`, `UserRegistered`, `OrderShipped`
+- Listeners: verb phrase describing the reaction → `SendInvoicePaidNotification`, `UpdateInventory`
+- Dispatch events from inside an **Action** after the operation completes — never from a controller or model directly
+- Register events and listeners in `EventServiceProvider`
+- Implement `ShouldQueue` on listeners for side effects that can be deferred
+- Define a `failed()` method on queued listeners
+- Use events when one action triggers multiple independent side effects
+
+## Examples
+
+```php
+// Event — data container only
+namespace App\Events;
+
+use App\Models\Invoice;
+use Illuminate\Foundation\Events\Dispatchable;
+use Illuminate\Queue\SerializesModels;
+
+class InvoicePaid
+{
+    use Dispatchable, SerializesModels;
+
+    public function __construct(
+        public readonly Invoice $invoice,
+    ) {}
+}
+```
+
+```php
+// Listener — one reaction
+namespace App\Listeners;
+
+use App\Events\InvoicePaid;
+use App\Notifications\InvoicePaidNotification;
+use Illuminate\Contracts\Queue\ShouldQueue;
+
+class SendInvoicePaidNotification implements ShouldQueue
+{
+    public function handle(InvoicePaid $event): void
+    {
+        $event->invoice->user->notify(new InvoicePaidNotification($event->invoice));
+    }
+
+    public function failed(InvoicePaid $event, \Throwable $exception): void
+    {
+        // Handle failure
+    }
+}
+```
+
+```php
+// Dispatching — from inside an Action
+class MarkInvoiceAsPaid
+{
+    public function execute(Invoice $invoice): void
+    {
+        $invoice->update(['paid_at' => now()]);
+        InvoicePaid::dispatch($invoice);
+    }
+}
+```
+
+```php
+// Registration — one event, many listeners
+protected $listen = [
+    InvoicePaid::class => [
+        SendInvoicePaidNotification::class,
+        UpdateAccountingRecords::class,
+        NotifyAccountManager::class,
+    ],
+];
+```
+
+## Anti-Patterns
+
+- Adding business logic inside an Event class
+- Bundling multiple reactions in a single Listener (one listener, one reaction)
+- Dispatching events from controllers or models directly — dispatch from Actions
+- Using events for simple, single side effects that can be triggered directly
+- Not implementing `failed()` on queued listeners for critical side effects
+- Creating event chains that obscure control flow and make debugging hard
+
+## References
+
+- [Laravel Events](https://laravel.com/docs/events)
+- Related: `Actions/SKILL.md` — events should be dispatched from Actions
+- Related: `Observers/SKILL.md` — for model lifecycle reactions
diff --git a/resources/boost/skills/exceptions/SKILL.md b/resources/boost/skills/exceptions/SKILL.md
new file mode 100644
index 0000000..1b7e876
--- /dev/null
+++ b/resources/boost/skills/exceptions/SKILL.md
@@ -0,0 +1,90 @@
+---
+name: exceptions
+description: Named, meaningful failure states in your domain. Custom exceptions communicate precise failure reasons to callers and optionally carry domain-specific data.
+---
+
+**Name:** Exceptions
+**Description:** Named, meaningful failure states in your domain. Custom exceptions communicate precise failure reasons to callers and optionally carry domain-specific data.
+**Compatible Agents:** general-purpose, backend
+**Tags:** app/Exceptions/**/*.php, laravel, php, backend, exception, error-handling
+
+## Rules
+
+- Exception classes live in `app/Exceptions/`
+- Custom exceptions represent **named, meaningful failure states** — not generic error wrappers
+- Use a clear noun phrase describing what went wrong: `InvoiceAlreadyPaid`, `InsufficientFunds`, `PaymentGatewayUnavailable`
+- Always suffix with `Exception`: `InvoiceAlreadyPaidException`
+- Use named static constructors (`static for()`) to make throw sites readable
+- Set the message via `parent::__construct()` inside the constructor
+- Expose domain-specific context data as `public readonly` properties
+- Implement `render()` directly on exceptions that always map to the same HTTP response
+- Register exception rendering in `bootstrap/app.php` using `withExceptions()`
+- Avoid `try-catch` blocks — let exceptions bubble up to the framework handler unless you must react locally
+
+## Examples
+
+```php
+namespace App\Exceptions;
+
+use App\Models\Invoice;
+use RuntimeException;
+
+class InvoiceAlreadyPaidException extends RuntimeException
+{
+    public function __construct(
+        public readonly Invoice $invoice,
+    ) {
+        parent::__construct(
+            "Invoice #{$invoice->id} has already been paid and cannot be modified."
+        );
+    }
+
+    public static function for(Invoice $invoice): static
+    {
+        return new static($invoice);
+    }
+}
+```
+
+```php
+// Throwing — from inside an Action
+class MarkInvoiceAsPaid
+{
+    public function execute(Invoice $invoice): void
+    {
+        if ($invoice->isPaid()) {
+            throw InvoiceAlreadyPaidException::for($invoice);
+        }
+
+        $invoice->update(['paid_at' => now()]);
+    }
+}
+```
+
+```php
+// Registering in bootstrap/app.php
+->withExceptions(function (Exceptions $exceptions) {
+    $exceptions->render(function (InvoiceAlreadyPaidException $e, Request $request) {
+        return response()->json(['message' => $e->getMessage()], 422);
+    });
+
+    $exceptions->dontReport([
+        InvoiceAlreadyPaidException::class,
+    ]);
+})
+```
+
+## Anti-Patterns
+
+- Creating generic exception wrappers instead of named domain exceptions
+- Not using a named static constructor — verbose `new InvoiceAlreadyPaidException($invoice)` at every throw site
+- Putting business logic or recovery logic inside an exception class
+- Silently swallowing exceptions without logging or re-throwing
+- Using built-in exceptions where a domain-specific exception would communicate intent better
+- Creating an exception for cases already handled cleanly by validation or early returns
+
+## References
+
+- [Laravel Error Handling](https://laravel.com/docs/errors)
+- Related: `Actions/SKILL.md` — the typical place where domain exceptions are thrown
+- Related: `PHP/SKILL.md` — for error handling philosophy (avoid try-catch, let bubble)
diff --git a/resources/boost/skills/formrequests/SKILL.md b/resources/boost/skills/formrequests/SKILL.md
new file mode 100644
index 0000000..83e5049
--- /dev/null
+++ b/resources/boost/skills/formrequests/SKILL.md
@@ -0,0 +1,91 @@
+---
+name: formrequests
+description: Dedicated validation classes for all controller input. Form Requests encapsulate validation rules, authorization, and error messages outside of controllers.
+---
+
+**Name:** Form Requests
+**Description:** Dedicated validation classes for all controller input. Form Requests encapsulate validation rules, authorization, and error messages outside of controllers.
+**Compatible Agents:** general-purpose, backend
+**Tags:** app/Http/Requests/**/*.php, app/Http/Controllers/**/*.php, laravel, php, backend, validation, form-request
+
+## Rules
+
+- Every controller action that accepts user input **must** use a dedicated `FormRequest` class
+- Never call `$request->validate()` or `Validator::make()` inside a controller
+- Place Form Requests in `app/Http/Requests/` or a subdirectory matching the domain (e.g. `Auth/`)
+- Naming pattern: `Store{Resource}Request`, `Update{Resource}Request`
+- Match the resource name to the controller: `StoreSprintController` → `StoreSprintRequest`
+- Define `authorize(): bool` with proper authorization logic — never leave it as a passive `return true` without intention
+- Define `rules(): array` with a PHPDoc `@return` array shape
+- Use **array-based** rule definitions, not pipe-delimited strings
+- Add `messages(): array` when validation messages need localization or extra clarity
+
+## Examples
+
+```php
+class StoreSprintRequest extends FormRequest
+{
+    public function authorize(): bool
+    {
+        return $this->user() !== null;
+    }
+
+    /**
+     * @return array<string, array<int, string|object>>
+     */
+    public function rules(): array
+    {
+        return [
+            'title'  => ['required', 'string', 'max:255'],
+            'locale' => ['required', Locale::validationRule()],
+        ];
+    }
+
+    public function messages(): array
+    {
+        return [
+            'title.required' => __('A title is required.'),
+        ];
+    }
+}
+```
+
+```php
+// Controller usage — inject the FormRequest
+class StoreSprintController extends Controller
+{
+    public function __invoke(StoreSprintRequest $request, CreateSprint $action): JsonResponse
+    {
+        $sprint = $action->execute($request->validated());
+
+        return new JsonResponse(new SprintResource($sprint), 201);
+    }
+}
+```
+
+```php
+// Authorization using a policy
+public function authorize(): bool
+{
+    return $this->user()->can('create', Post::class);
+}
+
+// Scoped to an admin role
+public function authorize(): bool
+{
+    return $this->user()->isAdmin();
+}
+```
+
+## Anti-Patterns
+
+- Calling `$request->validate()` inside a controller — always use a FormRequest
+- Using pipe-delimited rule strings: `'required|string|max:255'` instead of `['required', 'string', 'max:255']`
+- Leaving `authorize()` as `return true` without documenting why all users are permitted
+- Not adding a `messages()` method for user-facing validation errors that need clarity
+
+## References
+
+- [Laravel Form Requests](https://laravel.com/docs/validation#form-request-validation)
+- Related: `Controllers/SKILL.md` — controllers that use Form Requests
+- Related: `Policies/SKILL.md` — `can()` used in `authorize()` method
diff --git a/resources/boost/skills/general/SKILL.md b/resources/boost/skills/general/SKILL.md
new file mode 100644
index 0000000..0ba652e
--- /dev/null
+++ b/resources/boost/skills/general/SKILL.md
@@ -0,0 +1,75 @@
+---
+name: general
+description: Project-wide Laravel conventions that always apply: configuration access, database patterns, logging, activity logging, and code formatting.
+---
+
+**Name:** Laravel General Conventions
+**Description:** Project-wide Laravel conventions that always apply: configuration access, database patterns, logging, activity logging, and code formatting.
+**Compatible Agents:** general-purpose, backend
+**Tags:** app/**/*.php, laravel, php, backend, config, logging, formatting, conventions
+
+## Rules
+
+- Use `config()` helper to read configuration values — **never** use `env()` directly outside of config files
+- Add new config keys to the appropriate file in `config/`
+- Use Eloquent or Query Builder — no raw DB queries
+- Wrap multi-step writes in `DB::transaction()`
+- Use `Illuminate\Support\Facades\Log` with structured context arrays for logging
+- Add the `Spatie\Activitylog\Traits\LogsActivity` trait on all models that track business data
+- Configure `getActivitylogOptions()` with `logAll()`, `logOnlyDirty()`, `dontSubmitEmptyLogs()`
+- Use `activity()->performedOn($model)->log(...)` for manual log entries in jobs and controllers
+- Run **Laravel Pint** on all PHP code before committing
+
+## Examples
+
+```php
+// Configuration — always use config()
+$secret = config('services.stripe.secret');
+// ❌ env('STRIPE_SECRET')
+```
+
+```php
+// Structured logging
+Log::info('Invoice created.', [
+    'invoice_id' => $invoice->id,
+    'order_id'   => $order->id,
+    'amount'     => $invoice->amount,
+]);
+
+Log::error('Payment failed.', [
+    'invoice_id' => $invoice->id,
+    'error'      => $exception->getMessage(),
+]);
+```
+
+```php
+// Database transactions for multi-step writes
+$payment = DB::transaction(function () use ($order) {
+    $invoice = $this->createInvoice->execute($order);
+    $payment = $this->chargePaymentMethod->execute($order, $invoice);
+
+    return $payment;
+});
+```
+
+```php
+// Manual activity log entry
+activity()
+    ->performedOn($invoice)
+    ->withProperties(['amount' => $invoice->amount])
+    ->log('Invoice paid manually via admin panel.');
+```
+
+## Anti-Patterns
+
+- Using `env('KEY')` directly in application code outside of config files
+- Writing raw SQL queries with `DB::statement()` or `DB::select()` when Eloquent/Query Builder can be used
+- Using `Log::info('Message')` without a context array — always include structured data
+- Not wrapping related database operations in a transaction
+
+## References
+
+- [Laravel Configuration](https://laravel.com/docs/configuration)
+- [Laravel Logging](https://laravel.com/docs/logging)
+- [Spatie Activity Log](https://spatie.be/docs/laravel-activitylog/)
+- [Laravel Pint](https://laravel.com/docs/pint)
diff --git a/resources/boost/skills/helperfunctions/SKILL.md b/resources/boost/skills/helperfunctions/SKILL.md
new file mode 100644
index 0000000..e656593
--- /dev/null
+++ b/resources/boost/skills/helperfunctions/SKILL.md
@@ -0,0 +1,96 @@
+---
+name: helperfunctions
+description: Always prefer Laravel's built-in helper classes over native PHP functions. Use `Arr::`, `Str::`, and Collection methods instead of native PHP equivalents.
+---
+
+**Name:** Laravel Helper Functions
+**Description:** Always prefer Laravel's built-in helper classes over native PHP functions. Use `Arr::`, `Str::`, and Collection methods instead of native PHP equivalents.
+**Compatible Agents:** general-purpose, backend
+**Tags:** app/**/*.php, laravel, php, backend, helpers, arr, str, collection
+
+## Rules
+
+- Always prefer Laravel's built-in helper classes over native PHP functions
+- **Arrays**: Use `Arr::` (import `Illuminate\Support\Arr`) — never use `array_map`, `array_filter`, `in_array`, `array_key_exists`, etc. when a Laravel equivalent exists
+- **Strings**: Use `Str::` (import `Illuminate\Support\Str`) — never use `substr`, `strpos`, `str_replace`, `strtolower`, etc. when a Laravel equivalent exists
+- **Collections**: Prefer `collect()` + Collection methods over manual array loops
+- Use `Str::of()` for chaining multiple string operations
+- Use `collect()` to wrap any array or iterable when performing multiple operations
+
+## Examples
+
+```php
+// Arrays
+use Illuminate\Support\Arr;
+
+// ✓ Dot-notation access
+Arr::get($array, 'user.address.city', 'Unknown');
+// ❌ $array['user']['address']['city'] ?? 'Unknown'
+
+// ✓ Keep only specific keys
+Arr::only($array, ['name', 'email']);
+// ❌ array_intersect_key(...)
+
+// ✓ Remove specific keys
+Arr::except($array, ['password', 'token']);
+// ❌ unset($array['key'])
+
+// ✓ Map values
+Arr::map($array, fn($value) => strtoupper($value));
+// ❌ array_map(fn($v) => strtoupper($v), $array)
+```
+
+```php
+// Strings
+use Illuminate\Support\Str;
+
+Str::upper('hello');        // ❌ strtoupper('hello')
+Str::lower('HELLO');        // ❌ strtolower('HELLO')
+Str::slug('Hello World');   // ❌ strtolower(str_replace(' ', '-', $string))
+Str::contains('foo bar', 'foo'); // ❌ str_contains()
+Str::random(32);            // ❌ bin2hex(random_bytes(16))
+
+// Fluent chaining
+$result = Str::of('  Hello World  ')
+    ->trim()
+    ->lower()
+    ->slug();
+```
+
+```php
+// Collections
+$users = collect(User::all());
+
+// ✓ Prefer collection methods
+$admins = $users->filter(fn($u) => $u->isAdmin())->values();
+$names  = $users->pluck('name');
+$byRole = $users->groupBy('role');
+
+// ❌ manual foreach loops
+```
+
+**Quick Reference: PHP → Laravel**
+
+| PHP native | Laravel equivalent |
+|---|---|
+| `array_map($fn, $arr)` | `Arr::map($arr, $fn)` |
+| `array_filter($arr, $fn)` | `Arr::where($arr, $fn)` |
+| `array_key_exists($k, $arr)` | `Arr::exists($arr, $k)` |
+| `in_array($v, $arr)` | `collect($arr)->contains($v)` |
+| `strtolower($str)` | `Str::lower($str)` |
+| `strtoupper($str)` | `Str::upper($str)` |
+| `str_contains($str, $sub)` | `Str::contains($str, $sub)` |
+| `http_build_query($arr)` | `Arr::query($arr)` |
+
+## Anti-Patterns
+
+- Using `array_map`, `array_filter`, `array_key_exists` when `Arr::` equivalents exist
+- Using `strtolower`, `strtoupper`, `str_replace` when `Str::` equivalents exist
+- Writing manual `foreach` loops when a Collection method achieves the same result
+- Not importing `Arr` or `Str` before use — always add the `use` statement
+
+## References
+
+- [Laravel Arr Helper](https://laravel.com/docs/helpers#arrays)
+- [Laravel Str Helper](https://laravel.com/docs/helpers#strings)
+- [Laravel Collections](https://laravel.com/docs/collections)
diff --git a/resources/boost/skills/helpers/SKILL.md b/resources/boost/skills/helpers/SKILL.md
new file mode 100644
index 0000000..d8385fa
--- /dev/null
+++ b/resources/boost/skills/helpers/SKILL.md
@@ -0,0 +1,70 @@
+---
+name: helpers
+description: Stateless utility classes providing shared formatting, conversion, or calculation logic needed across multiple parts of the application.
+---
+
+**Name:** Helpers
+**Description:** Stateless utility classes providing shared formatting, conversion, or calculation logic needed across multiple parts of the application.
+**Compatible Agents:** general-purpose, backend
+**Tags:** app/Helpers/**/*.php, laravel, php, backend, helper, utility
+
+## Rules
+
+- Helper classes live in `app/Helpers/`
+- Naming: `PascalCase` with a `Helper` suffix → `StringHelper`, `MoneyHelper`, `DateHelper`
+- Helpers are for utilities needed in **multiple places** across the project
+- For testability, static methods are acceptable but not enforced — use your judgement
+- Never put business logic in helpers — use Actions or Services
+- Never put database queries in helpers — use Model Scopes
+- Never put HTTP requests in helpers — use Services
+
+## Examples
+
+```php
+namespace App\Helpers;
+
+use Carbon\Carbon;
+
+class DateHelper
+{
+    public static function format(mixed $date, string $format = 'd M Y'): ?string
+    {
+        if (is_null($date)) {
+            return null;
+        }
+
+        return Carbon::parse($date)->format($format);
+    }
+}
+```
+
+```php
+namespace App\Helpers;
+
+class MoneyHelper
+{
+    public static function format(int $amountInCents, string $currency = 'CHF'): string
+    {
+        return number_format($amountInCents / 100, 2) . ' ' . $currency;
+    }
+}
+```
+
+```php
+// Usage in a Resource
+'created_at' => DateHelper::format($this->created_at),
+'amount'     => MoneyHelper::format($this->amount_in_cents),
+```
+
+## Anti-Patterns
+
+- Putting business logic in a helper (belongs in an Action or Service)
+- Putting database queries in a helper (use Model scopes instead)
+- Using a helper for logic only needed in one place (keep it inline)
+- Creating a catch-all `AppHelper` or `Utils` class — keep helpers domain-specific
+
+## References
+
+- [Carbon Documentation](https://carbon.nesbot.com/)
+- Related: `Actions/SKILL.md` — for business logic
+- Related: `Resources/SKILL.md` — helpers are commonly used for formatting in API resources
diff --git a/resources/boost/skills/interfaces/SKILL.md b/resources/boost/skills/interfaces/SKILL.md
new file mode 100644
index 0000000..b8216eb
--- /dev/null
+++ b/resources/boost/skills/interfaces/SKILL.md
@@ -0,0 +1,94 @@
+---
+name: interfaces
+description: Contracts defining the shape a class must conform to. Used for decoupling dependent classes from concrete implementations, enabling multiple implementations and easier testing.
+---
+
+**Name:** Interfaces & Contracts
+**Description:** Contracts defining the shape a class must conform to. Used for decoupling dependent classes from concrete implementations, enabling multiple implementations and easier testing.
+**Compatible Agents:** general-purpose, backend
+**Tags:** app/Contracts/**/*.php, laravel, php, backend, interface, contract, dependency-inversion
+
+## Rules
+
+- Interface classes live in `app/Contracts/`
+- Interfaces define a **contract** — the shape a class must conform to, without dictating the implementation
+- Use a clear noun or adjective that describes the capability: `PaymentGateway`, `Notifiable`, `ReportGenerator`
+- Avoid an `Interface` suffix — the namespace and context make it clear
+- Only create an interface when there are (or you anticipate) **multiple implementations**
+- Always type-hint the interface, never the concrete class, in consuming classes
+- Bind the interface to a concrete implementation in a service provider
+- Define only public method signatures — no implementation, no properties
+
+## Examples
+
+```php
+// Interface definition
+namespace App\Contracts;
+
+use App\Models\Order;
+use App\Data\PaymentResult;
+
+interface PaymentGateway
+{
+    public function charge(Order $order, int $amountInCents): PaymentResult;
+
+    public function refund(string $transactionId, int $amountInCents): PaymentResult;
+}
+```
+
+```php
+// Implementation
+namespace App\Services\Payment;
+
+use App\Contracts\PaymentGateway;
+
+class StripeGateway implements PaymentGateway
+{
+    public function charge(Order $order, int $amountInCents): PaymentResult
+    {
+        // Stripe-specific implementation
+    }
+
+    public function refund(string $transactionId, int $amountInCents): PaymentResult
+    {
+        // Stripe-specific implementation
+    }
+}
+```
+
+```php
+// Service container binding — AppServiceProvider
+public function register(): void
+{
+    $this->app->bind(PaymentGateway::class, StripeGateway::class);
+}
+```
+
+```php
+// Consuming — type-hint the interface
+class ChargePaymentMethod
+{
+    public function __construct(
+        private readonly PaymentGateway $gateway,
+    ) {}
+}
+```
+
+```php
+// Testing — swap the binding
+$this->app->bind(PaymentGateway::class, FakePaymentGateway::class);
+```
+
+## Anti-Patterns
+
+- Creating an interface for every class by default — only add interfaces where they provide real decoupling
+- Creating an interface when there is only one implementation and no realistic chance of another
+- Adding default implementations to an interface (use an abstract class instead)
+- Adding constants specific to one implementation (keep in the concrete class)
+- Type-hinting the concrete class instead of the interface in consumers
+
+## References
+
+- [Laravel Service Container](https://laravel.com/docs/container)
+- [PHP Interfaces](https://www.php.net/manual/en/language.oop5.interfaces.php)
+- Related: `Services/SKILL.md` — services often implement interfaces
diff --git a/resources/boost/skills/jobs/SKILL.md b/resources/boost/skills/jobs/SKILL.md
new file mode 100644
index 0000000..119f97d
--- /dev/null
+++ b/resources/boost/skills/jobs/SKILL.md
@@ -0,0 +1,85 @@
+---
+name: jobs
+description: Queueable units of work for background processing. Jobs handle queue configuration and failure handling — they delegate business logic to Actions or Services.
+---
+
+**Name:** Jobs
+**Description:** Queueable units of work for background processing. Jobs handle queue configuration and failure handling — they delegate business logic to Actions or Services.
+**Compatible Agents:** general-purpose, backend
+**Tags:** app/Jobs/**/*.php, laravel, php, backend, queue, job, background
+
+## Rules
+
+- Job classes live in `app/Jobs/`
+- Jobs are **queueable units of work** that execute a single task in the background
+- Use a clear verb-noun naming pattern: `ProcessInvoicePayment`, `SendWeeklyReport`, `ImportProductCsv`
+- The name should describe what the job does, not when it runs
+- Jobs delegate their work to an **Action** or **Service** — they own queue configuration and failure handling, not business logic
+- Always declare queue configuration explicitly on the job class rather than relying on defaults
+- Implement `ShouldQueue` for all jobs that should run asynchronously
+- Always use the `Dispatchable`, `InteractsWithQueue`, `Queueable`, `SerializesModels` traits
+- Define a `failed(Throwable $exception)` method for permanent failure handling
+
+## Examples
+
+```php
+namespace App\Jobs;
+
+use App\Actions\ProcessInvoicePayment;
+use App\Models\Invoice;
+use Illuminate\Bus\Queueable;
+use Illuminate\Contracts\Queue\ShouldQueue;
+use Illuminate\Foundation\Bus\Dispatchable;
+use Illuminate\Queue\InteractsWithQueue;
+use Illuminate\Queue\SerializesModels;
+use Throwable;
+
+class ProcessInvoicePaymentJob implements ShouldQueue
+{
+    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;
+
+    public int $tries = 3;
+    public int $backoff = 60;
+    public int $timeout = 120;
+    public string $queue = 'invoices';
+
+    public function __construct(
+        private readonly Invoice $invoice,
+    ) {}
+
+    public function handle(ProcessInvoicePayment $action): void
+    {
+        $action->execute($this->invoice);
+    }
+
+    public function failed(Throwable $exception): void
+    {
+        // Notify, log, or alert on permanent failure after all retries
+    }
+}
+```
+
+```php
+// Dispatch immediately to the queue
+ProcessInvoicePaymentJob::dispatch($invoice);
+
+// Dispatch with a delay
+ProcessInvoicePaymentJob::dispatch($invoice)->delay(now()->addMinutes(5));
+
+// Dispatch synchronously (bypasses queue — useful in tests)
+ProcessInvoicePaymentJob::dispatchSync($invoice);
+```
+
+## Anti-Patterns
+
+- Putting business logic directly in a job's `handle()` method instead of delegating to an Action or Service
+- Omitting `$tries`, `$backoff`, or `$timeout` and relying on global queue defaults
+- Not implementing a `failed()` method for jobs that process critical data
+- Using jobs for work that must complete synchronously before returning a response
+- Using jobs for simple, fast operations that don't justify queue overhead
+
+## References
+
+- [Laravel Queues](https://laravel.com/docs/queues)
+- Related: `Actions/SKILL.md` — for the business logic jobs delegate to
+- Related: `Services/SKILL.md` — for complex orchestration delegated from jobs
diff --git a/resources/boost/skills/livewire/SKILL.md b/resources/boost/skills/livewire/SKILL.md
new file mode 100644
index 0000000..f9be2d6
--- /dev/null
+++ b/resources/boost/skills/livewire/SKILL.md
@@ -0,0 +1,117 @@
+---
+name: livewire
+description: Laravel Livewire conventions for building interactive UI without custom JavaScript. Components are PHP classes with reactive properties, computed properties, and event dispatching.
+---
+
+**Name:** Livewire Components
+**Description:** Laravel Livewire conventions for building interactive UI without custom JavaScript. Components are PHP classes with reactive properties, computed properties, and event dispatching.
+**Compatible Agents:** general-purpose, frontend
+**Tags:** app/Livewire/**/*.php, resources/views/livewire/**/*.blade.php, laravel, php, frontend, livewire, interactive
+
+## Rules
+
+- Use **Livewire** for all interactive UI — no custom JavaScript unless absolutely necessary
+- Follow existing Livewire component patterns in the project
+- Keep component logic in the PHP class; keep Blade templates declarative
+- One Livewire component per feature/concern
+- Use public properties for reactive data
+- Use computed properties (`#[Computed]`) for derived data
+- Use `wire:model` for two-way binding, `wire:click` for actions
+- Keep components small and focused — extract sub-components when they grow
+- Use form objects (`Livewire\Form`) for complex form handling
+- Dispatch events for cross-component communication
+
+## Examples
+
+```php
+namespace App\Livewire;
+
+use App\Actions\CreateInvoice;
+use App\Models\Invoice;
+use Livewire\Attributes\Computed;
+use Livewire\Component;
+
+class InvoiceList extends Component
+{
+    public string $search = '';
+
+    #[Computed]
+    public function invoices()
+    {
+        return Invoice::where('title', 'like', "%{$this->search}%")
+            ->paginate(15);
+    }
+
+    public function delete(int $invoiceId): void
+    {
+        $invoice = Invoice::findOrFail($invoiceId);
+        $this->authorize('delete', $invoice);
+        $invoice->delete();
+    }
+
+    public function render()
+    {
+        return view('livewire.invoice-list');
+    }
+}
+```
+
+```blade
+{{-- Blade template — declarative, no logic --}}
+<div>
+    <input wire:model.live="search" type="text" placeholder="Search invoices...">
+
+    @foreach ($this->invoices as $invoice)
+        <div>
+            {{ $invoice->title }}
+            <button wire:click="delete({{ $invoice->id }})">Delete</button>
+        </div>
+    @endforeach
+
+    {{ $this->invoices->links() }}
+</div>
+```
+
+```php
+// Livewire Form Object for complex forms
+use Livewire\Form;
+
+class InvoiceForm extends Form
+{
+    public string $title = '';
+    public int $order_id = 0;
+    public ?string $notes = null;
+
+    public function rules(): array
+    {
+        return [
+            'title'    => ['required', 'string', 'max:255'],
+            'order_id' => ['required', 'integer', 'exists:orders,id'],
+            'notes'    => ['nullable', 'string'],
+        ];
+    }
+}
+```
+
+```php
+// Cross-component event dispatching
+$this->dispatch('invoice-created', invoiceId: $invoice->id);
+
+// Listening for events
+#[On('invoice-created')]
+public function refreshList(int $invoiceId): void { ... }
+```
+
+## Anti-Patterns
+
+- Writing custom JavaScript when Livewire can handle the interaction
+- Putting display logic in the PHP class instead of the Blade template
+- Growing a single component to handle multiple unrelated features
+- Using `wire:model` without `.live` or `.lazy` when immediate reactivity is not needed (unnecessary requests)
+- Not using form objects for forms with more than 3-4 fields
+
+## References
+
+- [Livewire Documentation](https://livewire.laravel.com/)
+- Related: `Blade/SKILL.md` — Blade templates used by Livewire components
+- Related: `Actions/SKILL.md` — Livewire components delegate business logic to Actions
diff --git a/resources/boost/skills/middleware/SKILL.md b/resources/boost/skills/middleware/SKILL.md
new file mode 100644
index 0000000..560fb98
--- /dev/null
+++ b/resources/boost/skills/middleware/SKILL.md
@@ -0,0 +1,90 @@
+---
+name: middleware
+description: HTTP request/response pipeline handlers that inspect, modify, or reject requests before or after they reach a controller. Used for authentication, throttling, header manipulation, and logging.
+---
+
+**Name:** Middleware
+**Description:** HTTP request/response pipeline handlers that inspect, modify, or reject requests before or after they reach a controller. Used for authentication, throttling, header manipulation, and logging.
+**Compatible Agents:** general-purpose, backend
+**Tags:** app/Http/Middleware/**/*.php, laravel, php, backend, middleware, http, pipeline
+
+## Rules
+
+- Middleware classes live in `app/Http/Middleware/`
+- Use a clear descriptive name that states what it does: `EnsureUserIsSubscribed`, `ForceJsonResponse`, `CheckMaintenanceWindow`
+- Avoid vague names like `ApiMiddleware` or `CheckMiddleware`
+- Middleware must call `$next($request)` to pass the request down the pipeline, or return early to reject it
+- Register middleware in `bootstrap/app.php` using `->withMiddleware()`
+- Apply middleware at the group level, not on individual routes, when possible
+- Code before `$next($request)` runs before the controller; code after runs on the response
+- Never put business logic in middleware — use Actions or Services
+- Never put model-level authorization in middleware — use Policies
+- Never put request body validation in middleware — use Form Requests
+
+## Examples
+
+```php
+namespace App\Http\Middleware;
+
+use Closure;
+use Illuminate\Http\Request;
+use Symfony\Component\HttpFoundation\Response;
+
+class EnsureUserIsSubscribed
+{
+    public function handle(Request $request, Closure $next): Response
+    {
+        if (!$request->user()?->isSubscribed()) {
+            return response()->json(['message' => 'Subscription required.'], 403);
+        }
+
+        return $next($request);
+    }
+}
+```
+
+```php
+// Before and After middleware
+public function handle(Request $request, Closure $next): Response
+{
+    // Runs BEFORE the controller
+    $request->headers->set('X-Request-Id', Str::uuid());
+
+    $response = $next($request);
+
+    // Runs AFTER the controller
+    $response->headers->set('X-Powered-By', 'MyApp');
+
+    return $response;
+}
+```
+
+```php
+// Registration in bootstrap/app.php
+->withMiddleware(function (Middleware $middleware) {
+    $middleware->append(ForceJsonResponse::class);
+
+    $middleware->alias([
+        'subscribed' => EnsureUserIsSubscribed::class,
+    ]);
+})
+
+// Applied to route group
+Route::middleware('subscribed')->group(function () {
+    Route::get('/dashboard', DashboardController::class);
+});
+```
+
+## Anti-Patterns
+
+- Putting business logic inside middleware (belongs in Actions or Services)
+- Putting model-level authorization in middleware (belongs in Policies)
+- Validating the request body in middleware (belongs in Form Requests)
+- Accessing validated input inside middleware — middleware runs before validation
+- Using middleware for things that only apply to a single route
+
+## References
+
+- [Laravel Middleware](https://laravel.com/docs/middleware)
+- Related: `Policies/SKILL.md` — for model-level authorization
+- Related: `FormRequests/SKILL.md` — for request body validation
diff --git a/resources/boost/skills/migrations/SKILL.md b/resources/boost/skills/migrations/SKILL.md
new file mode 100644
index 0000000..bdb4cac
--- /dev/null
+++ b/resources/boost/skills/migrations/SKILL.md
@@ -0,0 +1,77 @@
+---
+name: migrations
+description: Database schema change files. Always create new files for changes — never modify existing migrations. Use descriptive names, proper foreign key constraints, and reversible `down()` methods.
+---
+
+**Name:** Migrations
+**Description:** Database schema change files. Always create new files for changes — never modify existing migrations. Use descriptive names, proper foreign key constraints, and reversible `down()` methods.
+**Compatible Agents:** general-purpose, backend
+**Tags:** database/migrations/**/*.php, laravel, php, backend, database, migration, schema
+
+## Rules
+
+- Always create **new** migration files for database changes — **never** modify existing migration files
+- Use descriptive names: `create_invoices_table`, `add_status_to_invoices_table`
+- Implement both `up()` and `down()` methods — `down()` must fully reverse `up()`
+- Group related columns logically: IDs first, then data, then timestamps
+- Use enum string values for status columns: `$table->string('status')->default('draft')`
+- Add indexes on columns used in WHERE clauses and foreign keys
+- Use `foreignId()->constrained()->cascadeOnDelete()` for foreign keys
+- Keep migrations focused — one concern per migration
+
+## Examples
+
+```php
+public function up(): void
+{
+    Schema::create('invoices', function (Blueprint $table) {
+        $table->id();
+        $table->foreignId('order_id')->constrained()->cascadeOnDelete();
+        $table->foreignId('user_id')->constrained()->cascadeOnDelete();
+        $table->string('status')->default('draft');
+        $table->decimal('amount', 10, 2);
+        $table->date('due_date');
+        $table->timestamp('paid_at')->nullable();
+        $table->timestamps();
+
+        $table->index('status');
+    });
+}
+
+public function down(): void
+{
+    Schema::dropIfExists('invoices');
+}
+```
+
+```php
+// Adding a column to an existing table
+public function up(): void
+{
+    Schema::table('invoices', function (Blueprint $table) {
+        $table->string('reference')->nullable()->after('status');
+    });
+}
+
+public function down(): void
+{
+    Schema::table('invoices', function (Blueprint $table) {
+        $table->dropColumn('reference');
+    });
+}
+```
+
+## Anti-Patterns
+
+- Modifying existing migration files instead of creating new ones
+- Using an integer default for status columns instead of a string enum value
+- Omitting the `down()` method or leaving it empty
+- Not adding indexes on foreign key columns and frequently queried columns
+- Creating a single migration that makes multiple unrelated schema changes
+- Using `$table->integer('status')` instead of `$table->string('status')->default('...')`
+
+## References
+
+- [Laravel Migrations](https://laravel.com/docs/migrations)
+- Related: `Models/SKILL.md` — models reflect the schema defined in migrations
+- Related: `Enums/SKILL.md` — enum string values used as migration defaults
diff --git a/resources/boost/skills/models/SKILL.md b/resources/boost/skills/models/SKILL.md
new file mode 100644
index 0000000..45444b7
--- /dev/null
+++ b/resources/boost/skills/models/SKILL.md
@@ -0,0 +1,92 @@
+---
+name: models
+description: Eloquent model conventions covering mass assignment, casts, relationships, section headers, and activity logging. Every model must follow these structural rules.
+---
+
+**Name:** Models
+**Description:** Eloquent model conventions covering mass assignment, casts, relationships, section headers, and activity logging. Every model must follow these structural rules.
+**Compatible Agents:** general-purpose, backend
+**Tags:** app/Models/**/*.php, laravel, php, backend, eloquent, model, database
+
+## Rules
+
+- Use `$guarded = []` — never use `$fillable` arrays
+- Define `casts()` as a **method**, not a property
+- Cast enums, dates, decimals, and JSON in `casts()`
+- Add the `LogsActivity` trait on all business models
+- Configure `getActivitylogOptions()` with `logAll()`, `logOnlyDirty()`, `dontSubmitEmptyLogs()`
+- Use typed return types on all relationship methods (`HasMany`, `BelongsTo`, etc.)
+- Every new model must have a corresponding factory in `database/factories/`
+- Group model code with section comment headers: `// --- Relationships ---`, `// --- Status Helpers ---`, etc.
+
+## Examples
+
+```php
+namespace App\Models;
+
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Database\Eloquent\Relations\HasMany;
+use Spatie\Activitylog\LogOptions;
+use Spatie\Activitylog\Traits\LogsActivity;
+
+class Invoice extends Model
+{
+    use LogsActivity;
+
+    protected $guarded = [];
+
+    protected function casts(): array
+    {
+        return [
+            'status'   => Status::class,
+            'due_date' => 'date',
+            'amount'   => 'decimal:2',
+        ];
+    }
+
+    // --- Relationships ---
+
+    public function lines(): HasMany
+    {
+        return $this->hasMany(InvoiceLine::class);
+    }
+
+    // --- Status Helpers ---
+
+    public function isDraft(): bool
+    {
+        return $this->status === Status::Draft;
+    }
+
+    public function isPaid(): bool
+    {
+        return $this->status === Status::Paid;
+    }
+
+    // --- Activity Log ---
+
+    public function getActivitylogOptions(): LogOptions
+    {
+        return LogOptions::defaults()
+            ->logAll()
+            ->logOnlyDirty()
+            ->dontSubmitEmptyLogs();
+    }
+}
+```
+
+## Anti-Patterns
+
+- Using `$fillable` arrays instead of `$guarded = []`
+- Defining `$casts` as a property instead of a `casts()` method
+- Not using the `LogsActivity` trait on business models
+- Omitting return types on relationship methods
+- Creating a model without a corresponding factory
+- Putting business logic directly in the model — use Actions
+
+## References
+
+- [Laravel Eloquent Models](https://laravel.com/docs/eloquent)
+- [Spatie Activity Log](https://spatie.be/docs/laravel-activitylog/)
+- Related: `Enums/SKILL.md` — enums are cast in `casts()`
+- Related: `Migrations/SKILL.md` — migrations define the model's schema
diff --git a/resources/boost/skills/observers/SKILL.md b/resources/boost/skills/observers/SKILL.md
new file mode 100644
index 0000000..86eb8b4
--- /dev/null
+++ b/resources/boost/skills/observers/SKILL.md
@@ -0,0 +1,87 @@
+---
+name: observers
+description: Centralised classes that react to Eloquent model lifecycle events. Used for side effects that should always fire regardless of where a model is mutated — such as notifications, cache invalidation, and audit logging.
+---
+
+**Name:** Observers
+**Description:** Centralised classes that react to Eloquent model lifecycle events. Used for side effects that should always fire regardless of where a model is mutated — such as notifications, cache invalidation, and audit logging.
+**Compatible Agents:** general-purpose, backend
+**Tags:** app/Observers/**/*.php, laravel, php, backend, observer, eloquent, model-events
+
+## Rules
+
+- Observer classes live in `app/Observers/`
+- Naming: `PascalCase` with an `Observer` suffix, named after the model they observe: `UserObserver`, `InvoiceObserver`
+- Only define the event methods you actually need — do not scaffold empty methods
+- Register observers in `AppServiceProvider` using the `observe()` method
+- Use observers for side effects tied to model lifecycle events that should always fire
+- Never put business logic that should be explicitly controlled in an observer — use an Action instead
+
+## Examples
+
+```php
+namespace App\Observers;
+
+use App\Models\User;
+use App\Notifications\WelcomeNotification;
+use Illuminate\Support\Facades\Cache;
+
+class UserObserver
+{
+    public function created(User $user): void
+    {
+        $user->notify(new WelcomeNotification());
+    }
+
+    public function updated(User $user): void
+    {
+        Cache::forget("user:{$user->id}");
+    }
+
+    public function deleted(User $user): void
+    {
+        Cache::forget("user:{$user->id}");
+    }
+}
+```
+
+```php
+// Registration in AppServiceProvider
+use App\Models\User;
+use App\Observers\UserObserver;
+
+public function boot(): void
+{
+    User::observe(UserObserver::class);
+}
+```
+
+**Available lifecycle events:**
+
+| Method | Fires when... |
+|---|---|
+| `creating` | Before a model is first saved |
+| `created` | After a model is first saved |
+| `updating` | Before an existing model is saved |
+| `updated` | After an existing model is saved |
+| `saving` | Before creating or updating |
+| `saved` | After creating or updating |
+| `deleting` | Before a model is deleted |
+| `deleted` | After a model is deleted |
+| `restoring` | Before a soft-deleted model is restored |
+| `restored` | After a soft-deleted model is restored |
+
+## Anti-Patterns
+
+- Using an observer for side effects specific to one particular action (use the Action directly instead)
+- Scaffolding empty observer methods for all lifecycle events when only one is needed
+- Putting complex orchestration inside an observer (use a Service)
+- Using an observer for validation (use Form Requests)
+- Using an observer for authorization (use Policies)
+- Relying on observers when you need fine-grained control over when side effects fire
+
+## References
+
+- [Laravel Observers](https://laravel.com/docs/eloquent#observers)
+- Related: `Models/SKILL.md` — Eloquent model conventions
+- Related: `Events/SKILL.md` — alternative for decoupled side effects
diff --git a/resources/boost/skills/pesttesting/SKILL.md b/resources/boost/skills/pesttesting/SKILL.md
new file mode 100644
index 0000000..83783e5
--- /dev/null
+++ b/resources/boost/skills/pesttesting/SKILL.md
@@ -0,0 +1,120 @@
+---
+name: pesttesting
+description: Laravel testing conventions using the Pest PHP framework. Covers test structure, AAA pattern, HTTP assertions, datasets, mocking, browser tests, and architecture tests.
+---
+
+**Name:** Pest Testing
+**Description:** Laravel testing conventions using the Pest PHP framework. Covers test structure, AAA pattern, HTTP assertions, datasets, mocking, browser tests, and architecture tests.
+**Compatible Agents:** general-purpose, testing
+**Tags:** tests/**/*.php, laravel, php, testing, pest, feature-test, unit-test, browser-test
+
+## Rules
+
+- Always use **Pest syntax** — never raw PHPUnit classes or `$this->assert*` outside of HTTP responses
+- Always follow **AAA**: Arrange → Act → Assert, with a comment label for each section
+- Always use **named HTTP assertion methods** — never `assertStatus(int)` with a raw integer
+- Never delete a test without explicit approval
+- Test files mirror the class they test: `UserController` → `UserControllerTest.php`
+- Test descriptions read as plain English: `it('creates an invoice for the given order')`
+- Group related tests with `describe()` named after the class or feature under test
+- Use `uses(RefreshDatabase::class)` in every test file that touches the database
+- Use `beforeEach()` inside `describe()` blocks for shared setup — never repeat setup across tests
+- Use datasets instead of duplicating tests for multiple inputs
+- Prefer **Laravel fakes** over mocks for events, mail, notifications, and queues
+- Browser tests: always use `DatabaseTruncation` — never `RefreshDatabase`
+- Browser tests: always call `assertNoJavaScriptErrors()` after every `visit()`
+- Browser tests: always use `dusk=""` HTML attributes as selectors — never CSS classes or IDs
+- Browser tests: never use `pause()` — use `waitFor()`, `waitForText()`, or `waitUntilMissing()`
+- Add architecture tests in `tests/Architecture/` to enforce conventions automatically
+
+## Examples
+
+```php
+// Basic test — AAA pattern
+uses(RefreshDatabase::class);
+
+it('creates an invoice for the given order', function () {
+    // Arrange
+    $order = Order::factory()->create();
+
+    // Act
+    $response = $this->postJson('/api/invoices', ['order_id' => $order->id]);
+
+    // Assert
+    $response->assertCreated();
+    expect(Invoice::count())->toBe(1);
+});
+```
+
+```php
+// Grouped with describe() and beforeEach()
+describe('InvoiceController', function () {
+    beforeEach(function () {
+        $this->user = User::factory()->create();
+        $this->actingAs($this->user);
+    });
+
+    it('lists all invoices', function () {
+        Invoice::factory()->count(3)->create();
+        $this->getJson('/api/invoices')->assertSuccessful();
+    });
+
+    it('creates an invoice', function () {
+        $order = Order::factory()->create();
+        $this->postJson('/api/invoices', ['order_id' => $order->id])
+            ->assertCreated();
+    });
+});
+```
+
+```php
+// Datasets for multiple inputs
+it('rejects invalid email addresses', function (string $email) {
+    $this->postJson('/api/users', ['email' => $email])
+        ->assertUnprocessable();
+})->with([
+    'empty string'  => [''],
+    'missing @'     => ['notanemail'],
+    'missing tld'   => ['user@domain'],
+]);
+```
+
+```php
+// Named HTTP assertion methods
+$response->assertSuccessful();    // ❌ assertStatus(200)
+$response->assertCreated();       // ❌ assertStatus(201)
+$response->assertNoContent();     // ❌ assertStatus(204)
+$response->assertUnprocessable(); // ❌ assertStatus(422)
+$response->assertForbidden();     // ❌ assertStatus(403)
+$response->assertUnauthorized();  // ❌ assertStatus(401)
+$response->assertNotFound();      // ❌ assertStatus(404)
+```
+
+```php
+// Architecture tests
+arch('no debug calls in production code')
+    ->expect('App')
+    ->not->toUse(['dd', 'dump', 'var_dump', 'ray']);
+
+arch('controllers have the correct suffix')
+    ->expect('App\Http\Controllers')
+    ->toHaveSuffix('Controller');
+```
+
+## Anti-Patterns
+
+- Using `assertStatus(200)` instead of named assertion methods
+- Using `RefreshDatabase` in browser (Dusk) tests — use `DatabaseTruncation`
+- Using `pause(3000)` in browser tests — use `waitFor()` or `waitForText()`
+- Repeating the same test for multiple inputs instead of using datasets
+- Using CSS class or ID selectors in Dusk — use `dusk=""` attributes
+- Missing `uses(RefreshDatabase::class)` in feature/unit files that touch the database
+- Deleting a test without explicit approval
+- Missing `assertNoJavaScriptErrors()` after `visit()` in browser tests
+
+## References
+
+- [Pest PHP Documentation](https://pestphp.com/)
+- [Laravel Testing](https://laravel.com/docs/testing)
+- Related: `Dusk/SKILL.md` — full browser (E2E) test conventions
+- Related: `PHPStan/SKILL.md` — static analysis runs alongside tests
diff --git a/resources/boost/skills/php/SKILL.md b/resources/boost/skills/php/SKILL.md
new file mode 100644
index 0000000..ef8e6e7
--- /dev/null
+++ b/resources/boost/skills/php/SKILL.md
@@ -0,0 +1,101 @@
+---
+name: php
+description: General PHP coding standards covering strict typing, formatting, control flow, and error handling. Applies to all PHP files in the application.
+---
+
+**Name:** PHP Conventions
+**Description:** General PHP coding standards covering strict typing, formatting, control flow, and error handling. Applies to all PHP files in the application.
+**Compatible Agents:** general-purpose, backend
+**Tags:** app/**/*.php, laravel, php, backend, typing, formatting, conventions
+
+## Rules
+
+- Type hints on **all** parameters, return types, and properties — no untyped signatures
+- Use union types or nullable (`?Type`) where needed
+- Target **PHPStan Level 9** compliance
+- All code in **English**: variable names, comments, docblocks
+- Foreign-language domain terms from external APIs are acceptable in DTOs where they match the API
+- Run **Laravel Pint** before committing
+- Avoid `try-catch` blocks — let exceptions bubble up to the framework's handler
+- Only catch exceptions when you **must** react locally (retry logic, API fallback)
+- Use **early returns** (guard clauses) to handle edge cases at the top of a method
+- Never use `else`, `elseif`, or nested `if` blocks — invert the condition and return early
+- Prefer immutability — use `readonly` properties where possible
+- One class per file
+
+## Examples
+
+```php
+// ✓ Early returns — guard clauses
+public function process(Order $order): void
+{
+    if (! $order->isPaid()) {
+        throw new UnpaidOrderException();
+    }
+
+    if (! $order->hasItems()) {
+        throw new EmptyOrderException();
+    }
+
+    // Happy-path logic here
+}
+```
+
+```php
+// ✗ Nested if/else — never do this
+public function process(Order $order): void
+{
+    if ($order->isPaid()) {
+        if ($order->hasItems()) {
+            // deep logic
+        } else {
+            throw new EmptyOrderException();
+        }
+    } else {
+        throw new UnpaidOrderException();
+    }
+}
+```
+
+```php
+// ✓ Fully typed class
+class CreateInvoice
+{
+    public function __construct(
+        private readonly GenerateInvoicePdf $generatePdf,
+    ) {}
+
+    public function execute(Order $order): Invoice
+    {
+        // implementation
+    }
+}
+```
+
+```php
+// ✓ Structured logging when catching
+try {
+    $this->externalService->call($data);
+} catch (ServiceException $e) {
+    Log::error('External service failed.', [
+        'message' => $e->getMessage(),
+        'data'    => $data,
+    ]);
+    throw $e;
+}
+```
+
+## Anti-Patterns
+
+- Untyped function parameters or return types
+- Using `else` or `elseif` — invert and return early instead
+- Silently swallowing exceptions with empty catch blocks
+- Using `env()` directly in application code (only in config files)
+- Non-English variable names, comments, or method names
+- Multiple classes in a single file
+
+## References
+
+- [PHPStan](https://phpstan.org/)
+- [Laravel Pint](https://laravel.com/docs/pint)
+- Related: `PHPStan/SKILL.md` — static analysis compliance
diff --git a/resources/boost/skills/phpstan/SKILL.md b/resources/boost/skills/phpstan/SKILL.md
new file mode 100644
index 0000000..6250f82
--- /dev/null
+++ b/resources/boost/skills/phpstan/SKILL.md
@@ -0,0 +1,86 @@
+---
+name: phpstan
+description: Static analysis tool configured at Level 9. All code must pass PHPStan Level 9 with strict typing, no untyped signatures, and minimal suppression of errors.
+---
+
+**Name:** PHPStan
+**Description:** Static analysis tool configured at Level 9. All code must pass PHPStan Level 9 with strict typing, no untyped signatures, and minimal suppression of errors.
+**Compatible Agents:** general-purpose, testing, backend
+**Tags:** app/**/*.php, tests/**/*.php, laravel, php, static-analysis, phpstan, types
+
+## Rules
+
+- All code must pass **PHPStan Level 9**
+- Type hints on all parameters, return types, and properties — no untyped signatures
+- No `@phpstan-ignore` unless documented with a justification comment
+- Use `phpstan-assert`, `phpstan-param`, and `phpstan-return` PHPDoc tags when generics or complex types are needed
+- Replace `mixed` with specific union types where possible
+- Use `array<string, mixed>` instead of bare `array` in PHPDoc
+- Add `@throws` annotations for methods that throw exceptions
+- Use `assert()` or type narrowing instead of suppressing errors
+
+## Examples
+
+```php
+// ✓ Specific types instead of mixed
+public function process(Order $order): Invoice { ... }
+
+// ✓ PHPDoc with typed arrays
+/**
+ * @return array<string, array<int, string|object>>
+ */
+public function rules(): array { ... }
+
+// ✓ Union types instead of mixed
+public function format(string|int|null $value): string { ... }
+
+// ✓ Generics for collections
+/**
+ * @return Collection<int, Invoice>
+ */
+public function getInvoices(): Collection { ... }
+```
+
+```php
+// ✓ @throws annotation
+/**
+ * @throws InvoiceAlreadyPaidException
+ */
+public function markAsPaid(Invoice $invoice): void
+{
+    if ($invoice->isPaid()) {
+        throw InvoiceAlreadyPaidException::for($invoice);
+    }
+    // ...
+}
+```
+
+```php
+// ✓ Type narrowing with assert() instead of suppression
+public function handle(mixed $model): void
+{
+    assert($model instanceof Invoice);
+    $model->markAsPaid(); // PHPStan now knows it's an Invoice
+}
+```
+
+```php
+// ✓ Justified suppression with comment
+/** @phpstan-ignore-next-line Property accessed via magic method — documented in IDE helper */
+$user->custom_attribute;
+```
+
+## Anti-Patterns
+
+- Using bare `mixed` types when a more specific type is possible
+- Using bare `array` without a PHPDoc generic shape: `array<string, mixed>`
+- Using `@phpstan-ignore` without a comment explaining why it is necessary
+- Omitting `@throws` annotations on methods that throw
+- Leaving parameters, return types, or properties untyped
+- Using `(int)`, `(string)` casts as substitutes for proper type narrowing
+
+## References
+
+- [PHPStan Documentation](https://phpstan.org/user-guide/getting-started)
+- [PHPStan Rule Levels](https://phpstan.org/user-guide/rule-levels)
+- Related: `PHP/SKILL.md` — general PHP conventions including strict typing
diff --git a/resources/boost/skills/phpunit/SKILL.md b/resources/boost/skills/phpunit/SKILL.md
new file mode 100644
index 0000000..0055bbe
--- /dev/null
+++ b/resources/boost/skills/phpunit/SKILL.md
@@ -0,0 +1,94 @@
+---
+name: phpunit
+description: PHPUnit test structure, naming, assertions, and factory conventions for Laravel feature and unit tests.
+---
+
+**Name:** PHPUnit
+**Description:** PHPUnit test structure, naming, assertions, and factory conventions for Laravel feature and unit tests.
+**Compatible Agents:** general-purpose, testing
+**Tags:** tests/**/*.php, laravel, php, testing, phpunit, unit-test, feature-test
+
+## Rules
+
+- **Feature tests** go in `tests/Feature/` and extend `Tests\TestCase`
+- **Unit tests** go in `tests/Unit/` and extend `PHPUnit\Framework\TestCase`
+- Always use `Illuminate\Foundation\Testing\RefreshDatabase` in feature tests that touch the database
+- Unit tests have no Laravel bootstrap — pure PHP tests only
+- Use `test_` method prefix with snake_case names: `test_user_can_create_resource`
+- All test methods must have `: void` return type
+- One assertion concern per test method — keep tests focused
+- Prefer `assertSame` over `assertEquals` for strict type + value comparison
+- Assert specific values, not just truthiness
+- Every new model **must** have a corresponding factory in `database/factories/`
+- Use factories in tests instead of manual `create()` / `insert()` calls
+- Define meaningful default factory values; use states for variations
+
+## Examples
+
+```php
+// Feature test
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Tests\TestCase;
+
+class InvoiceControllerTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_user_can_create_invoice(): void
+    {
+        $user  = User::factory()->create();
+        $order = Order::factory()->create(['user_id' => $user->id]);
+
+        $response = $this->actingAs($user)
+            ->postJson('/api/invoices', ['order_id' => $order->id]);
+
+        $response->assertStatus(201);
+        $this->assertDatabaseHas('invoices', ['order_id' => $order->id]);
+    }
+}
+```
+
+```php
+// Unit test — no Laravel bootstrap
+use PHPUnit\Framework\TestCase;
+
+class MoneyHelperTest extends TestCase
+{
+    public function test_formats_amount_in_cents_as_currency_string(): void
+    {
+        $result = MoneyHelper::format(1000, 'CHF');
+
+        $this->assertSame('10.00 CHF', $result);
+    }
+}
+```
+
+```php
+// Factory with states
+// database/factories/UserFactory.php
+public function unverified(): static
+{
+    return $this->state(fn (array $attributes) => [
+        'email_verified_at' => null,
+    ]);
+}
+
+// Usage in tests
+User::factory()->create();
+User::factory()->unverified()->create();
+```
+
+## Anti-Patterns
+
+- Not using `RefreshDatabase` in feature tests that write to the database
+- Using raw `insert()` or `create()` calls in tests instead of factories
+- Mixing multiple assertion concerns in a single test method
+- Using `assertEquals` when `assertSame` is needed for strict comparison
+- Asserting truthiness (`assertTrue($result !== null)`) instead of a specific value
+- Unit tests that bootstrap the full Laravel application (use `Tests\TestCase` only for feature tests)
+
+## References
+
+- [PHPUnit Documentation](https://phpunit.de/)
+- [Laravel Testing](https://laravel.com/docs/testing)
+- Related: `PestTesting/SKILL.md` — the preferred test framework (Pest over raw PHPUnit)
diff --git a/resources/boost/skills/policies/SKILL.md b/resources/boost/skills/policies/SKILL.md
new file mode 100644
index 0000000..be6be4f
--- /dev/null
+++ b/resources/boost/skills/policies/SKILL.md
@@ -0,0 +1,90 @@
+---
+name: policies
+description: Centralised authorization logic for a given Eloquent model. Policies define per-ability access control and are enforced at the controller level.
+---
+
+**Name:** Policies
+**Description:** Centralised authorization logic for a given Eloquent model. Policies define per-ability access control and are enforced at the controller level.
+**Compatible Agents:** general-purpose, backend
+**Tags:** app/Policies/**/*.php, laravel, php, backend, policy, authorization, auth
+
+## Rules
+
+- Policy classes live in `app/Policies/`
+- Naming: `PascalCase` with a `Policy` suffix, named after the model they protect: `InvoicePolicy`, `PostPolicy`
+- Policies centralise **all authorization logic** for a given model in one place
+- Create one policy for **each** model
+- Define one method per ability — use standard names: `viewAny`, `view`, `create`, `update`, `delete`, `restore`, `forceDelete`
+- Always enforce authorization at the **controller** level — never inside actions or services
+- Laravel auto-discovers policies that follow the `ModelPolicy` naming convention
+- For custom locations, register manually in `AuthServiceProvider`
+
+## Examples
+
+```php
+namespace App\Policies;
+
+use App\Models\Invoice;
+use App\Models\User;
+
+class InvoicePolicy
+{
+    public function viewAny(User $user): bool
+    {
+        return $user->isAdmin();
+    }
+
+    public function view(User $user, Invoice $invoice): bool
+    {
+        return $user->id === $invoice->user_id || $user->isAdmin();
+    }
+
+    public function create(User $user): bool
+    {
+        return $user->hasVerifiedEmail();
+    }
+
+    public function update(User $user, Invoice $invoice): bool
+    {
+        return $user->id === $invoice->user_id && $invoice->isDraft();
+    }
+
+    public function delete(User $user, Invoice $invoice): bool
+    {
+        return $user->isAdmin();
+    }
+}
+```
+
+```php
+// Usage in controller
+public function update(UpdateInvoiceRequest $request, Invoice $invoice): InvoiceResource
+{
+    $this->authorize('update', $invoice);
+    // ...
+}
+
+// Usage in Form Request
+public function authorize(): bool
+{
+    return $this->user()->can('update', $this->route('invoice'));
+}
+
+// Usage via route middleware
+Route::put('/invoices/{invoice}', [InvoiceController::class, 'update'])
+    ->middleware('can:update,invoice');
+```
+
+## Anti-Patterns
+
+- Putting authorization logic directly in controllers, actions, or models
+- Creating global gates instead of model-specific policies when model-based auth is appropriate
+- Not creating a policy for each model
+- Putting business logic inside a policy method (belongs in Actions or Services)
+- Using `return true` in `authorize()` without documenting the intent
+
+## References
+
+- [Laravel Authorization](https://laravel.com/docs/authorization)
+- Related: `Controllers/SKILL.md` — the layer where policies are enforced
+- Related: `FormRequests/SKILL.md` — can use `can()` in `authorize()` method
diff --git a/resources/boost/skills/requests/SKILL.md b/resources/boost/skills/requests/SKILL.md
new file mode 100644
index 0000000..bfeca18
--- /dev/null
+++ b/resources/boost/skills/requests/SKILL.md
@@ -0,0 +1,81 @@
+---
+name: requests
+description: Dedicated Form Request validation classes for all controller input. Every endpoint that accepts user input must use a `FormRequest` class — validation never happens directly inside a controller.
+---
+
+**Name:** Form Request Validation
+**Description:** Dedicated Form Request validation classes for all controller input. Every endpoint that accepts user input must use a `FormRequest` class — validation never happens directly inside a controller.
+**Compatible Agents:** general-purpose, backend
+**Tags:** app/Http/Requests/**/*.php, laravel, php, backend, validation, request, form-request
+
+## Rules
+
+- Every controller action that accepts user input **must** use a dedicated `FormRequest` class
+- Never call `$request->validate()` or `Validator::make()` inside a controller
+- Place Form Requests in `app/Http/Requests/` or a subdirectory matching the domain (e.g. `Auth/`)
+- Naming: `Store{Resource}Request`, `Update{Resource}Request`
+- Define `authorize(): bool` with intentional access control
+- Define `rules(): array` with a PHPDoc `@return` array shape annotation
+- Use **array-based** rule definitions — not pipe-delimited strings
+- Override `messages(): array` for user-friendly or localized error messages
+
+## Examples
+
+```php
+class StoreInvoiceRequest extends FormRequest
+{
+    public function authorize(): bool
+    {
+        return $this->user()->can('create', Invoice::class);
+    }
+
+    /**
+     * @return array<string, array<int, string|object>>
+     */
+    public function rules(): array
+    {
+        return [
+            'order_id' => ['required', 'integer', 'exists:orders,id'],
+            'due_date' => ['required', 'date', 'after:today'],
+            'notes'    => ['nullable', 'string', 'max:1000'],
+        ];
+    }
+
+    public function messages(): array
+    {
+        return [
+            'order_id.exists'  => __('The selected order does not exist.'),
+            'due_date.after'   => __('The due date must be a future date.'),
+        ];
+    }
+}
+```
+
+```php
+// Custom authorization logic options
+public function authorize(): bool
+{
+    // Allow all authenticated users
+    return $this->user() !== null;
+
+    // Scope to admin role
+    return $this->user()->isAdmin();
+
+    // Delegate to a policy
+    return $this->user()->can('update', $this->route('invoice'));
+}
+```
+
+## Anti-Patterns
+
+- Using `$request->validate([...])` inside a controller
+- Using pipe-delimited rules: `'required|string|max:255'` instead of `['required', 'string', 'max:255']`
+- Leaving `authorize()` as a passive `return true` without a comment explaining intent
+- Not using a `messages()` method when default Laravel messages are unclear to end users
+- Skipping the `@return` PHPDoc annotation on `rules()` (breaks PHPStan analysis)
+
+## References
+
+- [Laravel Form Requests](https://laravel.com/docs/validation#form-request-validation)
+- Related: `Controllers/SKILL.md` — controllers that inject and use Form Requests
+- Related: `Policies/SKILL.md` — policies referenced in `authorize()`
diff --git a/resources/boost/skills/resources/SKILL.md b/resources/boost/skills/resources/SKILL.md
new file mode 100644
index 0000000..04097fc
--- /dev/null
+++ b/resources/boost/skills/resources/SKILL.md
@@ -0,0 +1,75 @@
+---
+name: resources
+description: API resource classes that transform Eloquent models into JSON-ready arrays. Resources control exactly what is exposed in API responses and handle relationships, conditional attributes, and date formatting.
+---
+
+**Name:** Resources
+**Description:** API resource classes that transform Eloquent models into JSON-ready arrays. Resources control exactly what is exposed in API responses and handle relationships, conditional attributes, and date formatting.
+**Compatible Agents:** general-purpose, backend
+**Tags:** app/Http/Resources/**/*.php, laravel, php, backend, api, resource, json, response
+
+## Rules
+
+- Resource classes live in `app/Http/Resources/`
+- Single resource: `ModelResource` → `UserResource`, `PostResource`
+- Collection resource: `ModelCollection` → `UserCollection`, `PostCollection`
+- Only expose what the API consumer needs — never blindly expose every model attribute
+- Use `whenLoaded()` for related resources — never eager load inside the resource itself
+- Use `when()`, `whenHas()`, or `whenNotNull()` for conditional attributes — not `if` statements in the array
+- Use `mergeWhen()` for multiple attributes sharing the same condition
+- Use `UserResource::collection()` for simple collections — only create a dedicated collection class when custom meta is needed
+- Do not add pagination meta manually — pass a paginator directly and let Laravel append it
+
+## Examples
+
+```php
+class UserResource extends JsonResource
+{
+    public function toArray(Request $request): array
+    {
+        return [
+            'id'         => $this->id,
+            'name'       => $this->name,
+            'email'      => $this->email,
+            'posts'      => PostResource::collection($this->whenLoaded('posts')),
+            'secret'     => $this->when($request->user()->isAdmin(), $this->secret),
+            'bio'        => $this->whenNotNull($this->bio),
+            'created_at' => DateHelper::format($this->created_at),
+        ];
+    }
+}
+```
+
+```php
+// Controller — eager load before passing to resource
+return UserResource::collection(User::with('posts')->paginate());
+```
+
+```php
+// Dedicated collection — only when custom meta is needed
+class UserCollection extends ResourceCollection
+{
+    public function toArray(Request $request): array
+    {
+        return [
+            'data'  => $this->collection,
+            'links' => ['self' => route('users.index')],
+        ];
+    }
+}
+```
+
+## Anti-Patterns
+
+- Exposing all model attributes without whitelisting
+- Eager loading relationships inside the resource's `toArray()` — load them in the controller
+- Using `if` statements inside the response array instead of `when()`, `whenLoaded()`, `whenNotNull()`
+- Creating a dedicated collection class just for a simple list (use `UserResource::collection()`)
+- Putting business logic or database queries in a resource
+- Manually adding pagination meta that Laravel already provides automatically
+
+## References
+
+- [Laravel API Resources](https://laravel.com/docs/eloquent-resources)
+- Related: `Controllers/SKILL.md` — eager loading is done in the controller
+- Related: `Helpers/SKILL.md` — use `DateHelper::format()` for date formatting
diff --git a/resources/boost/skills/routing/SKILL.md b/resources/boost/skills/routing/SKILL.md
new file mode 100644
index 0000000..d10a851
--- /dev/null
+++ b/resources/boost/skills/routing/SKILL.md
@@ -0,0 +1,68 @@
+---
+name: routing
+description: Route file conventions for organising API and web routes. Covers file separation, naming, grouping, middleware, and route model binding.
+---
+
+**Name:** Routing
+**Description:** Route file conventions for organising API and web routes. Covers file separation, naming, grouping, middleware, and route model binding.
+**Compatible Agents:** general-purpose, backend
+**Tags:** routes/**/*.php, laravel, php, backend, routing, routes, api, web
+
+## Rules
+
+- API routes in `routes/api.php`; web routes in `routes/web.php`
+- Group related routes with prefixes and middleware
+- Use route model binding where possible
+- Use resourceful route names: `invoices.index`, `invoices.store`
+- Use kebab-case for URL segments: `/invoice-lines`
+- Prefix API routes with `/api` (handled by Laravel automatically via `api.php`)
+- Apply authentication middleware at the group level
+- Apply throttle middleware on API endpoints
+- Use custom middleware for webhook signature verification
+
+## Examples
+
+```php
+// routes/api.php
+Route::middleware('auth:sanctum')->group(function () {
+    Route::apiResource('invoices', InvoiceController::class);
+
+    Route::prefix('invoices')->group(function () {
+        Route::post('{invoice}/pay', PayInvoiceController::class)->name('invoices.pay');
+    });
+});
+
+Route::middleware(['throttle:webhook'])->group(function () {
+    Route::post('webhooks/stripe', ProcessStripeWebhookController::class)
+        ->middleware(VerifyStripeSignature::class)
+        ->name('webhooks.stripe');
+});
+```
+
+```php
+// Route model binding — automatic resolution
+Route::get('invoices/{invoice}', ShowInvoiceController::class);
+
+// Controller resolves the model automatically
+public function __invoke(Invoice $invoice): JsonResponse { ... }
+```
+
+```php
+// Naming with resourceful convention
+Route::apiResource('invoice-lines', InvoiceLineController::class);
+// Generates: invoice-lines.index, invoice-lines.store, invoice-lines.show, etc.
+```
+
+## Anti-Patterns
+
+- Mixing API and web routes in the same file
+- Not using route model binding when an ID is passed to look up a model
+- Applying authentication middleware per route instead of at the group level
+- Using camelCase or snake_case in URL segments instead of kebab-case
+- Not naming routes (anonymous routes are harder to reference and refactor)
+
+## References
+
+- [Laravel Routing](https://laravel.com/docs/routing)
+- Related: `Controllers/SKILL.md` — controllers that handle routes
+- Related: `Middleware/SKILL.md` — middleware applied at the route group level
diff --git a/resources/boost/skills/saloon/SKILL.md b/resources/boost/skills/saloon/SKILL.md
new file mode 100644
index 0000000..fa72675
--- /dev/null
+++ b/resources/boost/skills/saloon/SKILL.md
@@ -0,0 +1,130 @@
+---
+name: saloon
+description: Saloon-based service layer pattern for all external API integrations. Every new external API integration must use Saloon — no raw HTTP calls.
+---
+
+**Name:** Saloon API Integration
+**Description:** Saloon-based service layer pattern for all external API integrations. Every new external API integration must use Saloon — no raw HTTP calls.
+**Compatible Agents:** general-purpose, backend
+**Tags:** app/Services/**/*.php, laravel, php, backend, saloon, api, http-client, integration
+
+## Rules
+
+- **All** new external API integrations must use the Saloon pattern
+- No raw HTTP calls (`Http::get(...)`, `file_get_contents`, `curl`)
+- Organize each external integration under `app/Services/{ServiceName}/`
+- The connector extends `Saloon\Http\Connector` and handles authentication and base URL
+- One class per API endpoint, extending `Saloon\Http\Request`
+- Use constructor promotion for request parameters
+- GET requests define `defaultQuery()` for query parameters
+- POST/PUT requests implement `HasBody` + use `HasJsonBody` trait with `defaultBody()`
+- The service class wraps the connector, sends requests, and returns typed DTOs
+- Register the connector as a singleton in a service provider when needed
+- Accept an optional connector in the service constructor for testability
+- Exceptions: **Prism** is acceptable for AI/LLM integrations; inline `Http::get()` is acceptable for simple binary file downloads (not API integrations)
+
+## Examples
+
+**Directory Structure:**
+```
+app/Services/Stripe/
+  StripeConnector.php
+  StripeService.php
+  Requests/
+    Charges/
+      CreateChargeRequest.php
+      ListChargesRequest.php
+  DataObjects/
+    ChargeData.php
+```
+
+```php
+// Connector
+namespace App\Services\Stripe;
+
+use Saloon\Http\Connector;
+
+class StripeConnector extends Connector
+{
+    public function resolveBaseUrl(): string
+    {
+        return 'https://api.stripe.com/v1';
+    }
+
+    protected function defaultHeaders(): array
+    {
+        return [
+            'Authorization' => 'Bearer ' . config('services.stripe.secret'),
+            'Content-Type'  => 'application/json',
+        ];
+    }
+}
+```
+
+```php
+// GET Request
+use Saloon\Enums\Method;
+use Saloon\Http\Request;
+
+class ListChargesRequest extends Request
+{
+    protected Method $method = Method::GET;
+
+    public function __construct(
+        protected int $limit = 10,
+        protected ?string $customer = null,
+    ) {}
+
+    public function resolveEndpoint(): string
+    {
+        return '/charges';
+    }
+
+    protected function defaultQuery(): array
+    {
+        return array_filter([
+            'limit'    => $this->limit,
+            'customer' => $this->customer,
+        ]);
+    }
+}
+```
+
+```php
+// Service class
+use Illuminate\Support\Collection;
+
+class StripeService
+{
+    public function __construct(?StripeConnector $connector = null)
+    {
+        $this->connector = $connector ?? new StripeConnector();
+    }
+
+    /** @return Collection<int, ChargeData> */
+    public function listCharges(string $customerId): Collection
+    {
+        $response = $this->connector->send(
+            new ListChargesRequest(customer: $customerId)
+        );
+
+        return collect($response->json('data'))
+            ->map(fn (array $item) => ChargeData::fromArray($item));
+    }
+}
+```
+
+## Anti-Patterns
+
+- Using `Http::get(...)` or `file_get_contents()` for API integrations
+- Using `curl` directly
+- Creating one massive connector class with all API logic — separate requests into individual classes
+- Not returning typed DTOs from the service class (returning raw arrays)
+- Not caching expensive or frequently accessed API responses
+- Hard-coding API credentials in the connector — always use `config()`
+
+## References
+
+- [Saloon Documentation](https://docs.saloon.dev/)
+- Related: `DTO/SKILL.md` — service classes return typed DTOs
+- Related: `Services/SKILL.md` — general service class conventions
diff --git a/resources/boost/skills/services/SKILL.md b/resources/boost/skills/services/SKILL.md
new file mode 100644
index 0000000..fa78512
--- /dev/null
+++ b/resources/boost/skills/services/SKILL.md
@@ -0,0 +1,95 @@
+---
+name: services
+description: Orchestration classes that coordinate multiple Actions, external APIs, or domain operations into a cohesive workflow. Services own transaction boundaries and third-party API integrations.
+---
+
+**Name:** Services
+**Description:** Orchestration classes that coordinate multiple Actions, external APIs, or domain operations into a cohesive workflow. Services own transaction boundaries and third-party API integrations.
+**Compatible Agents:** general-purpose, backend
+**Tags:** app/Services/**/*.php, laravel, php, backend, service, orchestration, api-integration
+
+## Rules
+
+- Service classes live in `app/Services/`
+- Name after the domain or integration they serve: `PaymentService`, `SubscriptionService`, `StripeService`
+- Avoid generic suffixes like `Manager` or `Handler`
+- Services may expose multiple related methods, all scoped to their domain
+- Inject dependencies via the constructor
+- Use `DB::transaction()` for multi-step operations that must all succeed or fail together
+- Wrap third-party SDKs behind a service class with a clean internal interface
+- Register external service wrappers as singletons in a service provider
+- Use Actions for individual discrete operations — a Service orchestrates multiple Actions
+
+## Examples
+
+```php
+namespace App\Services;
+
+use App\Actions\CreateInvoice;
+use App\Actions\ChargePaymentMethod;
+use App\Actions\SendPaymentConfirmation;
+use App\Models\Order;
+use App\Models\Payment;
+use Illuminate\Support\Facades\DB;
+
+class PaymentService
+{
+    public function __construct(
+        private readonly CreateInvoice           $createInvoice,
+        private readonly ChargePaymentMethod     $chargePaymentMethod,
+        private readonly SendPaymentConfirmation $sendConfirmation,
+    ) {}
+
+    public function processOrderPayment(Order $order): Payment
+    {
+        return DB::transaction(function () use ($order) {
+            $invoice = $this->createInvoice->execute($order);
+            $payment = $this->chargePaymentMethod->execute($order, $invoice);
+            $this->sendConfirmation->execute($payment);
+
+            return $payment;
+        });
+    }
+
+    public function refund(Payment $payment): void
+    {
+        // refund orchestration logic
+    }
+}
+```
+
+```php
+// Registering an external service wrapper — AppServiceProvider
+$this->app->singleton(StripeService::class, function () {
+    return new StripeService(config('services.stripe.secret'));
+});
+```
+
+```php
+// Controller
+class PaymentController extends Controller
+{
+    public function store(StorePaymentRequest $request, PaymentService $service): JsonResponse
+    {
+        $order = Order::findOrFail($request->validated('order_id'));
+        $payment = $service->processOrderPayment($order);
+
+        return new JsonResponse(new PaymentResource($payment), 201);
+    }
+}
+```
+
+## Anti-Patterns
+
+- Using a Service for a single discrete operation (use an Action instead)
+- Putting HTTP concerns (request, response) inside a Service
+- Naming a service `DataManager` or `UserHandler` instead of a domain-specific name
+- Putting model attribute logic in a Service (belongs in the Model)
+- Putting authorization in a Service (belongs in Policies)
+- Making raw HTTP calls instead of using Saloon for external API integrations
+
+## References
+
+- [Laravel Service Container](https://laravel.com/docs/container)
+- Related: `Actions/SKILL.md` — individual operations that Services orchestrate
+- Related: `Saloon/SKILL.md` — the pattern for external API integrations
diff --git a/resources/boost/skills/traits/SKILL.md b/resources/boost/skills/traits/SKILL.md
new file mode 100644
index 0000000..3988056
--- /dev/null
+++ b/resources/boost/skills/traits/SKILL.md
@@ -0,0 +1,97 @@
+---
+name: traits
+description: Reusable behaviour shared across multiple unrelated classes. Traits provide shared Eloquent scopes, accessors, lifecycle hooks, and small stateless helper methods.
+---
+
+**Name:** Traits
+**Description:** Reusable behaviour shared across multiple unrelated classes. Traits provide shared Eloquent scopes, accessors, lifecycle hooks, and small stateless helper methods.
+**Compatible Agents:** general-purpose, backend
+**Tags:** app/Traits/**/*.php, laravel, php, backend, trait, reusable, eloquent
+
+## Rules
+
+- Trait classes live in `app/Traits/`
+- Each trait should have a **single, clearly defined responsibility**
+- Use descriptive names that reflect the behaviour they provide, not the classes that use them
+- Suffix with `able` when the trait grants a capability: `Archivable`, `Taggable`, `Sluggable`
+- Use a noun phrase when grouping related accessors/scopes: `HasTimestamps`, `HasAddress`
+- Use a trait only when the **same behaviour is needed across multiple unrelated classes**
+- Use `bootTraitName()` to hook into the model lifecycle without overriding `boot()` in the model
+- Use `initializeTraitName()` to set default property values on instantiation
+- Never put complex business logic in a trait — use an Action or Service
+
+## Examples
+
+```php
+namespace App\Traits;
+
+use Illuminate\Database\Eloquent\Builder;
+
+trait Archivable
+{
+    public function archive(): void
+    {
+        $this->update(['archived_at' => now()]);
+    }
+
+    public function unarchive(): void
+    {
+        $this->update(['archived_at' => null]);
+    }
+
+    public function isArchived(): bool
+    {
+        return ! is_null($this->archived_at);
+    }
+
+    public function scopeArchived(Builder $query): Builder
+    {
+        return $query->whereNotNull('archived_at');
+    }
+
+    public function scopeNotArchived(Builder $query): Builder
+    {
+        return $query->whereNull('archived_at');
+    }
+}
+```
+
+```php
+trait Sluggable
+{
+    public static function bootSluggable(): void
+    {
+        static::creating(function ($model) {
+            $model->slug = str($model->name)->slug();
+        });
+    }
+
+    public function scopeBySlug(Builder $query, string $slug): Builder
+    {
+        return $query->where('slug', $slug);
+    }
+}
+```
+
+```php
+// Usage across unrelated models
+class Post extends Model { use Archivable; }
+class Supplier extends Model { use Archivable; }
+
+$post->archive();
+Post::archived()->get();
+```
+
+## Anti-Patterns
+
+- Creating a trait for logic that only exists in one class (keep it inline)
+- Putting complex business rules in a trait (use an Action or Service)
+- Putting external service dependencies in a trait (use a Service class)
+- Using a trait to avoid inheritance instead of reconsidering the architecture
+- Creating catch-all traits that bundle unrelated behaviour
+
+## References
+
+- [PHP Traits](https://www.php.net/manual/en/language.oop5.traits.php)
+- [Laravel Model Booting](https://laravel.com/docs/eloquent#boot-and-initialize-traits)
+- Related: `Models/SKILL.md` — where traits are used on Eloquent models
diff --git a/src/CodingGuidelinesServiceProvider.php b/src/CodingGuidelinesServiceProvider.php
new file mode 100644
index 0000000..892e96e
--- /dev/null
+++ b/src/CodingGuidelinesServiceProvider.php
@@ -0,0 +1,27 @@
+<?php
+
+declare(strict_types=1);
+
+namespace CodebarAg\CodingGuidelines;
+
+use Illuminate\Support\ServiceProvider;
+
+class CodingGuidelinesServiceProvider extends ServiceProvider
+{
+    /**
+     * Register any application services.
+     */
+    public function register(): void
+    {
+        //
+    }
+
+    /**
+     * Bootstrap any application services.
+     */
+    public function boot(): void
+    {
+        // Skills are auto-discovered by Laravel Boost from resources/boost/skills/
+        // No registration needed — Boost v2.2+ reads vendor/{pkg}/resources/boost/skills/
+    }
+}
diff --git a/vendor/autoload.php b/vendor/autoload.php
new file mode 100644
index 0000000..b51bc02
--- /dev/null
+++ b/vendor/autoload.php
@@ -0,0 +1,22 @@
+<?php
+
+// autoload.php @generated by Composer
+
+if (PHP_VERSION_ID < 50600) {
+    if (!headers_sent()) {
+        header('HTTP/1.1 500 Internal Server Error');
+    }
+    $err = 'Composer 2.3.0 dropped support for autoloading on PHP <5.6 and you are running '.PHP_VERSION.', please upgrade PHP or use Composer 2.2 LTS via "composer self-update --2.2". Aborting.'.PHP_EOL;
+    if (!ini_get('display_errors')) {
+        if (PHP_SAPI === 'cli' || PHP_SAPI === 'phpdbg') {
+            fwrite(STDERR, $err);
+        } elseif (!headers_sent()) {
+            echo $err;
+        }
+    }
+    throw new RuntimeException($err);
+}
+
+require_once __DIR__ . '/composer/autoload_real.php';
+
+return ComposerAutoloaderInitb198656a13e411b31562de7dd0263755::getLoader();
diff --git a/vendor/composer/ClassLoader.php b/vendor/composer/ClassLoader.php
new file mode 100644
index 0000000..7824d8f
--- /dev/null
+++ b/vendor/composer/ClassLoader.php
@@ -0,0 +1,579 @@
+<?php
+
+/*
+ * This file is part of Composer.
+ *
+ * (c) Nils Adermann <naderman@naderman.de>
+ *     Jordi Boggiano <j.boggiano@seld.be>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Composer\Autoload;
+
+/**
+ * ClassLoader implements a PSR-0, PSR-4 and classmap class loader.
+ *
+ *     $loader = new \Composer\Autoload\ClassLoader();
+ *
+ *     // register classes with namespaces
+ *     $loader->add('Symfony\Component', __DIR__.'/component');
+ *     $loader->add('Symfony',           __DIR__.'/framework');
+ *
+ *     // activate the autoloader
+ *     $loader->register();
+ *
+ *     // to enable searching the include path (eg. for PEAR packages)
+ *     $loader->setUseIncludePath(true);
+ *
+ * In this example, if you try to use a class in the Symfony\Component
+ * namespace or one of its children (Symfony\Component\Console for instance),
+ * the autoloader will first look for the class under the component/
+ * directory, and it will then fallback to the framework/ directory if not
+ * found before giving up.
+ *
+ * This class is loosely based on the Symfony UniversalClassLoader.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ * @author Jordi Boggiano <j.boggiano@seld.be>
+ * @see    https://www.php-fig.org/psr/psr-0/
+ * @see    https://www.php-fig.org/psr/psr-4/
+ */
+class ClassLoader
+{
+    /** @var \Closure(string):void */
+    private static $includeFile;
+
+    /** @var string|null */
+    private $vendorDir;
+
+    // PSR-4
+    /**
+     * @var array<string, array<string, int>>
+     */
+    private $prefixLengthsPsr4 = array();
+    /**
+     * @var array<string, list<string>>
+     */
+    private $prefixDirsPsr4 = array();
+    /**
+     * @var list<string>
+     */
+    private $fallbackDirsPsr4 = array();
+
+    // PSR-0
+    /**
+     * List of PSR-0 prefixes
+     *
+     * Structured as array('F (first letter)' => array('Foo\Bar (full prefix)' => array('path', 'path2')))
+     *
+     * @var array<string, array<string, list<string>>>
+     */
+    private $prefixesPsr0 = array();
+    /**
+     * @var list<string>
+     */
+    private $fallbackDirsPsr0 = array();
+
+    /** @var bool */
+    private $useIncludePath = false;
+
+    /**
+     * @var array<string, string>
+     */
+    private $classMap = array();
+
+    /** @var bool */
+    private $classMapAuthoritative = false;
+
+    /**
+     * @var array<string, bool>
+     */
+    private $missingClasses = array();
+
+    /** @var string|null */
+    private $apcuPrefix;
+
+    /**
+     * @var array<string, self>
+     */
+    private static $registeredLoaders = array();
+
+    /**
+     * @param string|null $vendorDir
+     */
+    public function __construct($vendorDir = null)
+    {
+        $this->vendorDir = $vendorDir;
+        self::initializeIncludeClosure();
+    }
+
+    /**
+     * @return array<string, list<string>>
+     */
+    public function getPrefixes()
+    {
+        if (!empty($this->prefixesPsr0)) {
+            return call_user_func_array('array_merge', array_values($this->prefixesPsr0));
+        }
+
+        return array();
+    }
+
+    /**
+     * @return array<string, list<string>>
+     */
+    public function getPrefixesPsr4()
+    {
+        return $this->prefixDirsPsr4;
+    }
+
+    /**
+     * @return list<string>
+     */
+    public function getFallbackDirs()
+    {
+        return $this->fallbackDirsPsr0;
+    }
+
+    /**
+     * @return list<string>
+     */
+    public function getFallbackDirsPsr4()
+    {
+        return $this->fallbackDirsPsr4;
+    }
+
+    /**
+     * @return array<string, string> Array of classname => path
+     */
+    public function getClassMap()
+    {
+        return $this->classMap;
+    }
+
+    /**
+     * @param array<string, string> $classMap Class to filename map
+     *
+     * @return void
+     */
+    public function addClassMap(array $classMap)
+    {
+        if ($this->classMap) {
+            $this->classMap = array_merge($this->classMap, $classMap);
+        } else {
+            $this->classMap = $classMap;
+        }
+    }
+
+    /**
+     * Registers a set of PSR-0 directories for a given prefix, either
+     * appending or prepending to the ones previously set for this prefix.
+     *
+     * @param string              $prefix  The prefix
+     * @param list<string>|string $paths   The PSR-0 root directories
+     * @param bool                $prepend Whether to prepend the directories
+     *
+     * @return void
+     */
+    public function add($prefix, $paths, $prepend = false)
+    {
+        $paths = (array) $paths;
+        if (!$prefix) {
+            if ($prepend) {
+                $this->fallbackDirsPsr0 = array_merge(
+                    $paths,
+                    $this->fallbackDirsPsr0
+                );
+            } else {
+                $this->fallbackDirsPsr0 = array_merge(
+                    $this->fallbackDirsPsr0,
+                    $paths
+                );
+            }
+
+            return;
+        }
+
+        $first = $prefix[0];
+        if (!isset($this->prefixesPsr0[$first][$prefix])) {
+            $this->prefixesPsr0[$first][$prefix] = $paths;
+
+            return;
+        }
+        if ($prepend) {
+            $this->prefixesPsr0[$first][$prefix] = array_merge(
+                $paths,
+                $this->prefixesPsr0[$first][$prefix]
+            );
+        } else {
+            $this->prefixesPsr0[$first][$prefix] = array_merge(
+                $this->prefixesPsr0[$first][$prefix],
+                $paths
+            );
+        }
+    }
+
+    /**
+     * Registers a set of PSR-4 directories for a given namespace, either
+     * appending or prepending to the ones previously set for this namespace.
+     *
+     * @param string              $prefix  The prefix/namespace, with trailing '\\'
+     * @param list<string>|string $paths   The PSR-4 base directories
+     * @param bool                $prepend Whether to prepend the directories
+     *
+     * @throws \InvalidArgumentException
+     *
+     * @return void
+     */
+    public function addPsr4($prefix, $paths, $prepend = false)
+    {
+        $paths = (array) $paths;
+        if (!$prefix) {
+            // Register directories for the root namespace.
+            if ($prepend) {
+                $this->fallbackDirsPsr4 = array_merge(
+                    $paths,
+                    $this->fallbackDirsPsr4
+                );
+            } else {
+                $this->fallbackDirsPsr4 = array_merge(
+                    $this->fallbackDirsPsr4,
+                    $paths
+                );
+            }
+        } elseif (!isset($this->prefixDirsPsr4[$prefix])) {
+            // Register directories for a new namespace.
+            $length = strlen($prefix);
+            if ('\\' !== $prefix[$length - 1]) {
+                throw new \InvalidArgumentException("A non-empty PSR-4 prefix must end with a namespace separator.");
+            }
+            $this->prefixLengthsPsr4[$prefix[0]][$prefix] = $length;
+            $this->prefixDirsPsr4[$prefix] = $paths;
+        } elseif ($prepend) {
+            // Prepend directories for an already registered namespace.
+            $this->prefixDirsPsr4[$prefix] = array_merge(
+                $paths,
+                $this->prefixDirsPsr4[$prefix]
+            );
+        } else {
+            // Append directories for an already registered namespace.
+            $this->prefixDirsPsr4[$prefix] = array_merge(
+                $this->prefixDirsPsr4[$prefix],
+                $paths
+            );
+        }
+    }
+
+    /**
+     * Registers a set of PSR-0 directories for a given prefix,
+     * replacing any others previously set for this prefix.
+     *
+     * @param string              $prefix The prefix
+     * @param list<string>|string $paths  The PSR-0 base directories
+     *
+     * @return void
+     */
+    public function set($prefix, $paths)
+    {
+        if (!$prefix) {
+            $this->fallbackDirsPsr0 = (array) $paths;
+        } else {
+            $this->prefixesPsr0[$prefix[0]][$prefix] = (array) $paths;
+        }
+    }
+
+    /**
+     * Registers a set of PSR-4 directories for a given namespace,
+     * replacing any others previously set for this namespace.
+     *
+     * @param string              $prefix The prefix/namespace, with trailing '\\'
+     * @param list<string>|string $paths  The PSR-4 base directories
+     *
+     * @throws \InvalidArgumentException
+     *
+     * @return void
+     */
+    public function setPsr4($prefix, $paths)
+    {
+        if (!$prefix) {
+            $this->fallbackDirsPsr4 = (array) $paths;
+        } else {
+            $length = strlen($prefix);
+            if ('\\' !== $prefix[$length - 1]) {
+                throw new \InvalidArgumentException("A non-empty PSR-4 prefix must end with a namespace separator.");
+            }
+            $this->prefixLengthsPsr4[$prefix[0]][$prefix] = $length;
+            $this->prefixDirsPsr4[$prefix] = (array) $paths;
+        }
+    }
+
+    /**
+     * Turns on searching the include path for class files.
+     *
+     * @param bool $useIncludePath
+     *
+     * @return void
+     */
+    public function setUseIncludePath($useIncludePath)
+    {
+        $this->useIncludePath = $useIncludePath;
+    }
+
+    /**
+     * Can be used to check if the autoloader uses the include path to check
+     * for classes.
+     *
+     * @return bool
+     */
+    public function getUseIncludePath()
+    {
+        return $this->useIncludePath;
+    }
+
+    /**
+     * Turns off searching the prefix and fallback directories for classes
+     * that have not been registered with the class map.
+     *
+     * @param bool $classMapAuthoritative
+     *
+     * @return void
+     */
+    public function setClassMapAuthoritative($classMapAuthoritative)
+    {
+        $this->classMapAuthoritative = $classMapAuthoritative;
+    }
+
+    /**
+     * Should class lookup fail if not found in the current class map?
+     *
+     * @return bool
+     */
+    public function isClassMapAuthoritative()
+    {
+        return $this->classMapAuthoritative;
+    }
+
+    /**
+     * APCu prefix to use to cache found/not-found classes, if the extension is enabled.
+     *
+     * @param string|null $apcuPrefix
+     *
+     * @return void
+     */
+    public function setApcuPrefix($apcuPrefix)
+    {
+        $this->apcuPrefix = function_exists('apcu_fetch') && filter_var(ini_get('apc.enabled'), FILTER_VALIDATE_BOOLEAN) ? $apcuPrefix : null;
+    }
+
+    /**
+     * The APCu prefix in use, or null if APCu caching is not enabled.
+     *
+     * @return string|null
+     */
+    public function getApcuPrefix()
+    {
+        return $this->apcuPrefix;
+    }
+
+    /**
+     * Registers this instance as an autoloader.
+     *
+     * @param bool $prepend Whether to prepend the autoloader or not
+     *
+     * @return void
+     */
+    public function register($prepend = false)
+    {
+        spl_autoload_register(array($this, 'loadClass'), true, $prepend);
+
+        if (null === $this->vendorDir) {
+            return;
+        }
+
+        if ($prepend) {
+            self::$registeredLoaders = array($this->vendorDir => $this) + self::$registeredLoaders;
+        } else {
+            unset(self::$registeredLoaders[$this->vendorDir]);
+            self::$registeredLoaders[$this->vendorDir] = $this;
+        }
+    }
+
+    /**
+     * Unregisters this instance as an autoloader.
+     *
+     * @return void
+     */
+    public function unregister()
+    {
+        spl_autoload_unregister(array($this, 'loadClass'));
+
+        if (null !== $this->vendorDir) {
+            unset(self::$registeredLoaders[$this->vendorDir]);
+        }
+    }
+
+    /**
+     * Loads the given class or interface.
+     *
+     * @param  string    $class The name of the class
+     * @return true|null True if loaded, null otherwise
+     */
+    public function loadClass($class)
+    {
+        if ($file = $this->findFile($class)) {
+            $includeFile = self::$includeFile;
+            $includeFile($file);
+
+            return true;
+        }
+
+        return null;
+    }
+
+    /**
+     * Finds the path to the file where the class is defined.
+     *
+     * @param string $class The name of the class
+     *
+     * @return string|false The path if found, false otherwise
+     */
+    public function findFile($class)
+    {
+        // class map lookup
+        if (isset($this->classMap[$class])) {
+            return $this->classMap[$class];
+        }
+        if ($this->classMapAuthoritative || isset($this->missingClasses[$class])) {
+            return false;
+        }
+        if (null !== $this->apcuPrefix) {
+            $file = apcu_fetch($this->apcuPrefix.$class, $hit);
+            if ($hit) {
+                return $file;
+            }
+        }
+
+        $file = $this->findFileWithExtension($class, '.php');
+
+        // Search for Hack files if we are running on HHVM
+        if (false === $file && defined('HHVM_VERSION')) {
+            $file = $this->findFileWithExtension($class, '.hh');
+        }
+
+        if (null !== $this->apcuPrefix) {
+            apcu_add($this->apcuPrefix.$class, $file);
+        }
+
+        if (false === $file) {
+            // Remember that this class does not exist.
+            $this->missingClasses[$class] = true;
+        }
+
+        return $file;
+    }
+
+    /**
+     * Returns the currently registered loaders keyed by their corresponding vendor directories.
+     *
+     * @return array<string, self>
+     */
+    public static function getRegisteredLoaders()
+    {
+        return self::$registeredLoaders;
+    }
+
+    /**
+     * @param  string       $class
+     * @param  string       $ext
+     * @return string|false
+     */
+    private function findFileWithExtension($class, $ext)
+    {
+        // PSR-4 lookup
+        $logicalPathPsr4 = strtr($class, '\\', DIRECTORY_SEPARATOR) . $ext;
+
+        $first = $class[0];
+        if (isset($this->prefixLengthsPsr4[$first])) {
+            $subPath = $class;
+            while (false !== $lastPos = strrpos($subPath, '\\')) {
+                $subPath = substr($subPath, 0, $lastPos);
+                $search = $subPath . '\\';
+                if (isset($this->prefixDirsPsr4[$search])) {
+                    $pathEnd = DIRECTORY_SEPARATOR . substr($logicalPathPsr4, $lastPos + 1);
+                    foreach ($this->prefixDirsPsr4[$search] as $dir) {
+                        if (file_exists($file = $dir . $pathEnd)) {
+                            return $file;
+                        }
+                    }
+                }
+            }
+        }
+
+        // PSR-4 fallback dirs
+        foreach ($this->fallbackDirsPsr4 as $dir) {
+            if (file_exists($file = $dir . DIRECTORY_SEPARATOR . $logicalPathPsr4)) {
+                return $file;
+            }
+        }
+
+        // PSR-0 lookup
+        if (false !== $pos = strrpos($class, '\\')) {
+            // namespaced class name
+            $logicalPathPsr0 = substr($logicalPathPsr4, 0, $pos + 1)
+                . strtr(substr($logicalPathPsr4, $pos + 1), '_', DIRECTORY_SEPARATOR);
+        } else {
+            // PEAR-like class name
+            $logicalPathPsr0 = strtr($class, '_', DIRECTORY_SEPARATOR) . $ext;
+        }
+
+        if (isset($this->prefixesPsr0[$first])) {
+            foreach ($this->prefixesPsr0[$first] as $prefix => $dirs) {
+                if (0 === strpos($class, $prefix)) {
+                    foreach ($dirs as $dir) {
+                        if (file_exists($file = $dir . DIRECTORY_SEPARATOR . $logicalPathPsr0)) {
+                            return $file;
+                        }
+                    }
+                }
+            }
+        }
+
+        // PSR-0 fallback dirs
+        foreach ($this->fallbackDirsPsr0 as $dir) {
+            if (file_exists($file = $dir . DIRECTORY_SEPARATOR . $logicalPathPsr0)) {
+                return $file;
+            }
+        }
+
+        // PSR-0 include paths.
+        if ($this->useIncludePath && $file = stream_resolve_include_path($logicalPathPsr0)) {
+            return $file;
+        }
+
+        return false;
+    }
+
+    /**
+     * @return void
+     */
+    private static function initializeIncludeClosure()
+    {
+        if (self::$includeFile !== null) {
+            return;
+        }
+
+        /**
+         * Scope isolated include.
+         *
+         * Prevents access to $this/self from included files.
+         *
+         * @param  string $file
+         * @return void
+         */
+        self::$includeFile = \Closure::bind(static function($file) {
+            include $file;
+        }, null, null);
+    }
+}
diff --git a/vendor/composer/LICENSE b/vendor/composer/LICENSE
new file mode 100644
index 0000000..f27399a
--- /dev/null
+++ b/vendor/composer/LICENSE
@@ -0,0 +1,21 @@
+
+Copyright (c) Nils Adermann, Jordi Boggiano
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is furnished
+to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
diff --git a/vendor/composer/autoload_classmap.php b/vendor/composer/autoload_classmap.php
new file mode 100644
index 0000000..0fb0a2c
--- /dev/null
+++ b/vendor/composer/autoload_classmap.php
@@ -0,0 +1,10 @@
+<?php
+
+// autoload_classmap.php @generated by Composer
+
+$vendorDir = dirname(__DIR__);
+$baseDir = dirname($vendorDir);
+
+return array(
+    'Composer\\InstalledVersions' => $vendorDir . '/composer/InstalledVersions.php',
+);
diff --git a/vendor/composer/autoload_namespaces.php b/vendor/composer/autoload_namespaces.php
new file mode 100644
index 0000000..15a2ff3
--- /dev/null
+++ b/vendor/composer/autoload_namespaces.php
@@ -0,0 +1,9 @@
+<?php
+
+// autoload_namespaces.php @generated by Composer
+
+$vendorDir = dirname(__DIR__);
+$baseDir = dirname($vendorDir);
+
+return array(
+);
diff --git a/vendor/composer/autoload_psr4.php b/vendor/composer/autoload_psr4.php
new file mode 100644
index 0000000..70b42f9
--- /dev/null
+++ b/vendor/composer/autoload_psr4.php
@@ -0,0 +1,10 @@
+<?php
+
+// autoload_psr4.php @generated by Composer
+
+$vendorDir = dirname(__DIR__);
+$baseDir = dirname($vendorDir);
+
+return array(
+    'CodebarAg\\CodingGuidelines\\' => array($baseDir . '/src'),
+);
diff --git a/vendor/composer/autoload_real.php b/vendor/composer/autoload_real.php
new file mode 100644
index 0000000..9ce41a7
--- /dev/null
+++ b/vendor/composer/autoload_real.php
@@ -0,0 +1,38 @@
+<?php
+
+// autoload_real.php @generated by Composer
+
+class ComposerAutoloaderInitb198656a13e411b31562de7dd0263755
+{
+    private static $loader;
+
+    public static function loadClassLoader($class)
+    {
+        if ('Composer\Autoload\ClassLoader' === $class) {
+            require __DIR__ . '/ClassLoader.php';
+        }
+    }
+
+    /**
+     * @return \Composer\Autoload\ClassLoader
+     */
+    public static function getLoader()
+    {
+        if (null !== self::$loader) {
+            return self::$loader;
+        }
+
+        require __DIR__ . '/platform_check.php';
+
+        spl_autoload_register(array('ComposerAutoloaderInitb198656a13e411b31562de7dd0263755', 'loadClassLoader'), true, true);
+        self::$loader = $loader = new \Composer\Autoload\ClassLoader(\dirname(__DIR__));
+        spl_autoload_unregister(array('ComposerAutoloaderInitb198656a13e411b31562de7dd0263755', 'loadClassLoader'));
+
+        require __DIR__ . '/autoload_static.php';
+        call_user_func(\Composer\Autoload\ComposerStaticInitb198656a13e411b31562de7dd0263755::getInitializer($loader));
+
+        $loader->register(true);
+
+        return $loader;
+    }
+}
diff --git a/vendor/composer/autoload_static.php b/vendor/composer/autoload_static.php
new file mode 100644
index 0000000..4a9bb79
--- /dev/null
+++ b/vendor/composer/autoload_static.php
@@ -0,0 +1,36 @@
+<?php
+
+// autoload_static.php @generated by Composer
+
+namespace Composer\Autoload;
+
+class ComposerStaticInitb198656a13e411b31562de7dd0263755
+{
+    public static $prefixLengthsPsr4 = array (
+        'C' =>
+        array (
+            'CodebarAg\\CodingGuidelines\\' => 27,
+        ),
+    );
+
+    public static $prefixDirsPsr4 = array (
+        'CodebarAg\\CodingGuidelines\\' =>
+        array (
+            0 => __DIR__ . '/../..' . '/src',
+        ),
+    );
+
+    public static $classMap = array (
+        'Composer\\InstalledVersions' => __DIR__ . '/..' . '/composer/InstalledVersions.php',
+    );
+
+    public static function getInitializer(ClassLoader $loader)
+    {
+        return \Closure::bind(function () use ($loader) {
+            $loader->prefixLengthsPsr4 = ComposerStaticInitb198656a13e411b31562de7dd0263755::$prefixLengthsPsr4;
+            $loader->prefixDirsPsr4 = ComposerStaticInitb198656a13e411b31562de7dd0263755::$prefixDirsPsr4;
+            $loader->classMap = ComposerStaticInitb198656a13e411b31562de7dd0263755::$classMap;
+
+        }, null, ClassLoader::class);
+    }
+}
diff --git a/vendor/composer/platform_check.php b/vendor/composer/platform_check.php
new file mode 100644
index 0000000..14bf88d
--- /dev/null
+++ b/vendor/composer/platform_check.php
@@ -0,0 +1,25 @@
+<?php
+
+// platform_check.php @generated by Composer
+
+$issues = array();
+
+if (!(PHP_VERSION_ID >= 80200)) {
+    $issues[] = 'Your Composer dependencies require a PHP version ">= 8.2.0". You are running ' . PHP_VERSION . '.';
+}
+
+if ($issues) {
+    if (!headers_sent()) {
+        header('HTTP/1.1 500 Internal Server Error');
+    }
+    if (!ini_get('display_errors')) {
+        if (PHP_SAPI === 'cli' || PHP_SAPI === 'phpdbg') {
+            fwrite(STDERR, 'Composer detected issues in your platform:' . PHP_EOL.PHP_EOL . implode(PHP_EOL, $issues) . PHP_EOL.PHP_EOL);
+        } elseif (!headers_sent()) {
+            echo 'Composer detected issues in your platform:' . PHP_EOL.PHP_EOL . str_replace('You are running '.PHP_VERSION.'.', '', implode(PHP_EOL, $issues)) . PHP_EOL.PHP_EOL;
+        }
+    }
+    throw new \RuntimeException(
+        'Composer detected issues in your platform: ' . implode(' ', $issues)
+    );
+}

From 1da39cef7cbfb2751025b101d23eea51d4defa49 Mon Sep 17 00:00:00 2001
From: Sebastian Fix <sebastian.fix@codebar.ch>
Date: Fri, 27 Feb 2026 23:00:33 +0100
Subject: [PATCH 2/9] Updated .gitignore

---
 .gitignore                      |  24 +++++-
 RULES.md                        | 129 ++++++++------------------------
 guidelines.mdc                  |  12 ---
 skills/Actions/SKILL.md         |  92 -----------------------
 skills/Blade/SKILL.md           |  71 ------------------
 skills/Commands/SKILL.md        |  75 -------------------
 skills/Controllers/SKILL.md     |  80 --------------------
 skills/DTO/SKILL.md             |  60 ---------------
 skills/Dusk/SKILL.md            |  97 ------------------------
 skills/Enums/SKILL.md           |  73 ------------------
 skills/Events/SKILL.md          |  99 ------------------------
 skills/Exceptions/SKILL.md      |  87 ---------------------
 skills/FormRequests/SKILL.md    |  88 ----------------------
 skills/General/SKILL.md         |  72 ------------------
 skills/HelperFunctions/SKILL.md |  93 -----------------------
 skills/Helpers/SKILL.md         |  67 -----------------
 skills/Interfaces/SKILL.md      |  91 ----------------------
 skills/Jobs/SKILL.md            |  82 --------------------
 skills/Livewire/SKILL.md        | 114 ----------------------------
 skills/Middleware/SKILL.md      |  87 ---------------------
 skills/Migrations/SKILL.md      |  74 ------------------
 skills/Models/SKILL.md          |  89 ----------------------
 skills/Observers/SKILL.md       |  84 ---------------------
 skills/PHP/SKILL.md             |  98 ------------------------
 skills/PHPStan/SKILL.md         |  83 --------------------
 skills/PHPUnit/SKILL.md         |  91 ----------------------
 skills/PestTesting/SKILL.md     | 117 -----------------------------
 skills/Policies/SKILL.md        |  87 ---------------------
 skills/Requests/SKILL.md        |  78 -------------------
 skills/Resources/SKILL.md       |  72 ------------------
 skills/Routing/SKILL.md         |  65 ----------------
 skills/Saloon/SKILL.md          | 127 -------------------------------
 skills/Services/SKILL.md        |  92 -----------------------
 skills/Traits/SKILL.md          |  94 -----------------------
 34 files changed, 56 insertions(+), 2788 deletions(-)
 delete mode 100644 guidelines.mdc
 delete mode 100644 skills/Actions/SKILL.md
 delete mode 100644 skills/Blade/SKILL.md
 delete mode 100644 skills/Commands/SKILL.md
 delete mode 100644 skills/Controllers/SKILL.md
 delete mode 100644 skills/DTO/SKILL.md
 delete mode 100644 skills/Dusk/SKILL.md
 delete mode 100644 skills/Enums/SKILL.md
 delete mode 100644 skills/Events/SKILL.md
 delete mode 100644 skills/Exceptions/SKILL.md
 delete mode 100644 skills/FormRequests/SKILL.md
 delete mode 100644 skills/General/SKILL.md
 delete mode 100644 skills/HelperFunctions/SKILL.md
 delete mode 100644 skills/Helpers/SKILL.md
 delete mode 100644 skills/Interfaces/SKILL.md
 delete mode 100644 skills/Jobs/SKILL.md
 delete mode 100644 skills/Livewire/SKILL.md
 delete mode 100644 skills/Middleware/SKILL.md
 delete mode 100644 skills/Migrations/SKILL.md
 delete mode 100644 skills/Models/SKILL.md
 delete mode 100644 skills/Observers/SKILL.md
 delete mode 100644 skills/PHP/SKILL.md
 delete mode 100644 skills/PHPStan/SKILL.md
 delete mode 100644 skills/PHPUnit/SKILL.md
 delete mode 100644 skills/PestTesting/SKILL.md
 delete mode 100644 skills/Policies/SKILL.md
 delete mode 100644 skills/Requests/SKILL.md
 delete mode 100644 skills/Resources/SKILL.md
 delete mode 100644 skills/Routing/SKILL.md
 delete mode 100644 skills/Saloon/SKILL.md
 delete mode 100644 skills/Services/SKILL.md
 delete mode 100644 skills/Traits/SKILL.md

diff --git a/.gitignore b/.gitignore
index 485dee6..b87ea3a 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1 +1,23 @@
-.idea
+# Dependencies
+/vendor/
+node_modules/
+
+# Composer
+composer.lock
+composer.phar
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# PHP / Testing
+.phpunit.result.cache
+.php-cs-fixer.cache
+coverage/
+.phpunit.cache/
diff --git a/RULES.md b/RULES.md
index d0c6b1b..5d790a5 100644
--- a/RULES.md
+++ b/RULES.md
@@ -1,113 +1,50 @@
 # Rules Structure
 
-This file defines the folder structure and conventions for adding new Cursor rules.
+This file defines the folder structure and conventions for skills in this package.
 
-## Folder Layout
+## Package Layout
+
+Skills live in `resources/boost/skills/{skill-name}/SKILL.md` — the path Laravel Boost discovers for vendor packages.
 
 ```
-rules/
-  testing/          # Test framework and quality tool rules
-  frontend/         # Blade, Livewire, CSS, and JS rules
-  backend/          # General PHP conventions
-  laravel/          # Laravel framework conventions
-  services/         # External API integration rules
+resources/boost/skills/
+  general/           # Laravel conventions
+  models/            # Eloquent models
+  actions/           # Action pattern
+  blade/             # Blade templates
+  livewire/          # Livewire components
+  phpunit/           # PHPUnit tests
+  saloon/            # Saloon API integrations
+  ...                # See README for full list
 ```
 
-## Categories
-
-### testing/
-
-Rules for test frameworks and static analysis tools.
-
-| File | Scope | Description |
-|------|-------|-------------|
-| `phpunit.mdc` | `tests/**/*.php` | PHPUnit test structure, naming, assertions, and factory conventions |
-| `phpstan.mdc` | Always | PHPStan Level 9 static analysis compliance |
-| `pest-testing.mdc` | Laravel Testing Framework Pest 4 |
-
-
-### frontend/
-
-Rules for frontend technologies and templating.
-
-| File | Scope | Description |
-|------|-------|-------------|
-| `blade.mdc` | `resources/views/**/*.blade.php` | Blade template conventions and best practices |
-| `design.mdc` | `resources/views/**/*.blade.php` | Component-first design system and responsive UI conventions |
-| `livewire.mdc` | `app/Livewire/**/*.php` | Livewire component patterns and conventions |
-| `tailwind.mdc` | `resources/css/**` | Tailwind CSS v4 styling conventions |
-| `translations.mdc` | `lang/**/*.php,lang/**/*.json,resources/views/**/*.blade.php,app/**/*.php` | Translation and localization conventions |
-
-### backend/
-
-Rules for general PHP backend conventions (not Laravel-specific).
-
-| File | Scope | Description |
-|------|-------|-------------|
-| `actions.mdc` | `app/Actions/**/*.php` | Action conventions — single-purpose business logic classes |
-| `commands.mdc` | `app/Console/Commands/**/*.php` | Command conventions — command classes, how to use them, and what belongs in them |
-| `dto.mdc` | `**/DataObjects/**/*.php` | Readonly Data Transfer Object conventions with fromArray factory |
-| `enums.mdc` | `app/Enums/**/*.php` | PHP backed enum conventions with label and color helpers |
-| `events-listeners.mdc` | `app/Events/**/*.php,app/Listeners/**/*.php` | Event & Listener conventions — decoupled communication between application layers |
-| `exceptions.mdc` | `app/Exceptions/**/*.php` | Exception conventions — custom exceptions for domain and application errors |
-| `helpers.mdc` | `app/Helpers/**/*.php` | Helper conventions — helper classes how to use and what belongs into it |
-| `interfaces-contracts.mdc` | `app/Contracts/**/*.php` | Interface & Contract conventions — defining contracts between components |
-| `jobs.mdc` | `app/Jobs/**/*.php` | Queued job conventions with retries, backoff, and structured logging |
-| `middleware.mdc` | `app/Http/Middleware/**/*.php` | Middleware conventions — HTTP request and response pipeline |
-| `observers.mdc` | `app/Observers/**/*.php` | Observer conventions — reacting to Eloquent model lifecycle events |
-| `php.mdc` | `app/**/*.php` | General PHP conventions -- strict typing, formatting, language |
-| `policies.mdc` | `app/Policies/**/*.php` | Policy conventions — authorization logic for models and resources |
-| `requests.mdc` | `app/Http/Requests/**/*.php` | Form Request validation conventions |
-| `resources.mdc` | `app/Http/Resources/**/*.php` | Resource conventions — API resources, collections, and response shaping |
-| `services.mdc` | `app/Services/**/*.php` | Service conventions — complex orchestration across multiple domains |
-| `traits.mdc` | `app/Traits/**/*.php` | Trait conventions — when to use traits, how to write them, and what belongs in them |
+## How to Add a New Skill
 
-### laravel/
-
-Rules for Laravel framework conventions.
-
-| File | Scope | Description |
-|------|-------|-------------|
-| `general.mdc` | Always | Project-wide Laravel conventions that always apply |
-| `laravel-helperfunctions.mdc` | Always | Laravel Helper Functions – Always use Arr::, Str:: and Collection methods instead of native PHP equivalents |
-| `models.mdc` | `app/Models/**/*.php` | Eloquent model conventions -- guarded, casts, sections, activity log |
-| `controllers.mdc` | `app/Http/Controllers/**/*.php` | Controller conventions -- thin controllers, invokable, service delegation |
-| `migrations.mdc` | `database/migrations/**/*.php` | Database migration conventions -- always new files, naming, structure |
-| `form-requests.mdc` | `app/Http/Requests/**/*.php,app/Http/Controllers/**/*.php` | Dedicated Form Request validation classes for all controller input |
-| `routing.mdc` | `routes/**/*.php` | Route file conventions -- api vs web, grouping, model binding |
-
-### services/
-
-Rules for external API integrations. Add a new file for each service.
-
-| File | Scope | Description |
-|------|-------|-------------|
-| `saloon.mdc` | `app/Services/**/*.php` | Saloon-based service layer pattern for external API integrations |
-| `docuware.mdc` | `app/Services/DocuWare/**/*.php` | DocuWare integration patterns -- connector, webhook, import lifecycle |
-| `albatros.mdc` | `app/Services/Albatros/**/*.php` | Albatros accounting API integration -- Saloon connector, DTOs, pagination |
-
-## How to Add a New Rule
-
-1. Choose the correct category folder (or create a new one if needed)
-2. Create a `.mdc` file with YAML frontmatter:
+1. Create `resources/boost/skills/{skill-name}/SKILL.md`
+2. Add YAML frontmatter with `name` and `description` (required by [Agent Skills format](https://agentskills.io/what-are-skills)):
 
 ```markdown
 ---
-description: Brief description of what this rule covers
-globs: app/Path/**/*.php
-alwaysApply: false
+name: my-skill
+description: Brief description of when to use this skill
 ---
 
-# Rule Title
+# Skill Title
+
+## Rules
+- Rule 1
+- Rule 2
 
-Your rule content here...
+## Examples
+...
+
+## Anti-Patterns
+...
 ```
 
-3. Set the frontmatter:
-   - `description`: shown in Cursor's rule picker
-   - `globs`: file pattern -- rule activates when matching files are open
-   - `alwaysApply: true`: rule applies to every conversation (use sparingly)
+3. Use lowercase kebab-case for folder names: `my-skill`
+4. Keep skills concise with clear Rules, Examples, and Anti-Patterns
+
+## Overriding Skills
 
-4. Keep rules concise (under 50 lines of content)
-5. Include code examples showing the preferred pattern
-6. Use lowercase kebab-case for filenames: `my-service.mdc`
+Projects can override any skill by creating `.ai/skills/{skill-name}/SKILL.md` in their Laravel project. The local file takes precedence over the package default.
diff --git a/guidelines.mdc b/guidelines.mdc
deleted file mode 100644
index 5f1c519..0000000
--- a/guidelines.mdc
+++ /dev/null
@@ -1,12 +0,0 @@
----
-description: References codebar-ag coding guidelines (installed via Laravel Boost)
-alwaysApply: true
----
-
-# Shared Coding Guidelines
-
-This project uses **codebar-ag/coding-guidelines** — Laravel AI skills installed via [Laravel Boost](https://laravel.com/docs/boost).
-
-Before making any code change, follow the relevant skills (PHP, Models, Actions, Livewire, etc.) that Boost has installed. Run `php artisan boost:update` to sync the latest skills.
-
-See the [README](https://github.com/codebar-ag/coding-guidelines) for the full skills index.
diff --git a/skills/Actions/SKILL.md b/skills/Actions/SKILL.md
deleted file mode 100644
index 6543468..0000000
--- a/skills/Actions/SKILL.md
+++ /dev/null
@@ -1,92 +0,0 @@
-# Actions
-
-**Name:** Actions
-**Description:** Single-purpose business logic classes that encapsulate one well-defined business operation. Actions are the primary location for business logic in Laravel applications, invoked from controllers, commands, or jobs.
-**Compatible Agents:** general-purpose, backend
-**Tags:** app/Actions/**/*.php, laravel, php, backend, business-logic, action
-
-## Rules
-
-- Action classes live in `app/Actions/`
-- Each action represents **one single business operation** — if you can't describe it in a single sentence, split it up
-- Use a clear verb-noun naming pattern: `CreateInvoice`, `SendPasswordResetEmail`, `ArchiveExpiredSubscriptions`
-- Never use vague names like `InvoiceAction` or `UserHandler`
-- Actions expose a single public `execute()` method
-- Keep the constructor for dependency injection only
-- Actions are resolved via the service container
-- Never include HTTP concerns (request, response, redirects) in an action
-- Never put multi-domain orchestration in an action — use a Service instead
-- Never put reusable formatting or utility logic in an action — use a Helper
-
-## Examples
-
-```php
-namespace App\Actions;
-
-use App\Models\Invoice;
-use App\Models\Order;
-use App\Notifications\InvoiceCreatedNotification;
-
-class CreateInvoice
-{
-    public function __construct(
-        private readonly GenerateInvoicePdf $generatePdf,
-    ) {}
-
-    public function execute(Order $order): Invoice
-    {
-        $invoice = Invoice::create([
-            'order_id' => $order->id,
-            'amount'   => $order->total,
-            'due_date' => now()->addDays(30),
-        ]);
-
-        $this->generatePdf->execute($invoice);
-
-        $order->user->notify(new InvoiceCreatedNotification($invoice));
-
-        return $invoice;
-    }
-}
-```
-
-```php
-// Controller usage
-class InvoiceController extends Controller
-{
-    public function store(StoreInvoiceRequest $request, CreateInvoice $action): JsonResponse
-    {
-        $order = Order::findOrFail($request->validated('order_id'));
-        $invoice = $action->execute($order);
-
-        return new JsonResponse(new InvoiceResource($invoice), 201);
-    }
-}
-
-// Command usage
-class GenerateInvoicesCommand extends Command
-{
-    public function handle(CreateInvoice $action): int
-    {
-        Order::pending()->each(fn ($order) => $action->execute($order));
-
-        return self::SUCCESS;
-    }
-}
-```
-
-## Anti-Patterns
-
-- Putting HTTP concerns (`Request`, `Response`, redirects) inside an action
-- Creating multi-step orchestration across domains in a single action (use a Service)
-- Naming an action vaguely: `InvoiceAction`, `UserHandler`, `DataProcessor`
-- Adding multiple `execute()` methods or public methods beyond the single operation
-- Adding business logic in a constructor — use `execute()` for that
-- Performing database queries unrelated to the action's single responsibility
-
-## References
-
-- [Laravel Service Container](https://laravel.com/docs/container)
-- Related: `Services/SKILL.md` — for multi-domain orchestration
-- Related: `Jobs/SKILL.md` — for deferring actions to the queue
-- Related: `Controllers/SKILL.md` — for how controllers delegate to actions
diff --git a/skills/Blade/SKILL.md b/skills/Blade/SKILL.md
deleted file mode 100644
index 2d12644..0000000
--- a/skills/Blade/SKILL.md
+++ /dev/null
@@ -1,71 +0,0 @@
-# Blade
-
-**Name:** Blade Templates
-**Description:** Laravel Blade template conventions covering components, output escaping, security, structure, and formatting.
-**Compatible Agents:** general-purpose, frontend
-**Tags:** resources/views/**/*.blade.php, laravel, php, frontend, blade, template, html
-
-## Rules
-
-- Use Blade components (`<x-component>`) for reusable UI pieces
-- Prefer anonymous components for simple, presentation-only elements
-- Use class-based components when logic is needed
-- Use `{{ }}` for escaped output (default) — never output raw user input unescaped
-- Use `{!! !!}` only when the content is explicitly safe (e.g., pre-sanitized HTML)
-- No inline `<style>` tags in Blade files
-- No inline `<script>` tags in Blade files — use Livewire or Alpine.js via Blade directives
-- Keep all user-facing text in English
-- Indent Blade directives consistently (4 spaces)
-- Use short attribute syntax where supported: `@class`, `@style`
-
-## Examples
-
-```blade
-{{-- Escaped output — always use {{ }} for user data --}}
-<h1>{{ $user->name }}</h1>
-<p>{{ $post->excerpt }}</p>
-
-{{-- Raw output — only for pre-sanitized content --}}
-{!! $article->sanitizedBody !!}
-
-{{-- Anonymous component --}}
-<x-card>
-    <x-slot:title>{{ $invoice->title }}</x-slot:title>
-    <p>{{ $invoice->amount }}</p>
-</x-card>
-```
-
-```blade
-{{-- @class directive for conditional classes --}}
-<div @class(['p-4 rounded', 'bg-green-100' => $active, 'bg-red-100' => $error])>
-    {{ $message }}
-</div>
-
-{{-- @style directive for conditional styles --}}
-<div @style(['color: green' => $success, 'color: red' => $failure])>
-    {{ $text }}
-</div>
-```
-
-```blade
-{{-- Alpine.js via directive — no inline script tags --}}
-<div x-data="{ open: false }">
-    <button @click="open = !open">Toggle</button>
-    <div x-show="open">Content</div>
-</div>
-```
-
-## Anti-Patterns
-
-- Using `{!! $user->input !!}` for user-provided data — XSS vulnerability
-- Adding `<style>` or `<script>` tags directly in Blade files
-- Putting complex PHP logic directly in Blade templates (use components or Livewire)
-- Using inconsistent indentation for `@if`, `@foreach`, `@while` blocks
-- Hardcoding non-English text directly in Blade (use translation helpers for user-facing strings)
-
-## References
-
-- [Laravel Blade Templates](https://laravel.com/docs/blade)
-- [Alpine.js](https://alpinejs.dev/)
-- Related: `Livewire/SKILL.md` — interactive UI in Blade templates
-- Related: `Design/SKILL.md` — component-first design system
diff --git a/skills/Commands/SKILL.md b/skills/Commands/SKILL.md
deleted file mode 100644
index df646d2..0000000
--- a/skills/Commands/SKILL.md
+++ /dev/null
@@ -1,75 +0,0 @@
-# Commands
-
-**Name:** Commands
-**Description:** Artisan console command classes that serve as the CLI entry point for operations. Commands validate input and delegate all business logic to Actions or Services.
-**Compatible Agents:** general-purpose, backend
-**Tags:** app/Console/Commands/**/*.php, laravel, php, backend, artisan, cli, console
-
-## Rules
-
-- Command classes live in `app/Console/Commands/`
-- Each command should have a single, clearly defined responsibility
-- Complex logic belongs in **Actions** or **Services**, not in the command itself — commands are the entry point only
-- Use descriptive verb-noun names: `SendInvoiceReminders`, `ImportProductCsv`, `PruneExpiredSessions`
-- Command signatures follow the `namespace:action` pattern: `invoices:send-reminders`, `products:import`
-- Every argument and option **must** have a clear description
-- Validate all input using the `Validator` class — never trust raw input
-- Use `--option` flags for optional behaviour; avoid positional ambiguity
-- Implement `PromptsForMissingInput` so users receive clear prompts instead of silent failures
-- Commands must **always** return either `self::SUCCESS` or `self::FAILURE` — never `void` or `null`
-
-## Examples
-
-```php
-class SendInvoiceReminders extends Command implements PromptsForMissingInput
-{
-    protected $signature = 'invoices:send-reminders
-                            {email : The email address to send the reminder to}
-                            {--dry-run : Simulate the command without persisting changes}';
-
-    protected $description = 'Send invoice payment reminders to a specific user.';
-
-    public function __construct(private readonly SendInvoiceReminderAction $action)
-    {
-        parent::__construct();
-    }
-
-    public function handle(): int
-    {
-        $validated = validator(
-            [
-                'email'   => $this->argument('email'),
-                'dry_run' => $this->option('dry-run'),
-            ],
-            [
-                'email'   => ['required', 'email'],
-                'dry_run' => ['boolean'],
-            ]
-        )->validate();
-
-        try {
-            $this->action->execute($validated['email']);
-            $this->info("Reminder sent to {$validated['email']}.");
-
-            return self::SUCCESS;
-        } catch (Throwable $e) {
-            $this->error("Failed: {$e->getMessage()}");
-
-            return self::FAILURE;
-        }
-    }
-}
-```
-
-## Anti-Patterns
-
-- Putting business logic directly inside `handle()` instead of delegating to an Action or Service
-- Not returning `self::SUCCESS` or `self::FAILURE` (e.g., returning `void` or `null`)
-- Trusting raw `$this->argument()` / `$this->option()` values without validation
-- Omitting descriptions from arguments and options in the signature
-- Not implementing `PromptsForMissingInput`, causing silent failures for missing arguments
-
-## References
-
-- [Laravel Artisan Console](https://laravel.com/docs/artisan)
-- Related: `Actions/SKILL.md` — for the business logic commands delegate to
diff --git a/skills/Controllers/SKILL.md b/skills/Controllers/SKILL.md
deleted file mode 100644
index 5fe6ef9..0000000
--- a/skills/Controllers/SKILL.md
+++ /dev/null
@@ -1,80 +0,0 @@
-# Controllers
-
-**Name:** Controllers
-**Description:** Thin HTTP entry points that validate input, delegate to Actions or Services, and return a response. Controllers contain no business logic.
-**Compatible Agents:** general-purpose, backend
-**Tags:** app/Http/Controllers/**/*.php, laravel, php, backend, controller, http, request-response
-
-## Rules
-
-- Keep controllers **thin** — delegate business logic to Services, Actions, or Jobs
-- Controllers handle: request validation, calling a service/job, returning a response
-- No direct database queries or complex logic in controller methods
-- Use dedicated `FormRequest` classes for all validation — never call `$request->validate()` or `Validator::make()` inside a controller
-- Use invokable controllers (`__invoke`) for single-action endpoints
-- Name invokable controllers after the action: `StoreInvoiceController`, `ProcessWebhookController`
-- Return JSON responses from API controllers
-- Return views from web controllers
-- Use appropriate HTTP status codes (200, 201, 422, 403, etc.)
-- Enforce authorization at the controller level using `$this->authorize()`, via Form Request `authorize()`, or route middleware
-
-## Examples
-
-```php
-// Invokable single-action controller
-class StoreInvoiceController extends Controller
-{
-    public function __invoke(StoreInvoiceRequest $request, CreateInvoice $action): JsonResponse
-    {
-        $order = Order::findOrFail($request->validated('order_id'));
-        $invoice = $action->execute($order);
-
-        return new JsonResponse(new InvoiceResource($invoice), 201);
-    }
-}
-```
-
-```php
-// Resource controller — thin, delegates to actions
-class InvoiceController extends Controller
-{
-    public function index(): JsonResponse
-    {
-        return new JsonResponse(InvoiceResource::collection(Invoice::paginate()));
-    }
-
-    public function store(StoreInvoiceRequest $request, CreateInvoice $action): JsonResponse
-    {
-        $this->authorize('create', Invoice::class);
-
-        $order = Order::findOrFail($request->validated('order_id'));
-        $invoice = $action->execute($order);
-
-        return new JsonResponse(new InvoiceResource($invoice), 201);
-    }
-
-    public function destroy(Invoice $invoice, DeleteInvoice $action): JsonResponse
-    {
-        $this->authorize('delete', $invoice);
-        $action->execute($invoice);
-
-        return new JsonResponse(null, 204);
-    }
-}
-```
-
-## Anti-Patterns
-
-- Calling `$request->validate()` directly in a controller (use a FormRequest)
-- Writing database queries directly in a controller
-- Putting business logic in a controller method
-- Using resource controllers with 7 methods when only 1-2 are needed (use invokable controllers)
-- Not using appropriate HTTP status codes in responses
-- Performing authorization inside Actions instead of at the controller level
-
-## References
-
-- [Laravel Controllers](https://laravel.com/docs/controllers)
-- Related: `FormRequests/SKILL.md` — all input validation
-- Related: `Actions/SKILL.md` — the business logic controllers delegate to
-- Related: `Policies/SKILL.md` — authorization enforced in controllers
diff --git a/skills/DTO/SKILL.md b/skills/DTO/SKILL.md
deleted file mode 100644
index ed529cb..0000000
--- a/skills/DTO/SKILL.md
+++ /dev/null
@@ -1,60 +0,0 @@
-# DTO
-
-**Name:** DTO (Data Transfer Object)
-**Description:** Readonly data containers with a `fromArray` factory method used to pass structured data between application layers — especially for external API responses and service boundaries.
-**Compatible Agents:** general-purpose, backend
-**Tags:** DataObjects/**/*.php, laravel, php, backend, dto, data-object, readonly
-
-## Rules
-
-- Use `readonly class` with constructor promotion
-- Include a `static fromArray(array $data): static` factory method
-- Place DTOs in the relevant service's `DataObjects/` directory
-- DTOs are immutable — never add setters or mutable state
-- Handle API field name variations (PascalCase, camelCase, snake_case) in `fromArray()`
-- Use nullable types for optional fields
-- Keep DTOs free of business logic — they are data containers only
-- All properties must have explicit types — no untyped properties
-
-## Examples
-
-```php
-readonly class CustomerData
-{
-    public function __construct(
-        public string $id,
-        public ?string $name,
-        public ?string $email,
-    ) {}
-
-    public static function fromArray(array $data): static
-    {
-        return new static(
-            id: (string) ($data['ID'] ?? $data['id'] ?? ''),
-            name: $data['Name'] ?? $data['name'] ?? null,
-            email: $data['Email'] ?? $data['email'] ?? null,
-        );
-    }
-}
-```
-
-```php
-// Usage
-$customer = CustomerData::fromArray($apiResponse);
-echo $customer->name;
-```
-
-## Anti-Patterns
-
-- Adding setters or mutable state to a DTO
-- Including business logic inside a DTO
-- Using a DTO as a model replacement (DTOs don't persist to the database)
-- Not handling API field name variations (assuming a single naming convention)
-- Leaving properties untyped or using `mixed` without narrowing
-- Placing DTOs in a global `DataObjects/` folder instead of within the relevant service directory
-
-## References
-
-- [PHP Readonly Classes](https://www.php.net/manual/en/language.oop5.readonly-properties.php)
-- Related: `Services/SKILL.md` — DTOs are typically returned by service classes
-- Related: `Saloon/SKILL.md` — Saloon integrations return typed DTOs
diff --git a/skills/Dusk/SKILL.md b/skills/Dusk/SKILL.md
deleted file mode 100644
index 5d89957..0000000
--- a/skills/Dusk/SKILL.md
+++ /dev/null
@@ -1,97 +0,0 @@
-# Dusk
-
-**Name:** Dusk (Browser Testing)
-**Description:** End-to-end browser testing with Laravel Dusk. Used exclusively for full user flows requiring a real Chrome browser — JavaScript interactions, multi-step forms, and visual assertions.
-**Compatible Agents:** general-purpose, testing
-**Tags:** tests/Browser/**/*.php, laravel, php, testing, dusk, browser, e2e, end-to-end
-
-## Rules
-
-- Browser tests live in `tests/Browser/`
-- Use Dusk only where a real browser interaction is required (JavaScript, multi-step flows)
-- Never use `RefreshDatabase` in Dusk tests — use `DatabaseTruncation` (preferred) or `DatabaseMigrations`
-- Always call `assertNoJavaScriptErrors()` after every `visit()`
-- Always use `dusk=""` HTML attributes as selectors — never CSS classes or IDs
-- Never use `pause()` — use `waitFor()`, `waitForText()`, or `waitUntilMissing()` instead
-- Use `loginAs()` to authenticate without going through the login form
-- Extract repeated navigation into **Page Objects**
-- Extract repeated interactive UI elements into **Dusk Components**
-- Create a dedicated `.env.dusk.local` file to use a separate test database
-
-## Examples
-
-```php
-uses(DatabaseTruncation::class);
-
-it('user can submit an invoice', function () {
-    // Arrange
-    $user = User::factory()->create();
-
-    // Act + Assert
-    $this->browse(function (Browser $browser) use ($user) {
-        $browser->loginAs($user)
-                ->visit('/invoices/create')
-                ->assertNoJavaScriptErrors()
-                ->type('@amount-input', '100')
-                ->press('@submit-button')
-                ->waitForText('Invoice created')
-                ->assertSee('Invoice created');
-    });
-});
-```
-
-```html
-<!-- Blade/HTML — use dusk attributes, not CSS classes -->
-<button dusk="submit-invoice">Submit</button>
-<input dusk="amount-input" type="number" name="amount">
-```
-
-```php
-// Page Object
-class InvoicePage extends Page
-{
-    public function __construct(private readonly int $invoiceId) {}
-
-    public function url(): string { return "/invoices/{$this->invoiceId}"; }
-
-    public function assert(Browser $browser): void
-    {
-        $browser->assertPathIs($this->url());
-    }
-
-    public function elements(): array
-    {
-        return [
-            '@mark-paid-button' => '[dusk="mark-paid-button"]',
-        ];
-    }
-
-    public function markAsPaid(Browser $browser): void
-    {
-        $browser->click('@mark-paid-button')
-                ->waitForText('Invoice marked as paid');
-    }
-}
-```
-
-```php
-// Waiting — never use pause()
-$browser->waitFor('@invoice-table');          // ❌ pause(3000)
-$browser->waitForText('Invoice created');     // ❌ pause(2000)
-$browser->waitUntilMissing('@loading-spinner'); // ❌ pause(5000)
-```
-
-## Anti-Patterns
-
-- Using `RefreshDatabase` in Dusk tests (transactions invisible across HTTP processes)
-- Using `pause(3000)` — arbitrary sleeps make tests slow and brittle
-- Using CSS classes or IDs as selectors instead of `dusk=""` attributes
-- Testing pure business logic or JSON API responses with Dusk (use feature tests instead)
-- Not calling `assertNoJavaScriptErrors()` after `visit()`
-- Repeating navigation and selector logic across test files instead of using Page Objects
-
-## References
-
-- [Laravel Dusk](https://laravel.com/docs/dusk)
-- Related: `PestTesting/SKILL.md` — Pest syntax used for Dusk tests
-- Related: `PHPUnit/SKILL.md` — feature tests for non-browser scenarios
diff --git a/skills/Enums/SKILL.md b/skills/Enums/SKILL.md
deleted file mode 100644
index cbd66e3..0000000
--- a/skills/Enums/SKILL.md
+++ /dev/null
@@ -1,73 +0,0 @@
-# Enums
-
-**Name:** Enums
-**Description:** PHP backed string enums used instead of constants or magic strings. Enums include `label()` and `color()` helper methods and are cast on Eloquent models.
-**Compatible Agents:** general-purpose, backend
-**Tags:** app/Enums/**/*.php, laravel, php, backend, enum, status
-
-## Rules
-
-- Use **backed string enums** — never use plain constants or magic strings for finite sets of values
-- Include `label(): string` and `color(): string` helper methods on every enum
-- Place all enums in `app/Enums/`
-- Always cast enum columns in model `casts()` methods
-- Use enum string values in migrations: `$table->string('status')->default('draft')`
-- Reference enum cases in code, never raw strings: `Status::Draft` not `'draft'`
-- Use `match` expressions in `label()` and `color()` — never if/else chains
-
-## Examples
-
-```php
-enum Status: string
-{
-    case Draft    = 'draft';
-    case Active   = 'active';
-    case Archived = 'archived';
-
-    public function label(): string
-    {
-        return match ($this) {
-            self::Draft    => 'Draft',
-            self::Active   => 'Active',
-            self::Archived => 'Archived',
-        };
-    }
-
-    public function color(): string
-    {
-        return match ($this) {
-            self::Draft    => 'gray',
-            self::Active   => 'green',
-            self::Archived => 'red',
-        };
-    }
-}
-```
-
-```php
-// Model cast
-protected function casts(): array
-{
-    return [
-        'status' => Status::class,
-    ];
-}
-
-// Usage
-if ($invoice->status === Status::Draft) { ... }
-echo $invoice->status->label(); // 'Draft'
-```
-
-## Anti-Patterns
-
-- Using raw strings instead of enum cases: `'draft'` instead of `Status::Draft`
-- Using integer-backed enums when string enums are more readable
-- Forgetting to cast enum columns in the model's `casts()` method
-- Using if/else chains instead of `match` expressions in `label()` or `color()`
-- Putting business logic inside enum methods (beyond label/color presentation helpers)
-
-## References
-
-- [PHP Enums](https://www.php.net/manual/en/language.enumerations.php)
-- [Laravel Enum Casting](https://laravel.com/docs/eloquent-mutators#enum-casting)
-- Related: `Models/SKILL.md` — for how enums are cast in Eloquent models
diff --git a/skills/Events/SKILL.md b/skills/Events/SKILL.md
deleted file mode 100644
index 3fd7219..0000000
--- a/skills/Events/SKILL.md
+++ /dev/null
@@ -1,99 +0,0 @@
-# Events
-
-**Name:** Events & Listeners
-**Description:** Decoupled communication between application layers. Events are plain data objects describing what happened; listeners react to those events with a single, specific side effect.
-**Compatible Agents:** general-purpose, backend
-**Tags:** app/Events/**/*.php, app/Listeners/**/*.php, laravel, php, backend, event, listener, observer-pattern
-
-## Rules
-
-- Event classes live in `app/Events/`; listener classes live in `app/Listeners/`
-- Events are plain data containers — no logic inside events
-- Listeners handle one specific reaction each — never bundle multiple side effects
-- Events: past-tense noun phrase → `InvoicePaid`, `UserRegistered`, `OrderShipped`
-- Listeners: verb phrase describing the reaction → `SendInvoicePaidNotification`, `UpdateInventory`
-- Dispatch events from inside an **Action** after the operation completes — never from a controller or model directly
-- Register events and listeners in `EventServiceProvider`
-- Implement `ShouldQueue` on listeners for side effects that can be deferred
-- Define a `failed()` method on queued listeners
-- Use events when one action triggers multiple independent side effects
-
-## Examples
-
-```php
-// Event — data container only
-namespace App\Events;
-
-use App\Models\Invoice;
-use Illuminate\Foundation\Events\Dispatchable;
-use Illuminate\Queue\SerializesModels;
-
-class InvoicePaid
-{
-    use Dispatchable, SerializesModels;
-
-    public function __construct(
-        public readonly Invoice $invoice,
-    ) {}
-}
-```
-
-```php
-// Listener — one reaction
-namespace App\Listeners;
-
-use App\Events\InvoicePaid;
-use App\Notifications\InvoicePaidNotification;
-use Illuminate\Contracts\Queue\ShouldQueue;
-
-class SendInvoicePaidNotification implements ShouldQueue
-{
-    public function handle(InvoicePaid $event): void
-    {
-        $event->invoice->user->notify(new InvoicePaidNotification($event->invoice));
-    }
-
-    public function failed(InvoicePaid $event, \Throwable $exception): void
-    {
-        // Handle failure
-    }
-}
-```
-
-```php
-// Dispatching — from inside an Action
-class MarkInvoiceAsPaid
-{
-    public function execute(Invoice $invoice): void
-    {
-        $invoice->update(['paid_at' => now()]);
-        InvoicePaid::dispatch($invoice);
-    }
-}
-```
-
-```php
-// Registration — one event, many listeners
-protected $listen = [
-    InvoicePaid::class => [
-        SendInvoicePaidNotification::class,
-        UpdateAccountingRecords::class,
-        NotifyAccountManager::class,
-    ],
-];
-```
-
-## Anti-Patterns
-
-- Adding business logic inside an Event class
-- Bundling multiple reactions in a single Listener (one listener, one reaction)
-- Dispatching events from controllers or models directly — dispatch from Actions
-- Using events for simple, single side effects that can be triggered directly
-- Not implementing `failed()` on queued listeners for critical side effects
-- Creating event chains that obscure control flow and make debugging hard
-
-## References
-
-- [Laravel Events](https://laravel.com/docs/events)
-- Related: `Actions/SKILL.md` — events should be dispatched from Actions
-- Related: `Observers/SKILL.md` — for model lifecycle reactions
diff --git a/skills/Exceptions/SKILL.md b/skills/Exceptions/SKILL.md
deleted file mode 100644
index 293edbf..0000000
--- a/skills/Exceptions/SKILL.md
+++ /dev/null
@@ -1,87 +0,0 @@
-# Exceptions
-
-**Name:** Exceptions
-**Description:** Named, meaningful failure states in your domain. Custom exceptions communicate precise failure reasons to callers and optionally carry domain-specific data.
-**Compatible Agents:** general-purpose, backend
-**Tags:** app/Exceptions/**/*.php, laravel, php, backend, exception, error-handling
-
-## Rules
-
-- Exception classes live in `app/Exceptions/`
-- Custom exceptions represent **named, meaningful failure states** — not generic error wrappers
-- Use a clear noun phrase describing what went wrong: `InvoiceAlreadyPaid`, `InsufficientFunds`, `PaymentGatewayUnavailable`
-- Always suffix with `Exception`: `InvoiceAlreadyPaidException`
-- Use named static constructors (`static for()`) to make throw sites readable
-- Set the message via `parent::__construct()` inside the constructor
-- Expose domain-specific context data as `public readonly` properties
-- Implement `render()` directly on exceptions that always map to the same HTTP response
-- Register exception rendering in `bootstrap/app.php` using `withExceptions()`
-- Avoid `try-catch` blocks — let exceptions bubble up to the framework handler unless you must react locally
-
-## Examples
-
-```php
-namespace App\Exceptions;
-
-use App\Models\Invoice;
-use RuntimeException;
-
-class InvoiceAlreadyPaidException extends RuntimeException
-{
-    public function __construct(
-        public readonly Invoice $invoice,
-    ) {
-        parent::__construct(
-            "Invoice #{$invoice->id} has already been paid and cannot be modified."
-        );
-    }
-
-    public static function for(Invoice $invoice): static
-    {
-        return new static($invoice);
-    }
-}
-```
-
-```php
-// Throwing — from inside an Action
-class MarkInvoiceAsPaid
-{
-    public function execute(Invoice $invoice): void
-    {
-        if ($invoice->isPaid()) {
-            throw InvoiceAlreadyPaidException::for($invoice);
-        }
-
-        $invoice->update(['paid_at' => now()]);
-    }
-}
-```
-
-```php
-// Registering in bootstrap/app.php
-->withExceptions(function (Exceptions $exceptions) {
-    $exceptions->render(function (InvoiceAlreadyPaidException $e, Request $request) {
-        return response()->json(['message' => $e->getMessage()], 422);
-    });
-
-    $exceptions->dontReport([
-        InvoiceAlreadyPaidException::class,
-    ]);
-})
-```
-
-## Anti-Patterns
-
-- Creating generic exception wrappers instead of named domain exceptions
-- Not using a named static constructor — verbose `new InvoiceAlreadyPaidException($invoice)` at every throw site
-- Putting business logic or recovery logic inside an exception class
-- Silently swallowing exceptions without logging or re-throwing
-- Using built-in exceptions where a domain-specific exception would communicate intent better
-- Creating an exception for cases already handled cleanly by validation or early returns
-
-## References
-
-- [Laravel Error Handling](https://laravel.com/docs/errors)
-- Related: `Actions/SKILL.md` — the typical place where domain exceptions are thrown
-- Related: `PHP/SKILL.md` — for error handling philosophy (avoid try-catch, let bubble)
diff --git a/skills/FormRequests/SKILL.md b/skills/FormRequests/SKILL.md
deleted file mode 100644
index 736cae5..0000000
--- a/skills/FormRequests/SKILL.md
+++ /dev/null
@@ -1,88 +0,0 @@
-# FormRequests
-
-**Name:** Form Requests
-**Description:** Dedicated validation classes for all controller input. Form Requests encapsulate validation rules, authorization, and error messages outside of controllers.
-**Compatible Agents:** general-purpose, backend
-**Tags:** app/Http/Requests/**/*.php, app/Http/Controllers/**/*.php, laravel, php, backend, validation, form-request
-
-## Rules
-
-- Every controller action that accepts user input **must** use a dedicated `FormRequest` class
-- Never call `$request->validate()` or `Validator::make()` inside a controller
-- Place Form Requests in `app/Http/Requests/` or a subdirectory matching the domain (e.g. `Auth/`)
-- Naming pattern: `Store{Resource}Request`, `Update{Resource}Request`
-- Match the resource name to the controller: `StoreSprintController` → `StoreSprintRequest`
-- Define `authorize(): bool` with proper authorization logic — never leave it as a passive `return true` without intention
-- Define `rules(): array` with a PHPDoc `@return` array shape
-- Use **array-based** rule definitions, not pipe-delimited strings
-- Add `messages(): array` when validation messages need localization or extra clarity
-
-## Examples
-
-```php
-class StoreSprintRequest extends FormRequest
-{
-    public function authorize(): bool
-    {
-        return $this->user() !== null;
-    }
-
-    /**
-     * @return array<string, array<int, string|object>>
-     */
-    public function rules(): array
-    {
-        return [
-            'title'  => ['required', 'string', 'max:255'],
-            'locale' => ['required', Locale::validationRule()],
-        ];
-    }
-
-    public function messages(): array
-    {
-        return [
-            'title.required' => __('A title is required.'),
-        ];
-    }
-}
-```
-
-```php
-// Controller usage — inject the FormRequest
-class StoreSprintController extends Controller
-{
-    public function __invoke(StoreSprintRequest $request, CreateSprint $action): JsonResponse
-    {
-        $sprint = $action->execute($request->validated());
-
-        return new JsonResponse(new SprintResource($sprint), 201);
-    }
-}
-```
-
-```php
-// Authorization using a policy
-public function authorize(): bool
-{
-    return $this->user()->can('create', Post::class);
-}
-
-// Scoped to an admin role
-public function authorize(): bool
-{
-    return $this->user()->isAdmin();
-}
-```
-
-## Anti-Patterns
-
-- Calling `$request->validate()` inside a controller — always use a FormRequest
-- Using pipe-delimited rule strings: `'required|string|max:255'` instead of `['required', 'string', 'max:255']`
-- Leaving `authorize()` as `return true` without documenting why all users are permitted
-- Not adding a `messages()` method for user-facing validation errors that need clarity
-
-## References
-
-- [Laravel Form Requests](https://laravel.com/docs/validation#form-request-validation)
-- Related: `Controllers/SKILL.md` — controllers that use Form Requests
-- Related: `Policies/SKILL.md` — `can()` used in `authorize()` method
diff --git a/skills/General/SKILL.md b/skills/General/SKILL.md
deleted file mode 100644
index f98c31b..0000000
--- a/skills/General/SKILL.md
+++ /dev/null
@@ -1,72 +0,0 @@
-# General
-
-**Name:** Laravel General Conventions
-**Description:** Project-wide Laravel conventions that always apply: configuration access, database patterns, logging, activity logging, and code formatting.
-**Compatible Agents:** general-purpose, backend
-**Tags:** app/**/*.php, laravel, php, backend, config, logging, formatting, conventions
-
-## Rules
-
-- Use `config()` helper to read configuration values — **never** use `env()` directly outside of config files
-- Add new config keys to the appropriate file in `config/`
-- Use Eloquent or Query Builder — no raw DB queries
-- Wrap multi-step writes in `DB::transaction()`
-- Use `Illuminate\Support\Facades\Log` with structured context arrays for logging
-- Add the `Spatie\Activitylog\Traits\LogsActivity` trait on all models that track business data
-- Configure `getActivitylogOptions()` with `logAll()`, `logOnlyDirty()`, `dontSubmitEmptyLogs()`
-- Use `activity()->performedOn($model)->log(...)` for manual log entries in jobs and controllers
-- Run **Laravel Pint** on all PHP code before committing
-
-## Examples
-
-```php
-// Configuration — always use config()
-$secret = config('services.stripe.secret');
-// ❌ env('STRIPE_SECRET')
-```
-
-```php
-// Structured logging
-Log::info('Invoice created.', [
-    'invoice_id' => $invoice->id,
-    'order_id'   => $order->id,
-    'amount'     => $invoice->amount,
-]);
-
-Log::error('Payment failed.', [
-    'invoice_id' => $invoice->id,
-    'error'      => $exception->getMessage(),
-]);
-```
-
-```php
-// Database transactions for multi-step writes
-$payment = DB::transaction(function () use ($order) {
-    $invoice = $this->createInvoice->execute($order);
-    $payment = $this->chargePaymentMethod->execute($order, $invoice);
-
-    return $payment;
-});
-```
-
-```php
-// Manual activity log entry
-activity()
-    ->performedOn($invoice)
-    ->withProperties(['amount' => $invoice->amount])
-    ->log('Invoice paid manually via admin panel.');
-```
-
-## Anti-Patterns
-
-- Using `env('KEY')` directly in application code outside of config files
-- Writing raw SQL queries with `DB::statement()` or `DB::select()` when Eloquent/Query Builder can be used
-- Using `Log::info('Message')` without a context array — always include structured data
-- Not wrapping related database operations in a transaction
-
-## References
-
-- [Laravel Configuration](https://laravel.com/docs/configuration)
-- [Laravel Logging](https://laravel.com/docs/logging)
-- [Spatie Activity Log](https://spatie.be/docs/laravel-activitylog/)
-- [Laravel Pint](https://laravel.com/docs/pint)
diff --git a/skills/HelperFunctions/SKILL.md b/skills/HelperFunctions/SKILL.md
deleted file mode 100644
index 5908839..0000000
--- a/skills/HelperFunctions/SKILL.md
+++ /dev/null
@@ -1,93 +0,0 @@
-# HelperFunctions
-
-**Name:** Laravel Helper Functions
-**Description:** Always prefer Laravel's built-in helper classes over native PHP functions. Use `Arr::`, `Str::`, and Collection methods instead of native PHP equivalents.
-**Compatible Agents:** general-purpose, backend
-**Tags:** app/**/*.php, laravel, php, backend, helpers, arr, str, collection
-
-## Rules
-
-- Always prefer Laravel's built-in helper classes over native PHP functions
-- **Arrays**: Use `Arr::` (import `Illuminate\Support\Arr`) — never use `array_map`, `array_filter`, `in_array`, `array_key_exists`, etc. when a Laravel equivalent exists
-- **Strings**: Use `Str::` (import `Illuminate\Support\Str`) — never use `substr`, `strpos`, `str_replace`, `strtolower`, etc. when a Laravel equivalent exists
-- **Collections**: Prefer `collect()` + Collection methods over manual array loops
-- Use `Str::of()` for chaining multiple string operations
-- Use `collect()` to wrap any array or iterable when performing multiple operations
-
-## Examples
-
-```php
-// Arrays
-use Illuminate\Support\Arr;
-
-// ✓ Dot-notation access
-Arr::get($array, 'user.address.city', 'Unknown');
-// ❌ $array['user']['address']['city'] ?? 'Unknown'
-
-// ✓ Keep only specific keys
-Arr::only($array, ['name', 'email']);
-// ❌ array_intersect_key(...)
-
-// ✓ Remove specific keys
-Arr::except($array, ['password', 'token']);
-// ❌ unset($array['key'])
-
-// ✓ Map values
-Arr::map($array, fn($value) => strtoupper($value));
-// ❌ array_map(fn($v) => strtoupper($v), $array)
-```
-
-```php
-// Strings
-use Illuminate\Support\Str;
-
-Str::upper('hello');        // ❌ strtoupper('hello')
-Str::lower('HELLO');        // ❌ strtolower('HELLO')
-Str::slug('Hello World');   // ❌ strtolower(str_replace(' ', '-', $string))
-Str::contains('foo bar', 'foo'); // ❌ str_contains()
-Str::random(32);            // ❌ bin2hex(random_bytes(16))
-
-// Fluent chaining
-$result = Str::of('  Hello World  ')
-    ->trim()
-    ->lower()
-    ->slug();
-```
-
-```php
-// Collections
-$users = collect(User::all());
-
-// ✓ Prefer collection methods
-$admins = $users->filter(fn($u) => $u->isAdmin())->values();
-$names  = $users->pluck('name');
-$byRole = $users->groupBy('role');
-
-// ❌ manual foreach loops
-```
-
-**Quick Reference: PHP → Laravel**
-
-| PHP native | Laravel equivalent |
-|---|---|
-| `array_map($fn, $arr)` | `Arr::map($arr, $fn)` |
-| `array_filter($arr, $fn)` | `Arr::where($arr, $fn)` |
-| `array_key_exists($k, $arr)` | `Arr::exists($arr, $k)` |
-| `in_array($v, $arr)` | `collect($arr)->contains($v)` |
-| `strtolower($str)` | `Str::lower($str)` |
-| `strtoupper($str)` | `Str::upper($str)` |
-| `str_contains($str, $sub)` | `Str::contains($str, $sub)` |
-| `http_build_query($arr)` | `Arr::query($arr)` |
-
-## Anti-Patterns
-
-- Using `array_map`, `array_filter`, `array_key_exists` when `Arr::` equivalents exist
-- Using `strtolower`, `strtoupper`, `str_replace` when `Str::` equivalents exist
-- Writing manual `foreach` loops when a Collection method achieves the same result
-- Not importing `Arr` or `Str` before use — always add the `use` statement
-
-## References
-
-- [Laravel Arr Helper](https://laravel.com/docs/helpers#arrays)
-- [Laravel Str Helper](https://laravel.com/docs/helpers#strings)
-- [Laravel Collections](https://laravel.com/docs/collections)
diff --git a/skills/Helpers/SKILL.md b/skills/Helpers/SKILL.md
deleted file mode 100644
index c2eb4f1..0000000
--- a/skills/Helpers/SKILL.md
+++ /dev/null
@@ -1,67 +0,0 @@
-# Helpers
-
-**Name:** Helpers
-**Description:** Stateless utility classes providing shared formatting, conversion, or calculation logic needed across multiple parts of the application.
-**Compatible Agents:** general-purpose, backend
-**Tags:** app/Helpers/**/*.php, laravel, php, backend, helper, utility
-
-## Rules
-
-- Helper classes live in `app/Helpers/`
-- Naming: `PascalCase` with a `Helper` suffix → `StringHelper`, `MoneyHelper`, `DateHelper`
-- Helpers are for utilities needed in **multiple places** across the project
-- For testability, static methods are acceptable but not enforced — use your judgement
-- Never put business logic in helpers — use Actions or Services
-- Never put database queries in helpers — use Model Scopes
-- Never put HTTP requests in helpers — use Services
-
-## Examples
-
-```php
-namespace App\Helpers;
-
-use Carbon\Carbon;
-
-class DateHelper
-{
-    public static function format(mixed $date, string $format = 'd M Y'): ?string
-    {
-        if (is_null($date)) {
-            return null;
-        }
-
-        return Carbon::parse($date)->format($format);
-    }
-}
-```
-
-```php
-namespace App\Helpers;
-
-class MoneyHelper
-{
-    public static function format(int $amountInCents, string $currency = 'CHF'): string
-    {
-        return number_format($amountInCents / 100, 2) . ' ' . $currency;
-    }
-}
-```
-
-```php
-// Usage in a Resource
-'created_at' => DateHelper::format($this->created_at),
-'amount'     => MoneyHelper::format($this->amount_in_cents),
-```
-
-## Anti-Patterns
-
-- Putting business logic in a helper (belongs in an Action or Service)
-- Putting database queries in a helper (use Model scopes instead)
-- Using a helper for logic only needed in one place (keep it inline)
-- Creating a catch-all `AppHelper` or `Utils` class — keep helpers domain-specific
-
-## References
-
-- [Carbon Documentation](https://carbon.nesbot.com/)
-- Related: `Actions/SKILL.md` — for business logic
-- Related: `Resources/SKILL.md` — helpers are commonly used for formatting in API resources
diff --git a/skills/Interfaces/SKILL.md b/skills/Interfaces/SKILL.md
deleted file mode 100644
index 4585ff2..0000000
--- a/skills/Interfaces/SKILL.md
+++ /dev/null
@@ -1,91 +0,0 @@
-# Interfaces
-
-**Name:** Interfaces & Contracts
-**Description:** Contracts defining the shape a class must conform to. Used for decoupling dependent classes from concrete implementations, enabling multiple implementations and easier testing.
-**Compatible Agents:** general-purpose, backend
-**Tags:** app/Contracts/**/*.php, laravel, php, backend, interface, contract, dependency-inversion
-
-## Rules
-
-- Interface classes live in `app/Contracts/`
-- Interfaces define a **contract** — the shape a class must conform to, without dictating the implementation
-- Use a clear noun or adjective that describes the capability: `PaymentGateway`, `Notifiable`, `ReportGenerator`
-- Avoid an `Interface` suffix — the namespace and context make it clear
-- Only create an interface when there are (or you anticipate) **multiple implementations**
-- Always type-hint the interface, never the concrete class, in consuming classes
-- Bind the interface to a concrete implementation in a service provider
-- Define only public method signatures — no implementation, no properties
-
-## Examples
-
-```php
-// Interface definition
-namespace App\Contracts;
-
-use App\Models\Order;
-use App\Data\PaymentResult;
-
-interface PaymentGateway
-{
-    public function charge(Order $order, int $amountInCents): PaymentResult;
-
-    public function refund(string $transactionId, int $amountInCents): PaymentResult;
-}
-```
-
-```php
-// Implementation
-namespace App\Services\Payment;
-
-use App\Contracts\PaymentGateway;
-
-class StripeGateway implements PaymentGateway
-{
-    public function charge(Order $order, int $amountInCents): PaymentResult
-    {
-        // Stripe-specific implementation
-    }
-
-    public function refund(string $transactionId, int $amountInCents): PaymentResult
-    {
-        // Stripe-specific implementation
-    }
-}
-```
-
-```php
-// Service container binding — AppServiceProvider
-public function register(): void
-{
-    $this->app->bind(PaymentGateway::class, StripeGateway::class);
-}
-```
-
-```php
-// Consuming — type-hint the interface
-class ChargePaymentMethod
-{
-    public function __construct(
-        private readonly PaymentGateway $gateway,
-    ) {}
-}
-```
-
-```php
-// Testing — swap the binding
-$this->app->bind(PaymentGateway::class, FakePaymentGateway::class);
-```
-
-## Anti-Patterns
-
-- Creating an interface for every class by default — only add interfaces where they provide real decoupling
-- Creating an interface when there is only one implementation and no realistic chance of another
-- Adding default implementations to an interface (use an abstract class instead)
-- Adding constants specific to one implementation (keep in the concrete class)
-- Type-hinting the concrete class instead of the interface in consumers
-
-## References
-
-- [Laravel Service Container](https://laravel.com/docs/container)
-- [PHP Interfaces](https://www.php.net/manual/en/language.oop5.interfaces.php)
-- Related: `Services/SKILL.md` — services often implement interfaces
diff --git a/skills/Jobs/SKILL.md b/skills/Jobs/SKILL.md
deleted file mode 100644
index 75e65a6..0000000
--- a/skills/Jobs/SKILL.md
+++ /dev/null
@@ -1,82 +0,0 @@
-# Jobs
-
-**Name:** Jobs
-**Description:** Queueable units of work for background processing. Jobs handle queue configuration and failure handling — they delegate business logic to Actions or Services.
-**Compatible Agents:** general-purpose, backend
-**Tags:** app/Jobs/**/*.php, laravel, php, backend, queue, job, background
-
-## Rules
-
-- Job classes live in `app/Jobs/`
-- Jobs are **queueable units of work** that execute a single task in the background
-- Use a clear verb-noun naming pattern: `ProcessInvoicePayment`, `SendWeeklyReport`, `ImportProductCsv`
-- The name should describe what the job does, not when it runs
-- Jobs delegate their work to an **Action** or **Service** — they own queue configuration and failure handling, not business logic
-- Always declare queue configuration explicitly on the job class rather than relying on defaults
-- Implement `ShouldQueue` for all jobs that should run asynchronously
-- Always use the `Dispatchable`, `InteractsWithQueue`, `Queueable`, `SerializesModels` traits
-- Define a `failed(Throwable $exception)` method for permanent failure handling
-
-## Examples
-
-```php
-namespace App\Jobs;
-
-use App\Actions\ProcessInvoicePayment;
-use App\Models\Invoice;
-use Illuminate\Bus\Queueable;
-use Illuminate\Contracts\Queue\ShouldQueue;
-use Illuminate\Foundation\Bus\Dispatchable;
-use Illuminate\Queue\InteractsWithQueue;
-use Illuminate\Queue\SerializesModels;
-use Throwable;
-
-class ProcessInvoicePaymentJob implements ShouldQueue
-{
-    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;
-
-    public int $tries = 3;
-    public int $backoff = 60;
-    public int $timeout = 120;
-    public string $queue = 'invoices';
-
-    public function __construct(
-        private readonly Invoice $invoice,
-    ) {}
-
-    public function handle(ProcessInvoicePayment $action): void
-    {
-        $action->execute($this->invoice);
-    }
-
-    public function failed(Throwable $exception): void
-    {
-        // Notify, log, or alert on permanent failure after all retries
-    }
-}
-```
-
-```php
-// Dispatch immediately to the queue
-ProcessInvoicePaymentJob::dispatch($invoice);
-
-// Dispatch with a delay
-ProcessInvoicePaymentJob::dispatch($invoice)->delay(now()->addMinutes(5));
-
-// Dispatch synchronously (bypasses queue — useful in tests)
-ProcessInvoicePaymentJob::dispatchSync($invoice);
-```
-
-## Anti-Patterns
-
-- Putting business logic directly in a job's `handle()` method instead of delegating to an Action or Service
-- Omitting `$tries`, `$backoff`, or `$timeout` and relying on global queue defaults
-- Not implementing a `failed()` method for jobs that process critical data
-- Using jobs for work that must complete synchronously before returning a response
-- Using jobs for simple, fast operations that don't justify queue overhead
-
-## References
-
-- [Laravel Queues](https://laravel.com/docs/queues)
-- Related: `Actions/SKILL.md` — for the business logic jobs delegate to
-- Related: `Services/SKILL.md` — for complex orchestration delegated from jobs
diff --git a/skills/Livewire/SKILL.md b/skills/Livewire/SKILL.md
deleted file mode 100644
index 1e0ae17..0000000
--- a/skills/Livewire/SKILL.md
+++ /dev/null
@@ -1,114 +0,0 @@
-# Livewire
-
-**Name:** Livewire Components
-**Description:** Laravel Livewire conventions for building interactive UI without custom JavaScript. Components are PHP classes with reactive properties, computed properties, and event dispatching.
-**Compatible Agents:** general-purpose, frontend
-**Tags:** app/Livewire/**/*.php, resources/views/livewire/**/*.blade.php, laravel, php, frontend, livewire, interactive
-
-## Rules
-
-- Use **Livewire** for all interactive UI — no custom JavaScript unless absolutely necessary
-- Follow existing Livewire component patterns in the project
-- Keep component logic in the PHP class; keep Blade templates declarative
-- One Livewire component per feature/concern
-- Use public properties for reactive data
-- Use computed properties (`#[Computed]`) for derived data
-- Use `wire:model` for two-way binding, `wire:click` for actions
-- Keep components small and focused — extract sub-components when they grow
-- Use form objects (`Livewire\Form`) for complex form handling
-- Dispatch events for cross-component communication
-
-## Examples
-
-```php
-namespace App\Livewire;
-
-use App\Actions\CreateInvoice;
-use App\Models\Invoice;
-use Livewire\Attributes\Computed;
-use Livewire\Component;
-
-class InvoiceList extends Component
-{
-    public string $search = '';
-
-    #[Computed]
-    public function invoices()
-    {
-        return Invoice::where('title', 'like', "%{$this->search}%")
-            ->paginate(15);
-    }
-
-    public function delete(int $invoiceId): void
-    {
-        $invoice = Invoice::findOrFail($invoiceId);
-        $this->authorize('delete', $invoice);
-        $invoice->delete();
-    }
-
-    public function render()
-    {
-        return view('livewire.invoice-list');
-    }
-}
-```
-
-```blade
-{{-- Blade template — declarative, no logic --}}
-<div>
-    <input wire:model.live="search" type="text" placeholder="Search invoices...">
-
-    @foreach ($this->invoices as $invoice)
-        <div>
-            {{ $invoice->title }}
-            <button wire:click="delete({{ $invoice->id }})">Delete</button>
-        </div>
-    @endforeach
-
-    {{ $this->invoices->links() }}
-</div>
-```
-
-```php
-// Livewire Form Object for complex forms
-use Livewire\Form;
-
-class InvoiceForm extends Form
-{
-    public string $title = '';
-    public int $order_id = 0;
-    public ?string $notes = null;
-
-    public function rules(): array
-    {
-        return [
-            'title'    => ['required', 'string', 'max:255'],
-            'order_id' => ['required', 'integer', 'exists:orders,id'],
-            'notes'    => ['nullable', 'string'],
-        ];
-    }
-}
-```
-
-```php
-// Cross-component event dispatching
-$this->dispatch('invoice-created', invoiceId: $invoice->id);
-
-// Listening for events
-#[On('invoice-created')]
-public function refreshList(int $invoiceId): void { ... }
-```
-
-## Anti-Patterns
-
-- Writing custom JavaScript when Livewire can handle the interaction
-- Putting display logic in the PHP class instead of the Blade template
-- Growing a single component to handle multiple unrelated features
-- Using `wire:model` without `.live` or `.lazy` when immediate reactivity is not needed (unnecessary requests)
-- Not using form objects for forms with more than 3-4 fields
-
-## References
-
-- [Livewire Documentation](https://livewire.laravel.com/)
-- Related: `Blade/SKILL.md` — Blade templates used by Livewire components
-- Related: `Actions/SKILL.md` — Livewire components delegate business logic to Actions
diff --git a/skills/Middleware/SKILL.md b/skills/Middleware/SKILL.md
deleted file mode 100644
index 46f2752..0000000
--- a/skills/Middleware/SKILL.md
+++ /dev/null
@@ -1,87 +0,0 @@
-# Middleware
-
-**Name:** Middleware
-**Description:** HTTP request/response pipeline handlers that inspect, modify, or reject requests before or after they reach a controller. Used for authentication, throttling, header manipulation, and logging.
-**Compatible Agents:** general-purpose, backend
-**Tags:** app/Http/Middleware/**/*.php, laravel, php, backend, middleware, http, pipeline
-
-## Rules
-
-- Middleware classes live in `app/Http/Middleware/`
-- Use a clear descriptive name that states what it does: `EnsureUserIsSubscribed`, `ForceJsonResponse`, `CheckMaintenanceWindow`
-- Avoid vague names like `ApiMiddleware` or `CheckMiddleware`
-- Middleware must call `$next($request)` to pass the request down the pipeline, or return early to reject it
-- Register middleware in `bootstrap/app.php` using `->withMiddleware()`
-- Apply middleware at the group level, not on individual routes, when possible
-- Code before `$next($request)` runs before the controller; code after runs on the response
-- Never put business logic in middleware — use Actions or Services
-- Never put model-level authorization in middleware — use Policies
-- Never put request body validation in middleware — use Form Requests
-
-## Examples
-
-```php
-namespace App\Http\Middleware;
-
-use Closure;
-use Illuminate\Http\Request;
-use Symfony\Component\HttpFoundation\Response;
-
-class EnsureUserIsSubscribed
-{
-    public function handle(Request $request, Closure $next): Response
-    {
-        if (!$request->user()?->isSubscribed()) {
-            return response()->json(['message' => 'Subscription required.'], 403);
-        }
-
-        return $next($request);
-    }
-}
-```
-
-```php
-// Before and After middleware
-public function handle(Request $request, Closure $next): Response
-{
-    // Runs BEFORE the controller
-    $request->headers->set('X-Request-Id', Str::uuid());
-
-    $response = $next($request);
-
-    // Runs AFTER the controller
-    $response->headers->set('X-Powered-By', 'MyApp');
-
-    return $response;
-}
-```
-
-```php
-// Registration in bootstrap/app.php
-->withMiddleware(function (Middleware $middleware) {
-    $middleware->append(ForceJsonResponse::class);
-
-    $middleware->alias([
-        'subscribed' => EnsureUserIsSubscribed::class,
-    ]);
-})
-
-// Applied to route group
-Route::middleware('subscribed')->group(function () {
-    Route::get('/dashboard', DashboardController::class);
-});
-```
-
-## Anti-Patterns
-
-- Putting business logic inside middleware (belongs in Actions or Services)
-- Putting model-level authorization in middleware (belongs in Policies)
-- Validating the request body in middleware (belongs in Form Requests)
-- Accessing validated input inside middleware — middleware runs before validation
-- Using middleware for things that only apply to a single route
-
-## References
-
-- [Laravel Middleware](https://laravel.com/docs/middleware)
-- Related: `Policies/SKILL.md` — for model-level authorization
-- Related: `FormRequests/SKILL.md` — for request body validation
diff --git a/skills/Migrations/SKILL.md b/skills/Migrations/SKILL.md
deleted file mode 100644
index 42bef08..0000000
--- a/skills/Migrations/SKILL.md
+++ /dev/null
@@ -1,74 +0,0 @@
-# Migrations
-
-**Name:** Migrations
-**Description:** Database schema change files. Always create new files for changes — never modify existing migrations. Use descriptive names, proper foreign key constraints, and reversible `down()` methods.
-**Compatible Agents:** general-purpose, backend
-**Tags:** database/migrations/**/*.php, laravel, php, backend, database, migration, schema
-
-## Rules
-
-- Always create **new** migration files for database changes — **never** modify existing migration files
-- Use descriptive names: `create_invoices_table`, `add_status_to_invoices_table`
-- Implement both `up()` and `down()` methods — `down()` must fully reverse `up()`
-- Group related columns logically: IDs first, then data, then timestamps
-- Use enum string values for status columns: `$table->string('status')->default('draft')`
-- Add indexes on columns used in WHERE clauses and foreign keys
-- Use `foreignId()->constrained()->cascadeOnDelete()` for foreign keys
-- Keep migrations focused — one concern per migration
-
-## Examples
-
-```php
-public function up(): void
-{
-    Schema::create('invoices', function (Blueprint $table) {
-        $table->id();
-        $table->foreignId('order_id')->constrained()->cascadeOnDelete();
-        $table->foreignId('user_id')->constrained()->cascadeOnDelete();
-        $table->string('status')->default('draft');
-        $table->decimal('amount', 10, 2);
-        $table->date('due_date');
-        $table->timestamp('paid_at')->nullable();
-        $table->timestamps();
-
-        $table->index('status');
-    });
-}
-
-public function down(): void
-{
-    Schema::dropIfExists('invoices');
-}
-```
-
-```php
-// Adding a column to an existing table
-public function up(): void
-{
-    Schema::table('invoices', function (Blueprint $table) {
-        $table->string('reference')->nullable()->after('status');
-    });
-}
-
-public function down(): void
-{
-    Schema::table('invoices', function (Blueprint $table) {
-        $table->dropColumn('reference');
-    });
-}
-```
-
-## Anti-Patterns
-
-- Modifying existing migration files instead of creating new ones
-- Using an integer default for status columns instead of a string enum value
-- Omitting the `down()` method or leaving it empty
-- Not adding indexes on foreign key columns and frequently queried columns
-- Creating a single migration that makes multiple unrelated schema changes
-- Using `$table->integer('status')` instead of `$table->string('status')->default('...')`
-
-## References
-
-- [Laravel Migrations](https://laravel.com/docs/migrations)
-- Related: `Models/SKILL.md` — models reflect the schema defined in migrations
-- Related: `Enums/SKILL.md` — enum string values used as migration defaults
diff --git a/skills/Models/SKILL.md b/skills/Models/SKILL.md
deleted file mode 100644
index c0f72f2..0000000
--- a/skills/Models/SKILL.md
+++ /dev/null
@@ -1,89 +0,0 @@
-# Models
-
-**Name:** Models
-**Description:** Eloquent model conventions covering mass assignment, casts, relationships, section headers, and activity logging. Every model must follow these structural rules.
-**Compatible Agents:** general-purpose, backend
-**Tags:** app/Models/**/*.php, laravel, php, backend, eloquent, model, database
-
-## Rules
-
-- Use `$guarded = []` — never use `$fillable` arrays
-- Define `casts()` as a **method**, not a property
-- Cast enums, dates, decimals, and JSON in `casts()`
-- Add the `LogsActivity` trait on all business models
-- Configure `getActivitylogOptions()` with `logAll()`, `logOnlyDirty()`, `dontSubmitEmptyLogs()`
-- Use typed return types on all relationship methods (`HasMany`, `BelongsTo`, etc.)
-- Every new model must have a corresponding factory in `database/factories/`
-- Group model code with section comment headers: `// --- Relationships ---`, `// --- Status Helpers ---`, etc.
-
-## Examples
-
-```php
-namespace App\Models;
-
-use Illuminate\Database\Eloquent\Model;
-use Illuminate\Database\Eloquent\Relations\HasMany;
-use Spatie\Activitylog\LogOptions;
-use Spatie\Activitylog\Traits\LogsActivity;
-
-class Invoice extends Model
-{
-    use LogsActivity;
-
-    protected $guarded = [];
-
-    protected function casts(): array
-    {
-        return [
-            'status'   => Status::class,
-            'due_date' => 'date',
-            'amount'   => 'decimal:2',
-        ];
-    }
-
-    // --- Relationships ---
-
-    public function lines(): HasMany
-    {
-        return $this->hasMany(InvoiceLine::class);
-    }
-
-    // --- Status Helpers ---
-
-    public function isDraft(): bool
-    {
-        return $this->status === Status::Draft;
-    }
-
-    public function isPaid(): bool
-    {
-        return $this->status === Status::Paid;
-    }
-
-    // --- Activity Log ---
-
-    public function getActivitylogOptions(): LogOptions
-    {
-        return LogOptions::defaults()
-            ->logAll()
-            ->logOnlyDirty()
-            ->dontSubmitEmptyLogs();
-    }
-}
-```
-
-## Anti-Patterns
-
-- Using `$fillable` arrays instead of `$guarded = []`
-- Defining `$casts` as a property instead of a `casts()` method
-- Not using the `LogsActivity` trait on business models
-- Omitting return types on relationship methods
-- Creating a model without a corresponding factory
-- Putting business logic directly in the model — use Actions
-
-## References
-
-- [Laravel Eloquent Models](https://laravel.com/docs/eloquent)
-- [Spatie Activity Log](https://spatie.be/docs/laravel-activitylog/)
-- Related: `Enums/SKILL.md` — enums are cast in `casts()`
-- Related: `Migrations/SKILL.md` — migrations define the model's schema
diff --git a/skills/Observers/SKILL.md b/skills/Observers/SKILL.md
deleted file mode 100644
index 7e911f9..0000000
--- a/skills/Observers/SKILL.md
+++ /dev/null
@@ -1,84 +0,0 @@
-# Observers
-
-**Name:** Observers
-**Description:** Centralised classes that react to Eloquent model lifecycle events. Used for side effects that should always fire regardless of where a model is mutated — such as notifications, cache invalidation, and audit logging.
-**Compatible Agents:** general-purpose, backend
-**Tags:** app/Observers/**/*.php, laravel, php, backend, observer, eloquent, model-events
-
-## Rules
-
-- Observer classes live in `app/Observers/`
-- Naming: `PascalCase` with an `Observer` suffix, named after the model they observe: `UserObserver`, `InvoiceObserver`
-- Only define the event methods you actually need — do not scaffold empty methods
-- Register observers in `AppServiceProvider` using the `observe()` method
-- Use observers for side effects tied to model lifecycle events that should always fire
-- Never put business logic that should be explicitly controlled in an observer — use an Action instead
-
-## Examples
-
-```php
-namespace App\Observers;
-
-use App\Models\User;
-use App\Notifications\WelcomeNotification;
-use Illuminate\Support\Facades\Cache;
-
-class UserObserver
-{
-    public function created(User $user): void
-    {
-        $user->notify(new WelcomeNotification());
-    }
-
-    public function updated(User $user): void
-    {
-        Cache::forget("user:{$user->id}");
-    }
-
-    public function deleted(User $user): void
-    {
-        Cache::forget("user:{$user->id}");
-    }
-}
-```
-
-```php
-// Registration in AppServiceProvider
-use App\Models\User;
-use App\Observers\UserObserver;
-
-public function boot(): void
-{
-    User::observe(UserObserver::class);
-}
-```
-
-**Available lifecycle events:**
-
-| Method | Fires when... |
-|---|---|
-| `creating` | Before a model is first saved |
-| `created` | After a model is first saved |
-| `updating` | Before an existing model is saved |
-| `updated` | After an existing model is saved |
-| `saving` | Before creating or updating |
-| `saved` | After creating or updating |
-| `deleting` | Before a model is deleted |
-| `deleted` | After a model is deleted |
-| `restoring` | Before a soft-deleted model is restored |
-| `restored` | After a soft-deleted model is restored |
-
-## Anti-Patterns
-
-- Using an observer for side effects specific to one particular action (use the Action directly instead)
-- Scaffolding empty observer methods for all lifecycle events when only one is needed
-- Putting complex orchestration inside an observer (use a Service)
-- Using an observer for validation (use Form Requests)
-- Using an observer for authorization (use Policies)
-- Relying on observers when you need fine-grained control over when side effects fire
-
-## References
-
-- [Laravel Observers](https://laravel.com/docs/eloquent#observers)
-- Related: `Models/SKILL.md` — Eloquent model conventions
-- Related: `Events/SKILL.md` — alternative for decoupled side effects
diff --git a/skills/PHP/SKILL.md b/skills/PHP/SKILL.md
deleted file mode 100644
index fe441ae..0000000
--- a/skills/PHP/SKILL.md
+++ /dev/null
@@ -1,98 +0,0 @@
-# PHP
-
-**Name:** PHP Conventions
-**Description:** General PHP coding standards covering strict typing, formatting, control flow, and error handling. Applies to all PHP files in the application.
-**Compatible Agents:** general-purpose, backend
-**Tags:** app/**/*.php, laravel, php, backend, typing, formatting, conventions
-
-## Rules
-
-- Type hints on **all** parameters, return types, and properties — no untyped signatures
-- Use union types or nullable (`?Type`) where needed
-- Target **PHPStan Level 9** compliance
-- All code in **English**: variable names, comments, docblocks
-- Foreign-language domain terms from external APIs are acceptable in DTOs where they match the API
-- Run **Laravel Pint** before committing
-- Avoid `try-catch` blocks — let exceptions bubble up to the framework's handler
-- Only catch exceptions when you **must** react locally (retry logic, API fallback)
-- Use **early returns** (guard clauses) to handle edge cases at the top of a method
-- Never use `else`, `elseif`, or nested `if` blocks — invert the condition and return early
-- Prefer immutability — use `readonly` properties where possible
-- One class per file
-
-## Examples
-
-```php
-// ✓ Early returns — guard clauses
-public function process(Order $order): void
-{
-    if (! $order->isPaid()) {
-        throw new UnpaidOrderException();
-    }
-
-    if (! $order->hasItems()) {
-        throw new EmptyOrderException();
-    }
-
-    // Happy-path logic here
-}
-```
-
-```php
-// ✗ Nested if/else — never do this
-public function process(Order $order): void
-{
-    if ($order->isPaid()) {
-        if ($order->hasItems()) {
-            // deep logic
-        } else {
-            throw new EmptyOrderException();
-        }
-    } else {
-        throw new UnpaidOrderException();
-    }
-}
-```
-
-```php
-// ✓ Fully typed class
-class CreateInvoice
-{
-    public function __construct(
-        private readonly GenerateInvoicePdf $generatePdf,
-    ) {}
-
-    public function execute(Order $order): Invoice
-    {
-        // implementation
-    }
-}
-```
-
-```php
-// ✓ Structured logging when catching
-try {
-    $this->externalService->call($data);
-} catch (ServiceException $e) {
-    Log::error('External service failed.', [
-        'message' => $e->getMessage(),
-        'data'    => $data,
-    ]);
-    throw $e;
-}
-```
-
-## Anti-Patterns
-
-- Untyped function parameters or return types
-- Using `else` or `elseif` — invert and return early instead
-- Silently swallowing exceptions with empty catch blocks
-- Using `env()` directly in application code (only in config files)
-- Non-English variable names, comments, or method names
-- Multiple classes in a single file
-
-## References
-
-- [PHPStan](https://phpstan.org/)
-- [Laravel Pint](https://laravel.com/docs/pint)
-- Related: `PHPStan/SKILL.md` — static analysis compliance
diff --git a/skills/PHPStan/SKILL.md b/skills/PHPStan/SKILL.md
deleted file mode 100644
index 5ea8c12..0000000
--- a/skills/PHPStan/SKILL.md
+++ /dev/null
@@ -1,83 +0,0 @@
-# PHPStan
-
-**Name:** PHPStan
-**Description:** Static analysis tool configured at Level 9. All code must pass PHPStan Level 9 with strict typing, no untyped signatures, and minimal suppression of errors.
-**Compatible Agents:** general-purpose, testing, backend
-**Tags:** app/**/*.php, tests/**/*.php, laravel, php, static-analysis, phpstan, types
-
-## Rules
-
-- All code must pass **PHPStan Level 9**
-- Type hints on all parameters, return types, and properties — no untyped signatures
-- No `@phpstan-ignore` unless documented with a justification comment
-- Use `phpstan-assert`, `phpstan-param`, and `phpstan-return` PHPDoc tags when generics or complex types are needed
-- Replace `mixed` with specific union types where possible
-- Use `array<string, mixed>` instead of bare `array` in PHPDoc
-- Add `@throws` annotations for methods that throw exceptions
-- Use `assert()` or type narrowing instead of suppressing errors
-
-## Examples
-
-```php
-// ✓ Specific types instead of mixed
-public function process(Order $order): Invoice { ... }
-
-// ✓ PHPDoc with typed arrays
-/**
- * @return array<string, array<int, string|object>>
- */
-public function rules(): array { ... }
-
-// ✓ Union types instead of mixed
-public function format(string|int|null $value): string { ... }
-
-// ✓ Generics for collections
-/**
- * @return Collection<int, Invoice>
- */
-public function getInvoices(): Collection { ... }
-```
-
-```php
-// ✓ @throws annotation
-/**
- * @throws InvoiceAlreadyPaidException
- */
-public function markAsPaid(Invoice $invoice): void
-{
-    if ($invoice->isPaid()) {
-        throw InvoiceAlreadyPaidException::for($invoice);
-    }
-    // ...
-}
-```
-
-```php
-// ✓ Type narrowing with assert() instead of suppression
-public function handle(mixed $model): void
-{
-    assert($model instanceof Invoice);
-    $model->markAsPaid(); // PHPStan now knows it's an Invoice
-}
-```
-
-```php
-// ✓ Justified suppression with comment
-/** @phpstan-ignore-next-line Property accessed via magic method — documented in IDE helper */
-$user->custom_attribute;
-```
-
-## Anti-Patterns
-
-- Using bare `mixed` types when a more specific type is possible
-- Using bare `array` without a PHPDoc generic shape: `array<string, mixed>`
-- Using `@phpstan-ignore` without a comment explaining why it is necessary
-- Omitting `@throws` annotations on methods that throw
-- Leaving parameters, return types, or properties untyped
-- Using `(int)`, `(string)` casts as substitutes for proper type narrowing
-
-## References
-
-- [PHPStan Documentation](https://phpstan.org/user-guide/getting-started)
-- [PHPStan Rule Levels](https://phpstan.org/user-guide/rule-levels)
-- Related: `PHP/SKILL.md` — general PHP conventions including strict typing
diff --git a/skills/PHPUnit/SKILL.md b/skills/PHPUnit/SKILL.md
deleted file mode 100644
index ca064bc..0000000
--- a/skills/PHPUnit/SKILL.md
+++ /dev/null
@@ -1,91 +0,0 @@
-# PHPUnit
-
-**Name:** PHPUnit
-**Description:** PHPUnit test structure, naming, assertions, and factory conventions for Laravel feature and unit tests.
-**Compatible Agents:** general-purpose, testing
-**Tags:** tests/**/*.php, laravel, php, testing, phpunit, unit-test, feature-test
-
-## Rules
-
-- **Feature tests** go in `tests/Feature/` and extend `Tests\TestCase`
-- **Unit tests** go in `tests/Unit/` and extend `PHPUnit\Framework\TestCase`
-- Always use `Illuminate\Foundation\Testing\RefreshDatabase` in feature tests that touch the database
-- Unit tests have no Laravel bootstrap — pure PHP tests only
-- Use `test_` method prefix with snake_case names: `test_user_can_create_resource`
-- All test methods must have `: void` return type
-- One assertion concern per test method — keep tests focused
-- Prefer `assertSame` over `assertEquals` for strict type + value comparison
-- Assert specific values, not just truthiness
-- Every new model **must** have a corresponding factory in `database/factories/`
-- Use factories in tests instead of manual `create()` / `insert()` calls
-- Define meaningful default factory values; use states for variations
-
-## Examples
-
-```php
-// Feature test
-use Illuminate\Foundation\Testing\RefreshDatabase;
-use Tests\TestCase;
-
-class InvoiceControllerTest extends TestCase
-{
-    use RefreshDatabase;
-
-    public function test_user_can_create_invoice(): void
-    {
-        $user  = User::factory()->create();
-        $order = Order::factory()->create(['user_id' => $user->id]);
-
-        $response = $this->actingAs($user)
-            ->postJson('/api/invoices', ['order_id' => $order->id]);
-
-        $response->assertStatus(201);
-        $this->assertDatabaseHas('invoices', ['order_id' => $order->id]);
-    }
-}
-```
-
-```php
-// Unit test — no Laravel bootstrap
-use PHPUnit\Framework\TestCase;
-
-class MoneyHelperTest extends TestCase
-{
-    public function test_formats_amount_in_cents_as_currency_string(): void
-    {
-        $result = MoneyHelper::format(1000, 'CHF');
-
-        $this->assertSame('10.00 CHF', $result);
-    }
-}
-```
-
-```php
-// Factory with states
-// database/factories/UserFactory.php
-public function unverified(): static
-{
-    return $this->state(fn (array $attributes) => [
-        'email_verified_at' => null,
-    ]);
-}
-
-// Usage in tests
-User::factory()->create();
-User::factory()->unverified()->create();
-```
-
-## Anti-Patterns
-
-- Not using `RefreshDatabase` in feature tests that write to the database
-- Using raw `insert()` or `create()` calls in tests instead of factories
-- Mixing multiple assertion concerns in a single test method
-- Using `assertEquals` when `assertSame` is needed for strict comparison
-- Asserting truthiness (`assertTrue($result !== null)`) instead of a specific value
-- Unit tests that bootstrap the full Laravel application (use `Tests\TestCase` only for feature tests)
-
-## References
-
-- [PHPUnit Documentation](https://phpunit.de/)
-- [Laravel Testing](https://laravel.com/docs/testing)
-- Related: `PestTesting/SKILL.md` — the preferred test framework (Pest over raw PHPUnit)
diff --git a/skills/PestTesting/SKILL.md b/skills/PestTesting/SKILL.md
deleted file mode 100644
index 33cc747..0000000
--- a/skills/PestTesting/SKILL.md
+++ /dev/null
@@ -1,117 +0,0 @@
-# PestTesting
-
-**Name:** Pest Testing
-**Description:** Laravel testing conventions using the Pest PHP framework. Covers test structure, AAA pattern, HTTP assertions, datasets, mocking, browser tests, and architecture tests.
-**Compatible Agents:** general-purpose, testing
-**Tags:** tests/**/*.php, laravel, php, testing, pest, feature-test, unit-test, browser-test
-
-## Rules
-
-- Always use **Pest syntax** — never raw PHPUnit classes or `$this->assert*` outside of HTTP responses
-- Always follow **AAA**: Arrange → Act → Assert, with a comment label for each section
-- Always use **named HTTP assertion methods** — never `assertStatus(int)` with a raw integer
-- Never delete a test without explicit approval
-- Test files mirror the class they test: `UserController` → `UserControllerTest.php`
-- Test descriptions read as plain English: `it('creates an invoice for the given order')`
-- Group related tests with `describe()` named after the class or feature under test
-- Use `uses(RefreshDatabase::class)` in every test file that touches the database
-- Use `beforeEach()` inside `describe()` blocks for shared setup — never repeat setup across tests
-- Use datasets instead of duplicating tests for multiple inputs
-- Prefer **Laravel fakes** over mocks for events, mail, notifications, and queues
-- Browser tests: always use `DatabaseTruncation` — never `RefreshDatabase`
-- Browser tests: always call `assertNoJavaScriptErrors()` after every `visit()`
-- Browser tests: always use `dusk=""` HTML attributes as selectors — never CSS classes or IDs
-- Browser tests: never use `pause()` — use `waitFor()`, `waitForText()`, or `waitUntilMissing()`
-- Add architecture tests in `tests/Architecture/` to enforce conventions automatically
-
-## Examples
-
-```php
-// Basic test — AAA pattern
-uses(RefreshDatabase::class);
-
-it('creates an invoice for the given order', function () {
-    // Arrange
-    $order = Order::factory()->create();
-
-    // Act
-    $response = $this->postJson('/api/invoices', ['order_id' => $order->id]);
-
-    // Assert
-    $response->assertCreated();
-    expect(Invoice::count())->toBe(1);
-});
-```
-
-```php
-// Grouped with describe() and beforeEach()
-describe('InvoiceController', function () {
-    beforeEach(function () {
-        $this->user = User::factory()->create();
-        $this->actingAs($this->user);
-    });
-
-    it('lists all invoices', function () {
-        Invoice::factory()->count(3)->create();
-        $this->getJson('/api/invoices')->assertSuccessful();
-    });
-
-    it('creates an invoice', function () {
-        $order = Order::factory()->create();
-        $this->postJson('/api/invoices', ['order_id' => $order->id])
-            ->assertCreated();
-    });
-});
-```
-
-```php
-// Datasets for multiple inputs
-it('rejects invalid email addresses', function (string $email) {
-    $this->postJson('/api/users', ['email' => $email])
-        ->assertUnprocessable();
-})->with([
-    'empty string'  => [''],
-    'missing @'     => ['notanemail'],
-    'missing tld'   => ['user@domain'],
-]);
-```
-
-```php
-// Named HTTP assertion methods
-$response->assertSuccessful();    // ❌ assertStatus(200)
-$response->assertCreated();       // ❌ assertStatus(201)
-$response->assertNoContent();     // ❌ assertStatus(204)
-$response->assertUnprocessable(); // ❌ assertStatus(422)
-$response->assertForbidden();     // ❌ assertStatus(403)
-$response->assertUnauthorized();  // ❌ assertStatus(401)
-$response->assertNotFound();      // ❌ assertStatus(404)
-```
-
-```php
-// Architecture tests
-arch('no debug calls in production code')
-    ->expect('App')
-    ->not->toUse(['dd', 'dump', 'var_dump', 'ray']);
-
-arch('controllers have the correct suffix')
-    ->expect('App\Http\Controllers')
-    ->toHaveSuffix('Controller');
-```
-
-## Anti-Patterns
-
-- Using `assertStatus(200)` instead of named assertion methods
-- Using `RefreshDatabase` in browser (Dusk) tests — use `DatabaseTruncation`
-- Using `pause(3000)` in browser tests — use `waitFor()` or `waitForText()`
-- Repeating the same test for multiple inputs instead of using datasets
-- Using CSS class or ID selectors in Dusk — use `dusk=""` attributes
-- Missing `uses(RefreshDatabase::class)` in feature/unit files that touch the database
-- Deleting a test without explicit approval
-- Missing `assertNoJavaScriptErrors()` after `visit()` in browser tests
-
-## References
-
-- [Pest PHP Documentation](https://pestphp.com/)
-- [Laravel Testing](https://laravel.com/docs/testing)
-- Related: `Dusk/SKILL.md` — full browser (E2E) test conventions
-- Related: `PHPStan/SKILL.md` — static analysis runs alongside tests
diff --git a/skills/Policies/SKILL.md b/skills/Policies/SKILL.md
deleted file mode 100644
index fa19fe7..0000000
--- a/skills/Policies/SKILL.md
+++ /dev/null
@@ -1,87 +0,0 @@
-# Policies
-
-**Name:** Policies
-**Description:** Centralised authorization logic for a given Eloquent model. Policies define per-ability access control and are enforced at the controller level.
-**Compatible Agents:** general-purpose, backend
-**Tags:** app/Policies/**/*.php, laravel, php, backend, policy, authorization, auth
-
-## Rules
-
-- Policy classes live in `app/Policies/`
-- Naming: `PascalCase` with a `Policy` suffix, named after the model they protect: `InvoicePolicy`, `PostPolicy`
-- Policies centralise **all authorization logic** for a given model in one place
-- Create one policy for **each** model
-- Define one method per ability — use standard names: `viewAny`, `view`, `create`, `update`, `delete`, `restore`, `forceDelete`
-- Always enforce authorization at the **controller** level — never inside actions or services
-- Laravel auto-discovers policies that follow the `ModelPolicy` naming convention
-- For custom locations, register manually in `AuthServiceProvider`
-
-## Examples
-
-```php
-namespace App\Policies;
-
-use App\Models\Invoice;
-use App\Models\User;
-
-class InvoicePolicy
-{
-    public function viewAny(User $user): bool
-    {
-        return $user->isAdmin();
-    }
-
-    public function view(User $user, Invoice $invoice): bool
-    {
-        return $user->id === $invoice->user_id || $user->isAdmin();
-    }
-
-    public function create(User $user): bool
-    {
-        return $user->hasVerifiedEmail();
-    }
-
-    public function update(User $user, Invoice $invoice): bool
-    {
-        return $user->id === $invoice->user_id && $invoice->isDraft();
-    }
-
-    public function delete(User $user, Invoice $invoice): bool
-    {
-        return $user->isAdmin();
-    }
-}
-```
-
-```php
-// Usage in controller
-public function update(UpdateInvoiceRequest $request, Invoice $invoice): InvoiceResource
-{
-    $this->authorize('update', $invoice);
-    // ...
-}
-
-// Usage in Form Request
-public function authorize(): bool
-{
-    return $this->user()->can('update', $this->route('invoice'));
-}
-
-// Usage via route middleware
-Route::put('/invoices/{invoice}', [InvoiceController::class, 'update'])
-    ->middleware('can:update,invoice');
-```
-
-## Anti-Patterns
-
-- Putting authorization logic directly in controllers, actions, or models
-- Creating global gates instead of model-specific policies when model-based auth is appropriate
-- Not creating a policy for each model
-- Putting business logic inside a policy method (belongs in Actions or Services)
-- Using `return true` in `authorize()` without documenting the intent
-
-## References
-
-- [Laravel Authorization](https://laravel.com/docs/authorization)
-- Related: `Controllers/SKILL.md` — the layer where policies are enforced
-- Related: `FormRequests/SKILL.md` — can use `can()` in `authorize()` method
diff --git a/skills/Requests/SKILL.md b/skills/Requests/SKILL.md
deleted file mode 100644
index 44eb19a..0000000
--- a/skills/Requests/SKILL.md
+++ /dev/null
@@ -1,78 +0,0 @@
-# Requests
-
-**Name:** Form Request Validation
-**Description:** Dedicated Form Request validation classes for all controller input. Every endpoint that accepts user input must use a `FormRequest` class — validation never happens directly inside a controller.
-**Compatible Agents:** general-purpose, backend
-**Tags:** app/Http/Requests/**/*.php, laravel, php, backend, validation, request, form-request
-
-## Rules
-
-- Every controller action that accepts user input **must** use a dedicated `FormRequest` class
-- Never call `$request->validate()` or `Validator::make()` inside a controller
-- Place Form Requests in `app/Http/Requests/` or a subdirectory matching the domain (e.g. `Auth/`)
-- Naming: `Store{Resource}Request`, `Update{Resource}Request`
-- Define `authorize(): bool` with intentional access control
-- Define `rules(): array` with a PHPDoc `@return` array shape annotation
-- Use **array-based** rule definitions — not pipe-delimited strings
-- Override `messages(): array` for user-friendly or localized error messages
-
-## Examples
-
-```php
-class StoreInvoiceRequest extends FormRequest
-{
-    public function authorize(): bool
-    {
-        return $this->user()->can('create', Invoice::class);
-    }
-
-    /**
-     * @return array<string, array<int, string|object>>
-     */
-    public function rules(): array
-    {
-        return [
-            'order_id' => ['required', 'integer', 'exists:orders,id'],
-            'due_date' => ['required', 'date', 'after:today'],
-            'notes'    => ['nullable', 'string', 'max:1000'],
-        ];
-    }
-
-    public function messages(): array
-    {
-        return [
-            'order_id.exists'  => __('The selected order does not exist.'),
-            'due_date.after'   => __('The due date must be a future date.'),
-        ];
-    }
-}
-```
-
-```php
-// Custom authorization logic options
-public function authorize(): bool
-{
-    // Allow all authenticated users
-    return $this->user() !== null;
-
-    // Scope to admin role
-    return $this->user()->isAdmin();
-
-    // Delegate to a policy
-    return $this->user()->can('update', $this->route('invoice'));
-}
-```
-
-## Anti-Patterns
-
-- Using `$request->validate([...])` inside a controller
-- Using pipe-delimited rules: `'required|string|max:255'` instead of `['required', 'string', 'max:255']`
-- Leaving `authorize()` as a passive `return true` without a comment explaining intent
-- Not using a `messages()` method when default Laravel messages are unclear to end users
-- Skipping the `@return` PHPDoc annotation on `rules()` (breaks PHPStan analysis)
-
-## References
-
-- [Laravel Form Requests](https://laravel.com/docs/validation#form-request-validation)
-- Related: `Controllers/SKILL.md` — controllers that inject and use Form Requests
-- Related: `Policies/SKILL.md` — policies referenced in `authorize()`
diff --git a/skills/Resources/SKILL.md b/skills/Resources/SKILL.md
deleted file mode 100644
index 1939d21..0000000
--- a/skills/Resources/SKILL.md
+++ /dev/null
@@ -1,72 +0,0 @@
-# Resources
-
-**Name:** Resources
-**Description:** API resource classes that transform Eloquent models into JSON-ready arrays. Resources control exactly what is exposed in API responses and handle relationships, conditional attributes, and date formatting.
-**Compatible Agents:** general-purpose, backend
-**Tags:** app/Http/Resources/**/*.php, laravel, php, backend, api, resource, json, response
-
-## Rules
-
-- Resource classes live in `app/Http/Resources/`
-- Single resource: `ModelResource` → `UserResource`, `PostResource`
-- Collection resource: `ModelCollection` → `UserCollection`, `PostCollection`
-- Only expose what the API consumer needs — never blindly expose every model attribute
-- Use `whenLoaded()` for related resources — never eager load inside the resource itself
-- Use `when()`, `whenHas()`, or `whenNotNull()` for conditional attributes — not `if` statements in the array
-- Use `mergeWhen()` for multiple attributes sharing the same condition
-- Use `UserResource::collection()` for simple collections — only create a dedicated collection class when custom meta is needed
-- Do not add pagination meta manually — pass a paginator directly and let Laravel append it
-
-## Examples
-
-```php
-class UserResource extends JsonResource
-{
-    public function toArray(Request $request): array
-    {
-        return [
-            'id'         => $this->id,
-            'name'       => $this->name,
-            'email'      => $this->email,
-            'posts'      => PostResource::collection($this->whenLoaded('posts')),
-            'secret'     => $this->when($request->user()->isAdmin(), $this->secret),
-            'bio'        => $this->whenNotNull($this->bio),
-            'created_at' => DateHelper::format($this->created_at),
-        ];
-    }
-}
-```
-
-```php
-// Controller — eager load before passing to resource
-return UserResource::collection(User::with('posts')->paginate());
-```
-
-```php
-// Dedicated collection — only when custom meta is needed
-class UserCollection extends ResourceCollection
-{
-    public function toArray(Request $request): array
-    {
-        return [
-            'data'  => $this->collection,
-            'links' => ['self' => route('users.index')],
-        ];
-    }
-}
-```
-
-## Anti-Patterns
-
-- Exposing all model attributes without whitelisting
-- Eager loading relationships inside the resource's `toArray()` — load them in the controller
-- Using `if` statements inside the response array instead of `when()`, `whenLoaded()`, `whenNotNull()`
-- Creating a dedicated collection class just for a simple list (use `UserResource::collection()`)
-- Putting business logic or database queries in a resource
-- Manually adding pagination meta that Laravel already provides automatically
-
-## References
-
-- [Laravel API Resources](https://laravel.com/docs/eloquent-resources)
-- Related: `Controllers/SKILL.md` — eager loading is done in the controller
-- Related: `Helpers/SKILL.md` — use `DateHelper::format()` for date formatting
diff --git a/skills/Routing/SKILL.md b/skills/Routing/SKILL.md
deleted file mode 100644
index 82ace01..0000000
--- a/skills/Routing/SKILL.md
+++ /dev/null
@@ -1,65 +0,0 @@
-# Routing
-
-**Name:** Routing
-**Description:** Route file conventions for organising API and web routes. Covers file separation, naming, grouping, middleware, and route model binding.
-**Compatible Agents:** general-purpose, backend
-**Tags:** routes/**/*.php, laravel, php, backend, routing, routes, api, web
-
-## Rules
-
-- API routes in `routes/api.php`; web routes in `routes/web.php`
-- Group related routes with prefixes and middleware
-- Use route model binding where possible
-- Use resourceful route names: `invoices.index`, `invoices.store`
-- Use kebab-case for URL segments: `/invoice-lines`
-- Prefix API routes with `/api` (handled by Laravel automatically via `api.php`)
-- Apply authentication middleware at the group level
-- Apply throttle middleware on API endpoints
-- Use custom middleware for webhook signature verification
-
-## Examples
-
-```php
-// routes/api.php
-Route::middleware('auth:sanctum')->group(function () {
-    Route::apiResource('invoices', InvoiceController::class);
-
-    Route::prefix('invoices')->group(function () {
-        Route::post('{invoice}/pay', PayInvoiceController::class)->name('invoices.pay');
-    });
-});
-
-Route::middleware(['throttle:webhook'])->group(function () {
-    Route::post('webhooks/stripe', ProcessStripeWebhookController::class)
-        ->middleware(VerifyStripeSignature::class)
-        ->name('webhooks.stripe');
-});
-```
-
-```php
-// Route model binding — automatic resolution
-Route::get('invoices/{invoice}', ShowInvoiceController::class);
-
-// Controller resolves the model automatically
-public function __invoke(Invoice $invoice): JsonResponse { ... }
-```
-
-```php
-// Naming with resourceful convention
-Route::apiResource('invoice-lines', InvoiceLineController::class);
-// Generates: invoice-lines.index, invoice-lines.store, invoice-lines.show, etc.
-```
-
-## Anti-Patterns
-
-- Mixing API and web routes in the same file
-- Not using route model binding when an ID is passed to look up a model
-- Applying authentication middleware per route instead of at the group level
-- Using camelCase or snake_case in URL segments instead of kebab-case
-- Not naming routes (anonymous routes are harder to reference and refactor)
-
-## References
-
-- [Laravel Routing](https://laravel.com/docs/routing)
-- Related: `Controllers/SKILL.md` — controllers that handle routes
-- Related: `Middleware/SKILL.md` — middleware applied at the route group level
diff --git a/skills/Saloon/SKILL.md b/skills/Saloon/SKILL.md
deleted file mode 100644
index 22746ed..0000000
--- a/skills/Saloon/SKILL.md
+++ /dev/null
@@ -1,127 +0,0 @@
-# Saloon
-
-**Name:** Saloon API Integration
-**Description:** Saloon-based service layer pattern for all external API integrations. Every new external API integration must use Saloon — no raw HTTP calls.
-**Compatible Agents:** general-purpose, backend
-**Tags:** app/Services/**/*.php, laravel, php, backend, saloon, api, http-client, integration
-
-## Rules
-
-- **All** new external API integrations must use the Saloon pattern
-- No raw HTTP calls (`Http::get(...)`, `file_get_contents`, `curl`)
-- Organize each external integration under `app/Services/{ServiceName}/`
-- The connector extends `Saloon\Http\Connector` and handles authentication and base URL
-- One class per API endpoint, extending `Saloon\Http\Request`
-- Use constructor promotion for request parameters
-- GET requests define `defaultQuery()` for query parameters
-- POST/PUT requests implement `HasBody` + use `HasJsonBody` trait with `defaultBody()`
-- The service class wraps the connector, sends requests, and returns typed DTOs
-- Register the connector as a singleton in a service provider when needed
-- Accept an optional connector in the service constructor for testability
-- Exceptions: **Prism** is acceptable for AI/LLM integrations; inline `Http::get()` is acceptable for simple binary file downloads (not API integrations)
-
-## Examples
-
-**Directory Structure:**
-```
-app/Services/Stripe/
-  StripeConnector.php
-  StripeService.php
-  Requests/
-    Charges/
-      CreateChargeRequest.php
-      ListChargesRequest.php
-  DataObjects/
-    ChargeData.php
-```
-
-```php
-// Connector
-namespace App\Services\Stripe;
-
-use Saloon\Http\Connector;
-
-class StripeConnector extends Connector
-{
-    public function resolveBaseUrl(): string
-    {
-        return 'https://api.stripe.com/v1';
-    }
-
-    protected function defaultHeaders(): array
-    {
-        return [
-            'Authorization' => 'Bearer ' . config('services.stripe.secret'),
-            'Content-Type'  => 'application/json',
-        ];
-    }
-}
-```
-
-```php
-// GET Request
-use Saloon\Enums\Method;
-use Saloon\Http\Request;
-
-class ListChargesRequest extends Request
-{
-    protected Method $method = Method::GET;
-
-    public function __construct(
-        protected int $limit = 10,
-        protected ?string $customer = null,
-    ) {}
-
-    public function resolveEndpoint(): string
-    {
-        return '/charges';
-    }
-
-    protected function defaultQuery(): array
-    {
-        return array_filter([
-            'limit'    => $this->limit,
-            'customer' => $this->customer,
-        ]);
-    }
-}
-```
-
-```php
-// Service class
-use Illuminate\Support\Collection;
-
-class StripeService
-{
-    public function __construct(?StripeConnector $connector = null)
-    {
-        $this->connector = $connector ?? new StripeConnector();
-    }
-
-    /** @return Collection<int, ChargeData> */
-    public function listCharges(string $customerId): Collection
-    {
-        $response = $this->connector->send(
-            new ListChargesRequest(customer: $customerId)
-        );
-
-        return collect($response->json('data'))
-            ->map(fn (array $item) => ChargeData::fromArray($item));
-    }
-}
-```
-
-## Anti-Patterns
-
-- Using `Http::get(...)` or `file_get_contents()` for API integrations
-- Using `curl` directly
-- Creating one massive connector class with all API logic — separate requests into individual classes
-- Not returning typed DTOs from the service class (returning raw arrays)
-- Not caching expensive or frequently accessed API responses
-- Hard-coding API credentials in the connector — always use `config()`
-
-## References
-
-- [Saloon Documentation](https://docs.saloon.dev/)
-- Related: `DTO/SKILL.md` — service classes return typed DTOs
-- Related: `Services/SKILL.md` — general service class conventions
diff --git a/skills/Services/SKILL.md b/skills/Services/SKILL.md
deleted file mode 100644
index 8a80bed..0000000
--- a/skills/Services/SKILL.md
+++ /dev/null
@@ -1,92 +0,0 @@
-# Services
-
-**Name:** Services
-**Description:** Orchestration classes that coordinate multiple Actions, external APIs, or domain operations into a cohesive workflow. Services own transaction boundaries and third-party API integrations.
-**Compatible Agents:** general-purpose, backend
-**Tags:** app/Services/**/*.php, laravel, php, backend, service, orchestration, api-integration
-
-## Rules
-
-- Service classes live in `app/Services/`
-- Name after the domain or integration they serve: `PaymentService`, `SubscriptionService`, `StripeService`
-- Avoid generic suffixes like `Manager` or `Handler`
-- Services may expose multiple related methods, all scoped to their domain
-- Inject dependencies via the constructor
-- Use `DB::transaction()` for multi-step operations that must all succeed or fail together
-- Wrap third-party SDKs behind a service class with a clean internal interface
-- Register external service wrappers as singletons in a service provider
-- Use Actions for individual discrete operations — a Service orchestrates multiple Actions
-
-## Examples
-
-```php
-namespace App\Services;
-
-use App\Actions\CreateInvoice;
-use App\Actions\ChargePaymentMethod;
-use App\Actions\SendPaymentConfirmation;
-use App\Models\Order;
-use App\Models\Payment;
-use Illuminate\Support\Facades\DB;
-
-class PaymentService
-{
-    public function __construct(
-        private readonly CreateInvoice           $createInvoice,
-        private readonly ChargePaymentMethod     $chargePaymentMethod,
-        private readonly SendPaymentConfirmation $sendConfirmation,
-    ) {}
-
-    public function processOrderPayment(Order $order): Payment
-    {
-        return DB::transaction(function () use ($order) {
-            $invoice = $this->createInvoice->execute($order);
-            $payment = $this->chargePaymentMethod->execute($order, $invoice);
-            $this->sendConfirmation->execute($payment);
-
-            return $payment;
-        });
-    }
-
-    public function refund(Payment $payment): void
-    {
-        // refund orchestration logic
-    }
-}
-```
-
-```php
-// Registering an external service wrapper — AppServiceProvider
-$this->app->singleton(StripeService::class, function () {
-    return new StripeService(config('services.stripe.secret'));
-});
-```
-
-```php
-// Controller
-class PaymentController extends Controller
-{
-    public function store(StorePaymentRequest $request, PaymentService $service): JsonResponse
-    {
-        $order = Order::findOrFail($request->validated('order_id'));
-        $payment = $service->processOrderPayment($order);
-
-        return new JsonResponse(new PaymentResource($payment), 201);
-    }
-}
-```
-
-## Anti-Patterns
-
-- Using a Service for a single discrete operation (use an Action instead)
-- Putting HTTP concerns (request, response) inside a Service
-- Naming a service `DataManager` or `UserHandler` instead of a domain-specific name
-- Putting model attribute logic in a Service (belongs in the Model)
-- Putting authorization in a Service (belongs in Policies)
-- Making raw HTTP calls instead of using Saloon for external API integrations
-
-## References
-
-- [Laravel Service Container](https://laravel.com/docs/container)
-- Related: `Actions/SKILL.md` — individual operations that Services orchestrate
-- Related: `Saloon/SKILL.md` — the pattern for external API integrations
diff --git a/skills/Traits/SKILL.md b/skills/Traits/SKILL.md
deleted file mode 100644
index 387efea..0000000
--- a/skills/Traits/SKILL.md
+++ /dev/null
@@ -1,94 +0,0 @@
-# Traits
-
-**Name:** Traits
-**Description:** Reusable behaviour shared across multiple unrelated classes. Traits provide shared Eloquent scopes, accessors, lifecycle hooks, and small stateless helper methods.
-**Compatible Agents:** general-purpose, backend
-**Tags:** app/Traits/**/*.php, laravel, php, backend, trait, reusable, eloquent
-
-## Rules
-
-- Trait classes live in `app/Traits/`
-- Each trait should have a **single, clearly defined responsibility**
-- Use descriptive names that reflect the behaviour they provide, not the classes that use them
-- Suffix with `able` when the trait grants a capability: `Archivable`, `Taggable`, `Sluggable`
-- Use a noun phrase when grouping related accessors/scopes: `HasTimestamps`, `HasAddress`
-- Use a trait only when the **same behaviour is needed across multiple unrelated classes**
-- Use `bootTraitName()` to hook into the model lifecycle without overriding `boot()` in the model
-- Use `initializeTraitName()` to set default property values on instantiation
-- Never put complex business logic in a trait — use an Action or Service
-
-## Examples
-
-```php
-namespace App\Traits;
-
-use Illuminate\Database\Eloquent\Builder;
-
-trait Archivable
-{
-    public function archive(): void
-    {
-        $this->update(['archived_at' => now()]);
-    }
-
-    public function unarchive(): void
-    {
-        $this->update(['archived_at' => null]);
-    }
-
-    public function isArchived(): bool
-    {
-        return ! is_null($this->archived_at);
-    }
-
-    public function scopeArchived(Builder $query): Builder
-    {
-        return $query->whereNotNull('archived_at');
-    }
-
-    public function scopeNotArchived(Builder $query): Builder
-    {
-        return $query->whereNull('archived_at');
-    }
-}
-```
-
-```php
-trait Sluggable
-{
-    public static function bootSluggable(): void
-    {
-        static::creating(function ($model) {
-            $model->slug = str($model->name)->slug();
-        });
-    }
-
-    public function scopeBySlug(Builder $query, string $slug): Builder
-    {
-        return $query->where('slug', $slug);
-    }
-}
-```
-
-```php
-// Usage across unrelated models
-class Post extends Model { use Archivable; }
-class Supplier extends Model { use Archivable; }
-
-$post->archive();
-Post::archived()->get();
-```
-
-## Anti-Patterns
-
-- Creating a trait for logic that only exists in one class (keep it inline)
-- Putting complex business rules in a trait (use an Action or Service)
-- Putting external service dependencies in a trait (use a Service class)
-- Using a trait to avoid inheritance instead of reconsidering the architecture
-- Creating catch-all traits that bundle unrelated behaviour
-
-## References
-
-- [PHP Traits](https://www.php.net/manual/en/language.oop5.traits.php)
-- [Laravel Model Booting](https://laravel.com/docs/eloquent#boot-and-initialize-traits)
-- Related: `Models/SKILL.md` — where traits are used on Eloquent models

From 36ff96dcd2ec676930cf0406f9f6cd9fefd79f76 Mon Sep 17 00:00:00 2001
From: Sebastian Fix <sebastian.fix@codebar.ch>
Date: Fri, 27 Feb 2026 23:06:21 +0100
Subject: [PATCH 3/9] Stop tracking vendor directory

Made-with: Cursor
---
 vendor/autoload.php                     |  22 -
 vendor/composer/ClassLoader.php         | 579 ------------------------
 vendor/composer/LICENSE                 |  21 -
 vendor/composer/autoload_classmap.php   |  10 -
 vendor/composer/autoload_namespaces.php |   9 -
 vendor/composer/autoload_psr4.php       |  10 -
 vendor/composer/autoload_real.php       |  38 --
 vendor/composer/autoload_static.php     |  36 --
 vendor/composer/platform_check.php      |  25 -
 9 files changed, 750 deletions(-)
 delete mode 100644 vendor/autoload.php
 delete mode 100644 vendor/composer/ClassLoader.php
 delete mode 100644 vendor/composer/LICENSE
 delete mode 100644 vendor/composer/autoload_classmap.php
 delete mode 100644 vendor/composer/autoload_namespaces.php
 delete mode 100644 vendor/composer/autoload_psr4.php
 delete mode 100644 vendor/composer/autoload_real.php
 delete mode 100644 vendor/composer/autoload_static.php
 delete mode 100644 vendor/composer/platform_check.php

diff --git a/vendor/autoload.php b/vendor/autoload.php
deleted file mode 100644
index b51bc02..0000000
--- a/vendor/autoload.php
+++ /dev/null
@@ -1,22 +0,0 @@
-<?php
-
-// autoload.php @generated by Composer
-
-if (PHP_VERSION_ID < 50600) {
-    if (!headers_sent()) {
-        header('HTTP/1.1 500 Internal Server Error');
-    }
-    $err = 'Composer 2.3.0 dropped support for autoloading on PHP <5.6 and you are running '.PHP_VERSION.', please upgrade PHP or use Composer 2.2 LTS via "composer self-update --2.2". Aborting.'.PHP_EOL;
-    if (!ini_get('display_errors')) {
-        if (PHP_SAPI === 'cli' || PHP_SAPI === 'phpdbg') {
-            fwrite(STDERR, $err);
-        } elseif (!headers_sent()) {
-            echo $err;
-        }
-    }
-    throw new RuntimeException($err);
-}
-
-require_once __DIR__ . '/composer/autoload_real.php';
-
-return ComposerAutoloaderInitb198656a13e411b31562de7dd0263755::getLoader();
diff --git a/vendor/composer/ClassLoader.php b/vendor/composer/ClassLoader.php
deleted file mode 100644
index 7824d8f..0000000
--- a/vendor/composer/ClassLoader.php
+++ /dev/null
@@ -1,579 +0,0 @@
-<?php
-
-/*
- * This file is part of Composer.
- *
- * (c) Nils Adermann <naderman@naderman.de>
- *     Jordi Boggiano <j.boggiano@seld.be>
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-
-namespace Composer\Autoload;
-
-/**
- * ClassLoader implements a PSR-0, PSR-4 and classmap class loader.
- *
- *     $loader = new \Composer\Autoload\ClassLoader();
- *
- *     // register classes with namespaces
- *     $loader->add('Symfony\Component', __DIR__.'/component');
- *     $loader->add('Symfony',           __DIR__.'/framework');
- *
- *     // activate the autoloader
- *     $loader->register();
- *
- *     // to enable searching the include path (eg. for PEAR packages)
- *     $loader->setUseIncludePath(true);
- *
- * In this example, if you try to use a class in the Symfony\Component
- * namespace or one of its children (Symfony\Component\Console for instance),
- * the autoloader will first look for the class under the component/
- * directory, and it will then fallback to the framework/ directory if not
- * found before giving up.
- *
- * This class is loosely based on the Symfony UniversalClassLoader.
- *
- * @author Fabien Potencier <fabien@symfony.com>
- * @author Jordi Boggiano <j.boggiano@seld.be>
- * @see    https://www.php-fig.org/psr/psr-0/
- * @see    https://www.php-fig.org/psr/psr-4/
- */
-class ClassLoader
-{
-    /** @var \Closure(string):void */
-    private static $includeFile;
-
-    /** @var string|null */
-    private $vendorDir;
-
-    // PSR-4
-    /**
-     * @var array<string, array<string, int>>
-     */
-    private $prefixLengthsPsr4 = array();
-    /**
-     * @var array<string, list<string>>
-     */
-    private $prefixDirsPsr4 = array();
-    /**
-     * @var list<string>
-     */
-    private $fallbackDirsPsr4 = array();
-
-    // PSR-0
-    /**
-     * List of PSR-0 prefixes
-     *
-     * Structured as array('F (first letter)' => array('Foo\Bar (full prefix)' => array('path', 'path2')))
-     *
-     * @var array<string, array<string, list<string>>>
-     */
-    private $prefixesPsr0 = array();
-    /**
-     * @var list<string>
-     */
-    private $fallbackDirsPsr0 = array();
-
-    /** @var bool */
-    private $useIncludePath = false;
-
-    /**
-     * @var array<string, string>
-     */
-    private $classMap = array();
-
-    /** @var bool */
-    private $classMapAuthoritative = false;
-
-    /**
-     * @var array<string, bool>
-     */
-    private $missingClasses = array();
-
-    /** @var string|null */
-    private $apcuPrefix;
-
-    /**
-     * @var array<string, self>
-     */
-    private static $registeredLoaders = array();
-
-    /**
-     * @param string|null $vendorDir
-     */
-    public function __construct($vendorDir = null)
-    {
-        $this->vendorDir = $vendorDir;
-        self::initializeIncludeClosure();
-    }
-
-    /**
-     * @return array<string, list<string>>
-     */
-    public function getPrefixes()
-    {
-        if (!empty($this->prefixesPsr0)) {
-            return call_user_func_array('array_merge', array_values($this->prefixesPsr0));
-        }
-
-        return array();
-    }
-
-    /**
-     * @return array<string, list<string>>
-     */
-    public function getPrefixesPsr4()
-    {
-        return $this->prefixDirsPsr4;
-    }
-
-    /**
-     * @return list<string>
-     */
-    public function getFallbackDirs()
-    {
-        return $this->fallbackDirsPsr0;
-    }
-
-    /**
-     * @return list<string>
-     */
-    public function getFallbackDirsPsr4()
-    {
-        return $this->fallbackDirsPsr4;
-    }
-
-    /**
-     * @return array<string, string> Array of classname => path
-     */
-    public function getClassMap()
-    {
-        return $this->classMap;
-    }
-
-    /**
-     * @param array<string, string> $classMap Class to filename map
-     *
-     * @return void
-     */
-    public function addClassMap(array $classMap)
-    {
-        if ($this->classMap) {
-            $this->classMap = array_merge($this->classMap, $classMap);
-        } else {
-            $this->classMap = $classMap;
-        }
-    }
-
-    /**
-     * Registers a set of PSR-0 directories for a given prefix, either
-     * appending or prepending to the ones previously set for this prefix.
-     *
-     * @param string              $prefix  The prefix
-     * @param list<string>|string $paths   The PSR-0 root directories
-     * @param bool                $prepend Whether to prepend the directories
-     *
-     * @return void
-     */
-    public function add($prefix, $paths, $prepend = false)
-    {
-        $paths = (array) $paths;
-        if (!$prefix) {
-            if ($prepend) {
-                $this->fallbackDirsPsr0 = array_merge(
-                    $paths,
-                    $this->fallbackDirsPsr0
-                );
-            } else {
-                $this->fallbackDirsPsr0 = array_merge(
-                    $this->fallbackDirsPsr0,
-                    $paths
-                );
-            }
-
-            return;
-        }
-
-        $first = $prefix[0];
-        if (!isset($this->prefixesPsr0[$first][$prefix])) {
-            $this->prefixesPsr0[$first][$prefix] = $paths;
-
-            return;
-        }
-        if ($prepend) {
-            $this->prefixesPsr0[$first][$prefix] = array_merge(
-                $paths,
-                $this->prefixesPsr0[$first][$prefix]
-            );
-        } else {
-            $this->prefixesPsr0[$first][$prefix] = array_merge(
-                $this->prefixesPsr0[$first][$prefix],
-                $paths
-            );
-        }
-    }
-
-    /**
-     * Registers a set of PSR-4 directories for a given namespace, either
-     * appending or prepending to the ones previously set for this namespace.
-     *
-     * @param string              $prefix  The prefix/namespace, with trailing '\\'
-     * @param list<string>|string $paths   The PSR-4 base directories
-     * @param bool                $prepend Whether to prepend the directories
-     *
-     * @throws \InvalidArgumentException
-     *
-     * @return void
-     */
-    public function addPsr4($prefix, $paths, $prepend = false)
-    {
-        $paths = (array) $paths;
-        if (!$prefix) {
-            // Register directories for the root namespace.
-            if ($prepend) {
-                $this->fallbackDirsPsr4 = array_merge(
-                    $paths,
-                    $this->fallbackDirsPsr4
-                );
-            } else {
-                $this->fallbackDirsPsr4 = array_merge(
-                    $this->fallbackDirsPsr4,
-                    $paths
-                );
-            }
-        } elseif (!isset($this->prefixDirsPsr4[$prefix])) {
-            // Register directories for a new namespace.
-            $length = strlen($prefix);
-            if ('\\' !== $prefix[$length - 1]) {
-                throw new \InvalidArgumentException("A non-empty PSR-4 prefix must end with a namespace separator.");
-            }
-            $this->prefixLengthsPsr4[$prefix[0]][$prefix] = $length;
-            $this->prefixDirsPsr4[$prefix] = $paths;
-        } elseif ($prepend) {
-            // Prepend directories for an already registered namespace.
-            $this->prefixDirsPsr4[$prefix] = array_merge(
-                $paths,
-                $this->prefixDirsPsr4[$prefix]
-            );
-        } else {
-            // Append directories for an already registered namespace.
-            $this->prefixDirsPsr4[$prefix] = array_merge(
-                $this->prefixDirsPsr4[$prefix],
-                $paths
-            );
-        }
-    }
-
-    /**
-     * Registers a set of PSR-0 directories for a given prefix,
-     * replacing any others previously set for this prefix.
-     *
-     * @param string              $prefix The prefix
-     * @param list<string>|string $paths  The PSR-0 base directories
-     *
-     * @return void
-     */
-    public function set($prefix, $paths)
-    {
-        if (!$prefix) {
-            $this->fallbackDirsPsr0 = (array) $paths;
-        } else {
-            $this->prefixesPsr0[$prefix[0]][$prefix] = (array) $paths;
-        }
-    }
-
-    /**
-     * Registers a set of PSR-4 directories for a given namespace,
-     * replacing any others previously set for this namespace.
-     *
-     * @param string              $prefix The prefix/namespace, with trailing '\\'
-     * @param list<string>|string $paths  The PSR-4 base directories
-     *
-     * @throws \InvalidArgumentException
-     *
-     * @return void
-     */
-    public function setPsr4($prefix, $paths)
-    {
-        if (!$prefix) {
-            $this->fallbackDirsPsr4 = (array) $paths;
-        } else {
-            $length = strlen($prefix);
-            if ('\\' !== $prefix[$length - 1]) {
-                throw new \InvalidArgumentException("A non-empty PSR-4 prefix must end with a namespace separator.");
-            }
-            $this->prefixLengthsPsr4[$prefix[0]][$prefix] = $length;
-            $this->prefixDirsPsr4[$prefix] = (array) $paths;
-        }
-    }
-
-    /**
-     * Turns on searching the include path for class files.
-     *
-     * @param bool $useIncludePath
-     *
-     * @return void
-     */
-    public function setUseIncludePath($useIncludePath)
-    {
-        $this->useIncludePath = $useIncludePath;
-    }
-
-    /**
-     * Can be used to check if the autoloader uses the include path to check
-     * for classes.
-     *
-     * @return bool
-     */
-    public function getUseIncludePath()
-    {
-        return $this->useIncludePath;
-    }
-
-    /**
-     * Turns off searching the prefix and fallback directories for classes
-     * that have not been registered with the class map.
-     *
-     * @param bool $classMapAuthoritative
-     *
-     * @return void
-     */
-    public function setClassMapAuthoritative($classMapAuthoritative)
-    {
-        $this->classMapAuthoritative = $classMapAuthoritative;
-    }
-
-    /**
-     * Should class lookup fail if not found in the current class map?
-     *
-     * @return bool
-     */
-    public function isClassMapAuthoritative()
-    {
-        return $this->classMapAuthoritative;
-    }
-
-    /**
-     * APCu prefix to use to cache found/not-found classes, if the extension is enabled.
-     *
-     * @param string|null $apcuPrefix
-     *
-     * @return void
-     */
-    public function setApcuPrefix($apcuPrefix)
-    {
-        $this->apcuPrefix = function_exists('apcu_fetch') && filter_var(ini_get('apc.enabled'), FILTER_VALIDATE_BOOLEAN) ? $apcuPrefix : null;
-    }
-
-    /**
-     * The APCu prefix in use, or null if APCu caching is not enabled.
-     *
-     * @return string|null
-     */
-    public function getApcuPrefix()
-    {
-        return $this->apcuPrefix;
-    }
-
-    /**
-     * Registers this instance as an autoloader.
-     *
-     * @param bool $prepend Whether to prepend the autoloader or not
-     *
-     * @return void
-     */
-    public function register($prepend = false)
-    {
-        spl_autoload_register(array($this, 'loadClass'), true, $prepend);
-
-        if (null === $this->vendorDir) {
-            return;
-        }
-
-        if ($prepend) {
-            self::$registeredLoaders = array($this->vendorDir => $this) + self::$registeredLoaders;
-        } else {
-            unset(self::$registeredLoaders[$this->vendorDir]);
-            self::$registeredLoaders[$this->vendorDir] = $this;
-        }
-    }
-
-    /**
-     * Unregisters this instance as an autoloader.
-     *
-     * @return void
-     */
-    public function unregister()
-    {
-        spl_autoload_unregister(array($this, 'loadClass'));
-
-        if (null !== $this->vendorDir) {
-            unset(self::$registeredLoaders[$this->vendorDir]);
-        }
-    }
-
-    /**
-     * Loads the given class or interface.
-     *
-     * @param  string    $class The name of the class
-     * @return true|null True if loaded, null otherwise
-     */
-    public function loadClass($class)
-    {
-        if ($file = $this->findFile($class)) {
-            $includeFile = self::$includeFile;
-            $includeFile($file);
-
-            return true;
-        }
-
-        return null;
-    }
-
-    /**
-     * Finds the path to the file where the class is defined.
-     *
-     * @param string $class The name of the class
-     *
-     * @return string|false The path if found, false otherwise
-     */
-    public function findFile($class)
-    {
-        // class map lookup
-        if (isset($this->classMap[$class])) {
-            return $this->classMap[$class];
-        }
-        if ($this->classMapAuthoritative || isset($this->missingClasses[$class])) {
-            return false;
-        }
-        if (null !== $this->apcuPrefix) {
-            $file = apcu_fetch($this->apcuPrefix.$class, $hit);
-            if ($hit) {
-                return $file;
-            }
-        }
-
-        $file = $this->findFileWithExtension($class, '.php');
-
-        // Search for Hack files if we are running on HHVM
-        if (false === $file && defined('HHVM_VERSION')) {
-            $file = $this->findFileWithExtension($class, '.hh');
-        }
-
-        if (null !== $this->apcuPrefix) {
-            apcu_add($this->apcuPrefix.$class, $file);
-        }
-
-        if (false === $file) {
-            // Remember that this class does not exist.
-            $this->missingClasses[$class] = true;
-        }
-
-        return $file;
-    }
-
-    /**
-     * Returns the currently registered loaders keyed by their corresponding vendor directories.
-     *
-     * @return array<string, self>
-     */
-    public static function getRegisteredLoaders()
-    {
-        return self::$registeredLoaders;
-    }
-
-    /**
-     * @param  string       $class
-     * @param  string       $ext
-     * @return string|false
-     */
-    private function findFileWithExtension($class, $ext)
-    {
-        // PSR-4 lookup
-        $logicalPathPsr4 = strtr($class, '\\', DIRECTORY_SEPARATOR) . $ext;
-
-        $first = $class[0];
-        if (isset($this->prefixLengthsPsr4[$first])) {
-            $subPath = $class;
-            while (false !== $lastPos = strrpos($subPath, '\\')) {
-                $subPath = substr($subPath, 0, $lastPos);
-                $search = $subPath . '\\';
-                if (isset($this->prefixDirsPsr4[$search])) {
-                    $pathEnd = DIRECTORY_SEPARATOR . substr($logicalPathPsr4, $lastPos + 1);
-                    foreach ($this->prefixDirsPsr4[$search] as $dir) {
-                        if (file_exists($file = $dir . $pathEnd)) {
-                            return $file;
-                        }
-                    }
-                }
-            }
-        }
-
-        // PSR-4 fallback dirs
-        foreach ($this->fallbackDirsPsr4 as $dir) {
-            if (file_exists($file = $dir . DIRECTORY_SEPARATOR . $logicalPathPsr4)) {
-                return $file;
-            }
-        }
-
-        // PSR-0 lookup
-        if (false !== $pos = strrpos($class, '\\')) {
-            // namespaced class name
-            $logicalPathPsr0 = substr($logicalPathPsr4, 0, $pos + 1)
-                . strtr(substr($logicalPathPsr4, $pos + 1), '_', DIRECTORY_SEPARATOR);
-        } else {
-            // PEAR-like class name
-            $logicalPathPsr0 = strtr($class, '_', DIRECTORY_SEPARATOR) . $ext;
-        }
-
-        if (isset($this->prefixesPsr0[$first])) {
-            foreach ($this->prefixesPsr0[$first] as $prefix => $dirs) {
-                if (0 === strpos($class, $prefix)) {
-                    foreach ($dirs as $dir) {
-                        if (file_exists($file = $dir . DIRECTORY_SEPARATOR . $logicalPathPsr0)) {
-                            return $file;
-                        }
-                    }
-                }
-            }
-        }
-
-        // PSR-0 fallback dirs
-        foreach ($this->fallbackDirsPsr0 as $dir) {
-            if (file_exists($file = $dir . DIRECTORY_SEPARATOR . $logicalPathPsr0)) {
-                return $file;
-            }
-        }
-
-        // PSR-0 include paths.
-        if ($this->useIncludePath && $file = stream_resolve_include_path($logicalPathPsr0)) {
-            return $file;
-        }
-
-        return false;
-    }
-
-    /**
-     * @return void
-     */
-    private static function initializeIncludeClosure()
-    {
-        if (self::$includeFile !== null) {
-            return;
-        }
-
-        /**
-         * Scope isolated include.
-         *
-         * Prevents access to $this/self from included files.
-         *
-         * @param  string $file
-         * @return void
-         */
-        self::$includeFile = \Closure::bind(static function($file) {
-            include $file;
-        }, null, null);
-    }
-}
diff --git a/vendor/composer/LICENSE b/vendor/composer/LICENSE
deleted file mode 100644
index f27399a..0000000
--- a/vendor/composer/LICENSE
+++ /dev/null
@@ -1,21 +0,0 @@
-
-Copyright (c) Nils Adermann, Jordi Boggiano
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is furnished
-to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
diff --git a/vendor/composer/autoload_classmap.php b/vendor/composer/autoload_classmap.php
deleted file mode 100644
index 0fb0a2c..0000000
--- a/vendor/composer/autoload_classmap.php
+++ /dev/null
@@ -1,10 +0,0 @@
-<?php
-
-// autoload_classmap.php @generated by Composer
-
-$vendorDir = dirname(__DIR__);
-$baseDir = dirname($vendorDir);
-
-return array(
-    'Composer\\InstalledVersions' => $vendorDir . '/composer/InstalledVersions.php',
-);
diff --git a/vendor/composer/autoload_namespaces.php b/vendor/composer/autoload_namespaces.php
deleted file mode 100644
index 15a2ff3..0000000
--- a/vendor/composer/autoload_namespaces.php
+++ /dev/null
@@ -1,9 +0,0 @@
-<?php
-
-// autoload_namespaces.php @generated by Composer
-
-$vendorDir = dirname(__DIR__);
-$baseDir = dirname($vendorDir);
-
-return array(
-);
diff --git a/vendor/composer/autoload_psr4.php b/vendor/composer/autoload_psr4.php
deleted file mode 100644
index 70b42f9..0000000
--- a/vendor/composer/autoload_psr4.php
+++ /dev/null
@@ -1,10 +0,0 @@
-<?php
-
-// autoload_psr4.php @generated by Composer
-
-$vendorDir = dirname(__DIR__);
-$baseDir = dirname($vendorDir);
-
-return array(
-    'CodebarAg\\CodingGuidelines\\' => array($baseDir . '/src'),
-);
diff --git a/vendor/composer/autoload_real.php b/vendor/composer/autoload_real.php
deleted file mode 100644
index 9ce41a7..0000000
--- a/vendor/composer/autoload_real.php
+++ /dev/null
@@ -1,38 +0,0 @@
-<?php
-
-// autoload_real.php @generated by Composer
-
-class ComposerAutoloaderInitb198656a13e411b31562de7dd0263755
-{
-    private static $loader;
-
-    public static function loadClassLoader($class)
-    {
-        if ('Composer\Autoload\ClassLoader' === $class) {
-            require __DIR__ . '/ClassLoader.php';
-        }
-    }
-
-    /**
-     * @return \Composer\Autoload\ClassLoader
-     */
-    public static function getLoader()
-    {
-        if (null !== self::$loader) {
-            return self::$loader;
-        }
-
-        require __DIR__ . '/platform_check.php';
-
-        spl_autoload_register(array('ComposerAutoloaderInitb198656a13e411b31562de7dd0263755', 'loadClassLoader'), true, true);
-        self::$loader = $loader = new \Composer\Autoload\ClassLoader(\dirname(__DIR__));
-        spl_autoload_unregister(array('ComposerAutoloaderInitb198656a13e411b31562de7dd0263755', 'loadClassLoader'));
-
-        require __DIR__ . '/autoload_static.php';
-        call_user_func(\Composer\Autoload\ComposerStaticInitb198656a13e411b31562de7dd0263755::getInitializer($loader));
-
-        $loader->register(true);
-
-        return $loader;
-    }
-}
diff --git a/vendor/composer/autoload_static.php b/vendor/composer/autoload_static.php
deleted file mode 100644
index 4a9bb79..0000000
--- a/vendor/composer/autoload_static.php
+++ /dev/null
@@ -1,36 +0,0 @@
-<?php
-
-// autoload_static.php @generated by Composer
-
-namespace Composer\Autoload;
-
-class ComposerStaticInitb198656a13e411b31562de7dd0263755
-{
-    public static $prefixLengthsPsr4 = array (
-        'C' =>
-        array (
-            'CodebarAg\\CodingGuidelines\\' => 27,
-        ),
-    );
-
-    public static $prefixDirsPsr4 = array (
-        'CodebarAg\\CodingGuidelines\\' =>
-        array (
-            0 => __DIR__ . '/../..' . '/src',
-        ),
-    );
-
-    public static $classMap = array (
-        'Composer\\InstalledVersions' => __DIR__ . '/..' . '/composer/InstalledVersions.php',
-    );
-
-    public static function getInitializer(ClassLoader $loader)
-    {
-        return \Closure::bind(function () use ($loader) {
-            $loader->prefixLengthsPsr4 = ComposerStaticInitb198656a13e411b31562de7dd0263755::$prefixLengthsPsr4;
-            $loader->prefixDirsPsr4 = ComposerStaticInitb198656a13e411b31562de7dd0263755::$prefixDirsPsr4;
-            $loader->classMap = ComposerStaticInitb198656a13e411b31562de7dd0263755::$classMap;
-
-        }, null, ClassLoader::class);
-    }
-}
diff --git a/vendor/composer/platform_check.php b/vendor/composer/platform_check.php
deleted file mode 100644
index 14bf88d..0000000
--- a/vendor/composer/platform_check.php
+++ /dev/null
@@ -1,25 +0,0 @@
-<?php
-
-// platform_check.php @generated by Composer
-
-$issues = array();
-
-if (!(PHP_VERSION_ID >= 80200)) {
-    $issues[] = 'Your Composer dependencies require a PHP version ">= 8.2.0". You are running ' . PHP_VERSION . '.';
-}
-
-if ($issues) {
-    if (!headers_sent()) {
-        header('HTTP/1.1 500 Internal Server Error');
-    }
-    if (!ini_get('display_errors')) {
-        if (PHP_SAPI === 'cli' || PHP_SAPI === 'phpdbg') {
-            fwrite(STDERR, 'Composer detected issues in your platform:' . PHP_EOL.PHP_EOL . implode(PHP_EOL, $issues) . PHP_EOL.PHP_EOL);
-        } elseif (!headers_sent()) {
-            echo 'Composer detected issues in your platform:' . PHP_EOL.PHP_EOL . str_replace('You are running '.PHP_VERSION.'.', '', implode(PHP_EOL, $issues)) . PHP_EOL.PHP_EOL;
-        }
-    }
-    throw new \RuntimeException(
-        'Composer detected issues in your platform: ' . implode(' ', $issues)
-    );
-}

From 67fd10c19f9fadc7704f45ec68eb30dfaf079cd5 Mon Sep 17 00:00:00 2001
From: Sebastian Fix <sebastian.fix@codebar.ch>
Date: Fri, 27 Feb 2026 23:12:18 +0100
Subject: [PATCH 4/9] Updated Skills

---
 .gitignore                                   |   3 +-
 LICENSE.md                                   |   2 +-
 README.md                                    |   8 +-
 RULES.md                                     |   5 +
 composer.json                                |   2 +-
 resources/boost/skills/albatros/SKILL.md     | 130 +++++++++++++++++++
 resources/boost/skills/design/SKILL.md       |  87 +++++++++++++
 resources/boost/skills/docuware/SKILL.md     |  95 ++++++++++++++
 resources/boost/skills/tailwind/SKILL.md     |  67 ++++++++++
 resources/boost/skills/translations/SKILL.md |  77 +++++++++++
 10 files changed, 469 insertions(+), 7 deletions(-)
 create mode 100644 resources/boost/skills/albatros/SKILL.md
 create mode 100644 resources/boost/skills/design/SKILL.md
 create mode 100644 resources/boost/skills/docuware/SKILL.md
 create mode 100644 resources/boost/skills/tailwind/SKILL.md
 create mode 100644 resources/boost/skills/translations/SKILL.md

diff --git a/.gitignore b/.gitignore
index b87ea3a..b5bf0d0 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,5 +1,6 @@
 # Dependencies
-/vendor/
+vendor/*
+vendor/
 node_modules/
 
 # Composer
diff --git a/LICENSE.md b/LICENSE.md
index a5267d1..8d0d4a6 100644
--- a/LICENSE.md
+++ b/LICENSE.md
@@ -1,6 +1,6 @@
 # The MIT License (MIT)
 
-Copyright (c) codebar-ag
+Copyright (c) codebar Solutions AG, Sebastian Bürgin-Fix
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/README.md b/README.md
index 0a05777..96a4fc0 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,6 @@
 # Coding Guidelines
 
-Shared Laravel AI coding guidelines and skills for codebar-ag projects. A Boost-first Composer package that ships 30+ skills for consistent conventions across PHP, Laravel, testing, frontend, and services.
+Shared Laravel AI coding guidelines and skills for codebar-ag projects. A Boost-first Composer package that ships 36 skills for consistent conventions across PHP, Laravel, testing, frontend, and services.
 
 **Rule index:** See [RULES.md](RULES.md) for the full rule structure and file reference.
 
@@ -12,11 +12,11 @@ Shared Laravel AI coding guidelines and skills for codebar-ag projects. A Boost-
 |----------|--------|-------------|
 | **Laravel** | General, HelperFunctions, Models, Controllers, Migrations, Routing, FormRequests | Framework conventions, config/logging, Eloquent, routes, validation |
 | **Backend** | Actions, Commands, DTO, Enums, Events, Exceptions, Helpers, Interfaces, Jobs, Middleware, Observers, Policies, Requests, Resources, Services, Traits | PHP architecture, single-purpose classes, API resources, queue jobs |
-| **Frontend** | Blade, Livewire | Templates, components, reactive UI |
+| **Frontend** | Blade, Design, Livewire, Tailwind, Translations | Templates, design system, components, Tailwind CSS, i18n |
 | **Testing** | PHPUnit, PestTesting, PHPStan, Dusk | Unit/feature tests, static analysis, browser tests |
-| **Services** | Saloon | External API integrations (Saloon pattern) |
+| **Services** | Saloon, DocuWare, Albatros | External API integrations (Saloon, DocuWare, Albatros) |
 
-**Total: 30 skills.** Each skill includes Rules, Examples, Anti-Patterns, and References.
+**Total: 36 skills.** Each skill includes Rules, Examples, Anti-Patterns, and References.
 
 ---
 
diff --git a/RULES.md b/RULES.md
index 5d790a5..2d19e8c 100644
--- a/RULES.md
+++ b/RULES.md
@@ -12,9 +12,14 @@ resources/boost/skills/
   models/            # Eloquent models
   actions/           # Action pattern
   blade/             # Blade templates
+  design/            # Component-first design system
   livewire/          # Livewire components
+  tailwind/          # Tailwind CSS v4 styling
+  translations/      # Translation and localization
   phpunit/           # PHPUnit tests
   saloon/            # Saloon API integrations
+  docuware/          # DocuWare document management
+  albatros/          # Albatros accounting API
   ...                # See README for full list
 ```
 
diff --git a/composer.json b/composer.json
index 08904c1..47d9da7 100644
--- a/composer.json
+++ b/composer.json
@@ -11,7 +11,7 @@
     ],
     "license": "MIT",
     "require": {
-        "php": "^8.2"
+        "php": "^8.4"
     },
     "suggest": {
         "laravel/boost": "Required for skill discovery. Install in your Laravel project."
diff --git a/resources/boost/skills/albatros/SKILL.md b/resources/boost/skills/albatros/SKILL.md
new file mode 100644
index 0000000..24c856e
--- /dev/null
+++ b/resources/boost/skills/albatros/SKILL.md
@@ -0,0 +1,130 @@
+---
+name: albatros
+description: Albatros accounting API integration via Saloon. Use when working with app/Services/Albatros/, AlbatrosConnector, or Albatros DTOs.
+---
+
+**Name:** Albatros API Integration
+**Description:** Albatros accounting API integration via Saloon. Use when working with app/Services/Albatros/, AlbatrosConnector, or Albatros DTOs.
+**Compatible Agents:** general-purpose, backend
+**Tags:** app/Services/Albatros/**/*.php, albatros, accounting, saloon, api-integration
+
+## Rules
+
+- `AlbatrosConnector` extends `Saloon\Http\Connector`
+- Token-based authentication with Mandant header
+- Base URL from `config('albatros.base_url')`
+- `AlbatrosService` wraps all API calls and returns typed DTOs or `Collection` of DTOs
+- Use `Cache` for reference data (addresses, accounts, VAT codes, etc.)
+- Paginated endpoints use `fetchAllPages()` helper with `lastIndex` parameter
+- Organize requests by resource under `Requests/{Resource}/`: `Requests/Adresse/`, `Requests/PkKreditor/`, `Requests/Mandant/`, etc.
+- List requests accept `$lastIndex` and `$pageSize` for pagination
+- Create requests implement `HasBody` + `HasJsonBody`
+- Readonly DTOs in `DataObjects/` with `fromArray()` factory
+- **German domain terms are acceptable** in DTO property names and request classes (they match the Albatros API)
+- Handle API field name casing variations in `fromArray()`
+- Cache reference data to minimize API calls
+- Use `clearCache()` method when data needs refreshing
+- All monetary values as `decimal:2`
+
+## Examples
+
+```php
+// AlbatrosConnector
+class AlbatrosConnector extends Connector
+{
+    public function resolveBaseUrl(): string
+    {
+        return config('albatros.base_url');
+    }
+
+    protected function defaultHeaders(): array
+    {
+        return [
+            'Mandant' => config('albatros.mandant'),
+            'Authorization' => 'Bearer ' . config('albatros.token'),
+        ];
+    }
+}
+```
+
+```php
+// List request with pagination
+class ListAdressenRequest extends Request
+{
+    protected Method $method = Method::GET;
+
+    public function __construct(
+        protected string $lastIndex = '',
+        protected int $pageSize = 100,
+    ) {}
+
+    public function resolveEndpoint(): string
+    {
+        return '/Adresse';
+    }
+
+    protected function defaultQuery(): array
+    {
+        return array_filter([
+            'lastIndex' => $this->lastIndex,
+            'pageSize' => $this->pageSize,
+        ]);
+    }
+}
+```
+
+```php
+// DTO with German domain terms — acceptable for Albatros API
+readonly class AdresseData
+{
+    public function __construct(
+        public string $ID,
+        public ?string $Name,
+        public ?string $Strasse,
+        public ?string $PLZ,
+        public ?string $Ort,
+    ) {}
+
+    public static function fromArray(array $data): static
+    {
+        return new static(
+            ID: (string) ($data['ID'] ?? $data['id'] ?? ''),
+            Name: $data['Name'] ?? $data['name'] ?? null,
+            Strasse: $data['Strasse'] ?? $data['strasse'] ?? null,
+            PLZ: $data['PLZ'] ?? $data['plz'] ?? null,
+            Ort: $data['Ort'] ?? $data['ort'] ?? null,
+        );
+    }
+}
+```
+
+```php
+// Service with caching
+public function getAdressen(): Collection
+{
+    return Cache::remember('albatros.adressen', 3600, fn () =>
+        $this->fetchAllPages(fn ($lastIndex) => new ListAdressenRequest(lastIndex: $lastIndex))
+    );
+}
+
+public function clearCache(): void
+{
+    Cache::forget('albatros.adressen');
+}
+```
+
+## Anti-Patterns
+
+- Making uncached API calls for reference data that rarely changes
+- Not using `fetchAllPages()` for paginated endpoints — manual pagination loops
+- Translating German API field names to English in DTOs (keep matching API)
+- Not handling API field name casing variations in `fromArray()`
+- Storing monetary values as float or string instead of `decimal:2`
+- Forgetting to call `clearCache()` when reference data is updated
+
+## References
+
+- [Saloon Documentation](https://docs.saloon.dev/)
+- Related: `Saloon/SKILL.md` — Saloon connector and request patterns
+- Related: `DTO/SKILL.md` — DTO conventions with fromArray factory
+- Related: `Services/SKILL.md` — service class wrapping API calls
diff --git a/resources/boost/skills/design/SKILL.md b/resources/boost/skills/design/SKILL.md
new file mode 100644
index 0000000..ccb35a1
--- /dev/null
+++ b/resources/boost/skills/design/SKILL.md
@@ -0,0 +1,87 @@
+---
+name: design
+description: Component-first design system for Blade views. Use when creating UI components, designing responsive layouts, or implementing accessible interfaces.
+---
+
+**Name:** Design System
+**Description:** Component-first design system for Blade views. Use when creating UI components, designing responsive layouts, or implementing accessible interfaces.
+**Compatible Agents:** general-purpose, frontend
+**Tags:** resources/views/**/*.blade.php, laravel, blade, design-system, components, responsive, accessibility
+
+## Rules
+
+- Every UI element MUST use a Blade component — no raw `<button>`, `<input>`, `<table>`, `<textarea>`, or styled `<div>` badges in page views
+- Check the styleguide (`/styleguide`) for existing components before creating new ones
+- Every new component MUST be added to `config/styleguide.php` and have a styleguide section
+- Use anonymous components for presentation-only elements
+- Accept `$attributes` and merge with defaults via `$attributes->merge(['class' => '...'])`
+- Use named slots (`$header`, `$trigger`, `$content`) for composable layouts
+- Props with `@props([...])` — always provide sensible defaults
+- Mobile-first: base styles for 320px+, `sm:` for 640px+, `lg:` for 1024px+
+- Tables must fall back to stacked cards on mobile
+- All interactive elements: `min-h-[44px]` touch targets
+- Use `<x-heading>` for typography — no raw `<h1>`-`<h6>` in page views
+- Hover, focus, and disabled states on every interactive element
+- `focus-visible` rings on all interactive elements
+- ARIA labels for icon-only buttons
+- Keyboard navigation support
+- Screen-reader-only text (`sr-only`) where visual context is implicit
+
+## Examples
+
+```blade
+{{-- Anonymous component with $attributes and @props --}}
+@props([
+    'variant' => 'primary',
+    'size' => 'md',
+])
+
+<button
+    {{ $attributes->merge(['class' => 'min-h-[44px] rounded-lg px-4 transition ease-in-out duration-150 focus-visible:ring-2 focus-visible:ring-accent-500']) }}
+>
+    {{ $slot }}
+</button>
+```
+
+```blade
+{{-- Composable layout with named slots --}}
+<x-card>
+    <x-slot:header>
+        <x-heading level="2">{{ $title }}</x-heading>
+    </x-slot:header>
+    <x-slot:content>
+        {{ $slot }}
+    </x-slot:content>
+</x-card>
+```
+
+```blade
+{{-- Visual conventions: shadows, radius, color system --}}
+<div class="rounded-lg shadow-sm p-6 transition ease-in-out duration-150">
+    <span class="rounded-full bg-green-100 text-green-800 px-3 py-1">Active</span>
+</div>
+```
+
+```blade
+{{-- Icon-only button with ARIA label for screen readers --}}
+<button type="button" aria-label="Close dialog" class="min-h-[44px] min-w-[44px] rounded-lg focus-visible:ring-2">
+    <x-icon name="x" />
+</button>
+```
+
+## Anti-Patterns
+
+- Using raw HTML elements instead of Blade components in page views
+- Creating new components without checking the styleguide first
+- Forgetting to add new components to `config/styleguide.php`
+- Interactive elements without `min-h-[44px]` touch targets
+- Icon-only buttons without `aria-label` or `sr-only` alternative text
+- Tables that do not fall back to stacked cards on mobile
+- Missing `focus-visible` rings on interactive elements
+- Using raw `<h1>`-`<h6>` instead of `<x-heading>`
+
+## References
+
+- [Laravel Blade Components](https://laravel.com/docs/blade#components)
+- Related: `Blade/SKILL.md` — Blade template conventions
+- Related: `Tailwind/SKILL.md` — Tailwind CSS styling conventions
diff --git a/resources/boost/skills/docuware/SKILL.md b/resources/boost/skills/docuware/SKILL.md
new file mode 100644
index 0000000..e5d5e74
--- /dev/null
+++ b/resources/boost/skills/docuware/SKILL.md
@@ -0,0 +1,95 @@
+---
+name: docuware
+description: DocuWare document management integration patterns. Use when working with DocuWare connector, webhooks, document imports, or app/Services/DocuWare/.
+---
+
+**Name:** DocuWare Integration
+**Description:** DocuWare document management integration patterns. Use when working with DocuWare connector, webhooks, document imports, or app/Services/DocuWare/.
+**Compatible Agents:** general-purpose, backend
+**Tags:** app/Services/DocuWare/**/*.php, docuware, document-management, webhook, import
+
+## Rules
+
+- Uses `codebar-ag/laravel-docuware` package (not raw Saloon)
+- Connector: `CodebarAg\DocuWare\Connectors\DocuWareConnector` with `ConfigWithCredentials`
+- Credentials via `config('laravel-docuware.credentials.*')` — never `env()` directly
+- DocuWareService wraps the connector in `app/Services/DocuWare/DocuWareService.php`
+- Key methods: `fetchDocument()`, `downloadAndStore()`, `mapToInvoiceData()`, `processImport()`
+- Accept optional connector in constructor for testability
+- Field mapping defined in `config/docuware-fields.php`
+- Always check for DocuWare credentials before making API calls
+- Handle download failures gracefully (log warning, continue without file)
+- Use `DB::transaction()` for model creation + import status update
+- Duplicate detection: skip if same `source_document_id` already exists
+- Activity logging at each stage (webhook received, processing started/completed/failed)
+
+## Webhook Flow
+
+1. `POST /api/docuware/webhook` receives payload
+2. HMAC signature verification via `VerifyDocuWareSignature` middleware
+3. Create `DocumentImport` record with status `pending`
+4. Dispatch `ProcessDocuWareImport` queued job
+5. Job: fetch metadata, download document, create model, update import status
+
+## Import Lifecycle
+
+- `DocumentImport` model tracks: `pending` → `processing` → `completed` / `failed`
+- Use `DB::transaction()` when creating model and updating import status together
+
+## Examples
+
+```php
+// DocuWareService — optional connector for testability
+class DocuWareService
+{
+    public function __construct(?DocuWareConnector $connector = null)
+    {
+        $this->connector = $connector ?? new DocuWareConnector();
+    }
+
+    public function processImport(DocumentImport $import): void
+    {
+        if (! config('laravel-docuware.credentials.api_url')) {
+            throw new DocuWareNotConfiguredException();
+        }
+
+        $import->update(['status' => 'processing']);
+
+        try {
+            DB::transaction(function () use ($import) {
+                $document = $this->fetchDocument($import->source_document_id);
+                $data = $this->mapToInvoiceData($document);
+                $model = Invoice::create($data);
+                $import->update(['status' => 'completed', 'importable_id' => $model->id]);
+                activity()->performedOn($import)->log('Document import completed.');
+            });
+        } catch (Throwable $e) {
+            Log::warning('DocuWare download failed.', ['import_id' => $import->id]);
+            $import->update(['status' => 'failed']);
+            throw $e;
+        }
+    }
+}
+```
+
+```php
+// Duplicate detection before processing
+if (DocumentImport::where('source_document_id', $payload['id'])->exists()) {
+    return response()->json(['status' => 'skipped'], 200);
+}
+```
+
+## Anti-Patterns
+
+- Using `env()` directly for DocuWare credentials — use `config()`
+- Making API calls without checking credentials first
+- Not using `DB::transaction()` when creating models and updating import status
+- Swallowing download failures — log and handle gracefully
+- Missing activity logging at import lifecycle stages
+- Processing imports without duplicate detection on `source_document_id`
+
+## References
+
+- [codebar-ag/laravel-docuware](https://github.com/codebar-ag/laravel-docuware)
+- Related: `Services/SKILL.md` — service class conventions
+- Related: `Jobs/SKILL.md` — queued job for ProcessDocuWareImport
diff --git a/resources/boost/skills/tailwind/SKILL.md b/resources/boost/skills/tailwind/SKILL.md
new file mode 100644
index 0000000..b127254
--- /dev/null
+++ b/resources/boost/skills/tailwind/SKILL.md
@@ -0,0 +1,67 @@
+---
+name: tailwind
+description: Tailwind CSS v4 styling conventions. Use when working with CSS, Tailwind utilities, or customizing the theme in Laravel projects.
+---
+
+**Name:** Tailwind CSS
+**Description:** Tailwind CSS v4 styling conventions. Use when working with CSS, Tailwind utilities, or customizing the theme in Laravel projects.
+**Compatible Agents:** general-purpose, frontend
+**Tags:** resources/css/**/*.css, laravel, tailwind, css, vite, styling
+
+## Rules
+
+- **Tailwind CSS v4** utility classes only — no custom CSS classes
+- Theme customization via `@theme` directive in `resources/css/app.css`
+- Do not create custom `.css` class selectors — compose utilities in markup instead
+- Vite is the build tool with `@tailwindcss/vite` plugin
+- Entry point: `resources/css/app.css`
+- Use `@source` directive to include Blade and Livewire paths for class scanning
+- Use responsive prefixes (`sm:`, `md:`, `lg:`) for responsive design
+- Use dark mode variant (`dark:`) when dark mode is supported
+- Extract Blade components for complex repeated utility patterns — keep utility strings readable
+
+## Examples
+
+```css
+/* resources/css/app.css — theme customization via @theme */
+@import "tailwindcss";
+
+@theme {
+    --color-primary-500: #3b82f6;
+    --color-accent-500: #8b5cf6;
+    --font-sans: "Inter", system-ui, sans-serif;
+}
+
+@source "../views/**/*.blade.php";
+@source "../../app/Livewire/**/*.php";
+```
+
+```blade
+{{-- Compose utilities in markup — no custom CSS classes --}}
+<div class="rounded-lg shadow-sm p-4 sm:p-6 lg:p-8 transition ease-in-out duration-150">
+    <h2 class="text-lg font-semibold text-gray-900 dark:text-gray-100">Title</h2>
+</div>
+```
+
+```blade
+{{-- Extract complex patterns to components — avoid long utility strings in views --}}
+<x-card class="p-4">
+    {{ $slot }}
+</x-card>
+```
+
+## Anti-Patterns
+
+- Creating custom `.my-class { ... }` selectors in CSS files
+- Using inline styles or `<style>` tags instead of Tailwind utilities
+- Long, repeated utility strings in Blade views — extract to components
+- Missing `@source` directives for Blade/Livewire paths (classes won't be scanned)
+- Not using responsive prefixes when layout changes by viewport
+- Hardcoding colors instead of using theme variables via `@theme`
+
+## References
+
+- [Tailwind CSS v4 Documentation](https://tailwindcss.com/docs)
+- [Vite Plugin](https://tailwindcss.com/docs/installation/framework-guides/vite)
+- Related: `Design/SKILL.md` — design system and component conventions
+- Related: `Blade/SKILL.md` — Blade template structure
diff --git a/resources/boost/skills/translations/SKILL.md b/resources/boost/skills/translations/SKILL.md
new file mode 100644
index 0000000..498118d
--- /dev/null
+++ b/resources/boost/skills/translations/SKILL.md
@@ -0,0 +1,77 @@
+---
+name: translations
+description: Translation and localization conventions for Laravel. Use when adding user-facing strings, creating translation files, or working with lang/ directory.
+---
+
+**Name:** Translations
+**Description:** Translation and localization conventions for Laravel. Use when adding user-facing strings, creating translation files, or working with lang/ directory.
+**Compatible Agents:** general-purpose, frontend, backend
+**Tags:** lang/**/*.php, lang/**/*.json, resources/views/**/*.blade.php, app/**/*.php, translations, localization, i18n
+
+## Rules
+
+- Never hardcode user-facing text — always use `__()` or `@lang()`
+- This project supports **English (`en`)** and **German (`de`)** — add keys to both locales when creating new translations
+- Use **namespaced keys** (`lang/{locale}/{group}.php`) for domain-specific terms (e.g. `sprints.`, `organizations.`)
+- Use **JSON keys** (`lang/{locale}.json`) for generic UI labels (Save, Back, Cancel, etc.)
+- Use `:placeholder` for dynamic values in translation strings
+- Case matters — `Organizations.foo` is not the same as `organizations.foo`
+- Run translation tests after changes: `php artisan test --filter=MissingTranslation`
+- Automated detection: `MissingTranslationTest.php` scans for `__()`, `trans()`, and `@lang()` and verifies every key exists in every locale
+
+## Examples
+
+```php
+// lang/en/sprints.php — namespaced keys for domain-specific strings
+return [
+    'step_locked' => 'This step is locked.',
+    'create_success' => 'Sprint :name was created successfully.',
+];
+
+// Usage
+__('sprints.step_locked');
+__('sprints.create_success', ['name' => $sprint->name]);
+```
+
+```json
+// lang/de.json — generic UI labels
+{
+    "Save": "Speichern",
+    "Back": "Zurück",
+    "Cancel": "Abbrechen"
+}
+
+// Usage
+__('Save');
+__('Back');
+```
+
+```blade
+{{-- In Blade templates — always use translation helpers --}}
+<button type="submit">{{ __('Save') }}</button>
+<p>{{ __('sprints.step_locked') }}</p>
+<p>{{ __('Configure the :provider API key.', ['provider' => $provider]) }}</p>
+```
+
+```php
+// In PHP — use trans() or __()
+throw new ValidationException(__('validation.required', ['attribute' => 'email']));
+Log::info(__('sprints.import_started', ['count' => $count]));
+```
+
+## Anti-Patterns
+
+- Hardcoding user-facing strings like `'Save'` or `'This step is locked.'` directly in views or PHP
+- Adding a translation key to only one locale (en or de)
+- Using namespaced keys for generic labels — use JSON for Save, Back, Cancel
+- Using JSON keys for domain-specific terminology — use PHP files with namespaces
+- Forgetting `:placeholder` syntax for dynamic values: `__('Welcome, :name')` with `['name' => $user->name]`
+- Assuming case-insensitive key lookup — keys are case-sensitive
+- Not running `php artisan test --filter=MissingTranslation` after adding or changing translations
+
+## References
+
+- [Laravel Localization](https://laravel.com/docs/localization)
+- [Translation Helper](https://laravel.com/docs/helpers#method-__)
+- Related: `Blade/SKILL.md` — use `__()` in Blade for all user-facing text
+- Related: `PHPUnit/SKILL.md` — MissingTranslationTest validates translation coverage

From dec08e7eaf975514381faa2e517266381b33e9a7 Mon Sep 17 00:00:00 2001
From: Sebastian Fix <sebastian.fix@codebar.ch>
Date: Fri, 27 Feb 2026 23:23:32 +0100
Subject: [PATCH 5/9] Implemented Github Actions

---
 .github/prompts/actions.prompt.yml         |  16 +++
 .github/prompts/albatros.prompt.yml        |  16 +++
 .github/prompts/blade.prompt.yml           |  16 +++
 .github/prompts/commands.prompt.yml        |  16 +++
 .github/prompts/controllers.prompt.yml     |  16 +++
 .github/prompts/design.prompt.yml          |  16 +++
 .github/prompts/docuware.prompt.yml        |  16 +++
 .github/prompts/dto.prompt.yml             |  16 +++
 .github/prompts/dusk.prompt.yml            |  16 +++
 .github/prompts/enums.prompt.yml           |  16 +++
 .github/prompts/events.prompt.yml          |  16 +++
 .github/prompts/exceptions.prompt.yml      |  16 +++
 .github/prompts/formrequests.prompt.yml    |  17 +++
 .github/prompts/general.prompt.yml         |  16 +++
 .github/prompts/helperfunctions.prompt.yml |  16 +++
 .github/prompts/helpers.prompt.yml         |  16 +++
 .github/prompts/interfaces.prompt.yml      |  16 +++
 .github/prompts/jobs.prompt.yml            |  16 +++
 .github/prompts/livewire.prompt.yml        |  16 +++
 .github/prompts/middleware.prompt.yml      |  16 +++
 .github/prompts/migrations.prompt.yml      |  16 +++
 .github/prompts/models.prompt.yml          |  16 +++
 .github/prompts/observers.prompt.yml       |  16 +++
 .github/prompts/pesttesting.prompt.yml     |  16 +++
 .github/prompts/php.prompt.yml             |  16 +++
 .github/prompts/phpstan.prompt.yml         |  16 +++
 .github/prompts/phpunit.prompt.yml         |  16 +++
 .github/prompts/policies.prompt.yml        |  16 +++
 .github/prompts/requests.prompt.yml        |  16 +++
 .github/prompts/resources.prompt.yml       |  16 +++
 .github/prompts/routing.prompt.yml         |  16 +++
 .github/prompts/saloon.prompt.yml          |  16 +++
 .github/prompts/services.prompt.yml        |  16 +++
 .github/prompts/tailwind.prompt.yml        |  16 +++
 .github/prompts/traits.prompt.yml          |  16 +++
 .github/prompts/translations.prompt.yml    |  16 +++
 .github/scripts/validate-skill-response.sh | 133 +++++++++++++++++++++
 .github/workflows/ci.yml                   |  30 +++++
 .github/workflows/skill-integration.yml    |  80 +++++++++++++
 .gitignore                                 |   1 +
 README.md                                  |  11 ++
 composer.json                              |   3 +
 scripts/validate-skills.php                |  73 +++++++++++
 43 files changed, 908 insertions(+)
 create mode 100644 .github/prompts/actions.prompt.yml
 create mode 100644 .github/prompts/albatros.prompt.yml
 create mode 100644 .github/prompts/blade.prompt.yml
 create mode 100644 .github/prompts/commands.prompt.yml
 create mode 100644 .github/prompts/controllers.prompt.yml
 create mode 100644 .github/prompts/design.prompt.yml
 create mode 100644 .github/prompts/docuware.prompt.yml
 create mode 100644 .github/prompts/dto.prompt.yml
 create mode 100644 .github/prompts/dusk.prompt.yml
 create mode 100644 .github/prompts/enums.prompt.yml
 create mode 100644 .github/prompts/events.prompt.yml
 create mode 100644 .github/prompts/exceptions.prompt.yml
 create mode 100644 .github/prompts/formrequests.prompt.yml
 create mode 100644 .github/prompts/general.prompt.yml
 create mode 100644 .github/prompts/helperfunctions.prompt.yml
 create mode 100644 .github/prompts/helpers.prompt.yml
 create mode 100644 .github/prompts/interfaces.prompt.yml
 create mode 100644 .github/prompts/jobs.prompt.yml
 create mode 100644 .github/prompts/livewire.prompt.yml
 create mode 100644 .github/prompts/middleware.prompt.yml
 create mode 100644 .github/prompts/migrations.prompt.yml
 create mode 100644 .github/prompts/models.prompt.yml
 create mode 100644 .github/prompts/observers.prompt.yml
 create mode 100644 .github/prompts/pesttesting.prompt.yml
 create mode 100644 .github/prompts/php.prompt.yml
 create mode 100644 .github/prompts/phpstan.prompt.yml
 create mode 100644 .github/prompts/phpunit.prompt.yml
 create mode 100644 .github/prompts/policies.prompt.yml
 create mode 100644 .github/prompts/requests.prompt.yml
 create mode 100644 .github/prompts/resources.prompt.yml
 create mode 100644 .github/prompts/routing.prompt.yml
 create mode 100644 .github/prompts/saloon.prompt.yml
 create mode 100644 .github/prompts/services.prompt.yml
 create mode 100644 .github/prompts/tailwind.prompt.yml
 create mode 100644 .github/prompts/traits.prompt.yml
 create mode 100644 .github/prompts/translations.prompt.yml
 create mode 100755 .github/scripts/validate-skill-response.sh
 create mode 100644 .github/workflows/ci.yml
 create mode 100644 .github/workflows/skill-integration.yml
 create mode 100644 scripts/validate-skills.php

diff --git a/.github/prompts/actions.prompt.yml b/.github/prompts/actions.prompt.yml
new file mode 100644
index 0000000..eb54be5
--- /dev/null
+++ b/.github/prompts/actions.prompt.yml
@@ -0,0 +1,16 @@
+messages:
+  - role: system
+    content: |
+      You are a Laravel developer. Apply these guidelines exactly:
+
+      {{skill_content}}
+
+      Respond with only the requested code. No explanations unless asked.
+  - role: user
+    content: |
+      Write a CreateInvoice Action class. It receives an Order, creates an Invoice, and returns it.
+      Use execute() method and constructor dependency injection. No HTTP concerns.
+model: openai/gpt-4o
+modelParameters:
+  temperature: 0.2
+  maxCompletionTokens: 512
diff --git a/.github/prompts/albatros.prompt.yml b/.github/prompts/albatros.prompt.yml
new file mode 100644
index 0000000..6ca064f
--- /dev/null
+++ b/.github/prompts/albatros.prompt.yml
@@ -0,0 +1,16 @@
+messages:
+  - role: system
+    content: |
+      You are a Laravel developer. Apply these guidelines exactly:
+
+      {{skill_content}}
+
+      Respond with only the requested code. No explanations unless asked.
+  - role: user
+    content: |
+      Write an AlbatrosConnector extending Saloon Connector. Use config('albatros.base_url'), Mandant header, Bearer token.
+      Use Cache for reference data. German domain terms in DTOs are acceptable.
+model: openai/gpt-4o
+modelParameters:
+  temperature: 0.2
+  maxCompletionTokens: 512
diff --git a/.github/prompts/blade.prompt.yml b/.github/prompts/blade.prompt.yml
new file mode 100644
index 0000000..44f842d
--- /dev/null
+++ b/.github/prompts/blade.prompt.yml
@@ -0,0 +1,16 @@
+messages:
+  - role: system
+    content: |
+      You are a Laravel developer. Apply these guidelines exactly:
+
+      {{skill_content}}
+
+      Respond with only the requested code. No explanations unless asked.
+  - role: user
+    content: |
+      Write a Blade component that displays a user's name and email. Use {{ }} for escaped output.
+      No inline style or script tags. Use x-component syntax.
+model: openai/gpt-4o
+modelParameters:
+  temperature: 0.2
+  maxCompletionTokens: 384
diff --git a/.github/prompts/commands.prompt.yml b/.github/prompts/commands.prompt.yml
new file mode 100644
index 0000000..45e3f93
--- /dev/null
+++ b/.github/prompts/commands.prompt.yml
@@ -0,0 +1,16 @@
+messages:
+  - role: system
+    content: |
+      You are a Laravel developer. Apply these guidelines exactly:
+
+      {{skill_content}}
+
+      Respond with only the requested code. No explanations unless asked.
+  - role: user
+    content: |
+      Write an Artisan command invoices:send-reminders with required email argument and --dry-run option.
+      Delegate to SendInvoiceReminderAction. Return self::SUCCESS or self::FAILURE. Validate input.
+model: openai/gpt-4o
+modelParameters:
+  temperature: 0.2
+  maxCompletionTokens: 512
diff --git a/.github/prompts/controllers.prompt.yml b/.github/prompts/controllers.prompt.yml
new file mode 100644
index 0000000..b734da3
--- /dev/null
+++ b/.github/prompts/controllers.prompt.yml
@@ -0,0 +1,16 @@
+messages:
+  - role: system
+    content: |
+      You are a Laravel developer. Apply these guidelines exactly:
+
+      {{skill_content}}
+
+      Respond with only the requested code. No explanations unless asked.
+  - role: user
+    content: |
+      Write an invokable StoreInvoiceController that receives StoreInvoiceRequest, calls a CreateInvoice action,
+      and returns a JsonResponse with InvoiceResource. No business logic in the controller.
+model: openai/gpt-4o
+modelParameters:
+  temperature: 0.2
+  maxCompletionTokens: 512
diff --git a/.github/prompts/design.prompt.yml b/.github/prompts/design.prompt.yml
new file mode 100644
index 0000000..0138de8
--- /dev/null
+++ b/.github/prompts/design.prompt.yml
@@ -0,0 +1,16 @@
+messages:
+  - role: system
+    content: |
+      You are a Laravel developer. Apply these guidelines exactly:
+
+      {{skill_content}}
+
+      Respond with only the requested code. No explanations unless asked.
+  - role: user
+    content: |
+      Write an anonymous Blade button component with @props for variant and size. Merge $attributes with defaults.
+      Use min-h-[44px] for touch target, focus-visible:ring-2. Mobile-first.
+model: openai/gpt-4o
+modelParameters:
+  temperature: 0.2
+  maxCompletionTokens: 512
diff --git a/.github/prompts/docuware.prompt.yml b/.github/prompts/docuware.prompt.yml
new file mode 100644
index 0000000..179f6cc
--- /dev/null
+++ b/.github/prompts/docuware.prompt.yml
@@ -0,0 +1,16 @@
+messages:
+  - role: system
+    content: |
+      You are a Laravel developer. Apply these guidelines exactly:
+
+      {{skill_content}}
+
+      Respond with only the requested code. No explanations unless asked.
+  - role: user
+    content: |
+      Write a DocuWareService that wraps the DocuWare connector. Constructor accepts optional connector for testability.
+      Use config('laravel-docuware.credentials.*') not env(). Include fetchDocument or similar method signature.
+model: openai/gpt-4o
+modelParameters:
+  temperature: 0.2
+  maxCompletionTokens: 512
diff --git a/.github/prompts/dto.prompt.yml b/.github/prompts/dto.prompt.yml
new file mode 100644
index 0000000..f6f475d
--- /dev/null
+++ b/.github/prompts/dto.prompt.yml
@@ -0,0 +1,16 @@
+messages:
+  - role: system
+    content: |
+      You are a Laravel developer. Apply these guidelines exactly:
+
+      {{skill_content}}
+
+      Respond with only the requested code. No explanations unless asked.
+  - role: user
+    content: |
+      Write a readonly CustomerData DTO with id, name, email. Include fromArray() factory that handles
+      PascalCase and snake_case API field names. Use nullable for optional fields.
+model: openai/gpt-4o
+modelParameters:
+  temperature: 0.2
+  maxCompletionTokens: 512
diff --git a/.github/prompts/dusk.prompt.yml b/.github/prompts/dusk.prompt.yml
new file mode 100644
index 0000000..7b4292a
--- /dev/null
+++ b/.github/prompts/dusk.prompt.yml
@@ -0,0 +1,16 @@
+messages:
+  - role: system
+    content: |
+      You are a Laravel developer. Apply these guidelines exactly:
+
+      {{skill_content}}
+
+      Respond with only the requested code. No explanations unless asked.
+  - role: user
+    content: |
+      Write a Dusk test that logs in, visits /invoices/create, uses dusk="" selectors, calls assertNoJavaScriptErrors().
+      Use DatabaseTruncation. Use loginAs(), waitForText, never pause().
+model: openai/gpt-4o
+modelParameters:
+  temperature: 0.2
+  maxCompletionTokens: 512
diff --git a/.github/prompts/enums.prompt.yml b/.github/prompts/enums.prompt.yml
new file mode 100644
index 0000000..b0c47a1
--- /dev/null
+++ b/.github/prompts/enums.prompt.yml
@@ -0,0 +1,16 @@
+messages:
+  - role: system
+    content: |
+      You are a Laravel developer. Apply these guidelines exactly:
+
+      {{skill_content}}
+
+      Respond with only the requested code. No explanations unless asked.
+  - role: user
+    content: |
+      Write a Status enum with Draft, Active, Archived. Include label() and color() methods using match expressions.
+      Use backed string enum.
+model: openai/gpt-4o
+modelParameters:
+  temperature: 0.2
+  maxCompletionTokens: 512
diff --git a/.github/prompts/events.prompt.yml b/.github/prompts/events.prompt.yml
new file mode 100644
index 0000000..8b948d4
--- /dev/null
+++ b/.github/prompts/events.prompt.yml
@@ -0,0 +1,16 @@
+messages:
+  - role: system
+    content: |
+      You are a Laravel developer. Apply these guidelines exactly:
+
+      {{skill_content}}
+
+      Respond with only the requested code. No explanations unless asked.
+  - role: user
+    content: |
+      Write an InvoicePaid event (plain data container with Invoice) and a SendInvoicePaidNotification listener.
+      Event uses Dispatchable, SerializesModels. Listener has single responsibility. Use past-tense for event name.
+model: openai/gpt-4o
+modelParameters:
+  temperature: 0.2
+  maxCompletionTokens: 512
diff --git a/.github/prompts/exceptions.prompt.yml b/.github/prompts/exceptions.prompt.yml
new file mode 100644
index 0000000..5e9f97f
--- /dev/null
+++ b/.github/prompts/exceptions.prompt.yml
@@ -0,0 +1,16 @@
+messages:
+  - role: system
+    content: |
+      You are a Laravel developer. Apply these guidelines exactly:
+
+      {{skill_content}}
+
+      Respond with only the requested code. No explanations unless asked.
+  - role: user
+    content: |
+      Write an InvoiceAlreadyPaidException that extends RuntimeException. It receives an Invoice as readonly property
+      and sets a clear message via parent::__construct(). Use a named failure state.
+model: openai/gpt-4o
+modelParameters:
+  temperature: 0.2
+  maxCompletionTokens: 384
diff --git a/.github/prompts/formrequests.prompt.yml b/.github/prompts/formrequests.prompt.yml
new file mode 100644
index 0000000..7a362c2
--- /dev/null
+++ b/.github/prompts/formrequests.prompt.yml
@@ -0,0 +1,17 @@
+messages:
+  - role: system
+    content: |
+      You are a Laravel developer. Apply these guidelines exactly:
+
+      {{skill_content}}
+
+      Respond with only the requested code. No explanations unless asked.
+  - role: user
+    content: |
+      Write a StoreInvoiceRequest with authorize() and rules() returning array-based rules.
+      Rules: order_id required exists in orders, amount required numeric min 0.
+      Add PHPDoc @return for rules().
+model: openai/gpt-4o
+modelParameters:
+  temperature: 0.2
+  maxCompletionTokens: 512
diff --git a/.github/prompts/general.prompt.yml b/.github/prompts/general.prompt.yml
new file mode 100644
index 0000000..3bc0e44
--- /dev/null
+++ b/.github/prompts/general.prompt.yml
@@ -0,0 +1,16 @@
+messages:
+  - role: system
+    content: |
+      You are a Laravel developer. Apply these guidelines exactly:
+
+      {{skill_content}}
+
+      Respond with only the requested code. No explanations unless asked.
+  - role: user
+    content: |
+      Add a Stripe API key to the Laravel config and show how to read it in a controller.
+      Use the correct helper for config access. Show the config file addition and one line of controller code.
+model: openai/gpt-4o
+modelParameters:
+  temperature: 0.2
+  maxCompletionTokens: 512
diff --git a/.github/prompts/helperfunctions.prompt.yml b/.github/prompts/helperfunctions.prompt.yml
new file mode 100644
index 0000000..4f2e3a4
--- /dev/null
+++ b/.github/prompts/helperfunctions.prompt.yml
@@ -0,0 +1,16 @@
+messages:
+  - role: system
+    content: |
+      You are a Laravel developer. Apply these guidelines exactly:
+
+      {{skill_content}}
+
+      Respond with only the requested code. No explanations unless asked.
+  - role: user
+    content: |
+      Write PHP code to filter an array of users to only active ones, then get their email addresses as a comma-separated string.
+      Use Laravel Arr and Str helpers instead of native PHP functions.
+model: openai/gpt-4o
+modelParameters:
+  temperature: 0.2
+  maxCompletionTokens: 512
diff --git a/.github/prompts/helpers.prompt.yml b/.github/prompts/helpers.prompt.yml
new file mode 100644
index 0000000..27d7818
--- /dev/null
+++ b/.github/prompts/helpers.prompt.yml
@@ -0,0 +1,16 @@
+messages:
+  - role: system
+    content: |
+      You are a Laravel developer. Apply these guidelines exactly:
+
+      {{skill_content}}
+
+      Respond with only the requested code. No explanations unless asked.
+  - role: user
+    content: |
+      Write a DateHelper class with a static format() method that accepts a date and format string, returns formatted string or null.
+      Use Carbon. No business logic, no database queries. PascalCase with Helper suffix.
+model: openai/gpt-4o
+modelParameters:
+  temperature: 0.2
+  maxCompletionTokens: 384
diff --git a/.github/prompts/interfaces.prompt.yml b/.github/prompts/interfaces.prompt.yml
new file mode 100644
index 0000000..25f51ea
--- /dev/null
+++ b/.github/prompts/interfaces.prompt.yml
@@ -0,0 +1,16 @@
+messages:
+  - role: system
+    content: |
+      You are a Laravel developer. Apply these guidelines exactly:
+
+      {{skill_content}}
+
+      Respond with only the requested code. No explanations unless asked.
+  - role: user
+    content: |
+      Write a PaymentGateway interface in app/Contracts/ with charge(Order, int) and refund(string, int) methods.
+      Return a PaymentResult. No implementation. Clear noun describing the capability.
+model: openai/gpt-4o
+modelParameters:
+  temperature: 0.2
+  maxCompletionTokens: 384
diff --git a/.github/prompts/jobs.prompt.yml b/.github/prompts/jobs.prompt.yml
new file mode 100644
index 0000000..03e04db
--- /dev/null
+++ b/.github/prompts/jobs.prompt.yml
@@ -0,0 +1,16 @@
+messages:
+  - role: system
+    content: |
+      You are a Laravel developer. Apply these guidelines exactly:
+
+      {{skill_content}}
+
+      Respond with only the requested code. No explanations unless asked.
+  - role: user
+    content: |
+      Write a ProcessInvoicePaymentJob that implements ShouldQueue. Delegate to ProcessInvoicePayment action.
+      Use Dispatchable, InteractsWithQueue, Queueable, SerializesModels. Set tries, backoff, queue. Add failed() method.
+model: openai/gpt-4o
+modelParameters:
+  temperature: 0.2
+  maxCompletionTokens: 512
diff --git a/.github/prompts/livewire.prompt.yml b/.github/prompts/livewire.prompt.yml
new file mode 100644
index 0000000..1ee5509
--- /dev/null
+++ b/.github/prompts/livewire.prompt.yml
@@ -0,0 +1,16 @@
+messages:
+  - role: system
+    content: |
+      You are a Laravel developer. Apply these guidelines exactly:
+
+      {{skill_content}}
+
+      Respond with only the requested code. No explanations unless asked.
+  - role: user
+    content: |
+      Write a Livewire InvoiceList component with search property, #[Computed] invoices(), and wire:model/wire:click.
+      Keep logic in PHP, template declarative. Use wire:model for search binding.
+model: openai/gpt-4o
+modelParameters:
+  temperature: 0.2
+  maxCompletionTokens: 512
diff --git a/.github/prompts/middleware.prompt.yml b/.github/prompts/middleware.prompt.yml
new file mode 100644
index 0000000..bb38228
--- /dev/null
+++ b/.github/prompts/middleware.prompt.yml
@@ -0,0 +1,16 @@
+messages:
+  - role: system
+    content: |
+      You are a Laravel developer. Apply these guidelines exactly:
+
+      {{skill_content}}
+
+      Respond with only the requested code. No explanations unless asked.
+  - role: user
+    content: |
+      Write an EnsureUserIsSubscribed middleware. If user is not subscribed, return 403 JSON response.
+      Otherwise call $next($request). Clear descriptive name. No business logic inside.
+model: openai/gpt-4o
+modelParameters:
+  temperature: 0.2
+  maxCompletionTokens: 384
diff --git a/.github/prompts/migrations.prompt.yml b/.github/prompts/migrations.prompt.yml
new file mode 100644
index 0000000..187d158
--- /dev/null
+++ b/.github/prompts/migrations.prompt.yml
@@ -0,0 +1,16 @@
+messages:
+  - role: system
+    content: |
+      You are a Laravel developer. Apply these guidelines exactly:
+
+      {{skill_content}}
+
+      Respond with only the requested code. No explanations unless asked.
+  - role: user
+    content: |
+      Write a migration to create an invoices table with id, order_id (foreign key), status (string default draft), amount (decimal), timestamps.
+      Use foreignId()->constrained()->cascadeOnDelete(). Include both up() and down() methods.
+model: openai/gpt-4o
+modelParameters:
+  temperature: 0.2
+  maxCompletionTokens: 512
diff --git a/.github/prompts/models.prompt.yml b/.github/prompts/models.prompt.yml
new file mode 100644
index 0000000..ad0f67a
--- /dev/null
+++ b/.github/prompts/models.prompt.yml
@@ -0,0 +1,16 @@
+messages:
+  - role: system
+    content: |
+      You are a Laravel developer. Apply these guidelines exactly:
+
+      {{skill_content}}
+
+      Respond with only the requested code. No explanations unless asked.
+  - role: user
+    content: |
+      Write a minimal Invoice Eloquent model with guarded, casts as method, and a belongsTo Order relationship.
+      Use typed return type on the relationship. Include section comment headers.
+model: openai/gpt-4o
+modelParameters:
+  temperature: 0.2
+  maxCompletionTokens: 512
diff --git a/.github/prompts/observers.prompt.yml b/.github/prompts/observers.prompt.yml
new file mode 100644
index 0000000..cea8529
--- /dev/null
+++ b/.github/prompts/observers.prompt.yml
@@ -0,0 +1,16 @@
+messages:
+  - role: system
+    content: |
+      You are a Laravel developer. Apply these guidelines exactly:
+
+      {{skill_content}}
+
+      Respond with only the requested code. No explanations unless asked.
+  - role: user
+    content: |
+      Write a UserObserver with created() that sends WelcomeNotification, and updated()/deleted() that clear cache.
+      Use Observer suffix. Only define methods you need. No business logic.
+model: openai/gpt-4o
+modelParameters:
+  temperature: 0.2
+  maxCompletionTokens: 384
diff --git a/.github/prompts/pesttesting.prompt.yml b/.github/prompts/pesttesting.prompt.yml
new file mode 100644
index 0000000..8113966
--- /dev/null
+++ b/.github/prompts/pesttesting.prompt.yml
@@ -0,0 +1,16 @@
+messages:
+  - role: system
+    content: |
+      You are a Laravel developer. Apply these guidelines exactly:
+
+      {{skill_content}}
+
+      Respond with only the requested code. No explanations unless asked.
+  - role: user
+    content: |
+      Write a Pest test it('creates an invoice for the given order') with AAA pattern and Arrange/Act/Assert comments.
+      Use uses(RefreshDatabase::class), postJson, assertCreated(), expect()->toBe(). Plain English description.
+model: openai/gpt-4o
+modelParameters:
+  temperature: 0.2
+  maxCompletionTokens: 512
diff --git a/.github/prompts/php.prompt.yml b/.github/prompts/php.prompt.yml
new file mode 100644
index 0000000..2027075
--- /dev/null
+++ b/.github/prompts/php.prompt.yml
@@ -0,0 +1,16 @@
+messages:
+  - role: system
+    content: |
+      You are a Laravel developer. Apply these guidelines exactly:
+
+      {{skill_content}}
+
+      Respond with only the requested code. No explanations unless asked.
+  - role: user
+    content: |
+      Write a process(Order $order) method with early returns. If !$order->isPaid() throw exception and return.
+      If !$order->hasItems() throw and return. Then happy-path logic. No else/elseif. Use guard clauses.
+model: openai/gpt-4o
+modelParameters:
+  temperature: 0.2
+  maxCompletionTokens: 512
diff --git a/.github/prompts/phpstan.prompt.yml b/.github/prompts/phpstan.prompt.yml
new file mode 100644
index 0000000..9dab006
--- /dev/null
+++ b/.github/prompts/phpstan.prompt.yml
@@ -0,0 +1,16 @@
+messages:
+  - role: system
+    content: |
+      You are a Laravel developer. Apply these guidelines exactly:
+
+      {{skill_content}}
+
+      Respond with only the requested code. No explanations unless asked.
+  - role: user
+    content: |
+      Write a method process(Order $order): Invoice with full type hints. Add PHPDoc @return array<string, array<int, string|object>> for a rules() method.
+      Use union types instead of mixed. No @phpstan-ignore.
+model: openai/gpt-4o
+modelParameters:
+  temperature: 0.2
+  maxCompletionTokens: 512
diff --git a/.github/prompts/phpunit.prompt.yml b/.github/prompts/phpunit.prompt.yml
new file mode 100644
index 0000000..6eec075
--- /dev/null
+++ b/.github/prompts/phpunit.prompt.yml
@@ -0,0 +1,16 @@
+messages:
+  - role: system
+    content: |
+      You are a Laravel developer. Apply these guidelines exactly:
+
+      {{skill_content}}
+
+      Respond with only the requested code. No explanations unless asked.
+  - role: user
+    content: |
+      Write a feature test test_user_can_create_invoice. Use RefreshDatabase, factories, actingAs.
+      Assert 201 and assertDatabaseHas. Use test_ prefix and : void return type.
+model: openai/gpt-4o
+modelParameters:
+  temperature: 0.2
+  maxCompletionTokens: 512
diff --git a/.github/prompts/policies.prompt.yml b/.github/prompts/policies.prompt.yml
new file mode 100644
index 0000000..2cc0436
--- /dev/null
+++ b/.github/prompts/policies.prompt.yml
@@ -0,0 +1,16 @@
+messages:
+  - role: system
+    content: |
+      You are a Laravel developer. Apply these guidelines exactly:
+
+      {{skill_content}}
+
+      Respond with only the requested code. No explanations unless asked.
+  - role: user
+    content: |
+      Write an InvoicePolicy with viewAny (admin only), view (owner or admin), create (authenticated).
+      Use Policy suffix. Standard ability names.
+model: openai/gpt-4o
+modelParameters:
+  temperature: 0.2
+  maxCompletionTokens: 512
diff --git a/.github/prompts/requests.prompt.yml b/.github/prompts/requests.prompt.yml
new file mode 100644
index 0000000..0198589
--- /dev/null
+++ b/.github/prompts/requests.prompt.yml
@@ -0,0 +1,16 @@
+messages:
+  - role: system
+    content: |
+      You are a Laravel developer. Apply these guidelines exactly:
+
+      {{skill_content}}
+
+      Respond with only the requested code. No explanations unless asked.
+  - role: user
+    content: |
+      Write a StoreInvoiceRequest with authorize() using can('create', Invoice::class) and rules() with array-based definitions.
+      Add PHPDoc @return for rules(). Never use $request->validate() in controller.
+model: openai/gpt-4o
+modelParameters:
+  temperature: 0.2
+  maxCompletionTokens: 512
diff --git a/.github/prompts/resources.prompt.yml b/.github/prompts/resources.prompt.yml
new file mode 100644
index 0000000..0ed9902
--- /dev/null
+++ b/.github/prompts/resources.prompt.yml
@@ -0,0 +1,16 @@
+messages:
+  - role: system
+    content: |
+      You are a Laravel developer. Apply these guidelines exactly:
+
+      {{skill_content}}
+
+      Respond with only the requested code. No explanations unless asked.
+  - role: user
+    content: |
+      Write a UserResource extending JsonResource. Return id, name, email, posts (whenLoaded), created_at (formatted).
+      Use whenLoaded for relations. Use when() for conditional admin-only secret field.
+model: openai/gpt-4o
+modelParameters:
+  temperature: 0.2
+  maxCompletionTokens: 512
diff --git a/.github/prompts/routing.prompt.yml b/.github/prompts/routing.prompt.yml
new file mode 100644
index 0000000..2b8f850
--- /dev/null
+++ b/.github/prompts/routing.prompt.yml
@@ -0,0 +1,16 @@
+messages:
+  - role: system
+    content: |
+      You are a Laravel developer. Apply these guidelines exactly:
+
+      {{skill_content}}
+
+      Respond with only the requested code. No explanations unless asked.
+  - role: user
+    content: |
+      Write API routes for invoices: index and store. Use auth:sanctum middleware, apiResource, and resourceful route names.
+      Group them properly. Use kebab-case for URL.
+model: openai/gpt-4o
+modelParameters:
+  temperature: 0.2
+  maxCompletionTokens: 384
diff --git a/.github/prompts/saloon.prompt.yml b/.github/prompts/saloon.prompt.yml
new file mode 100644
index 0000000..3032f9a
--- /dev/null
+++ b/.github/prompts/saloon.prompt.yml
@@ -0,0 +1,16 @@
+messages:
+  - role: system
+    content: |
+      You are a Laravel developer. Apply these guidelines exactly:
+
+      {{skill_content}}
+
+      Respond with only the requested code. No explanations unless asked.
+  - role: user
+    content: |
+      Write a StripeConnector extending Saloon Connector with resolveBaseUrl and defaultHeaders.
+      Write a ListChargesRequest for GET. No Http::get() or raw HTTP. Use Saloon pattern.
+model: openai/gpt-4o
+modelParameters:
+  temperature: 0.2
+  maxCompletionTokens: 512
diff --git a/.github/prompts/services.prompt.yml b/.github/prompts/services.prompt.yml
new file mode 100644
index 0000000..67f8199
--- /dev/null
+++ b/.github/prompts/services.prompt.yml
@@ -0,0 +1,16 @@
+messages:
+  - role: system
+    content: |
+      You are a Laravel developer. Apply these guidelines exactly:
+
+      {{skill_content}}
+
+      Respond with only the requested code. No explanations unless asked.
+  - role: user
+    content: |
+      Write a PaymentService that orchestrates CreateInvoice, ChargePaymentMethod, SendPaymentConfirmation actions.
+      Method processOrderPayment(Order) uses DB::transaction. Inject actions via constructor. No Manager/Handler suffix.
+model: openai/gpt-4o
+modelParameters:
+  temperature: 0.2
+  maxCompletionTokens: 512
diff --git a/.github/prompts/tailwind.prompt.yml b/.github/prompts/tailwind.prompt.yml
new file mode 100644
index 0000000..e06ad96
--- /dev/null
+++ b/.github/prompts/tailwind.prompt.yml
@@ -0,0 +1,16 @@
+messages:
+  - role: system
+    content: |
+      You are a Laravel developer. Apply these guidelines exactly:
+
+      {{skill_content}}
+
+      Respond with only the requested code. No explanations unless asked.
+  - role: user
+    content: |
+      Write the resources/css/app.css for Tailwind v4 with @theme directive setting --color-primary-500 and --font-sans.
+      Include @source for views and Livewire. No custom CSS classes.
+model: openai/gpt-4o
+modelParameters:
+  temperature: 0.2
+  maxCompletionTokens: 384
diff --git a/.github/prompts/traits.prompt.yml b/.github/prompts/traits.prompt.yml
new file mode 100644
index 0000000..749c9b4
--- /dev/null
+++ b/.github/prompts/traits.prompt.yml
@@ -0,0 +1,16 @@
+messages:
+  - role: system
+    content: |
+      You are a Laravel developer. Apply these guidelines exactly:
+
+      {{skill_content}}
+
+      Respond with only the requested code. No explanations unless asked.
+  - role: user
+    content: |
+      Write an Archivable trait with archive(), unarchive(), isArchived() methods for models with archived_at.
+      Use -able suffix. Single responsibility. No complex business logic.
+model: openai/gpt-4o
+modelParameters:
+  temperature: 0.2
+  maxCompletionTokens: 384
diff --git a/.github/prompts/translations.prompt.yml b/.github/prompts/translations.prompt.yml
new file mode 100644
index 0000000..c49218e
--- /dev/null
+++ b/.github/prompts/translations.prompt.yml
@@ -0,0 +1,16 @@
+messages:
+  - role: system
+    content: |
+      You are a Laravel developer. Apply these guidelines exactly:
+
+      {{skill_content}}
+
+      Respond with only the requested code. No explanations unless asked.
+  - role: user
+    content: |
+      Write lang/en/invoices.php with create_success key using :name placeholder.
+      Show usage with __('invoices.create_success', ['name' => $name]). Use namespaced keys.
+model: openai/gpt-4o
+modelParameters:
+  temperature: 0.2
+  maxCompletionTokens: 384
diff --git a/.github/scripts/validate-skill-response.sh b/.github/scripts/validate-skill-response.sh
new file mode 100755
index 0000000..2de934a
--- /dev/null
+++ b/.github/scripts/validate-skill-response.sh
@@ -0,0 +1,133 @@
+#!/bin/bash
+# Validates AI response against skill-specific rules.
+# Usage: validate-skill-response.sh <skill-name> <response>
+# Exits 0 if valid, 1 if invalid.
+
+skill="$1"
+response="$2"
+
+if [ -z "$response" ]; then
+  echo "::error::[$skill] Empty response"
+  exit 1
+fi
+
+case "$skill" in
+  general)
+    echo "$response" | grep -q 'env(' && { echo "::error::[$skill] Should use config() not env()"; exit 1; }
+    echo "$response" | grep -q 'config(' || { echo "::error::[$skill] Missing config()"; exit 1; }
+    ;;
+  helperfunctions)
+    echo "$response" | grep -qE 'Arr::|Str::|collect\(' || { echo "::error::[$skill] Should use Laravel helpers"; exit 1; }
+    ;;
+  models)
+    echo "$response" | grep -qE 'extends Model|BelongsTo|HasMany|HasOne' || { echo "::error::[$skill] Needs Model with relationship"; exit 1; }
+    ;;
+  controllers)
+    echo "$response" | grep -qE '__invoke|JsonResponse' || { echo "::error::[$skill] Needs invokable or JsonResponse"; exit 1; }
+    ;;
+  migrations)
+    echo "$response" | grep -qE 'foreignId|constrained|cascadeOnDelete' || { echo "::error::[$skill] Needs proper foreign key"; exit 1; }
+    echo "$response" | grep -qE 'function (up|down)\s*\(\)' || { echo "::error::[$skill] Needs up() and down()"; exit 1; }
+    ;;
+  routing)
+    echo "$response" | grep -qE 'Route::|Route::apiResource|middleware' || { echo "::error::[$skill] Needs Route definitions"; exit 1; }
+    ;;
+  formrequests|requests)
+    echo "$response" | grep -qE 'authorize\(\)|rules\(\)' || { echo "::error::[$skill] Needs authorize and rules"; exit 1; }
+    ;;
+  actions)
+    echo "$response" | grep -q 'execute(' || { echo "::error::[$skill] Action needs execute()"; exit 1; }
+    echo "$response" | grep -qE 'InvoiceAction|UserHandler' && { echo "::error::[$skill] Avoid vague names"; exit 1; } || true
+    ;;
+  commands)
+    echo "$response" | grep -qE 'self::SUCCESS|self::FAILURE' || { echo "::error::[$skill] Must return SUCCESS or FAILURE"; exit 1; }
+    ;;
+  dto)
+    echo "$response" | grep -q 'fromArray' || { echo "::error::[$skill] DTO needs fromArray()"; exit 1; }
+    echo "$response" | grep -q 'readonly' || { echo "::error::[$skill] DTO should be readonly"; exit 1; }
+    ;;
+  enums)
+    echo "$response" | grep -qE 'label\(\)|color\(\)' || { echo "::error::[$skill] Enum needs label() and color()"; exit 1; }
+    echo "$response" | grep -q 'match' || true
+    ;;
+  events)
+    echo "$response" | grep -qE 'Dispatchable|SerializesModels' || true
+    ;;
+  exceptions)
+    echo "$response" | grep -q 'Exception' || { echo "::error::[$skill] Needs Exception suffix"; exit 1; }
+    ;;
+  helpers)
+    echo "$response" | grep -qE 'Helper|format' || true
+    ;;
+  interfaces)
+    echo "$response" | grep -q 'interface' || { echo "::error::[$skill] Needs interface"; exit 1; }
+    ;;
+  jobs)
+    echo "$response" | grep -qE 'ShouldQueue|Dispatchable|Queueable' || { echo "::error::[$skill] Job needs queue traits"; exit 1; }
+    ;;
+  middleware)
+    echo "$response" | grep -q '\$next(\$request)' || { echo "::error::[$skill] Middleware must call next"; exit 1; }
+    ;;
+  observers)
+    echo "$response" | grep -qE 'Observer|created|updated' || { echo "::error::[$skill] Needs Observer and lifecycle methods"; exit 1; }
+    ;;
+  policies)
+    echo "$response" | grep -qE 'viewAny|view|create' || { echo "::error::[$skill] Policy needs ability methods"; exit 1; }
+    ;;
+  resources)
+    echo "$response" | grep -qE 'whenLoaded|when\(|JsonResource' || { echo "::error::[$skill] Resource needs whenLoaded/when"; exit 1; }
+    ;;
+  services)
+    echo "$response" | grep -qE 'DB::transaction|Service' || { echo "::error::[$skill] Service needs DB::transaction or Service class"; exit 1; }
+    ;;
+  traits)
+    echo "$response" | grep -q 'trait' || { echo "::error::[$skill] Needs trait"; exit 1; }
+    ;;
+  blade)
+    echo "$response" | grep -q '{{' || { echo "::error::[$skill] Blade needs {{ }} escaping"; exit 1; }
+    ;;
+  design)
+    echo "$response" | grep -qE '\$attributes|@props|min-h-\[44px\]' || true
+    ;;
+  livewire)
+    echo "$response" | grep -qE 'wire:model|wire:click|Computed' || { echo "::error::[$skill] Livewire needs wire: or Computed"; exit 1; }
+    ;;
+  tailwind)
+    echo "$response" | grep -qE '@theme|@source|tailwind' || { echo "::error::[$skill] Needs @theme or Tailwind setup"; exit 1; }
+    ;;
+  translations)
+    echo "$response" | grep -qE '__\(|trans\(' || { echo "::error::[$skill] Needs __() or trans()"; exit 1; }
+    ;;
+  phpunit)
+    echo "$response" | grep -qE 'test_|assertStatus|assertDatabaseHas|RefreshDatabase' || { echo "::error::[$skill] Needs test structure"; exit 1; }
+    ;;
+  pesttesting)
+    echo "$response" | grep -qE 'it\(|expect\(|assertCreated|Arrange|Act|Assert' || { echo "::error::[$skill] Needs Pest syntax"; exit 1; }
+    ;;
+  phpstan)
+    echo "$response" | grep -qE 'array<string|@return|: \w+' || true
+    ;;
+  dusk)
+    echo "$response" | grep -qE 'assertNoJavaScriptErrors|dusk=|DatabaseTruncation' || true
+    ;;
+  php)
+    echo "$response" | grep -qE 'throw new|return;' || true
+    ;;
+  saloon)
+    echo "$response" | grep -q 'Connector' || { echo "::error::[$skill] Needs Saloon Connector"; exit 1; }
+    echo "$response" | grep -qE 'Http::(get|post)|file_get_contents' && { echo "::error::[$skill] No raw HTTP"; exit 1; } || true
+    ;;
+  docuware)
+    echo "$response" | grep -q 'config(' || { echo "::error::[$skill] Use config() not env()"; exit 1; }
+    ;;
+  albatros)
+    echo "$response" | grep -qE 'Connector|Saloon' || { echo "::error::[$skill] Needs Saloon Connector"; exit 1; }
+    ;;
+  *)
+    # Unknown skill - just check non-empty
+    [ -n "$response" ] || exit 1
+    ;;
+esac
+
+echo "✓ [$skill] validation passed"
+exit 0
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
new file mode 100644
index 0000000..5bd2f32
--- /dev/null
+++ b/.github/workflows/ci.yml
@@ -0,0 +1,30 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  validate:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup PHP
+        uses: shivammathur/setup-php@v2
+        with:
+          php-version: "8.4"
+          tools: composer:v2
+
+      - name: Validate Composer
+        run: composer validate --strict
+
+      - name: PHP syntax check
+        run: |
+          for f in $(find src -name "*.php"); do php -l "$f" || exit 1; done
+
+      - name: Validate skills
+        run: php scripts/validate-skills.php
diff --git a/.github/workflows/skill-integration.yml b/.github/workflows/skill-integration.yml
new file mode 100644
index 0000000..5acf56d
--- /dev/null
+++ b/.github/workflows/skill-integration.yml
@@ -0,0 +1,80 @@
+name: Skill Integration
+
+on:
+  workflow_dispatch:
+  pull_request:
+    paths:
+      - ".github/prompts/**"
+      - ".github/workflows/skill-integration.yml"
+      - ".github/scripts/validate-skill-response.sh"
+      - "resources/boost/skills/**"
+  schedule:
+    - cron: "0 6 * * 1"
+
+permissions:
+  contents: read
+  models: read
+
+jobs:
+  skill-tests:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        skill:
+          - general
+          - helperfunctions
+          - models
+          - controllers
+          - migrations
+          - routing
+          - formrequests
+          - actions
+          - commands
+          - dto
+          - enums
+          - events
+          - exceptions
+          - helpers
+          - interfaces
+          - jobs
+          - middleware
+          - observers
+          - policies
+          - requests
+          - resources
+          - services
+          - traits
+          - blade
+          - design
+          - livewire
+          - tailwind
+          - translations
+          - phpunit
+          - pesttesting
+          - phpstan
+          - dusk
+          - php
+          - saloon
+          - docuware
+          - albatros
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Prepare skill content
+        run: |
+          cp "resources/boost/skills/${{ matrix.skill }}/SKILL.md" /tmp/skill-content.txt
+
+      - name: Test ${{ matrix.skill }} skill
+        id: infer
+        uses: actions/ai-inference@v2
+        with:
+          prompt-file: .github/prompts/${{ matrix.skill }}.prompt.yml
+          file_input: |
+            skill_content: /tmp/skill-content.txt
+
+      - name: Validate response
+        run: |
+          chmod +x .github/scripts/validate-skill-response.sh
+          .github/scripts/validate-skill-response.sh "${{ matrix.skill }}" "${{ steps.infer.outputs.response }}"
diff --git a/.gitignore b/.gitignore
index b5bf0d0..9e6935f 100644
--- a/.gitignore
+++ b/.gitignore
@@ -9,6 +9,7 @@ composer.phar
 
 # IDE
 .idea/
+.cursor/
 .vscode/
 *.swp
 *.swo
diff --git a/README.md b/README.md
index 96a4fc0..260e4c3 100644
--- a/README.md
+++ b/README.md
@@ -6,6 +6,17 @@ Shared Laravel AI coding guidelines and skills for codebar-ag projects. A Boost-
 
 ---
 
+## CI
+
+GitHub Actions run on push and pull requests:
+
+- **CI workflow** — Composer validate, PHP syntax check, skill structure validation (frontmatter, count)
+- **Skill Integration** — AI-powered verification: one test prompt per skill (36 total), sends to GitHub Models, validates responses follow guidelines. Runs on prompt/skill changes, weekly schedule, and manual trigger. Requires `models: read` and GitHub Models access.
+
+Run validation locally: `composer validate-skills`
+
+---
+
 ## Skills Summary
 
 | Category | Skills | Description |
diff --git a/composer.json b/composer.json
index 47d9da7..d49fec0 100644
--- a/composer.json
+++ b/composer.json
@@ -33,6 +33,9 @@
             ]
         }
     },
+    "scripts": {
+        "validate-skills": "php scripts/validate-skills.php"
+    },
     "config": {
         "sort-packages": true
     },
diff --git a/scripts/validate-skills.php b/scripts/validate-skills.php
new file mode 100644
index 0000000..9a38cf5
--- /dev/null
+++ b/scripts/validate-skills.php
@@ -0,0 +1,73 @@
+#!/usr/bin/env php
+<?php
+
+declare(strict_types=1);
+
+/**
+ * Validates all SKILL.md files in resources/boost/skills/.
+ *
+ * Each skill must have:
+ * - YAML frontmatter with "name" and "description"
+ * - Non-empty values for both fields
+ *
+ * Exits with code 1 if any skill is invalid.
+ */
+
+$skillsDir = __DIR__ . '/../resources/boost/skills';
+if (!is_dir($skillsDir)) {
+    fwrite(STDERR, "Skills directory not found: {$skillsDir}\n");
+    exit(1);
+}
+
+$skillDirs = glob($skillsDir . '/*', GLOB_ONLYDIR);
+$errors = [];
+$expectedCount = 36;
+
+foreach ($skillDirs as $dir) {
+    $skillFile = $dir . '/SKILL.md';
+    $skillName = basename($dir);
+
+    if (!file_exists($skillFile)) {
+        $errors[] = "{$skillName}: Missing SKILL.md";
+        continue;
+    }
+
+    $content = file_get_contents($skillFile);
+
+    if (!preg_match('/^---\s*\n(.*?)\n---\s*\n/s', $content, $matches)) {
+        $errors[] = "{$skillName}: Missing or invalid YAML frontmatter (must start with --- and end with ---)";
+        continue;
+    }
+
+    $frontmatter = $matches[1];
+    $parsed = [];
+    foreach (explode("\n", $frontmatter) as $line) {
+        if (preg_match('/^([a-z]+):\s*(.*)$/', trim($line), $m)) {
+            $parsed[$m[1]] = trim($m[2], " \t\n\r\0\x0B\"'");
+        }
+    }
+
+    if (empty($parsed['name'])) {
+        $errors[] = "{$skillName}: Frontmatter must include 'name'";
+    }
+
+    if (empty($parsed['description'])) {
+        $errors[] = "{$skillName}: Frontmatter must include 'description'";
+    }
+}
+
+if (!empty($errors)) {
+    foreach ($errors as $err) {
+        fwrite(STDERR, "ERROR: {$err}\n");
+    }
+    exit(1);
+}
+
+$count = count($skillDirs);
+if ($count !== $expectedCount) {
+    fwrite(STDERR, "ERROR: Expected {$expectedCount} skills, found {$count}. Update README or add missing skills.\n");
+    exit(1);
+}
+
+echo "✓ All {$count} skills validated successfully.\n";
+exit(0);

From cf92256e10bd544bbcc04f0d332790c8e4bbbaf3 Mon Sep 17 00:00:00 2001
From: Sebastian Fix <sebastian.fix@codebar.ch>
Date: Fri, 27 Feb 2026 23:31:38 +0100
Subject: [PATCH 6/9] Updated ActionS2

---
 .github/workflows/skill-integration.yml | 2 ++
 composer.json                           | 1 +
 2 files changed, 3 insertions(+)

diff --git a/.github/workflows/skill-integration.yml b/.github/workflows/skill-integration.yml
index 5acf56d..680e66d 100644
--- a/.github/workflows/skill-integration.yml
+++ b/.github/workflows/skill-integration.yml
@@ -70,6 +70,8 @@ jobs:
         id: infer
         uses: actions/ai-inference@v2
         with:
+          token: ${{ secrets.MY_GITHUB_TOKEN }}
+          endpoint: https://models.github.ai/orgs/${{ github.repository_owner }}/inference
           prompt-file: .github/prompts/${{ matrix.skill }}.prompt.yml
           file_input: |
             skill_content: /tmp/skill-content.txt
diff --git a/composer.json b/composer.json
index d49fec0..3db5f38 100644
--- a/composer.json
+++ b/composer.json
@@ -11,6 +11,7 @@
     ],
     "license": "MIT",
     "require": {
+        "illuminate/support": "^12.0",
         "php": "^8.4"
     },
     "suggest": {

From f2a5c5c6e13040efd35b03b0a83d923d3717a5e7 Mon Sep 17 00:00:00 2001
From: Sebastian Fix <sebastian.fix@codebar.ch>
Date: Fri, 27 Feb 2026 23:40:25 +0100
Subject: [PATCH 7/9] Updated Action

---
 .github/workflows/skill-integration.yml | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/.github/workflows/skill-integration.yml b/.github/workflows/skill-integration.yml
index 680e66d..40603e7 100644
--- a/.github/workflows/skill-integration.yml
+++ b/.github/workflows/skill-integration.yml
@@ -20,6 +20,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       fail-fast: false
+      max-parallel: 5
       matrix:
         skill:
           - general
@@ -72,6 +73,7 @@ jobs:
         with:
           token: ${{ secrets.MY_GITHUB_TOKEN }}
           endpoint: https://models.github.ai/orgs/${{ github.repository_owner }}/inference
+          model: openai/gpt-4o-mini
           prompt-file: .github/prompts/${{ matrix.skill }}.prompt.yml
           file_input: |
             skill_content: /tmp/skill-content.txt

From 558ea2dd112663694b84c5c4d4156b6c243472b6 Mon Sep 17 00:00:00 2001
From: Sebastian Fix <sebastian.fix@codebar.ch>
Date: Fri, 27 Feb 2026 23:43:18 +0100
Subject: [PATCH 8/9] Updated Action

---
 .github/prompts/actions.prompt.yml         | 2 +-
 .github/prompts/albatros.prompt.yml        | 2 +-
 .github/prompts/blade.prompt.yml           | 2 +-
 .github/prompts/commands.prompt.yml        | 2 +-
 .github/prompts/controllers.prompt.yml     | 2 +-
 .github/prompts/design.prompt.yml          | 2 +-
 .github/prompts/docuware.prompt.yml        | 2 +-
 .github/prompts/dto.prompt.yml             | 2 +-
 .github/prompts/dusk.prompt.yml            | 2 +-
 .github/prompts/enums.prompt.yml           | 2 +-
 .github/prompts/events.prompt.yml          | 2 +-
 .github/prompts/exceptions.prompt.yml      | 2 +-
 .github/prompts/formrequests.prompt.yml    | 2 +-
 .github/prompts/general.prompt.yml         | 2 +-
 .github/prompts/helperfunctions.prompt.yml | 2 +-
 .github/prompts/helpers.prompt.yml         | 2 +-
 .github/prompts/interfaces.prompt.yml      | 2 +-
 .github/prompts/jobs.prompt.yml            | 2 +-
 .github/prompts/livewire.prompt.yml        | 2 +-
 .github/prompts/middleware.prompt.yml      | 2 +-
 .github/prompts/migrations.prompt.yml      | 2 +-
 .github/prompts/models.prompt.yml          | 2 +-
 .github/prompts/observers.prompt.yml       | 2 +-
 .github/prompts/pesttesting.prompt.yml     | 2 +-
 .github/prompts/php.prompt.yml             | 2 +-
 .github/prompts/phpstan.prompt.yml         | 2 +-
 .github/prompts/phpunit.prompt.yml         | 2 +-
 .github/prompts/policies.prompt.yml        | 2 +-
 .github/prompts/requests.prompt.yml        | 2 +-
 .github/prompts/resources.prompt.yml       | 2 +-
 .github/prompts/routing.prompt.yml         | 2 +-
 .github/prompts/saloon.prompt.yml          | 2 +-
 .github/prompts/services.prompt.yml        | 2 +-
 .github/prompts/tailwind.prompt.yml        | 2 +-
 .github/prompts/traits.prompt.yml          | 2 +-
 .github/prompts/translations.prompt.yml    | 2 +-
 36 files changed, 36 insertions(+), 36 deletions(-)

diff --git a/.github/prompts/actions.prompt.yml b/.github/prompts/actions.prompt.yml
index eb54be5..8365cbe 100644
--- a/.github/prompts/actions.prompt.yml
+++ b/.github/prompts/actions.prompt.yml
@@ -10,7 +10,7 @@ messages:
     content: |
       Write a CreateInvoice Action class. It receives an Order, creates an Invoice, and returns it.
       Use execute() method and constructor dependency injection. No HTTP concerns.
-model: openai/gpt-4o
+model: openai/gpt-4o-mini
 modelParameters:
   temperature: 0.2
   maxCompletionTokens: 512
diff --git a/.github/prompts/albatros.prompt.yml b/.github/prompts/albatros.prompt.yml
index 6ca064f..a7f257d 100644
--- a/.github/prompts/albatros.prompt.yml
+++ b/.github/prompts/albatros.prompt.yml
@@ -10,7 +10,7 @@ messages:
     content: |
       Write an AlbatrosConnector extending Saloon Connector. Use config('albatros.base_url'), Mandant header, Bearer token.
       Use Cache for reference data. German domain terms in DTOs are acceptable.
-model: openai/gpt-4o
+model: openai/gpt-4o-mini
 modelParameters:
   temperature: 0.2
   maxCompletionTokens: 512
diff --git a/.github/prompts/blade.prompt.yml b/.github/prompts/blade.prompt.yml
index 44f842d..4f7402f 100644
--- a/.github/prompts/blade.prompt.yml
+++ b/.github/prompts/blade.prompt.yml
@@ -10,7 +10,7 @@ messages:
     content: |
       Write a Blade component that displays a user's name and email. Use {{ }} for escaped output.
       No inline style or script tags. Use x-component syntax.
-model: openai/gpt-4o
+model: openai/gpt-4o-mini
 modelParameters:
   temperature: 0.2
   maxCompletionTokens: 384
diff --git a/.github/prompts/commands.prompt.yml b/.github/prompts/commands.prompt.yml
index 45e3f93..7339676 100644
--- a/.github/prompts/commands.prompt.yml
+++ b/.github/prompts/commands.prompt.yml
@@ -10,7 +10,7 @@ messages:
     content: |
       Write an Artisan command invoices:send-reminders with required email argument and --dry-run option.
       Delegate to SendInvoiceReminderAction. Return self::SUCCESS or self::FAILURE. Validate input.
-model: openai/gpt-4o
+model: openai/gpt-4o-mini
 modelParameters:
   temperature: 0.2
   maxCompletionTokens: 512
diff --git a/.github/prompts/controllers.prompt.yml b/.github/prompts/controllers.prompt.yml
index b734da3..0b30014 100644
--- a/.github/prompts/controllers.prompt.yml
+++ b/.github/prompts/controllers.prompt.yml
@@ -10,7 +10,7 @@ messages:
     content: |
       Write an invokable StoreInvoiceController that receives StoreInvoiceRequest, calls a CreateInvoice action,
       and returns a JsonResponse with InvoiceResource. No business logic in the controller.
-model: openai/gpt-4o
+model: openai/gpt-4o-mini
 modelParameters:
   temperature: 0.2
   maxCompletionTokens: 512
diff --git a/.github/prompts/design.prompt.yml b/.github/prompts/design.prompt.yml
index 0138de8..f658312 100644
--- a/.github/prompts/design.prompt.yml
+++ b/.github/prompts/design.prompt.yml
@@ -10,7 +10,7 @@ messages:
     content: |
       Write an anonymous Blade button component with @props for variant and size. Merge $attributes with defaults.
       Use min-h-[44px] for touch target, focus-visible:ring-2. Mobile-first.
-model: openai/gpt-4o
+model: openai/gpt-4o-mini
 modelParameters:
   temperature: 0.2
   maxCompletionTokens: 512
diff --git a/.github/prompts/docuware.prompt.yml b/.github/prompts/docuware.prompt.yml
index 179f6cc..513e1c3 100644
--- a/.github/prompts/docuware.prompt.yml
+++ b/.github/prompts/docuware.prompt.yml
@@ -10,7 +10,7 @@ messages:
     content: |
       Write a DocuWareService that wraps the DocuWare connector. Constructor accepts optional connector for testability.
       Use config('laravel-docuware.credentials.*') not env(). Include fetchDocument or similar method signature.
-model: openai/gpt-4o
+model: openai/gpt-4o-mini
 modelParameters:
   temperature: 0.2
   maxCompletionTokens: 512
diff --git a/.github/prompts/dto.prompt.yml b/.github/prompts/dto.prompt.yml
index f6f475d..5579d6b 100644
--- a/.github/prompts/dto.prompt.yml
+++ b/.github/prompts/dto.prompt.yml
@@ -10,7 +10,7 @@ messages:
     content: |
       Write a readonly CustomerData DTO with id, name, email. Include fromArray() factory that handles
       PascalCase and snake_case API field names. Use nullable for optional fields.
-model: openai/gpt-4o
+model: openai/gpt-4o-mini
 modelParameters:
   temperature: 0.2
   maxCompletionTokens: 512
diff --git a/.github/prompts/dusk.prompt.yml b/.github/prompts/dusk.prompt.yml
index 7b4292a..8f92d68 100644
--- a/.github/prompts/dusk.prompt.yml
+++ b/.github/prompts/dusk.prompt.yml
@@ -10,7 +10,7 @@ messages:
     content: |
       Write a Dusk test that logs in, visits /invoices/create, uses dusk="" selectors, calls assertNoJavaScriptErrors().
       Use DatabaseTruncation. Use loginAs(), waitForText, never pause().
-model: openai/gpt-4o
+model: openai/gpt-4o-mini
 modelParameters:
   temperature: 0.2
   maxCompletionTokens: 512
diff --git a/.github/prompts/enums.prompt.yml b/.github/prompts/enums.prompt.yml
index b0c47a1..85984b1 100644
--- a/.github/prompts/enums.prompt.yml
+++ b/.github/prompts/enums.prompt.yml
@@ -10,7 +10,7 @@ messages:
     content: |
       Write a Status enum with Draft, Active, Archived. Include label() and color() methods using match expressions.
       Use backed string enum.
-model: openai/gpt-4o
+model: openai/gpt-4o-mini
 modelParameters:
   temperature: 0.2
   maxCompletionTokens: 512
diff --git a/.github/prompts/events.prompt.yml b/.github/prompts/events.prompt.yml
index 8b948d4..2c67ac5 100644
--- a/.github/prompts/events.prompt.yml
+++ b/.github/prompts/events.prompt.yml
@@ -10,7 +10,7 @@ messages:
     content: |
       Write an InvoicePaid event (plain data container with Invoice) and a SendInvoicePaidNotification listener.
       Event uses Dispatchable, SerializesModels. Listener has single responsibility. Use past-tense for event name.
-model: openai/gpt-4o
+model: openai/gpt-4o-mini
 modelParameters:
   temperature: 0.2
   maxCompletionTokens: 512
diff --git a/.github/prompts/exceptions.prompt.yml b/.github/prompts/exceptions.prompt.yml
index 5e9f97f..493c99b 100644
--- a/.github/prompts/exceptions.prompt.yml
+++ b/.github/prompts/exceptions.prompt.yml
@@ -10,7 +10,7 @@ messages:
     content: |
       Write an InvoiceAlreadyPaidException that extends RuntimeException. It receives an Invoice as readonly property
       and sets a clear message via parent::__construct(). Use a named failure state.
-model: openai/gpt-4o
+model: openai/gpt-4o-mini
 modelParameters:
   temperature: 0.2
   maxCompletionTokens: 384
diff --git a/.github/prompts/formrequests.prompt.yml b/.github/prompts/formrequests.prompt.yml
index 7a362c2..50dd9f9 100644
--- a/.github/prompts/formrequests.prompt.yml
+++ b/.github/prompts/formrequests.prompt.yml
@@ -11,7 +11,7 @@ messages:
       Write a StoreInvoiceRequest with authorize() and rules() returning array-based rules.
       Rules: order_id required exists in orders, amount required numeric min 0.
       Add PHPDoc @return for rules().
-model: openai/gpt-4o
+model: openai/gpt-4o-mini
 modelParameters:
   temperature: 0.2
   maxCompletionTokens: 512
diff --git a/.github/prompts/general.prompt.yml b/.github/prompts/general.prompt.yml
index 3bc0e44..eb0559e 100644
--- a/.github/prompts/general.prompt.yml
+++ b/.github/prompts/general.prompt.yml
@@ -10,7 +10,7 @@ messages:
     content: |
       Add a Stripe API key to the Laravel config and show how to read it in a controller.
       Use the correct helper for config access. Show the config file addition and one line of controller code.
-model: openai/gpt-4o
+model: openai/gpt-4o-mini
 modelParameters:
   temperature: 0.2
   maxCompletionTokens: 512
diff --git a/.github/prompts/helperfunctions.prompt.yml b/.github/prompts/helperfunctions.prompt.yml
index 4f2e3a4..9106477 100644
--- a/.github/prompts/helperfunctions.prompt.yml
+++ b/.github/prompts/helperfunctions.prompt.yml
@@ -10,7 +10,7 @@ messages:
     content: |
       Write PHP code to filter an array of users to only active ones, then get their email addresses as a comma-separated string.
       Use Laravel Arr and Str helpers instead of native PHP functions.
-model: openai/gpt-4o
+model: openai/gpt-4o-mini
 modelParameters:
   temperature: 0.2
   maxCompletionTokens: 512
diff --git a/.github/prompts/helpers.prompt.yml b/.github/prompts/helpers.prompt.yml
index 27d7818..9916643 100644
--- a/.github/prompts/helpers.prompt.yml
+++ b/.github/prompts/helpers.prompt.yml
@@ -10,7 +10,7 @@ messages:
     content: |
       Write a DateHelper class with a static format() method that accepts a date and format string, returns formatted string or null.
       Use Carbon. No business logic, no database queries. PascalCase with Helper suffix.
-model: openai/gpt-4o
+model: openai/gpt-4o-mini
 modelParameters:
   temperature: 0.2
   maxCompletionTokens: 384
diff --git a/.github/prompts/interfaces.prompt.yml b/.github/prompts/interfaces.prompt.yml
index 25f51ea..1474d0a 100644
--- a/.github/prompts/interfaces.prompt.yml
+++ b/.github/prompts/interfaces.prompt.yml
@@ -10,7 +10,7 @@ messages:
     content: |
       Write a PaymentGateway interface in app/Contracts/ with charge(Order, int) and refund(string, int) methods.
       Return a PaymentResult. No implementation. Clear noun describing the capability.
-model: openai/gpt-4o
+model: openai/gpt-4o-mini
 modelParameters:
   temperature: 0.2
   maxCompletionTokens: 384
diff --git a/.github/prompts/jobs.prompt.yml b/.github/prompts/jobs.prompt.yml
index 03e04db..49b05f9 100644
--- a/.github/prompts/jobs.prompt.yml
+++ b/.github/prompts/jobs.prompt.yml
@@ -10,7 +10,7 @@ messages:
     content: |
       Write a ProcessInvoicePaymentJob that implements ShouldQueue. Delegate to ProcessInvoicePayment action.
       Use Dispatchable, InteractsWithQueue, Queueable, SerializesModels. Set tries, backoff, queue. Add failed() method.
-model: openai/gpt-4o
+model: openai/gpt-4o-mini
 modelParameters:
   temperature: 0.2
   maxCompletionTokens: 512
diff --git a/.github/prompts/livewire.prompt.yml b/.github/prompts/livewire.prompt.yml
index 1ee5509..54e63c7 100644
--- a/.github/prompts/livewire.prompt.yml
+++ b/.github/prompts/livewire.prompt.yml
@@ -10,7 +10,7 @@ messages:
     content: |
       Write a Livewire InvoiceList component with search property, #[Computed] invoices(), and wire:model/wire:click.
       Keep logic in PHP, template declarative. Use wire:model for search binding.
-model: openai/gpt-4o
+model: openai/gpt-4o-mini
 modelParameters:
   temperature: 0.2
   maxCompletionTokens: 512
diff --git a/.github/prompts/middleware.prompt.yml b/.github/prompts/middleware.prompt.yml
index bb38228..290c471 100644
--- a/.github/prompts/middleware.prompt.yml
+++ b/.github/prompts/middleware.prompt.yml
@@ -10,7 +10,7 @@ messages:
     content: |
       Write an EnsureUserIsSubscribed middleware. If user is not subscribed, return 403 JSON response.
       Otherwise call $next($request). Clear descriptive name. No business logic inside.
-model: openai/gpt-4o
+model: openai/gpt-4o-mini
 modelParameters:
   temperature: 0.2
   maxCompletionTokens: 384
diff --git a/.github/prompts/migrations.prompt.yml b/.github/prompts/migrations.prompt.yml
index 187d158..da7aeb7 100644
--- a/.github/prompts/migrations.prompt.yml
+++ b/.github/prompts/migrations.prompt.yml
@@ -10,7 +10,7 @@ messages:
     content: |
       Write a migration to create an invoices table with id, order_id (foreign key), status (string default draft), amount (decimal), timestamps.
       Use foreignId()->constrained()->cascadeOnDelete(). Include both up() and down() methods.
-model: openai/gpt-4o
+model: openai/gpt-4o-mini
 modelParameters:
   temperature: 0.2
   maxCompletionTokens: 512
diff --git a/.github/prompts/models.prompt.yml b/.github/prompts/models.prompt.yml
index ad0f67a..3ad494e 100644
--- a/.github/prompts/models.prompt.yml
+++ b/.github/prompts/models.prompt.yml
@@ -10,7 +10,7 @@ messages:
     content: |
       Write a minimal Invoice Eloquent model with guarded, casts as method, and a belongsTo Order relationship.
       Use typed return type on the relationship. Include section comment headers.
-model: openai/gpt-4o
+model: openai/gpt-4o-mini
 modelParameters:
   temperature: 0.2
   maxCompletionTokens: 512
diff --git a/.github/prompts/observers.prompt.yml b/.github/prompts/observers.prompt.yml
index cea8529..6596e0b 100644
--- a/.github/prompts/observers.prompt.yml
+++ b/.github/prompts/observers.prompt.yml
@@ -10,7 +10,7 @@ messages:
     content: |
       Write a UserObserver with created() that sends WelcomeNotification, and updated()/deleted() that clear cache.
       Use Observer suffix. Only define methods you need. No business logic.
-model: openai/gpt-4o
+model: openai/gpt-4o-mini
 modelParameters:
   temperature: 0.2
   maxCompletionTokens: 384
diff --git a/.github/prompts/pesttesting.prompt.yml b/.github/prompts/pesttesting.prompt.yml
index 8113966..15faa12 100644
--- a/.github/prompts/pesttesting.prompt.yml
+++ b/.github/prompts/pesttesting.prompt.yml
@@ -10,7 +10,7 @@ messages:
     content: |
       Write a Pest test it('creates an invoice for the given order') with AAA pattern and Arrange/Act/Assert comments.
       Use uses(RefreshDatabase::class), postJson, assertCreated(), expect()->toBe(). Plain English description.
-model: openai/gpt-4o
+model: openai/gpt-4o-mini
 modelParameters:
   temperature: 0.2
   maxCompletionTokens: 512
diff --git a/.github/prompts/php.prompt.yml b/.github/prompts/php.prompt.yml
index 2027075..e46c1b9 100644
--- a/.github/prompts/php.prompt.yml
+++ b/.github/prompts/php.prompt.yml
@@ -10,7 +10,7 @@ messages:
     content: |
       Write a process(Order $order) method with early returns. If !$order->isPaid() throw exception and return.
       If !$order->hasItems() throw and return. Then happy-path logic. No else/elseif. Use guard clauses.
-model: openai/gpt-4o
+model: openai/gpt-4o-mini
 modelParameters:
   temperature: 0.2
   maxCompletionTokens: 512
diff --git a/.github/prompts/phpstan.prompt.yml b/.github/prompts/phpstan.prompt.yml
index 9dab006..4bcab75 100644
--- a/.github/prompts/phpstan.prompt.yml
+++ b/.github/prompts/phpstan.prompt.yml
@@ -10,7 +10,7 @@ messages:
     content: |
       Write a method process(Order $order): Invoice with full type hints. Add PHPDoc @return array<string, array<int, string|object>> for a rules() method.
       Use union types instead of mixed. No @phpstan-ignore.
-model: openai/gpt-4o
+model: openai/gpt-4o-mini
 modelParameters:
   temperature: 0.2
   maxCompletionTokens: 512
diff --git a/.github/prompts/phpunit.prompt.yml b/.github/prompts/phpunit.prompt.yml
index 6eec075..4f079f8 100644
--- a/.github/prompts/phpunit.prompt.yml
+++ b/.github/prompts/phpunit.prompt.yml
@@ -10,7 +10,7 @@ messages:
     content: |
       Write a feature test test_user_can_create_invoice. Use RefreshDatabase, factories, actingAs.
       Assert 201 and assertDatabaseHas. Use test_ prefix and : void return type.
-model: openai/gpt-4o
+model: openai/gpt-4o-mini
 modelParameters:
   temperature: 0.2
   maxCompletionTokens: 512
diff --git a/.github/prompts/policies.prompt.yml b/.github/prompts/policies.prompt.yml
index 2cc0436..fdfb351 100644
--- a/.github/prompts/policies.prompt.yml
+++ b/.github/prompts/policies.prompt.yml
@@ -10,7 +10,7 @@ messages:
     content: |
       Write an InvoicePolicy with viewAny (admin only), view (owner or admin), create (authenticated).
       Use Policy suffix. Standard ability names.
-model: openai/gpt-4o
+model: openai/gpt-4o-mini
 modelParameters:
   temperature: 0.2
   maxCompletionTokens: 512
diff --git a/.github/prompts/requests.prompt.yml b/.github/prompts/requests.prompt.yml
index 0198589..4584210 100644
--- a/.github/prompts/requests.prompt.yml
+++ b/.github/prompts/requests.prompt.yml
@@ -10,7 +10,7 @@ messages:
     content: |
       Write a StoreInvoiceRequest with authorize() using can('create', Invoice::class) and rules() with array-based definitions.
       Add PHPDoc @return for rules(). Never use $request->validate() in controller.
-model: openai/gpt-4o
+model: openai/gpt-4o-mini
 modelParameters:
   temperature: 0.2
   maxCompletionTokens: 512
diff --git a/.github/prompts/resources.prompt.yml b/.github/prompts/resources.prompt.yml
index 0ed9902..c7e6db8 100644
--- a/.github/prompts/resources.prompt.yml
+++ b/.github/prompts/resources.prompt.yml
@@ -10,7 +10,7 @@ messages:
     content: |
       Write a UserResource extending JsonResource. Return id, name, email, posts (whenLoaded), created_at (formatted).
       Use whenLoaded for relations. Use when() for conditional admin-only secret field.
-model: openai/gpt-4o
+model: openai/gpt-4o-mini
 modelParameters:
   temperature: 0.2
   maxCompletionTokens: 512
diff --git a/.github/prompts/routing.prompt.yml b/.github/prompts/routing.prompt.yml
index 2b8f850..5265a06 100644
--- a/.github/prompts/routing.prompt.yml
+++ b/.github/prompts/routing.prompt.yml
@@ -10,7 +10,7 @@ messages:
     content: |
       Write API routes for invoices: index and store. Use auth:sanctum middleware, apiResource, and resourceful route names.
       Group them properly. Use kebab-case for URL.
-model: openai/gpt-4o
+model: openai/gpt-4o-mini
 modelParameters:
   temperature: 0.2
   maxCompletionTokens: 384
diff --git a/.github/prompts/saloon.prompt.yml b/.github/prompts/saloon.prompt.yml
index 3032f9a..9d01368 100644
--- a/.github/prompts/saloon.prompt.yml
+++ b/.github/prompts/saloon.prompt.yml
@@ -10,7 +10,7 @@ messages:
     content: |
       Write a StripeConnector extending Saloon Connector with resolveBaseUrl and defaultHeaders.
       Write a ListChargesRequest for GET. No Http::get() or raw HTTP. Use Saloon pattern.
-model: openai/gpt-4o
+model: openai/gpt-4o-mini
 modelParameters:
   temperature: 0.2
   maxCompletionTokens: 512
diff --git a/.github/prompts/services.prompt.yml b/.github/prompts/services.prompt.yml
index 67f8199..f8524a3 100644
--- a/.github/prompts/services.prompt.yml
+++ b/.github/prompts/services.prompt.yml
@@ -10,7 +10,7 @@ messages:
     content: |
       Write a PaymentService that orchestrates CreateInvoice, ChargePaymentMethod, SendPaymentConfirmation actions.
       Method processOrderPayment(Order) uses DB::transaction. Inject actions via constructor. No Manager/Handler suffix.
-model: openai/gpt-4o
+model: openai/gpt-4o-mini
 modelParameters:
   temperature: 0.2
   maxCompletionTokens: 512
diff --git a/.github/prompts/tailwind.prompt.yml b/.github/prompts/tailwind.prompt.yml
index e06ad96..460c1e7 100644
--- a/.github/prompts/tailwind.prompt.yml
+++ b/.github/prompts/tailwind.prompt.yml
@@ -10,7 +10,7 @@ messages:
     content: |
       Write the resources/css/app.css for Tailwind v4 with @theme directive setting --color-primary-500 and --font-sans.
       Include @source for views and Livewire. No custom CSS classes.
-model: openai/gpt-4o
+model: openai/gpt-4o-mini
 modelParameters:
   temperature: 0.2
   maxCompletionTokens: 384
diff --git a/.github/prompts/traits.prompt.yml b/.github/prompts/traits.prompt.yml
index 749c9b4..dcf4a2e 100644
--- a/.github/prompts/traits.prompt.yml
+++ b/.github/prompts/traits.prompt.yml
@@ -10,7 +10,7 @@ messages:
     content: |
       Write an Archivable trait with archive(), unarchive(), isArchived() methods for models with archived_at.
       Use -able suffix. Single responsibility. No complex business logic.
-model: openai/gpt-4o
+model: openai/gpt-4o-mini
 modelParameters:
   temperature: 0.2
   maxCompletionTokens: 384
diff --git a/.github/prompts/translations.prompt.yml b/.github/prompts/translations.prompt.yml
index c49218e..b9ca04c 100644
--- a/.github/prompts/translations.prompt.yml
+++ b/.github/prompts/translations.prompt.yml
@@ -10,7 +10,7 @@ messages:
     content: |
       Write lang/en/invoices.php with create_success key using :name placeholder.
       Show usage with __('invoices.create_success', ['name' => $name]). Use namespaced keys.
-model: openai/gpt-4o
+model: openai/gpt-4o-mini
 modelParameters:
   temperature: 0.2
   maxCompletionTokens: 384

From 53b8218b375d5c66626feb246f27ef8d2026e8e9 Mon Sep 17 00:00:00 2001
From: Sebastian Fix <sebastian.fix@codebar.ch>
Date: Fri, 27 Feb 2026 23:53:34 +0100
Subject: [PATCH 9/9] Disabled Skill Test

---
 .github/workflows/skill-integration.yml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.github/workflows/skill-integration.yml b/.github/workflows/skill-integration.yml
index 40603e7..8041f12 100644
--- a/.github/workflows/skill-integration.yml
+++ b/.github/workflows/skill-integration.yml
@@ -17,6 +17,7 @@ permissions:
 
 jobs:
   skill-tests:
+    if: false  # Disabled until GitHub Models 403 is fixed
     runs-on: ubuntu-latest
     strategy:
       fail-fast: false