@cubis/foundry 0.3.83 → 0.3.84

package/workflows/workflows/agent-environment-setup/platforms/codex/skills/laravel/evals/evals.json

@@ -1,66 +0,0 @@
-[
-  {
-    "name": "api-resource-with-eloquent-relationships",
-    "description": "Validate that the skill produces a correct Laravel API Resource backed by Eloquent relationships with eager loading and proper JSON structure.",
-    "prompt": "Create a Laravel 11 API resource for an Order model that belongs to a Customer and has many OrderItems. Each OrderItem belongs to a Product. Return nested JSON with customer name, order total, and line items with product name and quantity. Include the controller, resource classes, and route registration.",
-    "assertions": [
-      {
-        "type": "contains",
-        "value": "JsonResource",
-        "description": "Must use Laravel API Resource (JsonResource) for response shaping."
-      },
-      {
-        "type": "contains",
-        "value": "with(",
-        "description": "Must eager-load relationships using with() to prevent N+1 queries."
-      },
-      {
-        "type": "contains",
-        "value": "belongsTo",
-        "description": "Must define belongsTo relationship on the Order model for Customer."
-      },
-      {
-        "type": "contains",
-        "value": "hasMany",
-        "description": "Must define hasMany relationship on the Order model for OrderItems."
-      },
-      {
-        "type": "contains",
-        "value": "Route::",
-        "description": "Must include route registration for the API resource endpoint."
-      }
-    ]
-  },
-  {
-    "name": "queue-based-job-processing",
-    "description": "Validate that the skill produces a robust queued job with retry logic, backoff, failure handling, and event-driven dispatch.",
-    "prompt": "Create a Laravel 11 queued job that processes a payment via a third-party API. The job should have exponential backoff, a maximum of 5 retries, a failed() method that notifies an admin, and be dispatched from a PaymentController after an order is created. Include the event/listener pattern for triggering post-payment side effects.",
-    "assertions": [
-      {
-        "type": "contains",
-        "value": "implements ShouldQueue",
-        "description": "Must implement ShouldQueue interface for async queue processing."
-      },
-      {
-        "type": "contains",
-        "value": "backoff",
-        "description": "Must define backoff strategy (exponential or array-based) for retry delays."
-      },
-      {
-        "type": "contains",
-        "value": "failed(",
-        "description": "Must implement failed() method for handling permanent job failures."
-      },
-      {
-        "type": "contains",
-        "value": "dispatch(",
-        "description": "Must dispatch the job from the controller or service layer."
-      },
-      {
-        "type": "contains",
-        "value": "event(",
-        "description": "Must use event dispatch for post-payment side effects decoupled from the job."
-      }
-    ]
-  }
-]

package/workflows/workflows/agent-environment-setup/platforms/codex/skills/laravel/examples/01-api-resource-with-relationships.md

@@ -1,180 +0,0 @@
-# Example: API Resource with Eloquent Relationships
-
-## Scenario
-
-Build a JSON API endpoint that returns orders with nested customer and line-item data. The response must avoid N+1 queries and hide internal database columns from the public contract.
-
-## Models
-
-```php
-// app/Models/Order.php
-<?php
-
-declare(strict_types=1);
-
-namespace App\Models;
-
-use Illuminate\Database\Eloquent\Factories\HasFactory;
-use Illuminate\Database\Eloquent\Model;
-use Illuminate\Database\Eloquent\Relations\BelongsTo;
-use Illuminate\Database\Eloquent\Relations\HasMany;
-
-class Order extends Model
-{
-    use HasFactory;
-
-    protected $fillable = ['customer_id', 'status', 'total_cents'];
-
-    public function customer(): BelongsTo
-    {
-        return $this->belongsTo(Customer::class);
-    }
-
-    public function items(): HasMany
-    {
-        return $this->hasMany(OrderItem::class);
-    }
-}
-```
-
-```php
-// app/Models/OrderItem.php
-<?php
-
-declare(strict_types=1);
-
-namespace App\Models;
-
-use Illuminate\Database\Eloquent\Factories\HasFactory;
-use Illuminate\Database\Eloquent\Model;
-use Illuminate\Database\Eloquent\Relations\BelongsTo;
-
-class OrderItem extends Model
-{
-    use HasFactory;
-
-    protected $fillable = ['order_id', 'product_id', 'quantity', 'unit_price_cents'];
-
-    public function order(): BelongsTo
-    {
-        return $this->belongsTo(Order::class);
-    }
-
-    public function product(): BelongsTo
-    {
-        return $this->belongsTo(Product::class);
-    }
-}
-```
-
-## API Resources
-
-```php
-// app/Http/Resources/OrderItemResource.php
-<?php
-
-declare(strict_types=1);
-
-namespace App\Http\Resources;
-
-use Illuminate\Http\Request;
-use Illuminate\Http\Resources\Json\JsonResource;
-
-class OrderItemResource extends JsonResource
-{
-    public function toArray(Request $request): array
-    {
-        return [
-            'id'              => $this->id,
-            'product_name'    => $this->product->name,
-            'quantity'        => $this->quantity,
-            'unit_price'      => $this->unit_price_cents / 100,
-            'line_total'      => ($this->unit_price_cents * $this->quantity) / 100,
-        ];
-    }
-}
-```
-
-```php
-// app/Http/Resources/OrderResource.php
-<?php
-
-declare(strict_types=1);
-
-namespace App\Http\Resources;
-
-use Illuminate\Http\Request;
-use Illuminate\Http\Resources\Json\JsonResource;
-
-class OrderResource extends JsonResource
-{
-    public function toArray(Request $request): array
-    {
-        return [
-            'id'            => $this->id,
-            'status'        => $this->status,
-            'total'         => $this->total_cents / 100,
-            'customer'      => [
-                'id'   => $this->customer->id,
-                'name' => $this->customer->name,
-            ],
-            'items'         => OrderItemResource::collection($this->items),
-            'created_at'    => $this->created_at->toIso8601String(),
-        ];
-    }
-}
-```
-
-## Controller
-
-```php
-// app/Http/Controllers/Api/OrderController.php
-<?php
-
-declare(strict_types=1);
-
-namespace App\Http\Controllers\Api;
-
-use App\Http\Controllers\Controller;
-use App\Http\Resources\OrderResource;
-use App\Models\Order;
-use Illuminate\Http\Resources\Json\AnonymousResourceCollection;
-
-class OrderController extends Controller
-{
-    public function index(): AnonymousResourceCollection
-    {
-        $orders = Order::with(['customer', 'items.product'])
-            ->latest()
-            ->paginate(25);
-
-        return OrderResource::collection($orders);
-    }
-
-    public function show(Order $order): OrderResource
-    {
-        $order->load(['customer', 'items.product']);
-
-        return new OrderResource($order);
-    }
-}
-```
-
-## Route Registration
-
-```php
-// routes/api.php
-use App\Http\Controllers\Api\OrderController;
-use Illuminate\Support\Facades\Route;
-
-Route::middleware('auth:sanctum')->group(function () {
-    Route::apiResource('orders', OrderController::class)->only(['index', 'show']);
-});
-```
-
-## Key Decisions
-
-- **Eager loading**: `with(['customer', 'items.product'])` eliminates N+1 queries across three relationship levels.
-- **Resource isolation**: `OrderResource` and `OrderItemResource` control exactly which fields reach the client, decoupling the API contract from the database schema.
-- **Pagination**: `paginate(25)` prevents unbounded result sets. The resource collection automatically includes pagination metadata.
-- **Sanctum middleware**: Protects the endpoint. Replace with `auth:api` if using Passport.

package/workflows/workflows/agent-environment-setup/platforms/codex/skills/laravel/examples/02-queue-job-with-retry-and-events.md

@@ -1,229 +0,0 @@
-# Example: Queue Job with Retry Logic and Event Dispatch
-
-## Scenario
-
-Process a payment through a third-party API asynchronously. The job must retry with exponential backoff, notify an admin on permanent failure, and fire an event after successful payment so downstream listeners can handle side effects independently.
-
-## Queued Job
-
-```php
-// app/Jobs/ProcessPayment.php
-<?php
-
-declare(strict_types=1);
-
-namespace App\Jobs;
-
-use App\Events\PaymentCompleted;
-use App\Models\Order;
-use App\Notifications\PaymentFailedNotification;
-use App\Services\PaymentGateway;
-use Illuminate\Bus\Queueable;
-use Illuminate\Contracts\Queue\ShouldQueue;
-use Illuminate\Foundation\Bus\Dispatchable;
-use Illuminate\Queue\InteractsWithQueue;
-use Illuminate\Queue\SerializesModels;
-use Illuminate\Support\Facades\Log;
-use Illuminate\Support\Facades\Notification;
-use Throwable;
-
-class ProcessPayment implements ShouldQueue
-{
-    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;
-
-    public int $tries = 5;
-
-    public int $maxExceptions = 3;
-
-    public int $timeout = 30;
-
-    public function __construct(
-        public readonly Order $order,
-    ) {}
-
-    /**
-     * Exponential backoff: 10s, 30s, 90s, 270s, 810s.
-     */
-    public function backoff(): array
-    {
-        return [10, 30, 90, 270, 810];
-    }
-
-    public function handle(PaymentGateway $gateway): void
-    {
-        Log::info('Processing payment', ['order_id' => $this->order->id]);
-
-        $result = $gateway->charge(
-            amount: $this->order->total_cents,
-            currency: 'usd',
-            customerId: $this->order->customer->stripe_id,
-        );
-
-        $this->order->update([
-            'status'             => 'paid',
-            'payment_reference'  => $result->transactionId,
-        ]);
-
-        event(new PaymentCompleted($this->order));
-    }
-
-    public function failed(Throwable $exception): void
-    {
-        Log::error('Payment failed permanently', [
-            'order_id'  => $this->order->id,
-            'error'     => $exception->getMessage(),
-        ]);
-
-        $this->order->update(['status' => 'payment_failed']);
-
-        Notification::route('mail', config('app.admin_email'))
-            ->notify(new PaymentFailedNotification($this->order, $exception));
-    }
-}
-```
-
-## Event and Listener
-
-```php
-// app/Events/PaymentCompleted.php
-<?php
-
-declare(strict_types=1);
-
-namespace App\Events;
-
-use App\Models\Order;
-use Illuminate\Foundation\Events\Dispatchable;
-use Illuminate\Queue\SerializesModels;
-
-class PaymentCompleted
-{
-    use Dispatchable, SerializesModels;
-
-    public function __construct(
-        public readonly Order $order,
-    ) {}
-}
-```
-
-```php
-// app/Listeners/SendPaymentReceipt.php
-<?php
-
-declare(strict_types=1);
-
-namespace App\Listeners;
-
-use App\Events\PaymentCompleted;
-use App\Notifications\PaymentReceiptNotification;
-use Illuminate\Contracts\Queue\ShouldQueue;
-
-class SendPaymentReceipt implements ShouldQueue
-{
-    public function handle(PaymentCompleted $event): void
-    {
-        $event->order->customer->notify(
-            new PaymentReceiptNotification($event->order)
-        );
-    }
-}
-```
-
-## Controller Dispatch
-
-```php
-// app/Http/Controllers/Api/PaymentController.php
-<?php
-
-declare(strict_types=1);
-
-namespace App\Http\Controllers\Api;
-
-use App\Http\Controllers\Controller;
-use App\Http\Requests\CreatePaymentRequest;
-use App\Jobs\ProcessPayment;
-use App\Models\Order;
-use Illuminate\Http\JsonResponse;
-use Symfony\Component\HttpFoundation\Response;
-
-class PaymentController extends Controller
-{
-    public function store(CreatePaymentRequest $request, Order $order): JsonResponse
-    {
-        $this->authorize('pay', $order);
-
-        $order->update(['status' => 'processing']);
-
-        ProcessPayment::dispatch($order);
-
-        return response()->json(
-            ['message' => 'Payment is being processed.', 'order_id' => $order->id],
-            Response::HTTP_ACCEPTED,
-        );
-    }
-}
-```
-
-## Feature Test
-
-```php
-// tests/Feature/ProcessPaymentTest.php
-<?php
-
-declare(strict_types=1);
-
-namespace Tests\Feature;
-
-use App\Events\PaymentCompleted;
-use App\Jobs\ProcessPayment;
-use App\Models\Order;
-use Illuminate\Foundation\Testing\RefreshDatabase;
-use Illuminate\Support\Facades\Event;
-use Illuminate\Support\Facades\Queue;
-use Tests\TestCase;
-
-class ProcessPaymentTest extends TestCase
-{
-    use RefreshDatabase;
-
-    public function test_payment_endpoint_dispatches_job(): void
-    {
-        Queue::fake();
-
-        $order = Order::factory()->create(['status' => 'pending']);
-        $user = $order->customer->user;
-
-        $this->actingAs($user)
-            ->postJson("/api/orders/{$order->id}/pay")
-            ->assertStatus(202);
-
-        Queue::assertPushed(ProcessPayment::class, function ($job) use ($order) {
-            return $job->order->id === $order->id;
-        });
-    }
-
-    public function test_successful_payment_fires_event(): void
-    {
-        Event::fake([PaymentCompleted::class]);
-
-        $order = Order::factory()->create(['status' => 'processing']);
-
-        // Simulate the job running synchronously in tests
-        (new ProcessPayment($order))->handle(
-            app(\App\Services\PaymentGateway::class)
-        );
-
-        Event::assertDispatched(PaymentCompleted::class, function ($event) use ($order) {
-            return $event->order->id === $order->id;
-        });
-    }
-}
-```
-
-## Key Decisions
-
-- **Exponential backoff**: The stepped array `[10, 30, 90, 270, 810]` gives the third-party API increasing recovery time.
-- **`maxExceptions = 3`**: Caps distinct exception types to avoid burning retries on the same unrecoverable error.
-- **`failed()` notifies admin**: Permanent failures need human attention; logging alone is insufficient for payment processing.
-- **Event decoupling**: `PaymentCompleted` lets receipt emails, inventory updates, and analytics run independently without bloating the job.
-- **HTTP 202 Accepted**: The controller acknowledges the request without waiting for payment completion.

package/workflows/workflows/agent-environment-setup/platforms/codex/skills/laravel/references/eloquent.md

@@ -1,200 +0,0 @@
-# Eloquent ORM Reference
-
-## Model Definition Patterns
-
-### Fillable vs Guarded
-
-Always declare `$fillable` explicitly. Never rely on an empty `$guarded = []` in production
-because it opens every column to mass assignment.
-
-```php
-// Correct: explicit allow-list
-protected $fillable = ['name', 'email', 'role'];
-
-// Dangerous: allows mass assignment of any column including is_admin
-protected $guarded = [];
-```
-
-### Casts and Accessors
-
-Use `$casts` for type coercion. Use Attribute accessors (Laravel 11 syntax) for
-computed values that do not map to a database column.
-
-```php
-protected function casts(): array
-{
-    return [
-        'email_verified_at' => 'datetime',
-        'settings'          => 'array',
-        'amount_cents'      => 'integer',
-        'is_active'         => 'boolean',
-    ];
-}
-
-protected function fullName(): Attribute
-{
-    return Attribute::make(
-        get: fn () => "{$this->first_name} {$this->last_name}",
-    );
-}
-```
-
-## Relationships
-
-### Defining Relationships
-
-Always type-hint return types on relationship methods. Eloquent uses the method
-return type for IDE support and static analysis.
-
-```php
-public function posts(): HasMany
-{
-    return $this->hasMany(Post::class);
-}
-
-public function profile(): HasOne
-{
-    return $this->hasOne(Profile::class);
-}
-
-public function roles(): BelongsToMany
-{
-    return $this->belongsToMany(Role::class)
-        ->withPivot('assigned_at')
-        ->withTimestamps();
-}
-```
-
-### Polymorphic Relationships
-
-Use morphTo/morphMany for tagging, commenting, and media attachment patterns.
-
-```php
-// On the Comment model
-public function commentable(): MorphTo
-{
-    return $this->morphTo();
-}
-
-// On the Post model
-public function comments(): MorphMany
-{
-    return $this->morphMany(Comment::class, 'commentable');
-}
-```
-
-## Eager Loading
-
-### Preventing N+1 Queries
-
-Use `with()` at query time. Use `load()` on an existing model instance.
-
-```php
-// At query time (preferred)
-$orders = Order::with(['customer', 'items.product'])->get();
-
-// On an existing instance (e.g., route-model binding)
-$order->load(['customer', 'items.product']);
-```
-
-### Constraining Eager Loads
-
-Filter related models without affecting the parent query.
-
-```php
-$users = User::with(['posts' => function (Builder $query) {
-    $query->where('published', true)->latest()->limit(5);
-}])->get();
-```
-
-### Preventing Lazy Loading in Development
-
-Add this to `AppServiceProvider::boot()` to catch N+1 queries during development.
-
-```php
-Model::preventLazyLoading(! app()->isProduction());
-```
-
-## Query Scopes
-
-### Local Scopes
-
-Encapsulate reusable query constraints.
-
-```php
-public function scopeActive(Builder $query): Builder
-{
-    return $query->where('is_active', true);
-}
-
-public function scopeCreatedAfter(Builder $query, Carbon $date): Builder
-{
-    return $query->where('created_at', '>=', $date);
-}
-
-// Usage
-$users = User::active()->createdAfter(now()->subMonth())->get();
-```
-
-### Global Scopes
-
-Apply constraints automatically to every query on a model. Use sparingly
-because they affect all queries including relationships.
-
-```php
-protected static function booted(): void
-{
-    static::addGlobalScope('active', function (Builder $builder) {
-        $builder->where('is_active', true);
-    });
-}
-```
-
-## Factories and Seeders
-
-### Factory Definition (Laravel 11)
-
-```php
-class OrderFactory extends Factory
-{
-    public function definition(): array
-    {
-        return [
-            'customer_id' => Customer::factory(),
-            'status'       => fake()->randomElement(['pending', 'paid', 'shipped']),
-            'total_cents'  => fake()->numberBetween(1000, 500000),
-        ];
-    }
-
-    public function paid(): static
-    {
-        return $this->state(['status' => 'paid']);
-    }
-
-    public function withItems(int $count = 3): static
-    {
-        return $this->has(OrderItem::factory()->count($count));
-    }
-}
-
-// Usage in tests
-$order = Order::factory()->paid()->withItems(5)->create();
-```
-
-## Performance Patterns
-
-- Use `select()` to limit columns when you do not need the full model.
-- Use `chunk()` or `lazy()` for processing large datasets to control memory.
-- Use `toBase()` when you need raw stdClass objects without model hydration.
-- Index foreign keys and columns used in `where`, `orderBy`, and `groupBy`.
-- Use `explain()` to inspect query plans during development.
-
-```php
-// Memory-efficient processing
-Order::where('status', 'pending')
-    ->chunkById(500, function (Collection $orders) {
-        foreach ($orders as $order) {
-            ProcessOrder::dispatch($order);
-        }
-    });
-```