chore(release): v0.18.0 — onboarding module selection + develop features

backend/app/Enums/RevisionLifecycle.php

@@ -0,0 +1,42 @@
+<?php
+
+namespace App\Enums;
+
+/**
+ * Product revision lifecycle. A revision starts as DRAFT (editable, not
+ * selectable for production), is RELEASED once its configuration is approved
+ * (immutable, selectable for new work orders), and finally OBSOLETE (retained
+ * for historical traceability, no longer selectable). Ordered draft < released
+ * < obsolete.
+ */
+enum RevisionLifecycle: string
+{
+    case Draft = 'draft';
+    case Released = 'released';
+    case Obsolete = 'obsolete';
+
+    public function label(): string
+    {
+        return match ($this) {
+            self::Draft => __('Draft'),
+            self::Released => __('Released'),
+            self::Obsolete => __('Obsolete'),
+        };
+    }
+
+    /** Tailwind badge classes used by the front-end lifecycle badge. */
+    public function badgeColor(): string
+    {
+        return match ($this) {
+            self::Draft => 'bg-gray-200 text-gray-700',
+            self::Released => 'bg-green-100 text-green-800',
+            self::Obsolete => 'bg-amber-100 text-amber-800',
+        };
+    }
+
+    /** Only released revisions may be selected for new production orders. */
+    public function isSelectable(): bool
+    {
+        return $this === self::Released;
+    }
+}

backend/app/Http/Controllers/Web/Admin/ProductRevisionController.php

@@ -0,0 +1,129 @@
+<?php
+
+namespace App\Http\Controllers\Web\Admin;
+
+use App\Enums\RevisionLifecycle;
+use App\Http\Controllers\Controller;
+use App\Http\Requests\Web\Admin\StoreProductRevisionRequest;
+use App\Http\Requests\Web\Admin\UpdateProductRevisionRequest;
+use App\Models\ProcessTemplate;
+use App\Models\ProductRevision;
+use App\Models\ProductType;
+use Inertia\Inertia;
+
+class ProductRevisionController extends Controller
+{
+    /**
+     * List revisions. Rows live-sync via the `product_revisions` shape; product
+     * type + template names and work-order counts come as props.
+     */
+    public function index()
+    {
+        $counts = ProductRevision::withCount('workOrders')
+            ->get(['id'])
+            ->mapWithKeys(fn ($r) => [$r->id => $r->work_orders_count]);
+
+        return Inertia::render('admin/product-revisions/Index', [
+            'productTypes' => ProductType::orderBy('name')->get(['id', 'code', 'name']),
+            'processTemplates' => ProcessTemplate::orderBy('name')->get(['id', 'name', 'version', 'product_type_id', 'is_active']),
+            'counts' => $counts,
+        ]);
+    }
+
+    public function create()
+    {
+        return Inertia::render('admin/product-revisions/Create', $this->formOptions());
+    }
+
+    public function store(StoreProductRevisionRequest $request)
+    {
+        $validated = $request->validated();
+        $validated['lifecycle_status'] = RevisionLifecycle::Draft;
+
+        $revision = ProductRevision::create($validated);
+
+        return redirect()->route('admin.product-revisions.index')
+            ->with('success', __('Product revision :code created.', ['code' => $revision->revision_code]));
+    }
+
+    public function edit(ProductRevision $productRevision)
+    {
+        return Inertia::render('admin/product-revisions/Edit', array_merge($this->formOptions(), [
+            'revision' => $productRevision->only(
+                'id', 'product_type_id', 'revision_code', 'description',
+                'process_template_id', 'change_reason', 'external_ref',
+                'lifecycle_status', 'effective_from', 'effective_to'
+            ),
+        ]));
+    }
+
+    public function update(UpdateProductRevisionRequest $request, ProductRevision $productRevision)
+    {
+        // A released or obsolete revision is immutable — its configuration is
+        // frozen so historical work orders stay consistent. Only DRAFT edits.
+        if (! $productRevision->isDraft()) {
+            return back()->with('error', __('Only draft revisions can be edited. Released revisions are immutable.'));
+        }
+
+        $productRevision->update($request->validated());
+
+        return redirect()->route('admin.product-revisions.index')
+            ->with('success', __('Product revision :code updated.', ['code' => $productRevision->revision_code]));
+    }
+
+    public function destroy(ProductRevision $productRevision)
+    {
+        // A revision already used by a work order is kept for traceability.
+        if ($productRevision->workOrders()->exists()) {
+            return back()->with('error', __('Cannot delete a revision that is used by work orders.'));
+        }
+
+        $productRevision->delete();
+
+        return redirect()->route('admin.product-revisions.index')
+            ->with('success', __('Product revision :code deleted.', ['code' => $productRevision->revision_code]));
+    }
+
+    /** DRAFT → RELEASED. Requires a process template so production has a config. */
+    public function release(ProductRevision $productRevision)
+    {
+        if (! $productRevision->isDraft()) {
+            return back()->with('error', __('Only draft revisions can be released.'));
+        }
+
+        if (! $productRevision->process_template_id) {
+            return back()->with('error', __('Select a process template before releasing the revision.'));
+        }
+
+        $productRevision->update([
+            'lifecycle_status' => RevisionLifecycle::Released,
+            'released_at' => now(),
+            'released_by_id' => auth()->id(),
+        ]);
+
+        return back()->with('success', __('Product revision :code released.', ['code' => $productRevision->revision_code]));
+    }
+
+    /** RELEASED → OBSOLETE. Kept for historical traceability, no longer selectable. */
+    public function obsolete(ProductRevision $productRevision)
+    {
+        if (! $productRevision->isReleased()) {
+            return back()->with('error', __('Only released revisions can be made obsolete.'));
+        }
+
+        $productRevision->update([
+            'lifecycle_status' => RevisionLifecycle::Obsolete,
+            'obsolete_at' => now(),
+        ]);
+
+        return back()->with('success', __('Product revision :code marked obsolete.', ['code' => $productRevision->revision_code]));
+    }
+
+    private function formOptions(): array
+    {
+        return [
+            'productTypes' => ProductType::orderBy('name')->get(['id', 'code', 'name']),
+            'processTemplates' => ProcessTemplate::orderBy('name')->get(['id', 'name', 'version', 'product_type_id', 'is_active']),
+        ];
+    }
+}

backend/app/Http/Controllers/Web/Admin/WorkOrderManagementController.php

@@ -44,6 +44,7 @@ public function create(CustomFieldService $customFields)
             'lines' => Line::where('is_active', true)->orderBy('name')->get(['id', 'name']),
             'productTypes' => ProductType::where('is_active', true)->orderBy('name')->get(['id', 'name']),
             'bomTemplates' => $this->bomTemplateOptions(),
+            'productRevisions' => $this->productRevisionOptions(),
             'customers' => Customer::active()->orderBy('name')->get(['id', 'name', 'tier']),
             'customFields' => $customFields->clientConfig('work_order'),
         ]);
@@ -71,6 +72,26 @@ protected function bomTemplateOptions()
             ]);
     }
 
+    /**
+     * Released product revisions (#180) selectable on the work-order forms. Each
+     * option carries its product_type_id so the form can scope it to the order's
+     * product type.
+     *
+     * @return \Illuminate\Support\Collection<int, array<string, mixed>>
+     */
+    protected function productRevisionOptions()
+    {
+        return \App\Models\ProductRevision::selectable()
+            ->orderBy('product_type_id')
+            ->orderBy('revision_code')
+            ->get(['id', 'revision_code', 'product_type_id'])
+            ->map(fn ($r) => [
+                'id' => $r->id,
+                'revision_code' => $r->revision_code,
+                'product_type_id' => $r->product_type_id,
+            ]);
+    }
+
     public function store(StoreWorkOrderRequest $request, CustomFieldService $cf)
     {
         $validated = $request->validated();
@@ -164,7 +185,7 @@ public function edit(WorkOrder $workOrder, CustomFieldService $customFields)
     {
         return Inertia::render('admin/work-orders/Edit', [
             'workOrder' => [
-                ...$workOrder->only('id', 'order_no', 'customer_order_no', 'customer_id', 'line_id', 'product_type_id', 'planned_qty', 'unit_price', 'priority', 'description', 'status', 'custom_fields'),
+                ...$workOrder->only('id', 'order_no', 'customer_order_no', 'customer_id', 'line_id', 'product_type_id', 'product_revision_id', 'planned_qty', 'unit_price', 'counting_source', 'priority', 'description', 'status', 'custom_fields'),
                 'due_date' => $workOrder->due_date?->format('Y-m-d'),
                 // Current BOM selection (empty for legacy single-BOM orders).
                 'bom_template_ids' => $workOrder->bomTemplates()->pluck('process_templates.id')->all(),
@@ -174,6 +195,7 @@ public function edit(WorkOrder $workOrder, CustomFieldService $customFields)
             'lines' => Line::where('is_active', true)->orderBy('name')->get(['id', 'name']),
             'productTypes' => ProductType::where('is_active', true)->orderBy('name')->get(['id', 'name']),
             'bomTemplates' => $this->bomTemplateOptions(),
+            'productRevisions' => $this->productRevisionOptions(),
             'customers' => Customer::active()->orderBy('name')->get(['id', 'name', 'tier']),
             'customFields' => $customFields->clientConfig('work_order'),
         ]);
@@ -229,6 +251,16 @@ public function update(UpdateWorkOrderRequest $request, WorkOrder $workOrder, Cu
                 ->with('error', 'Cannot change BOMs after production has started.');
         }
 
+        // A product revision (#180) may be changed freely before production, but
+        // once batches exist the change must go through the controlled change
+        // workflow (#182) — reject it here to keep the as-built revision honest.
+        $revisionChanged = array_key_exists('product_revision_id', $validated)
+            && (int) $validated['product_revision_id'] !== (int) $workOrder->product_revision_id;
+        if ($revisionChanged && $workOrder->batches()->exists()) {
+            return redirect()->back()->withInput()
+                ->with('error', 'Cannot change the product revision after production has started.');
+        }
+
         // Field edits and the BOM re-selection commit together (or not at all).
         try {
             DB::transaction(function () use ($workOrder, $validated, $requested) {

backend/app/Http/Controllers/Web/Admin/WorkerController.php

@@ -105,6 +105,7 @@ public function store(StoreWorkerRequest $request, CustomFieldService $cf)
         $validated = $request->validated();
 
         $validated['is_active'] = $request->boolean('is_active', true);
+        $validated['is_logistics'] = $request->boolean('is_logistics');
         unset($validated['custom_field_files']);
         if ($cf->touched($request)) {
             $validated['custom_fields'] = $cf->fromRequest($request, 'worker') ?: null;
@@ -141,6 +142,7 @@ public function edit(Worker $worker, CustomFieldService $cf)
                 'pay_rate'           => $worker->pay_rate,
                 'pay_currency'       => $worker->pay_currency,
                 'is_active'          => $worker->is_active,
+                'is_logistics'       => $worker->is_logistics,
                 'custom_fields'      => $worker->custom_fields,
                 'skills'             => $worker->skills->map(fn ($s) => [
                     'id'    => $s->id,
@@ -163,6 +165,7 @@ public function update(UpdateWorkerRequest $request, Worker $worker, CustomField
         $validated = $request->validated();
 
         $validated['is_active'] = $request->boolean('is_active');
+        $validated['is_logistics'] = $request->boolean('is_logistics');
         unset($validated['custom_field_files']);
         if ($cf->touched($request)) {
             $validated['custom_fields'] = $cf->fromRequest($request, 'worker', $worker->custom_fields) ?: null;

backend/app/Http/Controllers/Web/Logistics/PalletMovementController.php

@@ -0,0 +1,75 @@
+<?php
+
+namespace App\Http\Controllers\Web\Logistics;
+
+use App\Enums\PalletStatus;
+use App\Http\Controllers\Controller;
+use App\Http\Requests\StorePalletMovementRequest;
+use App\Models\Pallet;
+use App\Models\PalletMovement;
+use App\Models\Worker;
+use App\Services\Logistics\PalletMovementService;
+use App\Sync\Shapes\PalletMovementsRecentShape;
+use Inertia\Inertia;
+
+/**
+ * Shop-floor pallet movement (#103): a lightweight terminal where a logistics
+ * operator identifies themselves, picks a pallet, and records a physical move —
+ * plus the admin movement-history list surfacing who moved what.
+ */
+class PalletMovementController extends Controller
+{
+    /** The tablet/terminal "Move Pallet" screen. */
+    public function terminal()
+    {
+        return Inertia::render('logistics/MovePallet', [
+            // Badge-style picker: active logistics operators only.
+            'operators' => Worker::active()->logistics()
+                ->orderBy('name')
+                ->get(['id', 'code', 'name']),
+            // Movable pallets (not yet shipped), most recent first.
+            'pallets' => Pallet::where('status', '!=', PalletStatus::Shipped->value)
+                ->orderByDesc('id')
+                ->limit(500)
+                ->get(['id', 'pallet_no', 'location']),
+        ]);
+    }
+
+    public function store(StorePalletMovementRequest $request, PalletMovementService $service)
+    {
+        $service->record(
+            Pallet::findOrFail($request->integer('pallet_id')),
+            Worker::findOrFail($request->integer('worker_id')),
+            $request->string('to_location')->toString(),
+            $request->user(),
+            $request->input('notes'),
+        );
+
+        return redirect()->route('logistics.move-pallet')
+            ->with('success', __('Pallet movement recorded.'));
+    }
+
+    /** Admin movement history — rows arrive client-side via the Electric shape. */
+    public function index()
+    {
+        // Match the live shape's rolling window: only movements the browser can
+        // actually receive need a resolved label, so the lookup maps stay
+        // bounded even as the append-only ledger grows without limit.
+        $since = now()->subDays(PalletMovementsRecentShape::WINDOW_DAYS)->toDateString();
+        $recent = PalletMovement::query()->where('moved_at', '>=', $since);
+
+        return Inertia::render('admin/pallet-movements/Index', [
+            // Lookup maps for the live table (rows stream via the shape). Bound
+            // to the ids the in-window ledger actually references so the payload
+            // can't balloon to the whole pallets/workers tables. withTrashed so
+            // soft-deleted pallets/operators still resolve to a label.
+            'operatorNames' => Worker::withTrashed()
+                ->whereIn('id', (clone $recent)->select('worker_id'))
+                ->get(['id', 'code', 'name'])
+                ->mapWithKeys(fn (Worker $w) => [$w->id => $w->code.' — '.$w->name]),
+            'palletNumbers' => Pallet::withTrashed()
+                ->whereIn('id', (clone $recent)->select('pallet_id'))
+                ->pluck('pallet_no', 'id'),
+        ]);
+    }
+}