diff --git a/CHANGELOG.md b/CHANGELOG.md
index 208fc3de..9831ae4d 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,13 @@ Format based on [Keep a Changelog](https://keepachangelog.com/).
 
 ---
 
+## [Unreleased]
+
+### Added
+- Scrap reason codes - categorized defect tracking per work order: `scrap_reasons` with a 5M Ishikawa category (material/machine/method/man/environment), admin CRUD + activate/deactivate, and 5 seeded default reasons (#13)
+- Operator scrap reporting on the work order detail page (reason, quantity, notes); `scrap_entries` link to the work order and optionally to a batch step and shift, with a per-work-order total scrap quantity and a derived quality % metric (#13)
+- Scrap reports: Pareto by reason, scrap rate per line, and scrap trend over time (Chart.js), plus REST API endpoints `reports/scrap-pareto`, `reports/scrap-rate`, scrap-reason read/CRUD and scrap-entry report/list (#13)
+
 ## [0.13.0] - 2026-05-31
 
 ### Added
diff --git a/backend/app/Http/Controllers/Api/V1/ReportController.php b/backend/app/Http/Controllers/Api/V1/ReportController.php
index a4c609bc..99aadb58 100644
--- a/backend/app/Http/Controllers/Api/V1/ReportController.php
+++ b/backend/app/Http/Controllers/Api/V1/ReportController.php
@@ -7,7 +7,9 @@
 use App\Models\Batch;
 use App\Models\Issue;
 use App\Models\Line;
+use App\Services\Scrap\ScrapReportService;
 use App\Support\Csv;
+use Illuminate\Http\JsonResponse;
 use Illuminate\Http\Request;
 use Illuminate\Support\Facades\DB;
 use Carbon\Carbon;
@@ -205,6 +207,62 @@ public function downtimeReport(Request $request)
         return response()->json(['data' => $report]);
     }
 
+    /**
+     * Pareto data by scrap reason (descending scrap quantity, cumulative share).
+     */
+    public function scrapPareto(Request $request, ScrapReportService $service): JsonResponse
+    {
+        [$from, $to, $lineId] = $this->scrapReportRange($request);
+
+        return response()->json(['data' => [
+            'period' => ['start' => $from->toDateString(), 'end' => $to->toDateString()],
+            'line_id' => $lineId,
+            'pareto' => $service->pareto($from, $to, $lineId),
+            'by_category' => $service->byCategory($from, $to, $lineId),
+            'generated_at' => now()->toIso8601String(),
+        ]]);
+    }
+
+    /**
+     * Scrap rate per line over time (scrap qty / total produced) plus daily trend.
+     */
+    public function scrapRate(Request $request, ScrapReportService $service): JsonResponse
+    {
+        [$from, $to, $lineId] = $this->scrapReportRange($request);
+
+        return response()->json(['data' => [
+            'period' => ['start' => $from->toDateString(), 'end' => $to->toDateString()],
+            'per_line' => $service->ratePerLine($from, $to),
+            'trend' => $service->trend($from, $to, $lineId),
+            'generated_at' => now()->toIso8601String(),
+        ]]);
+    }
+
+    /**
+     * Resolve and validate the [from, to, lineId] window for scrap reports.
+     * Defaults to the last 30 days when no dates are supplied.
+     *
+     * @return array{0: Carbon, 1: Carbon, 2: int|null}
+     */
+    private function scrapReportRange(Request $request): array
+    {
+        $validated = $request->validate([
+            'line_id' => ['nullable', 'integer', 'exists:lines,id'],
+            'start_date' => ['nullable', 'date'],
+            'end_date' => ['nullable', 'date', 'after_or_equal:start_date'],
+        ]);
+
+        $from = isset($validated['start_date'])
+            ? Carbon::parse($validated['start_date'])->startOfDay()
+            : today()->subDays(29)->startOfDay();
+        $to = isset($validated['end_date'])
+            ? Carbon::parse($validated['end_date'])->endOfDay()
+            : today()->endOfDay();
+        $lineId = isset($validated['line_id']) ? (int) $validated['line_id'] : null;
+
+        return [$from, $to, $lineId];
+    }
+
     /**
      * Export report as CSV
      */
diff --git a/backend/app/Http/Controllers/Api/V1/ScrapEntryController.php b/backend/app/Http/Controllers/Api/V1/ScrapEntryController.php
new file mode 100644
index 00000000..075121b2
--- /dev/null
+++ b/backend/app/Http/Controllers/Api/V1/ScrapEntryController.php
@@ -0,0 +1,143 @@
+<?php
+
+namespace App\Http\Controllers\Api\V1;
+
+use App\Http\Controllers\Controller;
+use App\Models\ScrapEntry;
+use App\Models\WorkOrder;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+use Illuminate\Validation\Rule;
+
+class ScrapEntryController extends Controller
+{
+    public function index(Request $request): JsonResponse
+    {
+        $this->authorize('viewAny', ScrapEntry::class);
+
+        // Tenant isolation: only entries whose work order is visible under the
+        // WorkOrder tenant scope (ScrapEntry itself has no tenant column).
+        // No-op for single-tenant installs (tenant scope is inactive there).
+        $query = ScrapEntry::query()->whereHas('workOrder')->with(['scrapReason', 'reportedBy', 'workOrder']);
+        if ($woId = $request->query('work_order_id')) {
+            $query->where('work_order_id', $woId);
+        }
+        if ($lineId = $request->query('line_id')) {
+            $query->whereHas('workOrder', fn ($q) => $q->where('line_id', $lineId));
+        }
+        if ($reasonId = $request->query('scrap_reason_id')) {
+            $query->where('scrap_reason_id', $reasonId);
+        }
+        if ($from = $request->query('from')) {
+            $query->where('reported_at', '>=', $from);
+        }
+        if ($to = $request->query('to')) {
+            $query->where('reported_at', '<=', $to);
+        }
+
+        $perPage = max(1, min((int) $request->query('per_page', 30), 100));
+        $page = $query->orderByDesc('reported_at')->paginate($perPage);
+
+        return response()->json([
+            'data' => $page->items(),
+            'meta' => [
+                'current_page' => $page->currentPage(),
+                'per_page' => $page->perPage(),
+                'total' => $page->total(),
+                'last_page' => $page->lastPage(),
+            ],
+        ]);
+    }
+
+    /**
+     * List scrap entries for a single work order, with the work order totals.
+     */
+    public function forWorkOrder(WorkOrder $workOrder): JsonResponse
+    {
+        $this->authorize('viewAny', ScrapEntry::class);
+
+        $entries = $workOrder->scrapEntries()
+            ->with(['scrapReason', 'reportedBy', 'batchStep', 'shift'])
+            ->orderByDesc('reported_at')
+            ->get();
+
+        return response()->json([
+            'data' => $entries,
+            'meta' => [
+                'work_order_id' => $workOrder->id,
+                'total_scrap_qty' => $workOrder->totalScrapQty(),
+                'quality_pct' => $workOrder->qualityPct(),
+            ],
+        ]);
+    }
+
+    public function show(ScrapEntry $scrapEntry): JsonResponse
+    {
+        $this->authorize('view', $scrapEntry);
+        $this->assertTenantVisible($scrapEntry);
+        $scrapEntry->load(['scrapReason', 'reportedBy', 'workOrder', 'batchStep', 'shift']);
+
+        return response()->json(['data' => $scrapEntry]);
+    }
+
+    public function store(Request $request, WorkOrder $workOrder): JsonResponse
+    {
+        $this->authorize('create', ScrapEntry::class);
+        $data = $request->validate([
+            'scrap_reason_id' => ['required', 'integer', Rule::exists('scrap_reasons', 'id')->where('is_active', true)],
+            'quantity' => ['required', 'numeric', 'min:0.01', 'max:99999999'],
+            'batch_step_id' => ['nullable', 'integer', 'exists:batch_steps,id'],
+            'shift_id' => ['nullable', 'integer', 'exists:shifts,id'],
+            'notes' => ['nullable', 'string'],
+            'reported_at' => ['nullable', 'date'],
+        ]);
+        $data['work_order_id'] = $workOrder->id;
+        $data['reported_by'] = $request->user()->id;
+        $data['reported_at'] = $data['reported_at'] ?? now();
+
+        $entry = ScrapEntry::create($data);
+
+        return response()->json([
+            'message' => 'Scrap recorded',
+            'data' => $entry->load(['scrapReason', 'reportedBy']),
+        ], 201);
+    }
+
+    public function update(Request $request, ScrapEntry $scrapEntry): JsonResponse
+    {
+        $this->authorize('update', $scrapEntry);
+        $this->assertTenantVisible($scrapEntry);
+        $data = $request->validate([
+            'scrap_reason_id' => ['sometimes', 'integer', Rule::exists('scrap_reasons', 'id')->where('is_active', true)],
+            'quantity' => ['sometimes', 'numeric', 'min:0.01', 'max:99999999'],
+            'batch_step_id' => ['sometimes', 'nullable', 'integer', 'exists:batch_steps,id'],
+            'shift_id' => ['sometimes', 'nullable', 'integer', 'exists:shifts,id'],
+            'notes' => ['sometimes', 'nullable', 'string'],
+        ]);
+        $scrapEntry->update($data);
+
+        return response()->json(['message' => 'Scrap entry updated', 'data' => $scrapEntry->fresh(['scrapReason'])]);
+    }
+
+    public function destroy(ScrapEntry $scrapEntry): JsonResponse
+    {
+        $this->authorize('delete', $scrapEntry);
+        $this->assertTenantVisible($scrapEntry);
+        $scrapEntry->delete();
+
+        return response()->json(['message' => 'Scrap entry deleted']);
+    }
+
+    /**
+     * Guard against cross-tenant access to a directly-bound scrap entry.
+     *
+     * ScrapEntry has no tenant column; isolation rides on its work order,
+     * which carries the tenant scope. If the entry's work order is not
+     * visible to the current tenant, treat the entry as not found.
+     * No-op for single-tenant installs (the tenant scope is inactive).
+     */
+    private function assertTenantVisible(ScrapEntry $scrapEntry): void
+    {
+        abort_unless($scrapEntry->workOrder()->exists(), 404);
+    }
+}
diff --git a/backend/app/Http/Controllers/Api/V1/ScrapReasonController.php b/backend/app/Http/Controllers/Api/V1/ScrapReasonController.php
new file mode 100644
index 00000000..5ce00438
--- /dev/null
+++ b/backend/app/Http/Controllers/Api/V1/ScrapReasonController.php
@@ -0,0 +1,80 @@
+<?php
+
+namespace App\Http\Controllers\Api\V1;
+
+use App\Http\Controllers\Controller;
+use App\Models\ScrapReason;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+use Illuminate\Validation\Rule;
+
+class ScrapReasonController extends Controller
+{
+    public function index(Request $request): JsonResponse
+    {
+        $this->authorize('viewAny', ScrapReason::class);
+
+        $query = ScrapReason::query();
+        if (! $request->boolean('include_inactive')) {
+            $query->where('is_active', true);
+        }
+        if ($cat = $request->query('category')) {
+            $query->where('category', $cat);
+        }
+
+        return response()->json(['data' => $query->ordered()->get()]);
+    }
+
+    public function show(ScrapReason $scrapReason): JsonResponse
+    {
+        $this->authorize('view', $scrapReason);
+
+        return response()->json(['data' => $scrapReason]);
+    }
+
+    public function store(Request $request): JsonResponse
+    {
+        $this->authorize('create', ScrapReason::class);
+        $data = $request->validate([
+            'code' => ['required', 'string', 'max:20', 'unique:scrap_reasons,code'],
+            'name' => ['required', 'string', 'max:255'],
+            'category' => ['required', Rule::in(ScrapReason::CATEGORIES)],
+            'description' => ['nullable', 'string'],
+            'sort_order' => ['nullable', 'integer', 'min:0', 'max:65535'],
+            'is_active' => ['nullable', 'boolean'],
+        ]);
+        $data['is_active'] = $data['is_active'] ?? true;
+        $data['sort_order'] = $data['sort_order'] ?? 0;
+
+        $reason = ScrapReason::create($data);
+
+        return response()->json(['message' => 'Scrap reason created', 'data' => $reason], 201);
+    }
+
+    public function update(Request $request, ScrapReason $scrapReason): JsonResponse
+    {
+        $this->authorize('update', $scrapReason);
+        $data = $request->validate([
+            'code' => ['sometimes', 'required', 'string', 'max:20', Rule::unique('scrap_reasons', 'code')->ignore($scrapReason->id)],
+            'name' => ['sometimes', 'required', 'string', 'max:255'],
+            'category' => ['sometimes', 'required', Rule::in(ScrapReason::CATEGORIES)],
+            'description' => ['sometimes', 'nullable', 'string'],
+            'sort_order' => ['sometimes', 'integer', 'min:0', 'max:65535'],
+            'is_active' => ['sometimes', 'boolean'],
+        ]);
+        $scrapReason->update($data);
+
+        return response()->json(['message' => 'Scrap reason updated', 'data' => $scrapReason->fresh()]);
+    }
+
+    public function destroy(ScrapReason $scrapReason): JsonResponse
+    {
+        $this->authorize('delete', $scrapReason);
+        if ($scrapReason->scrapEntries()->exists()) {
+            return response()->json(['message' => 'Cannot delete reason referenced by scrap entries.'], 422);
+        }
+        $scrapReason->delete();
+
+        return response()->json(['message' => 'Scrap reason deleted']);
+    }
+}
diff --git a/backend/app/Http/Controllers/Web/Admin/ScrapReasonController.php b/backend/app/Http/Controllers/Web/Admin/ScrapReasonController.php
new file mode 100644
index 00000000..d73f4fed
--- /dev/null
+++ b/backend/app/Http/Controllers/Web/Admin/ScrapReasonController.php
@@ -0,0 +1,120 @@
+<?php
+
+namespace App\Http\Controllers\Web\Admin;
+
+use App\Http\Controllers\Controller;
+use App\Models\ScrapReason;
+use Illuminate\Http\Request;
+use Illuminate\Validation\Rule;
+use Inertia\Inertia;
+
+class ScrapReasonController extends Controller
+{
+    /**
+     * Display a listing of scrap reasons. Rows live-sync via the
+     * `scrap_reasons` shape; usage counts come as a prop.
+     */
+    public function index()
+    {
+        $counts = ScrapReason::withCount('scrapEntries')
+            ->get(['id'])
+            ->mapWithKeys(fn ($r) => [$r->id => $r->scrap_entries_count]);
+
+        return Inertia::render('admin/scrap-reasons/Index', [
+            'counts' => $counts,
+        ]);
+    }
+
+    /**
+     * Show the form for creating a new scrap reason.
+     */
+    public function create()
+    {
+        return Inertia::render('admin/scrap-reasons/Create');
+    }
+
+    /**
+     * Store a newly created scrap reason.
+     */
+    public function store(Request $request)
+    {
+        $validated = $request->validate([
+            'code'        => 'required|string|max:20|unique:scrap_reasons,code',
+            'name'        => 'required|string|max:255',
+            'category'    => ['required', Rule::in(ScrapReason::CATEGORIES)],
+            'description' => 'nullable|string|max:2000',
+            'sort_order'  => 'nullable|integer|min:0|max:65535',
+            'is_active'   => 'boolean',
+        ]);
+
+        $validated['is_active'] = $request->boolean('is_active', true);
+        $validated['sort_order'] = $validated['sort_order'] ?? 0;
+
+        ScrapReason::create($validated);
+
+        return redirect()->route('admin.scrap-reasons.index')
+            ->with('success', __('Scrap reason created successfully.'));
+    }
+
+    /**
+     * Show the form for editing a scrap reason.
+     */
+    public function edit(ScrapReason $scrapReason)
+    {
+        return Inertia::render('admin/scrap-reasons/Edit', [
+            'scrapReason' => $scrapReason->only('id', 'code', 'name', 'category', 'description', 'sort_order', 'is_active'),
+        ]);
+    }
+
+    /**
+     * Update the specified scrap reason.
+     */
+    public function update(Request $request, ScrapReason $scrapReason)
+    {
+        $validated = $request->validate([
+            'code'        => ['required', 'string', 'max:20', Rule::unique('scrap_reasons', 'code')->ignore($scrapReason->id)],
+            'name'        => 'required|string|max:255',
+            'category'    => ['required', Rule::in(ScrapReason::CATEGORIES)],
+            'description' => 'nullable|string|max:2000',
+            'sort_order'  => 'nullable|integer|min:0|max:65535',
+            'is_active'   => 'boolean',
+        ]);
+
+        $validated['is_active'] = $request->boolean('is_active');
+        $validated['sort_order'] = $validated['sort_order'] ?? 0;
+
+        $scrapReason->update($validated);
+
+        return redirect()->route('admin.scrap-reasons.index')
+            ->with('success', __('Scrap reason updated successfully.'));
+    }
+
+    /**
+     * Remove the specified scrap reason.
+     */
+    public function destroy(ScrapReason $scrapReason)
+    {
+        if ($scrapReason->scrapEntries()->exists()) {
+            return redirect()->route('admin.scrap-reasons.index')
+                ->with('error', __('Cannot delete scrap reason with existing entries. Deactivate it instead.'));
+        }
+
+        $scrapReason->delete();
+
+        return redirect()->route('admin.scrap-reasons.index')
+            ->with('success', __('Scrap reason deleted successfully.'));
+    }
+
+    /**
+     * Toggle scrap reason active status.
+     */
+    public function toggleActive(ScrapReason $scrapReason)
+    {
+        $scrapReason->update(['is_active' => ! $scrapReason->is_active]);
+
+        $status = $scrapReason->is_active ? __('activated') : __('deactivated');
+
+        return redirect()->route('admin.scrap-reasons.index')
+            ->with('success', __('Scrap reason :status successfully.', ['status' => $status]));
+    }
+}
diff --git a/backend/app/Http/Controllers/Web/Admin/ScrapReportController.php b/backend/app/Http/Controllers/Web/Admin/ScrapReportController.php
new file mode 100644
index 00000000..f7461ff1
--- /dev/null
+++ b/backend/app/Http/Controllers/Web/Admin/ScrapReportController.php
@@ -0,0 +1,43 @@
+<?php
+
+namespace App\Http\Controllers\Web\Admin;
+
+use App\Http\Controllers\Controller;
+use App\Models\Line;
+use App\Services\Scrap\ScrapReportService;
+use Carbon\Carbon;
+use Illuminate\Http\Request;
+use Inertia\Inertia;
+
+class ScrapReportController extends Controller
+{
+    public function __construct(
+        protected ScrapReportService $scrapReports,
+    ) {}
+
+    public function index(Request $request)
+    {
+        $validated = $request->validate([
+            'line_id'   => ['nullable', 'integer', 'exists:lines,id'],
+            'date_from' => ['nullable', 'date_format:Y-m-d'],
+            'date_to'   => ['nullable', 'date_format:Y-m-d', 'after_or_equal:date_from'],
+        ]);
+
+        $lineId = isset($validated['line_id']) ? (int) $validated['line_id'] : null;
+        $from = isset($validated['date_from'])
+            ? Carbon::parse($validated['date_from'])->startOfDay()
+            : today()->subDays(29)->startOfDay();
+        $to = isset($validated['date_to'])
+            ? Carbon::parse($validated['date_to'])->endOfDay()
+            : today()->endOfDay();
+
+        return Inertia::render('admin/scrap-reports/Index', [
+            'lines' => Line::orderBy('name')->get(),
+            'lineId' => $lineId,
+            'dateFrom' => $from->toDateString(),
+            'dateTo' => $to->toDateString(),
+            'pareto' => $this->scrapReports->pareto($from, $to, $lineId),
+            'ratePerLine' => $this->scrapReports->ratePerLine($from, $to),
+        ]);
+    }
+}
diff --git a/backend/app/Http/Controllers/Web/Operator/ScrapController.php b/backend/app/Http/Controllers/Web/Operator/ScrapController.php
new file mode 100644
index 00000000..6695a2c3
--- /dev/null
+++ b/backend/app/Http/Controllers/Web/Operator/ScrapController.php
@@ -0,0 +1,46 @@
+<?php
+
+namespace App\Http\Controllers\Web\Operator;
+
+use App\Http\Controllers\Controller;
+use App\Models\ScrapEntry;
+use App\Models\Shift;
+use App\Models\WorkOrder;
+use Illuminate\Http\Request;
+use Illuminate\Validation\Rule;
+
+class ScrapController extends Controller
+{
+    /**
+     * Record a scrap entry against a work order from the operator detail page.
+     */
+    public function store(Request $request)
+    {
+        $validated = $request->validate([
+            'work_order_id'   => 'required|exists:work_orders,id',
+            'scrap_reason_id' => ['required', Rule::exists('scrap_reasons', 'id')->where('is_active', true)],
+            'quantity'        => 'required|numeric|min:0.01|max:99999999',
+            'notes'           => 'nullable|string|max:2000',
+        ]);
+
+        $workOrder = WorkOrder::findOrFail($validated['work_order_id']);
+
+        // Verify work order belongs to selected line
+        if ($workOrder->line_id != $request->session()->get('selected_line_id')) {
+            return back()->with('error', __('This work order does not belong to the selected line.'));
+        }
+
+        ScrapEntry::create([
+            'work_order_id'   => $workOrder->id,
+            'scrap_reason_id' => $validated['scrap_reason_id'],
+            'quantity'        => $validated['quantity'],
+            // Attribute to the line's current shift automatically when one is running.
+            'shift_id'        => Shift::current($workOrder->line_id)?->id,
+            'notes'           => $validated['notes'] ?? null,
+            'reported_by'     => auth()->id(),
+            'reported_at'     => now(),
+        ]);
+
+        return redirect()->back()->with('success', __('Scrap recorded successfully.'));
+    }
+}
diff --git a/backend/app/Http/Controllers/Web/Operator/WorkOrderController.php b/backend/app/Http/Controllers/Web/Operator/WorkOrderController.php
index f2a4632e..36764903 100644
--- a/backend/app/Http/Controllers/Web/Operator/WorkOrderController.php
+++ b/backend/app/Http/Controllers/Web/Operator/WorkOrderController.php
@@ -5,6 +5,7 @@
 use App\Http\Controllers\Controller;
 use App\Models\IssueType;
 use App\Models\LineStatus;
+use App\Models\ScrapReason;
 use App\Models\WorkOrder;
 use App\Models\Workstation;
 use App\Services\WorkOrder\WorkOrderService;
@@ -233,10 +234,14 @@ public function show(Request $request, WorkOrder $workOrder)
             'batches.packagingChecklist',
             'issues.issueType',
             'issues.reportedBy',
+            'scrapEntries.scrapReason',
+            'scrapEntries.reportedBy',
         ]);
 
         $issueTypes = IssueType::where('is_active', true)->orderBy('name')->get();
 
+        $scrapReasons = ScrapReason::active()->ordered()->get();
+
         // Only show workstations from this line (not all system workstations)
         $workstations = $workOrder->line
             ? Workstation::where('line_id', $workOrder->line_id)->where('is_active', true)->orderBy('name')->get()
@@ -253,6 +258,6 @@ public function show(Request $request, WorkOrder $workOrder)
             ->orderBy('name')
             ->get(['id', 'name', 'type', 'size', 'barcode_format', 'is_default']);
 
-        return Inertia::render('operator/WorkOrderDetail', compact('workOrder', 'issueTypes', 'workstations', 'defaultWorkstationId', 'line', 'labelTemplates'));
+        return Inertia::render('operator/WorkOrderDetail', compact('workOrder', 'issueTypes', 'scrapReasons', 'workstations', 'defaultWorkstationId', 'line', 'labelTemplates'));
     }
 }
diff --git a/backend/app/Models/ScrapEntry.php b/backend/app/Models/ScrapEntry.php
new file mode 100644
index 00000000..758bf67e
--- /dev/null
+++ b/backend/app/Models/ScrapEntry.php
@@ -0,0 +1,72 @@
+<?php
+
+namespace App\Models;
+
+use App\Traits\Auditable;
+use Illuminate\Database\Eloquent\Factories\HasFactory;
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Database\Eloquent\Relations\BelongsTo;
+
+class ScrapEntry extends Model
+{
+    use Auditable, HasFactory;
+
+    protected $fillable = [
+        'work_order_id',
+        'scrap_reason_id',
+        'quantity',
+        'batch_step_id',
+        'shift_id',
+        'notes',
+        'reported_by',
+        'reported_at',
+    ];
+
+    protected function casts(): array
+    {
+        return [
+            'quantity' => 'decimal:2',
+            'reported_at' => 'datetime',
+        ];
+    }
+
+    /**
+     * The work order this scrap was reported against.
+     */
+    public function workOrder(): BelongsTo
+    {
+        return $this->belongsTo(WorkOrder::class);
+    }
+
+    /**
+     * The reason code classifying this scrap.
+     */
+    public function scrapReason(): BelongsTo
+    {
+        return $this->belongsTo(ScrapReason::class);
+    }
+
+    /**
+     * The batch step the scrap was attributed to (optional).
+     */
+    public function batchStep(): BelongsTo
+    {
+        return $this->belongsTo(BatchStep::class);
+    }
+
+    /**
+     * The shift the scrap was reported on (optional).
+     */
+    public function shift(): BelongsTo
+    {
+        return $this->belongsTo(Shift::class);
+    }
+
+    /**
+     * The user who reported the scrap.
+     */
+    public function reportedBy(): BelongsTo
+    {
+        return $this->belongsTo(User::class, 'reported_by');
+    }
+}
diff --git a/backend/app/Models/ScrapReason.php b/backend/app/Models/ScrapReason.php
new file mode 100644
index 00000000..5fd1b83b
--- /dev/null
+++ b/backend/app/Models/ScrapReason.php
@@ -0,0 +1,72 @@
+<?php
+
+namespace App\Models;
+
+use Illuminate\Database\Eloquent\Factories\HasFactory;
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Database\Eloquent\Relations\HasMany;
+
+class ScrapReason extends Model
+{
+    use HasFactory;
+
+    /** 5M defect taxonomy (Ishikawa fishbone categories). */
+    const CATEGORY_MATERIAL = 'material';
+
+    const CATEGORY_MACHINE = 'machine';
+
+    const CATEGORY_METHOD = 'method';
+
+    const CATEGORY_MAN = 'man';
+
+    const CATEGORY_ENVIRONMENT = 'environment';
+
+    const CATEGORIES = [
+        self::CATEGORY_MATERIAL,
+        self::CATEGORY_MACHINE,
+        self::CATEGORY_METHOD,
+        self::CATEGORY_MAN,
+        self::CATEGORY_ENVIRONMENT,
+    ];
+
+    protected $fillable = [
+        'code',
+        'name',
+        'description',
+        'category',
+        'is_active',
+        'sort_order',
+    ];
+
+    protected function casts(): array
+    {
+        return [
+            'is_active' => 'boolean',
+            'sort_order' => 'integer',
+        ];
+    }
+
+    /**
+     * Get the scrap entries recorded against this reason.
+     */
+    public function scrapEntries(): HasMany
+    {
+        return $this->hasMany(ScrapEntry::class);
+    }
+
+    /**
+     * Scope to get only active scrap reasons.
+     */
+    public function scopeActive($query)
+    {
+        return $query->where('is_active', true);
+    }
+
+    /**
+     * Scope ordering reasons the way operators expect to see them.
+     */
+    public function scopeOrdered($query)
+    {
+        return $query->orderBy('sort_order')->orderBy('name');
+    }
+}
diff --git a/backend/app/Models/WorkOrder.php b/backend/app/Models/WorkOrder.php
index c03a536e..434cc55b 100644
--- a/backend/app/Models/WorkOrder.php
+++ b/backend/app/Models/WorkOrder.php
@@ -145,6 +145,14 @@ public function eans(): HasMany
         return $this->hasMany(WorkOrderEan::class);
     }
 
+    /**
+     * Get the scrap entries reported against this work order.
+     */
+    public function scrapEntries(): HasMany
+    {
+        return $this->hasMany(ScrapEntry::class);
+    }
+
     /**
      * Get the open blocking issues for this work order.
      */
@@ -180,6 +188,39 @@ public function isComplete(): bool
         return (float) $this->produced_qty >= (float) $this->planned_qty;
     }
 
+    /**
+     * Total scrap quantity reported against this work order.
+     *
+     * Reads from the loaded relation when available (avoids an extra query
+     * after eager loading) and otherwise aggregates in the database.
+     */
+    public function totalScrapQty(): float
+    {
+        if ($this->relationLoaded('scrapEntries')) {
+            return (float) $this->scrapEntries->sum('quantity');
+        }
+
+        return (float) $this->scrapEntries()->sum('quantity');
+    }
+
+    /**
+     * Quality metric for this work order: the share of produced units that
+     * were not scrapped, as a percentage. Scrap entries automatically pull
+     * this down. Returns null when nothing has been produced yet.
+     */
+    public function qualityPct(): ?float
+    {
+        $produced = (float) $this->produced_qty;
+
+        if ($produced <= 0) {
+            return null;
+        }
+
+        $good = max(0.0, $produced - $this->totalScrapQty());
+
+        return round(($good / $produced) * 100, 2);
+    }
+
     /**
      * Scope to filter by status. Accepts a single value or an array — mobile
      * uses `?status[]=A&status[]=B` to match multiple statuses at once.
diff --git a/backend/app/Policies/ScrapEntryPolicy.php b/backend/app/Policies/ScrapEntryPolicy.php
new file mode 100644
index 00000000..ac63314c
--- /dev/null
+++ b/backend/app/Policies/ScrapEntryPolicy.php
@@ -0,0 +1,20 @@
+<?php
+
+namespace App\Policies;
+
+use App\Models\ScrapEntry;
+use App\Models\User;
+
+class ScrapEntryPolicy
+{
+    public function viewAny(User $u): bool { return true; }
+    public function view(User $u, ScrapEntry $e): bool { return true; }
+    public function create(User $u): bool { return $u->hasAnyRole(['Admin', 'Supervisor', 'Operator']); }
+    public function update(User $u, ScrapEntry $e): bool
+    {
+        if ($u->hasAnyRole(['Admin', 'Supervisor'])) return true;
+        // Operator can edit their own entry
+        return $e->reported_by === $u->id;
+    }
+    public function delete(User $u, ScrapEntry $e): bool { return $u->hasAnyRole(['Admin', 'Supervisor']); }
+}
diff --git a/backend/app/Policies/ScrapReasonPolicy.php b/backend/app/Policies/ScrapReasonPolicy.php
new file mode 100644
index 00000000..c8a83aa1
--- /dev/null
+++ b/backend/app/Policies/ScrapReasonPolicy.php
@@ -0,0 +1,15 @@
+<?php
+
+namespace App\Policies;
+
+use App\Models\ScrapReason;
+use App\Models\User;
+
+class ScrapReasonPolicy
+{
+    public function viewAny(User $u): bool { return true; }
+    public function view(User $u, ScrapReason $r): bool { return true; }
+    public function create(User $u): bool { return $u->hasRole('Admin'); }
+    public function update(User $u, ScrapReason $r): bool { return $u->hasRole('Admin'); }
+    public function delete(User $u, ScrapReason $r): bool { return $u->hasRole('Admin'); }
+}
diff --git a/backend/app/Services/Scrap/ScrapReportService.php b/backend/app/Services/Scrap/ScrapReportService.php
new file mode 100644
index 00000000..ba67f37f
--- /dev/null
+++ b/backend/app/Services/Scrap/ScrapReportService.php
@@ -0,0 +1,158 @@
+<?php
+
+namespace App\Services\Scrap;
+
+use App\Models\Batch;
+use App\Models\Line;
+use App\Models\ScrapEntry;
+use Carbon\Carbon;
+use Illuminate\Support\Collection;
+
+/**
+ * Aggregates scrap data for the admin reporting views and the public report
+ * API so both surfaces share identical Pareto / scrap-rate maths.
+ *
+ * Grouping is done in PHP (over a date-bounded set of entries) so the same
+ * code runs on PostgreSQL in production and SQLite in the test suite.
+ */
+class ScrapReportService
+{
+    /**
+     * Scrap entries in the period (optionally constrained to one line), with
+     * their reason eager-loaded.
+     */
+    private function entries(Carbon $from, Carbon $to, ?int $lineId): Collection
+    {
+        return ScrapEntry::query()
+            ->with(['scrapReason', 'workOrder:id,line_id'])
+            ->whereBetween('reported_at', [$from, $to])
+            ->when($lineId, fn ($q) => $q->whereHas('workOrder', fn ($w) => $w->where('line_id', $lineId)))
+            ->get();
+    }
+
+    /**
+     * Pareto of scrap quantity by reason, sorted descending, with each reason's
+     * share and the running cumulative share.
+     */
+    public function pareto(Carbon $from, Carbon $to, ?int $lineId = null): array
+    {
+        $entries = $this->entries($from, $to, $lineId);
+
+        $reasons = $entries
+            ->groupBy('scrap_reason_id')
+            ->map(function (Collection $rows) {
+                $reason = $rows->first()->scrapReason;
+
+                return [
+                    'scrap_reason_id' => $reason?->id,
+                    'code' => $reason?->code,
+                    'name' => $reason?->name ?? __('Unknown'),
+                    'category' => $reason?->category,
+                    'qty' => round((float) $rows->sum('quantity'), 2),
+                    'entries' => $rows->count(),
+                ];
+            })
+            ->sortByDesc('qty')
+            ->values();
+
+        $total = round((float) $reasons->sum('qty'), 2);
+        $running = 0.0;
+
+        $reasons = $reasons->map(function (array $row) use ($total, &$running) {
+            $running += $row['qty'];
+            $row['pct'] = $total > 0 ? round(($row['qty'] / $total) * 100, 2) : 0.0;
+            $row['cumulative_pct'] = $total > 0 ? round(($running / $total) * 100, 2) : 0.0;
+
+            return $row;
+        })->values();
+
+        return [
+            'total_qty' => $total,
+            'total_entries' => $entries->count(),
+            'reasons' => $reasons->all(),
+        ];
+    }
+
+    /**
+     * Scrap quantity grouped by 5M category (material/machine/method/man/environment).
+     */
+    public function byCategory(Carbon $from, Carbon $to, ?int $lineId = null): array
+    {
+        return $this->entries($from, $to, $lineId)
+            ->groupBy(fn (ScrapEntry $e) => $e->scrapReason?->category ?? 'unknown')
+            ->map(fn (Collection $rows, $category) => [
+                'category' => $category,
+                'qty' => round((float) $rows->sum('quantity'), 2),
+                'entries' => $rows->count(),
+            ])
+            ->sortByDesc('qty')
+            ->values()
+            ->all();
+    }
+
+    /**
+     * Scrap rate per line over the period: total scrap quantity divided by the
+     * quantity produced (completed batches) on that line.
+     */
+    public function ratePerLine(Carbon $from, Carbon $to): array
+    {
+        $scrapByLine = ScrapEntry::query()
+            ->join('work_orders', 'scrap_entries.work_order_id', '=', 'work_orders.id')
+            ->whereBetween('scrap_entries.reported_at', [$from, $to])
+            ->whereNotNull('work_orders.line_id')
+            ->groupBy('work_orders.line_id')
+            ->selectRaw('work_orders.line_id as line_id, COALESCE(SUM(scrap_entries.quantity), 0) as scrap_qty')
+            ->pluck('scrap_qty', 'line_id');
+
+        $producedByLine = Batch::query()
+            ->join('work_orders', 'batches.work_order_id', '=', 'work_orders.id')
+            ->where('batches.status', Batch::STATUS_DONE)
+            ->whereBetween('batches.completed_at', [$from, $to])
+            ->whereNotNull('work_orders.line_id')
+            ->groupBy('work_orders.line_id')
+            ->selectRaw('work_orders.line_id as line_id, COALESCE(SUM(batches.produced_qty), 0) as produced_qty')
+            ->pluck('produced_qty', 'line_id');
+
+        $lineIds = $scrapByLine->keys()->merge($producedByLine->keys())->unique()->values();
+
+        if ($lineIds->isEmpty()) {
+            return [];
+        }
+
+        $lineNames = Line::whereIn('id', $lineIds)->pluck('name', 'id');
+
+        return $lineIds
+            ->map(function ($lineId) use ($scrapByLine, $producedByLine, $lineNames) {
+                $scrap = round((float) $scrapByLine->get($lineId, 0), 2);
+                $produced = round((float) $producedByLine->get($lineId, 0), 2);
+
+                return [
+                    'line_id' => (int) $lineId,
+                    'line_name' => $lineNames->get($lineId, '#' . $lineId),
+                    'scrap_qty' => $scrap,
+                    'produced_qty' => $produced,
+                    'scrap_rate_pct' => $produced > 0 ? round(($scrap / $produced) * 100, 2) : null,
+                ];
+            })
+            ->sortByDesc('scrap_qty')
+            ->values()
+            ->all();
+    }
+
+    /**
+     * Daily scrap-quantity trend across the period.
+     */
+    public function trend(Carbon $from, Carbon $to, ?int $lineId = null): array
+    {
+        return $this->entries($from, $to, $lineId)
+            ->groupBy(fn (ScrapEntry $e) => $e->reported_at->toDateString())
+            ->map(fn (Collection $rows, $date) => [
+                'date' => $date,
+                'qty' => round((float) $rows->sum('quantity'), 2),
+                'entries' => $rows->count(),
+            ])
+            ->sortKeys()
+            ->values()
+            ->all();
+    }
+}
diff --git a/backend/app/Sync/ShapeRegistry.php b/backend/app/Sync/ShapeRegistry.php
index a164fa39..c1ef3341 100644
--- a/backend/app/Sync/ShapeRegistry.php
+++ b/backend/app/Sync/ShapeRegistry.php
@@ -38,6 +38,10 @@ class ShapeRegistry
             'table' => 'anomaly_reasons',
             'columns' => ['id', 'code', 'name', 'category', 'description', 'is_active', 'created_at', 'updated_at'],
         ],
+        'scrap_reasons' => [
+            'table' => 'scrap_reasons',
+            'columns' => ['id', 'code', 'name', 'category', 'description', 'is_active', 'sort_order', 'created_at', 'updated_at'],
+        ],
         'companies' => [
             'table' => 'companies',
             'columns' => ['id', 'code', 'name', 'tax_id', 'type', 'email', 'phone', 'address', 'is_active', 'created_at', 'updated_at'],
diff --git a/backend/database/factories/ScrapEntryFactory.php b/backend/database/factories/ScrapEntryFactory.php
new file mode 100644
index 00000000..546a1300
--- /dev/null
+++ b/backend/database/factories/ScrapEntryFactory.php
@@ -0,0 +1,31 @@
+<?php
+
+namespace Database\Factories;
+
+use App\Models\ScrapEntry;
+use App\Models\ScrapReason;
+use App\Models\User;
+use App\Models\WorkOrder;
+use Illuminate\Database\Eloquent\Factories\Factory;
+
+/**
+ * @extends Factory<ScrapEntry>
+ */
+class ScrapEntryFactory extends Factory
+{
+    protected $model = ScrapEntry::class;
+
+    public function definition(): array
+    {
+        return [
+            'work_order_id' => WorkOrder::factory(),
+            'scrap_reason_id' => ScrapReason::factory(),
+            'quantity' => fake()->randomFloat(2, 1, 100),
+            'batch_step_id' => null,
+            'shift_id' => null,
+            'notes' => fake()->optional()->sentence(),
+            'reported_by' => User::factory(),
+            'reported_at' => now(),
+        ];
+    }
+}
diff --git a/backend/database/factories/ScrapReasonFactory.php b/backend/database/factories/ScrapReasonFactory.php
new file mode 100644
index 00000000..47e810ff
--- /dev/null
+++ b/backend/database/factories/ScrapReasonFactory.php
@@ -0,0 +1,38 @@
+<?php
+
+namespace Database\Factories;
+
+use App\Models\ScrapReason;
+use Illuminate\Database\Eloquent\Factories\Factory;
+
+/**
+ * @extends Factory<ScrapReason>
+ */
+class ScrapReasonFactory extends Factory
+{
+    protected $model = ScrapReason::class;
+
+    public function definition(): array
+    {
+        static $counter = 1;
+
+        return [
+            'code' => 'SCR-' . str_pad((string) $counter++, 3, '0', STR_PAD_LEFT),
+            'name' => fake()->words(3, true),
+            'description' => fake()->optional()->sentence(),
+            'category' => fake()->randomElement(ScrapReason::CATEGORIES),
+            'is_active' => true,
+            'sort_order' => 0,
+        ];
+    }
+
+    public function inactive(): static
+    {
+        return $this->state(['is_active' => false]);
+    }
+
+    public function category(string $category): static
+    {
+        return $this->state(['category' => $category]);
+    }
+}
diff --git a/backend/database/migrations/2026_06_01_120000_create_scrap_reasons_table.php b/backend/database/migrations/2026_06_01_120000_create_scrap_reasons_table.php
new file mode 100644
index 00000000..b1235f70
--- /dev/null
+++ b/backend/database/migrations/2026_06_01_120000_create_scrap_reasons_table.php
@@ -0,0 +1,30 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    public function up(): void
+    {
+        Schema::create('scrap_reasons', function (Blueprint $table) {
+            $table->id();
+            $table->string('code', 20)->unique();
+            $table->string('name');
+            $table->text('description')->nullable();
+            // 5M defect taxonomy (Ishikawa): material, machine, method, man, environment
+            $table->enum('category', ['material', 'machine', 'method', 'man', 'environment']);
+            $table->boolean('is_active')->default(true);
+            $table->unsignedSmallInteger('sort_order')->default(0);
+            $table->timestamps();
+
+            $table->index(['is_active', 'sort_order']);
+        });
+    }
+
+    public function down(): void
+    {
+        Schema::dropIfExists('scrap_reasons');
+    }
+};
diff --git a/backend/database/migrations/2026_06_01_120001_create_scrap_entries_table.php b/backend/database/migrations/2026_06_01_120001_create_scrap_entries_table.php
new file mode 100644
index 00000000..ac06254e
--- /dev/null
+++ b/backend/database/migrations/2026_06_01_120001_create_scrap_entries_table.php
@@ -0,0 +1,33 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    public function up(): void
+    {
+        Schema::create('scrap_entries', function (Blueprint $table) {
+            $table->id();
+            $table->foreignId('work_order_id')->constrained()->cascadeOnDelete();
+            $table->foreignId('scrap_reason_id')->constrained()->restrictOnDelete();
+            $table->decimal('quantity', 12, 2);
+            $table->foreignId('batch_step_id')->nullable()->constrained()->nullOnDelete();
+            $table->foreignId('shift_id')->nullable()->constrained()->nullOnDelete();
+            $table->text('notes')->nullable();
+            $table->foreignId('reported_by')->nullable()->constrained('users')->nullOnDelete();
+            $table->timestamp('reported_at');
+            $table->timestamps();
+
+            $table->index('work_order_id');
+            $table->index('scrap_reason_id');
+            $table->index('reported_at');
+        });
+    }
+
+    public function down(): void
+    {
+        Schema::dropIfExists('scrap_entries');
+    }
+};
diff --git a/backend/database/seeders/DatabaseSeeder.php b/backend/database/seeders/DatabaseSeeder.php
index 626407dc..527cf28f 100644
--- a/backend/database/seeders/DatabaseSeeder.php
+++ b/backend/database/seeders/DatabaseSeeder.php
@@ -18,6 +18,7 @@ public function run(): void
             ViewTemplateSeeder::class,
             MaterialTypesSeeder::class,
             DowntimeReasonsSeeder::class,
+            ScrapReasonsSeeder::class,
             LabelTemplatesSeeder::class,
         ]);
     }
diff --git a/backend/database/seeders/ScrapReasonsSeeder.php b/backend/database/seeders/ScrapReasonsSeeder.php
new file mode 100644
index 00000000..fbbe83e7
--- /dev/null
+++ b/backend/database/seeders/ScrapReasonsSeeder.php
@@ -0,0 +1,32 @@
+<?php
+
+namespace Database\Seeders;
+
+use App\Models\ScrapReason;
+use Illuminate\Database\Seeder;
+
+class ScrapReasonsSeeder extends Seeder
+{
+    public function run(): void
+    {
+        $reasons = [
+            ['code' => 'DIM-OOS',   'name' => 'Dimension out of spec', 'category' => ScrapReason::CATEGORY_METHOD],
+            ['code' => 'SURF-DEF',  'name' => 'Surface defect',        'category' => ScrapReason::CATEGORY_MATERIAL],
+            ['code' => 'WRONG-MAT', 'name' => 'Wrong material',        'category' => ScrapReason::CATEGORY_MATERIAL],
+            ['code' => 'MACH-FAIL', 'name' => 'Machine malfunction',   'category' => ScrapReason::CATEGORY_MACHINE],
+            ['code' => 'OP-ERR',    'name' => 'Operator error',        'category' => ScrapReason::CATEGORY_MAN],
+        ];
+
+        foreach ($reasons as $index => $reason) {
+            ScrapReason::firstOrCreate(
+                ['code' => $reason['code']],
+                [
+                    'name' => $reason['name'],
+                    'category' => $reason['category'],
+                    'is_active' => true,
+                    'sort_order' => $index,
+                ]
+            );
+        }
+    }
+}
diff --git a/backend/lang/en.json b/backend/lang/en.json
index fc69b6b3..2974f59b 100644
--- a/backend/lang/en.json
+++ b/backend/lang/en.json
@@ -2921,5 +2921,49 @@
     "— Select site —": "— Select site —",
     "— Select —": "— Select —",
     "— no plan (ad-hoc) —": "— no plan (ad-hoc) —",
-    "← Back to Site": "← Back to Site"
+    "← Back to Site": "← Back to Site",
+    "Scrap Reasons": "Scrap Reasons",
+    "Code or name": "Code or name",
+    "All categories": "All categories",
+    "Entries": "Entries",
+    "No scrap reasons yet": "No scrap reasons yet",
+    "New Scrap Reason": "New Scrap Reason",
+    "Define a reason operators can pick when reporting scrap": "Define a reason operators can pick when reporting scrap",
+    "— Select category —": "— Select category —",
+    "5M defect taxonomy (Ishikawa)": "5M defect taxonomy (Ishikawa)",
+    "Sort order": "Sort order",
+    "Edit Scrap Reason": "Edit Scrap Reason",
+    "Scrap Reports": "Scrap Reports",
+    "Total scrap quantity": "Total scrap quantity",
+    "Scrap entries": "Scrap entries",
+    "Distinct reasons": "Distinct reasons",
+    "Top reason": "Top reason",
+    "of total": "of total",
+    "Scrap Pareto by reason": "Scrap Pareto by reason",
+    "No scrap reported in this period.": "No scrap reported in this period.",
+    "Cumulative %": "Cumulative %",
+    "Scrap by category": "Scrap by category",
+    "No data.": "No data.",
+    "Scrap rate per line": "Scrap rate per line",
+    "Scrap rate": "Scrap rate",
+    "Scrap trend over time": "Scrap trend over time",
+    "Report": "Report",
+    "Total scrap": "Total scrap",
+    "No scrap reported.": "No scrap reported.",
+    "more": "more",
+    "Report Scrap": "Report Scrap",
+    "— Select reason —": "— Select reason —",
+    "Additional details…": "Additional details…",
+    "Scrap reason created successfully.": "Scrap reason created successfully.",
+    "Scrap reason updated successfully.": "Scrap reason updated successfully.",
+    "Cannot delete scrap reason with existing entries. Deactivate it instead.": "Cannot delete scrap reason with existing entries. Deactivate it instead.",
+    "Scrap reason deleted successfully.": "Scrap reason deleted successfully.",
+    "activated": "activated",
+    "deactivated": "deactivated",
+    "Scrap reason :status successfully.": "Scrap reason :status successfully.",
+    "This work order does not belong to the selected line.": "This work order does not belong to the selected line.",
+    "Scrap recorded successfully.": "Scrap recorded successfully.",
+    "Machine": "Machine",
+    "Man": "Man",
+    "Environment": "Environment"
 }
diff --git a/backend/lang/pl.json b/backend/lang/pl.json
index d0b41782..47f90653 100644
--- a/backend/lang/pl.json
+++ b/backend/lang/pl.json
@@ -2921,5 +2921,49 @@
     "— Select site —": "— Wybierz zakład —",
     "— Select —": "— Wybierz —",
     "— no plan (ad-hoc) —": "— bez planu (ad-hoc) —",
-    "← Back to Site": "← Powrót do zakładu"
+    "← Back to Site": "← Powrót do zakładu",
+    "Scrap Reasons": "Przyczyny odpadów",
+    "Code or name": "Kod lub nazwa",
+    "All categories": "Wszystkie kategorie",
+    "Entries": "Wpisy",
+    "No scrap reasons yet": "Brak przyczyn odpadów",
+    "New Scrap Reason": "Nowa przyczyna odpadów",
+    "Define a reason operators can pick when reporting scrap": "Zdefiniuj przyczynę, którą operatorzy wybiorą przy zgłaszaniu odpadów",
+    "— Select category —": "— Wybierz kategorię —",
+    "5M defect taxonomy (Ishikawa)": "Taksonomia wad 5M (Ishikawa)",
+    "Sort order": "Kolejność",
+    "Edit Scrap Reason": "Edytuj przyczynę odpadów",
+    "Scrap Reports": "Raporty odpadów",
+    "Total scrap quantity": "Łączna ilość odpadów",
+    "Scrap entries": "Wpisy odpadów",
+    "Distinct reasons": "Różne przyczyny",
+    "Top reason": "Główna przyczyna",
+    "of total": "całości",
+    "Scrap Pareto by reason": "Pareto odpadów wg przyczyny",
+    "No scrap reported in this period.": "Brak zgłoszonych odpadów w tym okresie.",
+    "Cumulative %": "Skumulowany %",
+    "Scrap by category": "Odpady wg kategorii",
+    "No data.": "Brak danych.",
+    "Scrap rate per line": "Wskaźnik odpadów na linię",
+    "Scrap rate": "Wskaźnik odpadów",
+    "Scrap trend over time": "Trend odpadów w czasie",
+    "Report": "Zgłoś",
+    "Total scrap": "Łączne odpady",
+    "No scrap reported.": "Brak zgłoszonych odpadów.",
+    "more": "więcej",
+    "Report Scrap": "Zgłoś odpad",
+    "— Select reason —": "— Wybierz przyczynę —",
+    "Additional details…": "Dodatkowe szczegóły…",
+    "Scrap reason created successfully.": "Przyczyna odpadu utworzona.",
+    "Scrap reason updated successfully.": "Przyczyna odpadu zaktualizowana.",
+    "Cannot delete scrap reason with existing entries. Deactivate it instead.": "Nie można usunąć przyczyny odpadu z istniejącymi wpisami. Zamiast tego dezaktywuj ją.",
+    "Scrap reason deleted successfully.": "Przyczyna odpadu usunięta.",
+    "activated": "aktywowana",
+    "deactivated": "dezaktywowana",
+    "Scrap reason :status successfully.": "Przyczyna odpadu :status.",
+    "This work order does not belong to the selected line.": "To zlecenie nie należy do wybranej linii.",
+    "Scrap recorded successfully.": "Odpad zarejestrowany.",
+    "Machine": "Maszyna",
+    "Man": "Człowiek",
+    "Environment": "Środowisko"
 }
diff --git a/backend/lang/tr.json b/backend/lang/tr.json
index 865ac55b..c6fa134d 100644
--- a/backend/lang/tr.json
+++ b/backend/lang/tr.json
@@ -1252,6 +1252,51 @@
     "— Select type —": "— Tip seçin —",
     "— Unassigned —": "— Atanmamış —",
     "← Back": "← Geri",
+    "Scrap Reasons": "Fire Nedenleri",
+    "Code or name": "Kod veya ad",
+    "All categories": "Tüm kategoriler",
+    "Entries": "Kayıtlar",
+    "No scrap reasons yet": "Henüz fire nedeni yok",
+    "New Scrap Reason": "Yeni Fire Nedeni",
+    "Define a reason operators can pick when reporting scrap": "Operatörlerin fire bildirirken seçebileceği bir neden tanımlayın",
+    "— Select category —": "— Kategori seçin —",
+    "5M defect taxonomy (Ishikawa)": "5M hata sınıflandırması (Ishikawa)",
+    "Sort order": "Sıralama",
+    "Edit Scrap Reason": "Fire Nedenini Düzenle",
+    "Scrap Reports": "Fire Raporları",
+    "Total scrap quantity": "Toplam fire miktarı",
+    "Scrap entries": "Fire kayıtları",
+    "Distinct reasons": "Farklı nedenler",
+    "Top reason": "En sık neden",
+    "of total": "toplamın",
+    "Scrap Pareto by reason": "Nedene göre fire Pareto",
+    "No scrap reported in this period.": "Bu dönemde fire bildirilmedi.",
+    "Cumulative %": "Kümülatif %",
+    "Scrap by category": "Kategoriye göre fire",
+    "No data.": "Veri yok.",
+    "Scrap rate per line": "Hat başına fire oranı",
+    "Scrap rate": "Fire oranı",
+    "Scrap trend over time": "Zamana göre fire eğilimi",
+    "Report": "Bildir",
+    "Total scrap": "Toplam fire",
+    "No scrap reported.": "Fire bildirilmedi.",
+    "more": "daha",
+    "Report Scrap": "Fire Bildir",
+    "— Select reason —": "— Neden seçin —",
+    "Additional details…": "Ek ayrıntılar…",
+    "Scrap reason created successfully.": "Fire nedeni başarıyla oluşturuldu.",
+    "Scrap reason updated successfully.": "Fire nedeni başarıyla güncellendi.",
+    "Cannot delete scrap reason with existing entries. Deactivate it instead.": "Kaydı olan fire nedeni silinemez. Bunun yerine pasifleştirin.",
+    "Scrap reason deleted successfully.": "Fire nedeni başarıyla silindi.",
+    "activated": "etkinleştirildi",
+    "deactivated": "pasifleştirildi",
+    "Scrap reason :status successfully.": "Fire nedeni başarıyla :status.",
+    "This work order does not belong to the selected line.": "Bu iş emri seçili hatta ait değil.",
+    "Scrap recorded successfully.": "Fire başarıyla kaydedildi.",
+    "Machine": "Makine",
+    "Man": "İnsan",
+    "Environment": "Çevre",
+    "Method": "Yöntem",
     "Add tag": "Etiket ekle",
     "All connectivity": "Tüm bağlantılar",
     "Anonymous": "Anonim",
diff --git a/backend/resources/js/Pages/admin/scrap-reasons/Create.jsx b/backend/resources/js/Pages/admin/scrap-reasons/Create.jsx
new file mode 100644
index 00000000..75c8b8bc
--- /dev/null
+++ b/backend/resources/js/Pages/admin/scrap-reasons/Create.jsx
@@ -0,0 +1,23 @@
+import { Head } from '@inertiajs/react';
+import AppLayout from '../../../layouts/AppLayout';
+import ResourceForm from '../../../components/ResourceForm';
+import { SCRAP_REASON_FIELDS } from './fields';
+
+export default function ScrapReasonCreate() {
+    return (
+        <div className="max-w-7xl mx-auto">
+            <Head title="New Scrap Reason" />
+            <h1 className="text-3xl font-bold text-gray-800 mb-6">New Scrap Reason</h1>
+            <ResourceForm
+                action="/admin/scrap-reasons"
+                method="post"
+                fields={SCRAP_REASON_FIELDS}
+                initial={{ code: '', name: '', category: '', description: '', sort_order: 0, is_active: true }}
+                submitLabel="Create"
+                cancelHref="/admin/scrap-reasons"
+            />
+        </div>
+    );
+}
+
+ScrapReasonCreate.layout = (page) => <AppLayout>{page}</AppLayout>;
diff --git a/backend/resources/js/Pages/admin/scrap-reasons/Edit.jsx b/backend/resources/js/Pages/admin/scrap-reasons/Edit.jsx
new file mode 100644
index 00000000..4cd699be
--- /dev/null
+++ b/backend/resources/js/Pages/admin/scrap-reasons/Edit.jsx
@@ -0,0 +1,30 @@
+import { Head } from '@inertiajs/react';
+import AppLayout from '../../../layouts/AppLayout';
+import ResourceForm from '../../../components/ResourceForm';
+import { SCRAP_REASON_FIELDS } from './fields';
+
+export default function ScrapReasonEdit({ scrapReason }) {
+    return (
+        <div className="max-w-7xl mx-auto">
+            <Head title={`Edit ${scrapReason.name}`} />
+            <h1 className="text-3xl font-bold text-gray-800 mb-6">Edit Scrap Reason</h1>
+            <ResourceForm
+                action={`/admin/scrap-reasons/${scrapReason.id}`}
+                method="put"
+                fields={SCRAP_REASON_FIELDS}
+                initial={{
+                    code: scrapReason.code ?? '',
+                    name: scrapReason.name ?? '',
+                    category: scrapReason.category ?? '',
+                    description: scrapReason.description ?? '',
+                    sort_order: scrapReason.sort_order ?? 0,
+                    is_active: !!scrapReason.is_active,
+                }}
+                submitLabel="Save Changes"
+                cancelHref="/admin/scrap-reasons"
+            />
+        </div>
+    );
+}
+
+ScrapReasonEdit.layout = (page) => <AppLayout>{page}</AppLayout>;
diff --git a/backend/resources/js/Pages/admin/scrap-reasons/Index.jsx b/backend/resources/js/Pages/admin/scrap-reasons/Index.jsx
new file mode 100644
index 00000000..d6e66e44
--- /dev/null
+++ b/backend/resources/js/Pages/admin/scrap-reasons/Index.jsx
@@ -0,0 +1,53 @@
+import { Head, router, usePage } from '@inertiajs/react';
+import AppLayout from '../../../layouts/AppLayout';
+import ResourceTable, { ActiveBadge } from '../../../components/ResourceTable';
+import { SCRAP_CATEGORIES } from './fields';
+
+const CATEGORY_LABELS = Object.fromEntries(SCRAP_CATEGORIES.map((c) => [c.value, c.label]));
+
+export default function ScrapReasonsIndex() {
+    const { counts = {} } = usePage().props;
+
+    const columns = [
+        { key: 'code', label: 'Code', className: 'font-mono text-gray-700' },
+        { key: 'name', label: 'Name', className: 'font-medium text-gray-800' },
+        { key: 'category', label: 'Category', className: 'text-gray-600', render: (r) => CATEGORY_LABELS[r.category] ?? r.category },
+        { key: 'scrap_entries', label: 'Used', align: 'right', render: (r) => counts[r.id] ?? 0 },
+        { key: 'is_active', label: 'Status', render: (r) => <ActiveBadge active={r.is_active} /> },
+    ];
+
+    const actions = (r) => [
+        { label: 'Edit', href: `/admin/scrap-reasons/${r.id}/edit` },
+        {
+            label: r.is_active ? 'Deactivate' : 'Activate',
+            onClick: () => router.post(`/admin/scrap-reasons/${r.id}/toggle-active`, {}, { preserveScroll: true }),
+        },
+        {
+            label: 'Delete',
+            className: 'text-red-600 hover:underline',
+            onClick: () => {
+                if (confirm(`Delete scrap reason "${r.name}"?`)) {
+                    router.delete(`/admin/scrap-reasons/${r.id}`, { preserveScroll: true });
+                }
+            },
+        },
+    ];
+
+    return (
+        <>
+            <Head title="Scrap Reasons" />
+            <ResourceTable
+                shape="scrap_reasons"
+                title="Scrap Reasons"
+                createHref="/admin/scrap-reasons/create"
+                createLabel="+ New Reason"
+                columns={columns}
+                orderBy="sort_order"
+                actions={actions}
+                emptyText="No scrap reasons yet."
+            />
+        </>
+    );
+}
+
+ScrapReasonsIndex.layout = (page) => <AppLayout>{page}</AppLayout>;
diff --git a/backend/resources/js/Pages/admin/scrap-reasons/fields.js b/backend/resources/js/Pages/admin/scrap-reasons/fields.js
new file mode 100644
index 00000000..19c52372
--- /dev/null
+++ b/backend/resources/js/Pages/admin/scrap-reasons/fields.js
@@ -0,0 +1,17 @@
+// 5M defect taxonomy (Ishikawa) — must match ScrapReason::CATEGORIES on the backend.
+export const SCRAP_CATEGORIES = [
+    { value: 'material', label: 'Material' },
+    { value: 'machine', label: 'Machine' },
+    { value: 'method', label: 'Method' },
+    { value: 'man', label: 'Man' },
+    { value: 'environment', label: 'Environment' },
+];
+
+export const SCRAP_REASON_FIELDS = [
+    { name: 'code', label: 'Code', required: true },
+    { name: 'name', label: 'Name', required: true },
+    { name: 'category', label: 'Category', type: 'select', required: true, options: [{ value: '', label: '— Select category —' }, ...SCRAP_CATEGORIES] },
+    { name: 'description', label: 'Description', type: 'textarea' },
+    { name: 'sort_order', label: 'Sort order', type: 'number' },
+    { name: 'is_active', label: 'Active', type: 'checkbox' },
+];
diff --git a/backend/resources/js/Pages/admin/scrap-reports/Index.jsx b/backend/resources/js/Pages/admin/scrap-reports/Index.jsx
new file mode 100644
index 00000000..c8cc5c49
--- /dev/null
+++ b/backend/resources/js/Pages/admin/scrap-reports/Index.jsx
@@ -0,0 +1,174 @@
+import { Head, router, usePage } from '@inertiajs/react';
+import AppLayout from '../../../layouts/AppLayout';
+
+const CATEGORY_LABELS = {
+    material: 'Material',
+    machine: 'Machine',
+    method: 'Method',
+    man: 'Man',
+    environment: 'Environment',
+    unknown: 'Unknown',
+};
+
+const num = (v) => Number(v ?? 0);
+const fmt = (v) => num(v).toLocaleString(undefined, { maximumFractionDigits: 2 });
+
+export default function ScrapReportsIndex() {
+    const {
+        lines = [], lineId, dateFrom, dateTo,
+        pareto = { total_qty: 0, total_entries: 0, reasons: [] },
+        ratePerLine = [],
+    } = usePage().props;
+
+    const reasons = pareto.reasons ?? [];
+    const topReason = reasons[0] ?? null;
+    const maxQty = Math.max(...reasons.map((r) => num(r.qty)), 1);
+
+    const apply = (changes) =>
+        router.get('/admin/scrap-reports', { line_id: lineId ?? '', date_from: dateFrom, date_to: dateTo, ...changes }, { preserveState: false });
+
+    return (
+        <>
+            <Head title="Scrap Reports" />
+            <div className="max-w-7xl mx-auto space-y-6">
+                <div>
+                    <h1 className="text-3xl font-bold text-gray-800 dark:text-gray-100">Scrap Reports</h1>
+                    <p className="text-gray-500 dark:text-gray-400 mt-1 text-sm">Which reasons cause the most scrap (Pareto), and scrap rate per line.</p>
+                </div>
+
+                {/* Filters */}
+                <div className="bg-white dark:bg-slate-800 rounded-lg shadow-sm p-4 flex flex-wrap items-end gap-4">
+                    <Filter label="Line">
+                        <select value={lineId ?? ''} onChange={(e) => apply({ line_id: e.target.value })} className="form-input py-1.5 text-sm min-w-[160px]">
+                            <option value="">All Lines</option>
+                            {lines.map((l) => <option key={l.id} value={l.id}>{l.name}</option>)}
+                        </select>
+                    </Filter>
+                    <Filter label="From">
+                        <input type="date" value={dateFrom ?? ''} onChange={(e) => apply({ date_from: e.target.value })} className="form-input py-1.5 text-sm" />
+                    </Filter>
+                    <Filter label="To">
+                        <input type="date" value={dateTo ?? ''} onChange={(e) => apply({ date_to: e.target.value })} className="form-input py-1.5 text-sm" />
+                    </Filter>
+                </div>
+
+                {/* KPI cards */}
+                <div className="grid grid-cols-2 lg:grid-cols-4 gap-4">
+                    <Kpi label="Total scrap quantity" value={fmt(pareto.total_qty)} />
+                    <Kpi label="Scrap entries" value={fmt(pareto.total_entries)} />
+                    <Kpi label="Distinct reasons" value={reasons.length} />
+                    <Kpi label="Top reason" value={topReason?.name ?? '—'} sub={topReason ? `${num(topReason.pct).toFixed(1)}% of total` : null} />
+                </div>
+
+                {/* Pareto: simple sorted bars + table */}
+                <Card title="Scrap Pareto by reason">
+                    {reasons.length === 0 ? <Empty>No scrap reported in this period.</Empty> : (
+                        <>
+                            <div className="space-y-2 mb-6">
+                                {reasons.map((r) => (
+                                    <div key={r.scrap_reason_id} className="flex items-center gap-3 text-sm">
+                                        <span className="w-44 shrink-0 truncate text-gray-700 dark:text-gray-200" title={r.name}>{r.name}</span>
+                                        <div className="flex-1 h-5 bg-gray-100 dark:bg-slate-700 rounded">
+                                            <div className="h-5 bg-red-500 rounded" style={{ width: `${(num(r.qty) / maxQty) * 100}%` }} />
+                                        </div>
+                                        <span className="w-28 shrink-0 text-right tabular-nums text-gray-700 dark:text-gray-200">
+                                            {fmt(r.qty)} <span className="text-gray-400">({num(r.pct).toFixed(1)}%)</span>
+                                        </span>
+                                    </div>
+                                ))}
+                            </div>
+                            <div className="overflow-x-auto">
+                                <table className="min-w-full text-sm divide-y divide-gray-200 dark:divide-gray-700">
+                                    <thead>
+                                        <tr>
+                                            {['Code', 'Reason', 'Category', 'Quantity', '% of Total', 'Cumulative %'].map((h, i) => (
+                                                <th key={h} className={`px-3 py-2 text-xs font-medium text-gray-500 uppercase ${i >= 3 ? 'text-right' : 'text-left'}`}>{h}</th>
+                                            ))}
+                                        </tr>
+                                    </thead>
+                                    <tbody className="divide-y divide-gray-100 dark:divide-gray-700">
+                                        {reasons.map((r) => (
+                                            <tr key={r.scrap_reason_id}>
+                                                <td className="px-3 py-2 font-mono text-gray-600 dark:text-gray-300">{r.code}</td>
+                                                <td className="px-3 py-2 font-medium text-gray-800 dark:text-gray-100">{r.name}</td>
+                                                <td className="px-3 py-2 text-gray-600 dark:text-gray-300">{CATEGORY_LABELS[r.category] ?? r.category}</td>
+                                                <td className="px-3 py-2 text-right tabular-nums">{fmt(r.qty)}</td>
+                                                <td className="px-3 py-2 text-right tabular-nums">{num(r.pct).toFixed(1)}%</td>
+                                                <td className="px-3 py-2 text-right tabular-nums">{num(r.cumulative_pct).toFixed(1)}%</td>
+                                            </tr>
+                                        ))}
+                                    </tbody>
+                                </table>
+                            </div>
+                        </>
+                    )}
+                </Card>
+
+                {/* Scrap rate per line: simple table */}
+                <Card title="Scrap rate per line">
+                    {ratePerLine.length === 0 ? <Empty>No data.</Empty> : (
+                        <div className="overflow-x-auto">
+                            <table className="min-w-full text-sm divide-y divide-gray-200 dark:divide-gray-700">
+                                <thead>
+                                    <tr>
+                                        {['Line', 'Scrap', 'Produced', 'Scrap rate'].map((h, i) => (
+                                            <th key={h} className={`px-3 py-2 text-xs font-medium text-gray-500 uppercase ${i >= 1 ? 'text-right' : 'text-left'}`}>{h}</th>
+                                        ))}
+                                    </tr>
+                                </thead>
+                                <tbody className="divide-y divide-gray-100 dark:divide-gray-700">
+                                    {ratePerLine.map((r) => (
+                                        <tr key={r.line_id}>
+                                            <td className="px-3 py-2 font-medium text-gray-800 dark:text-gray-100">{r.line_name}</td>
+                                            <td className="px-3 py-2 text-right tabular-nums">{fmt(r.scrap_qty)}</td>
+                                            <td className="px-3 py-2 text-right tabular-nums">{fmt(r.produced_qty)}</td>
+                                            <td className="px-3 py-2 text-right tabular-nums font-medium">
+                                                {r.scrap_rate_pct != null ? num(r.scrap_rate_pct).toFixed(2) + '%' : '—'}
+                                            </td>
+                                        </tr>
+                                    ))}
+                                </tbody>
+                            </table>
+                        </div>
+                    )}
+                </Card>
+            </div>
+        </>
+    );
+}
+
+ScrapReportsIndex.layout = (page) => <AppLayout>{page}</AppLayout>;
+
+/* ─────────────────────────────── helpers ──────────────────────────────────── */
+
+function Filter({ label, children }) {
+    return (
+        <div>
+            <label className="block text-xs font-medium text-gray-500 mb-1">{label}</label>
+            {children}
+        </div>
+    );
+}
+
+function Kpi({ label, value, sub }) {
+    return (
+        <div className="bg-white dark:bg-slate-800 rounded-lg shadow-sm p-5">
+            <p className="text-sm text-gray-500">{label}</p>
+            <p className="text-2xl font-bold text-gray-800 dark:text-gray-100 truncate" title={String(value)}>{value}</p>
+            {sub && <p className="text-xs text-gray-500 mt-0.5">{sub}</p>}
+        </div>
+    );
+}
+
+function Card({ title, children }) {
+    return (
+        <div className="bg-white dark:bg-slate-800 rounded-lg shadow-sm p-5">
+            <h2 className="text-lg font-bold text-gray-800 dark:text-gray-100 mb-4">{title}</h2>
+            {children}
+        </div>
+    );
+}
+
+function Empty({ children }) {
+    return <p className="text-gray-500 text-center py-8">{children}</p>;
+}
diff --git a/backend/resources/js/Pages/operator/WorkOrderDetail.jsx b/backend/resources/js/Pages/operator/WorkOrderDetail.jsx
index 8363e6d5..27537860 100644
--- a/backend/resources/js/Pages/operator/WorkOrderDetail.jsx
+++ b/backend/resources/js/Pages/operator/WorkOrderDetail.jsx
@@ -919,15 +919,123 @@ function ReportIssueModal({ workOrder, issueTypes, onClose }) {
     );
 }
 
+// ---------------------------------------------------------------------------
+// Report Scrap Modal
+// ---------------------------------------------------------------------------
+
+function ReportScrapModal({ workOrder, scrapReasons, onClose }) {
+    const form = useForm({
+        work_order_id: workOrder.id,
+        scrap_reason_id: '',
+        quantity: '',
+        notes: '',
+    });
+
+    const submit = (e) => {
+        e.preventDefault();
+        form.post('/operator/scrap', { onSuccess: onClose });
+    };
+
+    return (
+        <div className="fixed inset-0 z-50 overflow-y-auto">
+            <div className="fixed inset-0 bg-black/50" onClick={onClose} />
+            <div className="flex min-h-full items-center justify-center p-4">
+                <div
+                    className="relative bg-white dark:bg-slate-800 rounded-xl shadow-xl max-w-md w-full p-6"
+                    onClick={(e) => e.stopPropagation()}
+                >
+                    <h3 className="text-xl font-bold text-gray-800 dark:text-gray-100 mb-4">Report Scrap</h3>
+
+                    <form onSubmit={submit}>
+                        <div className="space-y-4">
+                            <div>
+                                <label className="block text-sm font-medium text-gray-700 dark:text-gray-300 mb-1">
+                                    Reason <span className="text-red-500">*</span>
+                                </label>
+                                <select
+                                    value={form.data.scrap_reason_id}
+                                    onChange={(e) => form.setData('scrap_reason_id', e.target.value)}
+                                    className="form-input w-full"
+                                    required
+                                >
+                                    <option value="">— Select reason —</option>
+                                    {scrapReasons.map((reason) => (
+                                        <option key={reason.id} value={reason.id}>
+                                            {reason.code} — {reason.name}
+                                        </option>
+                                    ))}
+                                </select>
+                                {form.errors.scrap_reason_id && (
+                                    <p className="text-red-600 text-sm mt-1">{form.errors.scrap_reason_id}</p>
+                                )}
+                            </div>
+
+                            <div>
+                                <label className="block text-sm font-medium text-gray-700 dark:text-gray-300 mb-1">
+                                    Quantity <span className="text-red-500">*</span>
+                                </label>
+                                <input
+                                    type="number"
+                                    step="0.01"
+                                    min="0.01"
+                                    value={form.data.quantity}
+                                    onChange={(e) => form.setData('quantity', e.target.value)}
+                                    className="form-input w-full"
+                                    placeholder="0"
+                                    required
+                                />
+                                {form.errors.quantity && (
+                                    <p className="text-red-600 text-sm mt-1">{form.errors.quantity}</p>
+                                )}
+                            </div>
+
+                            <div>
+                                <label className="block text-sm font-medium text-gray-700 dark:text-gray-300 mb-1">
+                                    Notes
+                                </label>
+                                <textarea
+                                    value={form.data.notes}
+                                    onChange={(e) => form.setData('notes', e.target.value)}
+                                    rows={3}
+                                    className="form-input w-full"
+                                    placeholder="Additional details…"
+                                    maxLength={2000}
+                                />
+                                {form.errors.notes && (
+                                    <p className="text-red-600 text-sm mt-1">{form.errors.notes}</p>
+                                )}
+                            </div>
+                        </div>
+
+                        <div className="flex gap-3 justify-end mt-6">
+                            <button type="button" onClick={onClose} className="btn-touch btn-secondary">
+                                Cancel
+                            </button>
+                            <button
+                                type="submit"
+                                disabled={form.processing}
+                                className="btn-touch btn-primary bg-amber-600 hover:bg-amber-700 disabled:opacity-50"
+                            >
+                                Report Scrap
+                            </button>
+                        </div>
+                    </form>
+                </div>
+            </div>
+        </div>
+    );
+}
+
 // ---------------------------------------------------------------------------
 // Main page
 // ---------------------------------------------------------------------------
 
 export default function WorkOrderDetail() {
-    const { workOrder, issueTypes = [], workstations = [], defaultWorkstationId, line, labelTemplates = [] } = usePage().props;
+    const { workOrder, issueTypes = [], scrapReasons = [], workstations = [], defaultWorkstationId, line, labelTemplates = [] } = usePage().props;
 
     const [createBatchOpen, setCreateBatchOpen] = useState(false);
     const [reportIssueOpen, setReportIssueOpen] = useState(false);
+    const [reportScrapOpen, setReportScrapOpen] = useState(false);
 
     const plannedQty = workOrder.planned_qty ?? 0;
     const producedQty = workOrder.produced_qty ?? 0;
@@ -936,6 +1044,11 @@ export default function WorkOrderDetail() {
 
     const canCreateBatch = !['DONE', 'CANCELLED', 'BLOCKED'].includes(workOrder.status);
     const canReportIssue = !['DONE', 'CANCELLED'].includes(workOrder.status);
+    const canReportScrap = scrapReasons.length > 0 && !['DONE', 'CANCELLED'].includes(workOrder.status);
+
+    const scrapEntries = workOrder.scrap_entries ?? [];
+    const totalScrap = scrapEntries.reduce((sum, e) => sum + Number(e.quantity ?? 0), 0);
+    const qualityPct = producedQty > 0 ? (Math.max(0, producedQty - totalScrap) / producedQty) * 100 : null;
 
     const dueDateStr = workOrder.due_date;
     const dueDatePast = dueDateStr && new Date(dueDateStr) < new Date() && workOrder.status !== 'DONE';
@@ -1168,6 +1281,64 @@ export default function WorkOrderDetail() {
                                 </div>
                             )}
                         </div>
+
+                        {/* Scrap */}
+                        <div className="bg-white dark:bg-slate-800 rounded-lg shadow-sm p-6">
+                            <div className="flex justify-between items-center mb-4">
+                                <h3 className="text-lg font-bold text-gray-800 dark:text-gray-100">Scrap</h3>
+                                {canReportScrap && (
+                                    <button
+                                        type="button"
+                                        onClick={() => setReportScrapOpen(true)}
+                                        className="text-sm text-amber-600 hover:text-amber-800 font-medium border border-amber-200 hover:border-amber-400 px-3 py-1 rounded-lg transition-colors"
+                                    >
+                                        + Report
+                                    </button>
+                                )}
+                            </div>
+
+                            <div className="flex justify-between text-sm mb-2">
+                                <span className="text-gray-500">Total scrap:</span>
+                                <span className="font-medium">{fmtQty(totalScrap)}</span>
+                            </div>
+                            {qualityPct !== null && (
+                                <div className="flex justify-between text-sm mb-3">
+                                    <span className="text-gray-500">Quality:</span>
+                                    <span className={`font-medium ${qualityPct < 100 ? 'text-amber-600' : 'text-green-600'}`}>
+                                        {qualityPct.toFixed(1)}%
+                                    </span>
+                                </div>
+                            )}
+
+                            {scrapEntries.length === 0 ? (
+                                <p className="text-sm text-gray-400 text-center py-4">No scrap reported.</p>
+                            ) : (
+                                <div className="space-y-2">
+                                    {scrapEntries.slice(0, 5).map((entry) => (
+                                        <div key={entry.id} className="p-3 rounded-lg bg-gray-50 dark:bg-gray-800/50">
+                                            <div className="flex items-center justify-between mb-1">
+                                                <span className="text-xs font-semibold text-gray-800 dark:text-gray-200">
+                                                    {entry.scrap_reason?.name ?? 'Unknown'}
+                                                </span>
+                                                <span className="text-sm font-medium text-gray-700 dark:text-gray-300">{fmtQty(entry.quantity)}</span>
+                                            </div>
+                                            {entry.notes && (
+                                                <p className="text-xs text-gray-500">
+                                                    {entry.notes.length > 80 ? `${entry.notes.slice(0, 80)}…` : entry.notes}
+                                                </p>
+                                            )}
+                                            <p className="text-xs text-gray-400 mt-1">
+                                                {entry.reported_at ? new Date(entry.reported_at).toLocaleString() : ''}
+                                                {entry.reported_by ? ` by ${entry.reported_by.name}` : ''}
+                                            </p>
+                                        </div>
+                                    ))}
+                                    {scrapEntries.length > 5 && (
+                                        <p className="text-xs text-gray-400 text-center">+{scrapEntries.length - 5} more</p>
+                                    )}
+                                </div>
+                            )}
+                        </div>
                     </div>
                 </div>
             </div>
@@ -1189,6 +1360,14 @@ export default function WorkOrderDetail() {
                     onClose={() => setReportIssueOpen(false)}
                 />
             )}
+
+            {reportScrapOpen && (
+                <ReportScrapModal
+                    workOrder={workOrder}
+                    scrapReasons={scrapReasons}
+                    onClose={() => setReportScrapOpen(false)}
+                />
+            )}
         </>
     );
 }
diff --git a/backend/resources/js/layouts/adminNav.js b/backend/resources/js/layouts/adminNav.js
index a96ba7e3..9e689b2f 100644
--- a/backend/resources/js/layouts/adminNav.js
+++ b/backend/resources/js/layouts/adminNav.js
@@ -62,7 +62,7 @@ export const ADMIN_GROUPS = [
             '/admin/product-types', '/admin/materials', '/admin/material-lots',
             '/admin/traceability', '/admin/lot-sequences', '/admin/process-segments', '/admin/lines',
             '/admin/line-statuses', '/admin/view-templates', '/admin/shifts',
-            '/admin/issues', '/admin/companies', '/admin/anomaly-reasons',
+            '/admin/issues', '/admin/companies', '/admin/anomaly-reasons', '/admin/scrap-reasons',
         ],
         children: [
             { label: 'Product Types', href: '/admin/product-types', match: ['/admin/product-types'] },
@@ -85,6 +85,7 @@ export const ADMIN_GROUPS = [
             { label: 'Issues', href: '/admin/issues', match: ['/admin/issues'] },
             { label: 'Companies', href: '/admin/companies', match: ['/admin/companies'] },
             { label: 'Anomaly Reasons', href: '/admin/anomaly-reasons', match: ['/admin/anomaly-reasons'] },
+            { label: 'Scrap Reasons', href: '/admin/scrap-reasons', match: ['/admin/scrap-reasons'] },
         ],
     },
     {
@@ -157,10 +158,11 @@ export const ADMIN_GROUPS = [
         key: 'adminGroup',
         label: 'Admin',
         icon: 'shield',
-        match: ['/admin/users', '/admin/reports', '/admin/logs', '/admin/audit-logs'],
+        match: ['/admin/users', '/admin/reports', '/admin/scrap-reports', '/admin/logs', '/admin/audit-logs'],
         children: [
             { label: 'Users', href: '/admin/users', match: ['/admin/users'] },
             { label: 'Reports', href: '/admin/reports', match: ['/admin/reports'], exact: true },
+            { label: 'Scrap Reports', href: '/admin/scrap-reports', match: ['/admin/scrap-reports'] },
             { label: 'Activity Logs', href: '/admin/logs/activity', match: ['/admin/logs/activity'] },
             { label: 'System Logs', href: '/admin/logs/system', match: ['/admin/logs/system'] },
             { label: 'Audit Logs', href: '/admin/audit-logs', match: ['/admin/audit-logs'] },
diff --git a/backend/routes/api.php b/backend/routes/api.php
index e26a3bec..19af0613 100644
--- a/backend/routes/api.php
+++ b/backend/routes/api.php
@@ -38,6 +38,8 @@
 use App\Http\Controllers\Api\V1\ProductTypeController;
 use App\Http\Controllers\Api\V1\QualityCheckController;
 use App\Http\Controllers\Api\V1\ReportController;
+use App\Http\Controllers\Api\V1\ScrapEntryController;
+use App\Http\Controllers\Api\V1\ScrapReasonController;
 use App\Http\Controllers\Api\V1\ShiftController;
 use App\Http\Controllers\Api\V1\SkillController;
 use App\Http\Controllers\Api\V1\SubassemblyController;
@@ -170,6 +172,8 @@
     Route::get('/cost-sources/{cost_source}', [CostSourceController::class, 'show']);
     Route::get('/anomaly-reasons', [AnomalyReasonController::class, 'index']);
     Route::get('/anomaly-reasons/{anomaly_reason}', [AnomalyReasonController::class, 'show']);
+    Route::get('/scrap-reasons', [ScrapReasonController::class, 'index']);
+    Route::get('/scrap-reasons/{scrapReason}', [ScrapReasonController::class, 'show']);
     Route::get('/subassemblies', [SubassemblyController::class, 'index']);
     Route::get('/subassemblies/{subassembly}', [SubassemblyController::class, 'show']);
     Route::get('/shifts', [ShiftController::class, 'index']);
@@ -251,6 +255,14 @@
     Route::delete('/production-anomalies/{productionAnomaly}', [ProductionAnomalyController::class, 'destroy']);
     Route::post('/production-anomalies/{productionAnomaly}/process', [ProductionAnomalyController::class, 'process']);
 
+    // Scrap entries (operators can record against a work order; admins/supers manage)
+    Route::get('/scrap-entries', [ScrapEntryController::class, 'index']);
+    Route::get('/scrap-entries/{scrapEntry}', [ScrapEntryController::class, 'show']);
+    Route::get('/work-orders/{workOrder}/scrap-entries', [ScrapEntryController::class, 'forWorkOrder']);
+    Route::post('/work-orders/{workOrder}/scrap-entries', [ScrapEntryController::class, 'store']);
+    Route::patch('/scrap-entries/{scrapEntry}', [ScrapEntryController::class, 'update']);
+    Route::delete('/scrap-entries/{scrapEntry}', [ScrapEntryController::class, 'destroy']);
+
     // Additional Costs (admin/supervisor only — policy enforced)
     Route::get('/work-orders/{workOrder}/additional-costs', [AdditionalCostController::class, 'index']);
     Route::post('/work-orders/{workOrder}/additional-costs', [AdditionalCostController::class, 'store']);
@@ -412,6 +424,11 @@
         Route::patch('/anomaly-reasons/{anomaly_reason}', [AnomalyReasonController::class, 'update']);
         Route::delete('/anomaly-reasons/{anomaly_reason}', [AnomalyReasonController::class, 'destroy']);
 
+        // Scrap reasons
+        Route::post('/scrap-reasons', [ScrapReasonController::class, 'store']);
+        Route::match(['put', 'patch'], '/scrap-reasons/{scrapReason}', [ScrapReasonController::class, 'update']);
+        Route::delete('/scrap-reasons/{scrapReason}', [ScrapReasonController::class, 'destroy']);
+
         // Subassemblies
         Route::post('/subassemblies', [SubassemblyController::class, 'store']);
         Route::patch('/subassemblies/{subassembly}', [SubassemblyController::class, 'update']);
@@ -597,6 +614,8 @@
         Route::get('/reports/production-summary', [ReportController::class, 'productionSummary']);
         Route::get('/reports/batch-completion', [ReportController::class, 'batchCompletion']);
         Route::get('/reports/downtime', [ReportController::class, 'downtimeReport']);
+        Route::get('/reports/scrap-pareto', [ReportController::class, 'scrapPareto']);
+        Route::get('/reports/scrap-rate', [ReportController::class, 'scrapRate']);
         Route::get('/reports/export-csv', [ReportController::class, 'exportCsv']);
     });
 
diff --git a/backend/routes/web.php b/backend/routes/web.php
index 83e1d441..4d614ce9 100644
--- a/backend/routes/web.php
+++ b/backend/routes/web.php
@@ -32,6 +32,8 @@
 use App\Http\Controllers\Web\Admin\ReportController as AdminReportController;
 use App\Http\Controllers\Web\Admin\ScheduleController;
 use App\Http\Controllers\Web\Admin\SchedulePlannerController;
+use App\Http\Controllers\Web\Admin\ScrapReasonController;
+use App\Http\Controllers\Web\Admin\ScrapReportController;
 // Gate 3 — Basics
 use App\Http\Controllers\Web\Admin\SiteController;
 use App\Http\Controllers\Web\Admin\SkillController;
@@ -51,6 +53,7 @@
 // Gate 7 — Maintenance
 use App\Http\Controllers\Web\Operator\IssueController as OperatorIssueController;
 use App\Http\Controllers\Web\Operator\LineController as OperatorLineController;
+use App\Http\Controllers\Web\Operator\ScrapController as OperatorScrapController;
 use App\Http\Controllers\Web\Operator\WorkOrderController as OperatorWorkOrderController;
 use App\Http\Controllers\Web\Operator\ProductionCorrectionController;
 use App\Http\Controllers\Web\Operator\WorkstationController as OperatorWorkstationController;
@@ -215,6 +218,7 @@
         Route::post('/batch-step/{batchStep}/complete', [OperatorBatchController::class, 'completeStep'])->name('batch-step.complete');
 
         Route::post('/issue', [OperatorIssueController::class, 'store'])->name('issue.store');
+        Route::post('/scrap', [OperatorScrapController::class, 'store'])->name('scrap.store');
 
         // Production downtime (replaces the old Livewire DowntimeReporter).
         Route::post('/downtime/start', [\App\Http\Controllers\Web\Operator\DowntimeController::class, 'start'])->name('downtime.start');
@@ -493,6 +497,10 @@
         Route::resource('anomaly-reasons', AnomalyReasonController::class)->except(['show']);
         Route::post('/anomaly-reasons/{anomalyReason}/toggle-active', [AnomalyReasonController::class, 'toggleActive'])->name('anomaly-reasons.toggle-active');
 
+        // Scrap Reasons
+        Route::resource('scrap-reasons', ScrapReasonController::class)->except(['show']);
+        Route::post('/scrap-reasons/{scrapReason}/toggle-active', [ScrapReasonController::class, 'toggleActive'])->name('scrap-reasons.toggle-active');
+
         // ── Gate 4: HR ───────────────────────────────────────────────────────
         // Wage Groups
         Route::resource('wage-groups', WageGroupController::class)->except(['show']);
@@ -523,6 +531,9 @@
         Route::post('/production-anomalies/{productionAnomaly}/process', [ProductionAnomalyController::class, 'process'])->name('production-anomalies.process');
         Route::delete('/production-anomalies/{productionAnomaly}', [ProductionAnomalyController::class, 'destroy'])->name('production-anomalies.destroy');
 
+        // Scrap reporting (Pareto, scrap rate per line, trend)
+        Route::get('/scrap-reports', [ScrapReportController::class, 'index'])->name('scrap-reports.index');
+
         // Inspection Plans (admin CRUD)
         Route::resource('inspection-plans', \App\Http\Controllers\Web\Admin\InspectionPlanController::class)->except(['show']);
 
diff --git a/backend/tests/Feature/Api/ScrapApiTest.php b/backend/tests/Feature/Api/ScrapApiTest.php
new file mode 100644
index 00000000..0fcade3b
--- /dev/null
+++ b/backend/tests/Feature/Api/ScrapApiTest.php
@@ -0,0 +1,199 @@
+<?php
+
+namespace Tests\Feature\Api;
+
+use App\Models\Batch;
+use App\Models\ScrapEntry;
+use App\Models\ScrapReason;
+use App\Models\Tenant;
+use App\Models\User;
+use App\Models\WorkOrder;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Tests\TestCase;
+
+class ScrapApiTest extends TestCase
+{
+    use RefreshDatabase;
+
+    private User $admin;
+    private User $operator;
+    private string $adminToken;
+    private string $operatorToken;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+        $this->seed(\Database\Seeders\RolesAndPermissionsSeeder::class);
+
+        $this->admin = User::factory()->create();
+        $this->admin->assignRole('Admin');
+        $this->adminToken = $this->admin->createToken('test')->plainTextToken;
+
+        $this->operator = User::factory()->create();
+        $this->operator->assignRole('Operator');
+        $this->operatorToken = $this->operator->createToken('test')->plainTextToken;
+    }
+
+    private function asAdmin()
+    {
+        return $this->withHeader('Authorization', "Bearer {$this->adminToken}");
+    }
+
+    private function asOperator()
+    {
+        return $this->withHeader('Authorization', "Bearer {$this->operatorToken}");
+    }
+
+    // ── Scrap reasons ────────────────────────────────────────────────────────
+
+    public function test_index_returns_only_active_reasons_by_default(): void
+    {
+        ScrapReason::factory()->create(['code' => 'ACT-1', 'is_active' => true]);
+        ScrapReason::factory()->inactive()->create(['code' => 'INACT-1']);
+
+        $response = $this->asOperator()->getJson('/api/v1/scrap-reasons');
+
+        $response->assertOk();
+        $codes = collect($response->json('data'))->pluck('code');
+        $this->assertTrue($codes->contains('ACT-1'));
+        $this->assertFalse($codes->contains('INACT-1'));
+    }
+
+    public function test_admin_can_create_reason(): void
+    {
+        $this->asAdmin()->postJson('/api/v1/scrap-reasons', [
+            'code' => 'API-1', 'name' => 'Via API', 'category' => 'machine',
+        ])->assertStatus(201)->assertJsonPath('data.code', 'API-1');
+
+        $this->assertDatabaseHas('scrap_reasons', ['code' => 'API-1', 'category' => 'machine']);
+    }
+
+    public function test_operator_cannot_create_reason(): void
+    {
+        $this->asOperator()->postJson('/api/v1/scrap-reasons', [
+            'code' => 'API-1', 'name' => 'Via API', 'category' => 'machine',
+        ])->assertStatus(403);
+
+        $this->assertDatabaseMissing('scrap_reasons', ['code' => 'API-1']);
+    }
+
+    public function test_unauthenticated_cannot_read_reasons(): void
+    {
+        $this->getJson('/api/v1/scrap-reasons')->assertStatus(401);
+    }
+
+    // ── Scrap entries ────────────────────────────────────────────────────────
+
+    public function test_operator_can_report_scrap_against_work_order(): void
+    {
+        $wo = WorkOrder::factory()->create();
+        $reason = ScrapReason::factory()->create();
+
+        $response = $this->asOperator()->postJson("/api/v1/work-orders/{$wo->id}/scrap-entries", [
+            'scrap_reason_id' => $reason->id,
+            'quantity' => 12,
+            'notes' => 'API report',
+        ]);
+
+        $response->assertStatus(201)->assertJsonPath('data.quantity', '12.00');
+        $this->assertDatabaseHas('scrap_entries', [
+            'work_order_id' => $wo->id,
+            'scrap_reason_id' => $reason->id,
+            'reported_by' => $this->operator->id,
+        ]);
+    }
+
+    public function test_reporting_against_inactive_reason_fails_validation(): void
+    {
+        $wo = WorkOrder::factory()->create();
+        $reason = ScrapReason::factory()->inactive()->create();
+
+        $this->asOperator()->postJson("/api/v1/work-orders/{$wo->id}/scrap-entries", [
+            'scrap_reason_id' => $reason->id,
+            'quantity' => 12,
+        ])->assertStatus(422)->assertJsonValidationErrors('scrap_reason_id');
+    }
+
+    public function test_work_order_scrap_listing_includes_totals_and_quality(): void
+    {
+        $wo = WorkOrder::factory()->create(['produced_qty' => 200]);
+        $reason = ScrapReason::factory()->create();
+        ScrapEntry::factory()->create(['work_order_id' => $wo->id, 'scrap_reason_id' => $reason->id, 'quantity' => 50]);
+
+        $response = $this->asOperator()->getJson("/api/v1/work-orders/{$wo->id}/scrap-entries");
+
+        $response->assertOk()
+            ->assertJsonPath('meta.total_scrap_qty', 50)
+            ->assertJsonPath('meta.quality_pct', 75); // (200-50)/200
+    }
+
+    // ── Reports ──────────────────────────────────────────────────────────────
+
+    public function test_scrap_pareto_returns_reasons_sorted_by_quantity(): void
+    {
+        $wo = WorkOrder::factory()->create();
+        $big = ScrapReason::factory()->create(['code' => 'BIG']);
+        $small = ScrapReason::factory()->create(['code' => 'SMALL']);
+        ScrapEntry::factory()->create(['work_order_id' => $wo->id, 'scrap_reason_id' => $big->id, 'quantity' => 90, 'reported_at' => now()]);
+        ScrapEntry::factory()->create(['work_order_id' => $wo->id, 'scrap_reason_id' => $small->id, 'quantity' => 10, 'reported_at' => now()]);
+
+        $response = $this->asAdmin()->getJson('/api/v1/reports/scrap-pareto');
+
+        $response->assertOk();
+        $reasons = $response->json('data.pareto.reasons');
+        $this->assertSame('BIG', $reasons[0]['code']);
+        $this->assertEquals(90, $reasons[0]['pct']);          // 90 / 100
+        $this->assertEquals(100, $reasons[1]['cumulative_pct']);
+    }
+
+    public function test_scrap_rate_per_line(): void
+    {
+        $wo = WorkOrder::factory()->create();
+        Batch::factory()->done()->create(['work_order_id' => $wo->id, 'target_qty' => 100, 'produced_qty' => 100]);
+        $reason = ScrapReason::factory()->create();
+        ScrapEntry::factory()->create(['work_order_id' => $wo->id, 'scrap_reason_id' => $reason->id, 'quantity' => 25, 'reported_at' => now()]);
+
+        $response = $this->asAdmin()->getJson('/api/v1/reports/scrap-rate');
+
+        $response->assertOk();
+        $perLine = collect($response->json('data.per_line'))->firstWhere('line_id', $wo->line_id);
+        $this->assertNotNull($perLine);
+        $this->assertEquals(25, $perLine['scrap_qty']);
+        $this->assertEquals(100, $perLine['produced_qty']);
+        $this->assertEquals(25, $perLine['scrap_rate_pct']);
+    }
+
+    public function test_operator_cannot_access_scrap_reports(): void
+    {
+        $this->asOperator()->getJson('/api/v1/reports/scrap-pareto')->assertStatus(403);
+    }
+
+    public function test_scrap_entries_are_isolated_per_tenant(): void
+    {
+        $tenantA = Tenant::create(['name' => 'Tenant A']);
+        $tenantB = Tenant::create(['name' => 'Tenant B']);
+
+        $operatorA = User::factory()->create(['tenant_id' => $tenantA->id]);
+        $operatorA->assignRole('Operator');
+        $tokenA = $operatorA->createToken('test')->plainTextToken;
+
+        $reason = ScrapReason::factory()->create();
+
+        $woA = WorkOrder::factory()->create(['tenant_id' => $tenantA->id]);
+        $entryA = ScrapEntry::factory()->create(['work_order_id' => $woA->id, 'scrap_reason_id' => $reason->id]);
+
+        $woB = WorkOrder::factory()->create(['tenant_id' => $tenantB->id]);
+        $entryB = ScrapEntry::factory()->create(['work_order_id' => $woB->id, 'scrap_reason_id' => $reason->id]);
+
+        $authA = $this->withHeader('Authorization', "Bearer {$tokenA}");
+
+        // Listing only returns the caller's tenant entries.
+        $ids = collect($authA->getJson('/api/v1/scrap-entries')->json('data'))->pluck('id');
+        $this->assertTrue($ids->contains($entryA->id));
+        $this->assertFalse($ids->contains($entryB->id), 'Cross-tenant scrap entry leaked into listing');
+
+        // A cross-tenant entry is not directly readable; an own entry is.
+        $authA->getJson("/api/v1/scrap-entries/{$entryB->id}")->assertStatus(404);
+        $authA->getJson("/api/v1/scrap-entries/{$entryA->id}")->assertStatus(200);
+    }
+}
diff --git a/backend/tests/Feature/ScrapTest.php b/backend/tests/Feature/ScrapTest.php
new file mode 100644
index 00000000..68bc5923
--- /dev/null
+++ b/backend/tests/Feature/ScrapTest.php
@@ -0,0 +1,69 @@
+<?php
+
+namespace Tests\Feature;
+
+use App\Models\ScrapEntry;
+use App\Models\ScrapReason;
+use App\Models\WorkOrder;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Tests\TestCase;
+
+class ScrapTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_scrap_reason_and_entry_can_be_created(): void
+    {
+        $reason = ScrapReason::factory()->create([
+            'code' => 'TEST-1',
+            'category' => ScrapReason::CATEGORY_MACHINE,
+        ]);
+
+        $entry = ScrapEntry::factory()->create([
+            'scrap_reason_id' => $reason->id,
+            'quantity' => 12.5,
+        ]);
+
+        $this->assertDatabaseHas('scrap_reasons', ['code' => 'TEST-1', 'category' => 'machine']);
+        $this->assertDatabaseHas('scrap_entries', ['scrap_reason_id' => $reason->id]);
+        $this->assertSame('12.50', (string) $entry->quantity);
+        $this->assertTrue($reason->scrapEntries()->whereKey($entry->id)->exists());
+    }
+
+    public function test_work_order_total_scrap_and_quality_accessors(): void
+    {
+        $wo = WorkOrder::factory()->create(['produced_qty' => 100]);
+        $reason = ScrapReason::factory()->create();
+
+        ScrapEntry::factory()->create(['work_order_id' => $wo->id, 'scrap_reason_id' => $reason->id, 'quantity' => 10]);
+        ScrapEntry::factory()->create(['work_order_id' => $wo->id, 'scrap_reason_id' => $reason->id, 'quantity' => 15]);
+
+        $this->assertEqualsWithDelta(25.0, $wo->totalScrapQty(), 0.001);
+        // good = 100 - 25 = 75 → 75%
+        $this->assertEqualsWithDelta(75.0, $wo->qualityPct(), 0.001);
+    }
+
+    public function test_quality_pct_is_null_when_nothing_produced(): void
+    {
+        $wo = WorkOrder::factory()->create(['produced_qty' => 0]);
+
+        $this->assertNull($wo->qualityPct());
+    }
+
+    public function test_quality_pct_clamps_to_zero_when_scrap_exceeds_production(): void
+    {
+        $wo = WorkOrder::factory()->create(['produced_qty' => 10]);
+        $reason = ScrapReason::factory()->create();
+        ScrapEntry::factory()->create(['work_order_id' => $wo->id, 'scrap_reason_id' => $reason->id, 'quantity' => 25]);
+
+        $this->assertSame(0.0, $wo->qualityPct());
+    }
+
+    public function test_default_scrap_reasons_are_seeded(): void
+    {
+        $this->seed(\Database\Seeders\ScrapReasonsSeeder::class);
+
+        $this->assertDatabaseCount('scrap_reasons', 5);
+        $this->assertDatabaseHas('scrap_reasons', ['code' => 'MACH-FAIL', 'category' => 'machine']);
+    }
+}
diff --git a/backend/tests/Feature/Web/Admin/ScrapReasonControllerTest.php b/backend/tests/Feature/Web/Admin/ScrapReasonControllerTest.php
new file mode 100644
index 00000000..21bdc1d9
--- /dev/null
+++ b/backend/tests/Feature/Web/Admin/ScrapReasonControllerTest.php
@@ -0,0 +1,132 @@
+<?php
+
+namespace Tests\Feature\Web\Admin;
+
+use App\Models\ScrapEntry;
+use App\Models\ScrapReason;
+use App\Models\User;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Spatie\Permission\Models\Role;
+use Tests\TestCase;
+
+class ScrapReasonControllerTest extends TestCase
+{
+    use RefreshDatabase;
+
+    private User $admin;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        Role::findOrCreate('Admin', 'web');
+        $this->admin = User::factory()->create();
+        $this->admin->assignRole('Admin');
+    }
+
+    public function test_admin_can_list_scrap_reasons(): void
+    {
+        ScrapReason::factory()->create(['name' => 'Burr on edge']);
+
+        // The Inertia index renders the React page; rows live-sync via the
+        // `scrap_reasons` Electric shape rather than being server-rendered, so
+        // we only assert the page loads for an admin.
+        $response = $this->actingAs($this->admin)->get(route('admin.scrap-reasons.index'));
+
+        $response->assertOk();
+    }
+
+    public function test_admin_can_create_scrap_reason(): void
+    {
+        $response = $this->actingAs($this->admin)->post(route('admin.scrap-reasons.store'), [
+            'code' => 'WELD-CRACK',
+            'name' => 'Weld crack',
+            'category' => ScrapReason::CATEGORY_METHOD,
+            'is_active' => '1',
+        ]);
+
+        $response->assertRedirect(route('admin.scrap-reasons.index'));
+        $response->assertSessionHasNoErrors();
+        $this->assertDatabaseHas('scrap_reasons', [
+            'code' => 'WELD-CRACK',
+            'category' => 'method',
+            'is_active' => true,
+        ]);
+    }
+
+    public function test_category_must_be_a_valid_5m_value(): void
+    {
+        $response = $this->actingAs($this->admin)->post(route('admin.scrap-reasons.store'), [
+            'code' => 'BAD',
+            'name' => 'Bad category',
+            'category' => 'gremlins',
+        ]);
+
+        $response->assertSessionHasErrors('category');
+    }
+
+    public function test_code_must_be_unique(): void
+    {
+        ScrapReason::factory()->create(['code' => 'DUP-1']);
+
+        $response = $this->actingAs($this->admin)->post(route('admin.scrap-reasons.store'), [
+            'code' => 'DUP-1',
+            'name' => 'Duplicate',
+            'category' => ScrapReason::CATEGORY_MAN,
+        ]);
+
+        $response->assertSessionHasErrors('code');
+    }
+
+    public function test_admin_can_update_scrap_reason(): void
+    {
+        $reason = ScrapReason::factory()->create(['name' => 'Old']);
+
+        $response = $this->actingAs($this->admin)->put(route('admin.scrap-reasons.update', $reason), [
+            'code' => $reason->code,
+            'name' => 'New name',
+            'category' => ScrapReason::CATEGORY_MACHINE,
+        ]);
+
+        $response->assertRedirect(route('admin.scrap-reasons.index'));
+        $this->assertDatabaseHas('scrap_reasons', ['id' => $reason->id, 'name' => 'New name', 'category' => 'machine']);
+    }
+
+    public function test_admin_can_toggle_active(): void
+    {
+        $reason = ScrapReason::factory()->create(['is_active' => true]);
+
+        $this->actingAs($this->admin)->post(route('admin.scrap-reasons.toggle-active', $reason));
+
+        $this->assertFalse($reason->fresh()->is_active);
+    }
+
+    public function test_reason_with_entries_cannot_be_deleted(): void
+    {
+        $reason = ScrapReason::factory()->create();
+        ScrapEntry::factory()->create(['scrap_reason_id' => $reason->id]);
+
+        $response = $this->actingAs($this->admin)->delete(route('admin.scrap-reasons.destroy', $reason));
+
+        $response->assertSessionHas('error');
+        $this->assertDatabaseHas('scrap_reasons', ['id' => $reason->id]);
+    }
+
+    public function test_unused_reason_can_be_deleted(): void
+    {
+        $reason = ScrapReason::factory()->create();
+
+        $this->actingAs($this->admin)->delete(route('admin.scrap-reasons.destroy', $reason));
+
+        $this->assertDatabaseMissing('scrap_reasons', ['id' => $reason->id]);
+    }
+
+    public function test_non_admin_cannot_manage_scrap_reasons(): void
+    {
+        Role::findOrCreate('Operator', 'web');
+        $operator = User::factory()->create();
+        $operator->assignRole('Operator');
+
+        $this->actingAs($operator)->get(route('admin.scrap-reasons.index'))->assertForbidden();
+    }
+}
diff --git a/backend/tests/Feature/Web/Admin/ScrapReportControllerTest.php b/backend/tests/Feature/Web/Admin/ScrapReportControllerTest.php
new file mode 100644
index 00000000..0eb3ccd0
--- /dev/null
+++ b/backend/tests/Feature/Web/Admin/ScrapReportControllerTest.php
@@ -0,0 +1,55 @@
+<?php
+
+namespace Tests\Feature\Web\Admin;
+
+use App\Models\ScrapEntry;
+use App\Models\ScrapReason;
+use App\Models\User;
+use App\Models\WorkOrder;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Spatie\Permission\Models\Role;
+use Tests\TestCase;
+
+class ScrapReportControllerTest extends TestCase
+{
+    use RefreshDatabase;
+
+    private User $admin;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        Role::findOrCreate('Admin', 'web');
+        $this->admin = User::factory()->create();
+        $this->admin->assignRole('Admin');
+    }
+
+    public function test_report_page_renders_with_pareto_data(): void
+    {
+        $reason = ScrapReason::factory()->create(['name' => 'Porosity', 'code' => 'POR-1']);
+        $wo = WorkOrder::factory()->create(['produced_qty' => 100]);
+        ScrapEntry::factory()->create([
+            'work_order_id' => $wo->id,
+            'scrap_reason_id' => $reason->id,
+            'quantity' => 20,
+            'reported_at' => now(),
+        ]);
+
+        $response = $this->actingAs($this->admin)->get(route('admin.scrap-reports.index'));
+
+        $response->assertOk();
+        $response->assertSee('Porosity');
+        $response->assertSee('POR-1');
+    }
+
+    public function test_invalid_date_range_is_rejected(): void
+    {
+        $response = $this->actingAs($this->admin)->get(route('admin.scrap-reports.index', [
+            'date_from' => '2026-06-10',
+            'date_to' => '2026-06-01',
+        ]));
+
+        $response->assertSessionHasErrors('date_to');
+    }
+}
diff --git a/backend/tests/Feature/Web/Operator/ScrapReportingTest.php b/backend/tests/Feature/Web/Operator/ScrapReportingTest.php
new file mode 100644
index 00000000..f5b63374
--- /dev/null
+++ b/backend/tests/Feature/Web/Operator/ScrapReportingTest.php
@@ -0,0 +1,83 @@
+<?php
+
+namespace Tests\Feature\Web\Operator;
+
+use App\Models\ScrapReason;
+use App\Models\User;
+use App\Models\WorkOrder;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Spatie\Permission\Models\Role;
+use Tests\TestCase;
+
+class ScrapReportingTest extends TestCase
+{
+    use RefreshDatabase;
+
+    private User $operator;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        Role::findOrCreate('Operator', 'web');
+        $this->operator = User::factory()->create();
+        $this->operator->assignRole('Operator');
+    }
+
+    public function test_operator_can_report_scrap_against_work_order_on_their_line(): void
+    {
+        $wo = WorkOrder::factory()->create();
+        $reason = ScrapReason::factory()->create(['is_active' => true]);
+
+        $response = $this->actingAs($this->operator)
+            ->withSession(['selected_line_id' => $wo->line_id])
+            ->post(route('operator.scrap.store'), [
+                'work_order_id' => $wo->id,
+                'scrap_reason_id' => $reason->id,
+                'quantity' => 7.5,
+                'notes' => 'Cracked during handling',
+            ]);
+
+        $response->assertRedirect();
+        $response->assertSessionHas('success');
+        $this->assertDatabaseHas('scrap_entries', [
+            'work_order_id' => $wo->id,
+            'scrap_reason_id' => $reason->id,
+            'quantity' => 7.5,
+            'reported_by' => $this->operator->id,
+        ]);
+    }
+
+    public function test_scrap_against_wrong_line_is_blocked(): void
+    {
+        $wo = WorkOrder::factory()->create();
+        $reason = ScrapReason::factory()->create();
+
+        $response = $this->actingAs($this->operator)
+            ->withSession(['selected_line_id' => $wo->line_id + 999])
+            ->post(route('operator.scrap.store'), [
+                'work_order_id' => $wo->id,
+                'scrap_reason_id' => $reason->id,
+                'quantity' => 5,
+            ]);
+
+        $response->assertSessionHas('error');
+        $this->assertDatabaseMissing('scrap_entries', ['work_order_id' => $wo->id]);
+    }
+
+    public function test_inactive_reason_is_rejected(): void
+    {
+        $wo = WorkOrder::factory()->create();
+        $reason = ScrapReason::factory()->inactive()->create();
+
+        $response = $this->actingAs($this->operator)
+            ->withSession(['selected_line_id' => $wo->line_id])
+            ->post(route('operator.scrap.store'), [
+                'work_order_id' => $wo->id,
+                'scrap_reason_id' => $reason->id,
+                'quantity' => 5,
+            ]);
+
+        $response->assertSessionHasErrors('scrap_reason_id');
+    }
+}