Merge remote-tracking branch 'origin/dev' into agent/dex/CUB-33-moonraker-usage-polling

# Conflicts:
#	backend/Domain/Interfaces/IMoonrakerClient.cs
#	backend/Infrastructure/Services/MoonrakerClient.cs

README.md

@@ -0,0 +1,220 @@
+# Extrudex
+
+> Filament inventory and print tracking system for CubeCraft Creations.
+
+Extrudex replaces Spoolman with a fully custom solution built for Joshua's 7-printer fleet. It tracks spool stock, per-print material consumption, and cost-of-goods — with a touch-optimized kiosk interface on a Raspberry Pi 5.
+
+---
+
+## Tech Stack
+
+| Layer | Technology |
+|---|---|
+| Backend | ASP.NET Core Web API (.NET 8) |
+| Database | PostgreSQL (snake_case via EF Core) |
+| ORM | Entity Framework Core |
+| Real-time | SignalR (`PrinterHub`) |
+| Printer integration | Moonraker REST/WebSocket (Elegoo) · MQTTnet + TLS (Bambu Lab) |
+| Frontend | Angular 17+, Angular Material |
+| Deployment | Docker · Docker Compose |
+
+---
+
+## Project Structure
+
+```
+Extrudex/
+├── backend/
+│   ├── Domain/
+│   │   ├── Base/                   # BaseEntity, AuditableEntity
+│   │   ├── Entities/               # Spool, Printer, PrintJob, FilamentUsage,
+│   │   │                           #   AmsUnit, AmsSlot, MaterialBase,
+│   │   │                           #   MaterialFinish, MaterialModifier
+│   │   ├── Enums/                  # ConnectionType, DataSource, JobStatus,
+│   │   │                           #   PrinterStatus, PrinterType, QrResourceType
+│   │   └── Interfaces/             # ICostPerPrintService, IFilamentUsageSyncService,
+│   │                               #   IMoonrakerClient, IQrCodeService
+│   ├── Infrastructure/
+│   │   ├── Configuration/          # FilamentUsageSyncOptions
+│   │   ├── Data/
+│   │   │   ├── Configurations/     # EF Core fluent configs (snake_case)
+│   │   │   ├── Migrations/         # EF migrations
+│   │   │   ├── Seed/               # SeedData.cs
+│   │   │   └── ExtrudexDbContext.cs
+│   │   └── Services/               # CostPerPrintService, FilamentUsageSyncService,
+│   │                               #   MoonrakerClient, QrCodeService
+│   └── API/
+│       ├── Controllers/            # Filaments, Spools, Printers, PrintJobs,
+│       │                           #   MaterialBases, MaterialFinishes,
+│       │                           #   MaterialModifiers, MaterialLookups,
+│       │                           #   CostAnalysis, QR
+│       ├── DTOs/                   # Request/response shapes per domain
+│       ├── Filters/                # FluentValidationFilter
+│       ├── Hubs/                   # PrinterHub, IPrinterClient
+│       ├── Jobs/                   # FilamentUsageSyncJob (background)
+│       ├── Validators/             # FluentValidation validators
+│       ├── Program.cs
+│       └── appsettings.json
+├── frontend/
+│   └── src/app/
+│       ├── components/             # DashboardSummary, FilamentFilter, FilamentTable
+│       ├── models/                 # Filament, Agent model types
+│       └── app.routes.ts
+├── design/                         # UX specs and mockups (kiosk + mobile)
+├── docker-compose.dev.yml
+├── deploy.sh
+└── README.md
+```
+
+---
+
+## Domain Model
+
+### Materials (normalized taxonomy)
+
+| Entity | Description |
+|---|---|
+| `MaterialBase` | The base material type — PLA, PETG, ABS, ASA, TPU, etc. |
+| `MaterialFinish` | Required. Surface finish — Basic (default), Matte, Silk, Sparkle, etc. |
+| `MaterialModifier` | Optional. Composite fill — Carbon Fiber, Glass Fiber, Wood, etc. |
+
+**Rules:**
+- `MaterialFinish` is required — every spool must have one. Default is `"Basic"`.
+- `MaterialModifier` is optional — plain PLA has no modifier.
+
+### Consumption calculation
+
+```
+grams_used = mm_extruded × filament_cross_section_area × material_density
+```
+
+Grams are always derived, never assumed from printer telemetry directly.
+
+### Printers
+
+| Type | Integration |
+|---|---|
+| Bambu Lab (×5) | MQTTnet with TLS |
+| Elegoo Centauri Carbon | Moonraker REST + WebSocket |
+| Elegoo Saturn (resin ×2) | Manual / future |
+
+AMS units and slots are modelled as `AmsUnit` → `AmsSlot[]` → `Spool`.
+
+---
+
+## Key Design Decisions
+
+1. **Spoolman rejected** — Full custom system for data model control and workflow flexibility.
+2. **`"Basic"` not `"Standard"`** — Default `MaterialFinish` value is `Basic`.
+3. **`MaterialFinish` is required** — No null/optional finish state allowed.
+4. **`MaterialModifier` is optional** — Not every spool has a modifier.
+5. **Derived consumption** — Grams calculated from mm × density, never assumed.
+6. **Push over poll** — SignalR and MQTT preferred over periodic polling.
+7. **Snake_case PostgreSQL** — All database identifiers follow this convention via EF Core.
+
+---
+
+## Getting Started
+
+### Prerequisites
+
+- .NET 8 SDK
+- Node.js 20+
+- Docker + Docker Compose
+- PostgreSQL (or use the dev compose stack)
+
+### Backend
+
+```bash
+cd backend
+
+# Restore and build
+dotnet restore
+dotnet build
+
+# Apply migrations
+dotnet ef database update
+
+# Run API (dev)
+dotnet run --project API
+```
+
+API runs at `http://localhost:5000` · Swagger at `http://localhost:5000/swagger`
+
+### Frontend
+
+```bash
+cd frontend
+npm install
+ng serve
+```
+
+Frontend runs at `http://localhost:4200`
+
+### Docker (dev stack)
+
+```bash
+docker-compose -f docker-compose.dev.yml up
+```
+
+---
+
+## Configuration
+
+`backend/appsettings.json` — override in `appsettings.Development.json` or environment variables:
+
+| Key | Default | Description |
+|---|---|---|
+| `ConnectionStrings:ExtrudexDb` | `Host=localhost;...` | PostgreSQL connection string |
+| `FilamentUsageSync:PollingInterval` | `00:05:00` | Sync job interval |
+| `FilamentUsageSync:RequestTimeout` | `00:00:30` | Moonraker request timeout |
+| `FilamentUsageSync:Enabled` | `true` | Enable/disable background sync |
+
+---
+
+## Real-Time Events
+
+SignalR hub endpoint: `/hubs/printer`
+
+Clients receive `PrinterHub` events for live printer status, job progress, and spool consumption updates.
+
+---
+
+## API Overview
+
+| Route prefix | Resource |
+|---|---|
+| `/api/filaments` | Filament catalog |
+| `/api/spools` | Spool inventory |
+| `/api/printers` | Printer registry |
+| `/api/print-jobs` | Print job tracking |
+| `/api/material-bases` | Material base types |
+| `/api/material-finishes` | Material finishes |
+| `/api/material-modifiers` | Material modifiers |
+| `/api/material-lookups` | Combined material lookup |
+| `/api/cost-analysis` | Cost-per-print and COGS |
+| `/api/qr` | QR code generation |
+
+Full schema available at `/swagger` when running in dev.
+
+---
+
+## CI
+
+Gitea Actions pipeline (`.gitea/workflows/dev.yml`) runs on every push to `dev`:
+
+- `dotnet build`
+- Frontend `ng build`
+
+---
+
+## Branch & PR Rules
+
+- All feature branches target `dev` — **never `main`**
+- Branch naming: `agent/<agent>/CUB-N-short-description`
+- PR titles: `CUB-N: short description`
+- PRs require Otto review before Joshua merges
+
+---
+
+*Built by CubeCraft Creations · Orchestrated by Otto*

backend/API/Controllers/FilamentsController.cs

@@ -40,15 +40,18 @@ public class FilamentsController : ControllerBase
     /// <response code="200">Returns the paginated list of filament spools.</response>
     [HttpGet]
     [ProducesResponseType(typeof(PagedResponse<FilamentResponse>), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status400BadRequest)]
     public async Task<ActionResult<PagedResponse<FilamentResponse>>> GetFilaments(
         [FromQuery] FilamentQueryParameters query)
     {
         _logger.LogDebug(
             "Getting filaments: pageNumber={PageNumber}, pageSize={PageSize}, " +
             "materialBaseId={MaterialBaseId}, materialFinishId={MaterialFinishId}, " +
-            "materialModifierId={MaterialModifierId}, brand={Brand}, isActive={IsActive}",
+            "materialModifierId={MaterialModifierId}, brand={Brand}, isActive={IsActive}, " +
+            "includeArchived={IncludeArchived}, storageLocation={StorageLocation}",
             query.PageNumber, query.PageSize, query.MaterialBaseId,
-            query.MaterialFinishId, query.MaterialModifierId, query.Brand, query.IsActive);
+            query.MaterialFinishId, query.MaterialModifierId, query.Brand, query.IsActive,
+            query.IncludeArchived, query.StorageLocation);
 
         // Clamp pagination values
         var pageNumber = Math.Max(1, query.PageNumber);
@@ -77,6 +80,15 @@ public class FilamentsController : ControllerBase
         if (query.IsActive.HasValue)
             spoolQuery = spoolQuery.Where(s => s.IsActive == query.IsActive.Value);
 
+        // Exclude archived spools by default; include when explicitly requested
+        if (query.IncludeArchived != true)
+            spoolQuery = spoolQuery.Where(s => !s.IsArchived);
+
+        if (!string.IsNullOrWhiteSpace(query.StorageLocation))
+            spoolQuery = spoolQuery.Where(s =>
+                s.StorageLocation != null &&
+                s.StorageLocation.ToLower().Contains(query.StorageLocation.ToLower()));
+
         var totalCount = await spoolQuery.CountAsync();
 
         var items = await spoolQuery
@@ -185,7 +197,9 @@ public class FilamentsController : ControllerBase
             SpoolSerial = request.SpoolSerial,
             PurchasePrice = request.PurchasePrice,
             PurchaseDate = request.PurchaseDate,
-            IsActive = request.IsActive
+            IsActive = request.IsActive,
+            IsArchived = request.IsArchived,
+            StorageLocation = request.StorageLocation
         };
 
         _dbContext.Spools.Add(entity);
@@ -267,6 +281,8 @@ public class FilamentsController : ControllerBase
         entity.PurchasePrice = request.PurchasePrice;
         entity.PurchaseDate = request.PurchaseDate;
         entity.IsActive = request.IsActive;
+        entity.IsArchived = request.IsArchived;
+        entity.StorageLocation = request.StorageLocation;
 
         await _dbContext.SaveChangesAsync();
 
@@ -307,6 +323,8 @@ public class FilamentsController : ControllerBase
         PurchasePrice = s.PurchasePrice,
         PurchaseDate = s.PurchaseDate,
         IsActive = s.IsActive,
+        IsArchived = s.IsArchived,
+        StorageLocation = s.StorageLocation,
         CreatedAt = s.CreatedAt,
         UpdatedAt = s.UpdatedAt,
         QrCodeUrl = $"/api/qr/spool/{s.Id}"

backend/API/Controllers/PrintJobsController.cs

@@ -413,6 +413,92 @@ public class PrintJobsController : ControllerBase
         return NoContent();
     }
 
+    // ── GET /api/printjobs/{id}/cost-summary ──────────────────────────
+
+    /// <summary>
+    /// Gets the material cost summary for a specific print job.
+    /// Calculates total material cost from filament usage (grams derived)
+    /// and the spool's purchase price. Returns warnings instead of errors
+    /// when cost data is unavailable.
+    /// </summary>
+    /// <param name="id">The unique identifier of the print job.</param>
+    /// <returns>A cost summary with breakdown and any warnings about missing data.</returns>
+    /// <response code="200">Returns the cost summary. Warnings field lists any missing data.</response>
+    /// <response code="404">If the print job with the given ID is not found.</response>
+    [HttpGet("{id:guid}/cost-summary")]
+    [ProducesResponseType(typeof(CostSummaryResponse), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    public async Task<ActionResult<CostSummaryResponse>> GetCostSummary(Guid id)
+    {
+        _logger.LogDebug("Getting cost summary for print job {Id}", id);
+
+        var job = await _dbContext.PrintJobs
+            .Include(j => j.Spool)
+                .ThenInclude(s => s!.MaterialBase)
+            .FirstOrDefaultAsync(j => j.Id == id);
+
+        if (job is null)
+        {
+            _logger.LogWarning("Print job {Id} not found for cost summary", id);
+            return NotFound(new { error = $"Print job with ID '{id}' not found." });
+        }
+
+        var warnings = new List<string>();
+        var spool = job.Spool;
+
+        // Build response with what we have
+        var response = new CostSummaryResponse
+        {
+            PrintJobId = job.Id,
+            PrintName = job.PrintName,
+            SpoolId = job.SpoolId,
+            SpoolSerial = spool?.SpoolSerial ?? string.Empty,
+            SpoolBrand = spool?.Brand ?? string.Empty,
+            SpoolColorName = spool?.ColorName ?? string.Empty,
+            MmExtruded = job.MmExtruded,
+            GramsDerived = job.GramsDerived,
+            SpoolPurchasePrice = spool?.PurchasePrice,
+            SpoolWeightTotalGrams = spool?.WeightTotalGrams,
+            StoredCostPerPrint = job.CostPerPrint
+        };
+
+        // Validate spool data availability
+        if (spool is null)
+        {
+            warnings.Add("Spool data is not available for this print job. Cost cannot be calculated.");
+            response.Warnings = warnings;
+            return Ok(response);
+        }
+
+        // Check if we can calculate cost
+        if (!spool.PurchasePrice.HasValue)
+        {
+            warnings.Add("Spool purchase price is not set. Cost per gram and total material cost cannot be calculated.");
+        }
+
+        if (spool.WeightTotalGrams <= 0)
+        {
+            warnings.Add("Spool total weight is zero or invalid. Cost per gram and total material cost cannot be calculated.");
+        }
+
+        // If we have enough data, calculate the cost
+        if (spool.PurchasePrice.HasValue && spool.WeightTotalGrams > 0)
+        {
+            var pricePerGram = spool.PurchasePrice.Value / spool.WeightTotalGrams;
+            response.PricePerGram = Math.Round(pricePerGram, 4);
+            response.TotalMaterialCost = Math.Round(job.GramsDerived * pricePerGram, 4);
+        }
+
+        // Warn if grams derived is zero but mm extruded is non-zero
+        if (job.GramsDerived == 0 && job.MmExtruded > 0)
+        {
+            warnings.Add("GramsDerived is zero despite MmExtruded being non-zero. Cost may be inaccurate. Consider re-deriving grams from filament parameters.");
+        }
+
+        response.Warnings = warnings;
+        return Ok(response);
+    }
+
     // ── Gram Derivation Formula ────────────────────────────────────
 
     /// <summary>

backend/API/DTOs/Filaments/FilamentDtos.cs

@@ -59,6 +59,12 @@ public class FilamentResponse
     /// <summary>Whether the spool is currently active and available.</summary>
     public bool IsActive { get; set; }
 
+    /// <summary>Whether the spool has been archived (removed from active inventory).</summary>
+    public bool IsArchived { get; set; }
+
+    /// <summary>Physical storage location (e.g., "Shelf A", "Drawer 3"). Null if unset.</summary>
+    public string? StorageLocation { get; set; }
+
     /// <summary>Timestamp when this record was created (UTC).</summary>
     public DateTime CreatedAt { get; set; }
 
@@ -133,6 +139,15 @@ public class CreateFilamentRequest
 
     /// <summary>Whether the spool is active. Defaults to true.</summary>
     public bool IsActive { get; set; } = true;
+
+    /// <summary>Whether the spool is archived. Defaults to false.
+    /// </summary>
+    public bool IsArchived { get; set; } = false;
+
+    /// <summary>Physical storage location (e.g., "Shelf A", "Drawer 3"). Optional.
+    /// </summary>
+    [StringLength(200, ErrorMessage = "StorageLocation must not exceed 200 characters.")]
+    public string? StorageLocation { get; set; }
 }
 
 /// <summary>
@@ -196,4 +211,11 @@ public class UpdateFilamentRequest
 
     /// <summary>Whether the spool is active.</summary>
     public bool IsActive { get; set; } = true;
+
+    /// <summary>Whether the spool is archived. Defaults to false.</summary>
+    public bool IsArchived { get; set; } = false;
+
+    /// <summary>Physical storage location (e.g., "Shelf A", "Drawer 3"). Optional.</summary>
+    [StringLength(200, ErrorMessage = "StorageLocation must not exceed 200 characters.")]
+    public string? StorageLocation { get; set; }
 }

backend/API/DTOs/Filaments/FilamentQueryDtos.cs

@@ -30,4 +30,11 @@ public class FilamentQueryParameters
 
     /// <summary>Optional filter by active status. True = active only, False = inactive only.</summary>
     public bool? IsActive { get; set; }
+
+    /// <summary>Whether to include archived spools in results. Defaults to false (excludes archived).
+    /// </summary>
+    public bool? IncludeArchived { get; set; }
+
+    /// <summary>Optional filter by storage location (case-insensitive partial match).</summary>
+    public string? StorageLocation { get; set; }
 }

backend/API/DTOs/PrintJobs/CostSummaryResponse.cs

@@ -0,0 +1,55 @@
+namespace Extrudex.API.DTOs.PrintJobs;
+
+/// <summary>
+/// Response DTO for the cost summary of a print job.
+/// Provides a breakdown of material cost based on filament usage
+/// and spool pricing data. If cost data is incomplete, warnings
+/// are returned instead of throwing an error.
+/// </summary>
+public class CostSummaryResponse
+{
+    /// <summary>Unique identifier of the print job.</summary>
+    public Guid PrintJobId { get; set; }
+
+    /// <summary>Human-readable name of the print job.</summary>
+    public string PrintName { get; set; } = string.Empty;
+
+    /// <summary>Foreign key to the spool used for this print job.</summary>
+    public Guid SpoolId { get; set; }
+
+    /// <summary>Serial number of the spool.</summary>
+    public string SpoolSerial { get; set; } = string.Empty;
+
+    /// <summary>Brand of the spool.</summary>
+    public string SpoolBrand { get; set; } = string.Empty;
+
+    /// <summary>Color name of the spool.</summary>
+    public string SpoolColorName { get; set; } = string.Empty;
+
+    /// <summary>Total millimeters of filament extruded during this print.</summary>
+    public decimal MmExtruded { get; set; }
+
+    /// <summary>Derived grams consumed for this print job.</summary>
+    public decimal GramsDerived { get; set; }
+
+    /// <summary>Purchase price of the full spool, if available.</summary>
+    public decimal? SpoolPurchasePrice { get; set; }
+
+    /// <summary>Total weight of the spool in grams when full.</summary>
+    public decimal? SpoolWeightTotalGrams { get; set; }
+
+    /// <summary>Calculated price per gram (purchase price / total weight), if available.</summary>
+    public decimal? PricePerGram { get; set; }
+
+    /// <summary>Calculated total material cost for this print job, if available.</summary>
+    public decimal? TotalMaterialCost { get; set; }
+
+    /// <summary>The CostPerPrint stored on the print job entity, if set.</summary>
+    public decimal? StoredCostPerPrint { get; set; }
+
+    /// <summary>
+    /// Warnings about missing data that prevent cost calculation.
+    /// Empty if all data is available and cost was calculated successfully.
+    /// </summary>
+    public List<string> Warnings { get; set; } = new();
+}

backend/API/Validators/FilamentValidators.cs

@@ -10,6 +10,9 @@ namespace Extrudex.API.Validators;
 /// </summary>
 public class CreateFilamentRequestValidator : AbstractValidator<CreateFilamentRequest>
 {
+    /// <summary>
+    /// Initializes validation rules for <see cref="CreateFilamentRequest"/>.
+    /// </summary>
     public CreateFilamentRequestValidator()
     {
         RuleFor(x => x.MaterialBaseId)
@@ -52,6 +55,12 @@ public class CreateFilamentRequestValidator : AbstractValidator<CreateFilamentRe
             RuleFor(x => x.PurchasePrice!.Value)
                 .GreaterThanOrEqualTo(0).WithMessage("Purchase price must be non-negative.");
         });
+
+        When(x => x.StorageLocation != null, () =>
+        {
+            RuleFor(x => x.StorageLocation!)
+                .MaximumLength(200).WithMessage("StorageLocation must not exceed 200 characters.");
+        });
     }
 }
 
@@ -62,6 +71,9 @@ public class CreateFilamentRequestValidator : AbstractValidator<CreateFilamentRe
 /// </summary>
 public class UpdateFilamentRequestValidator : AbstractValidator<UpdateFilamentRequest>
 {
+    /// <summary>
+    /// Initializes validation rules for <see cref="UpdateFilamentRequest"/>.
+    /// </summary>
     public UpdateFilamentRequestValidator()
     {
         RuleFor(x => x.MaterialBaseId)
@@ -104,5 +116,11 @@ public class UpdateFilamentRequestValidator : AbstractValidator<UpdateFilamentRe
             RuleFor(x => x.PurchasePrice!.Value)
                 .GreaterThanOrEqualTo(0).WithMessage("Purchase price must be non-negative.");
         });
+
+        When(x => x.StorageLocation != null, () =>
+        {
+            RuleFor(x => x.StorageLocation!)
+                .MaximumLength(200).WithMessage("StorageLocation must not exceed 200 characters.");
+        });
     }
 }

backend/Domain/DTOs/Moonraker/MoonrakerDisplayStatus.cs

@@ -0,0 +1,19 @@
+namespace Extrudex.Domain.DTOs.Moonraker;
+
+/// <summary>
+/// Response DTO for Moonraker /printer/objects/query?display_status endpoint.
+/// Contains progress percentage and message for the current print job.
+/// Used by the SignalR hub to push real-time progress to connected clients.
+/// </summary>
+public class MoonrakerDisplayStatus
+{
+    /// <summary>
+    /// Print progress as a decimal between 0 and 1 (0% to 100%).
+    /// </summary>
+    public decimal Progress { get; set; }
+
+    /// <summary>
+    /// Status message displayed on the printer LCD (e.g., "Printing...", "Heating...").
+    /// </summary>
+    public string Message { get; set; } = string.Empty;
+}

backend/Domain/DTOs/Moonraker/MoonrakerHistoryResponse.cs

@@ -0,0 +1,20 @@
+namespace Extrudex.Domain.DTOs.Moonraker;
+
+/// <summary>
+/// Response DTO for the Moonraker /server/history/items endpoint.
+/// Wraps the paginated list of print job history items.
+/// </summary>
+public class MoonrakerHistoryResponse
+{
+    /// <summary>
+    /// The list of print job history items returned by Moonraker.
+    /// Most recent jobs appear first (descending by start time).
+    /// </summary>
+    public List<MoonrakerPrintJob> Items { get; set; } = [];
+
+    /// <summary>
+    /// Total number of print jobs available on the server
+    /// (for pagination; the Items list may be a subset).
+    /// </summary>
+    public int TotalCount { get; set; }
+}

backend/Domain/DTOs/Moonraker/MoonrakerPrintJob.cs

@@ -0,0 +1,56 @@
+namespace Extrudex.Domain.DTOs.Moonraker;
+
+/// <summary>
+/// Response DTO for a single Moonraker print job history item.
+/// Maps to the objects returned by /server/history/items.
+/// Contains filament usage, duration, and status for a completed or active print.
+/// </summary>
+public class MoonrakerPrintJob
+{
+    /// <summary>
+    /// Unique Moonraker job identifier (e.g., "000001").
+    /// </summary>
+    public string JobId { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Filename of the G-code file that was printed.
+    /// </summary>
+    public string Filename { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Current status of this print job: "completed", "cancelled", "error", "in_progress".
+    /// </summary>
+    public string Status { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Total filament used in millimeters for this print job.
+    /// This is the primary measurement; grams are derived from this value.
+    /// </summary>
+    public decimal FilamentUsedMm { get; set; }
+
+    /// <summary>
+    /// Total print duration in seconds.
+    /// </summary>
+    public decimal PrintDurationSeconds { get; set; }
+
+    /// <summary>
+    /// Total print duration including setup and warmup, in seconds.
+    /// </summary>
+    public decimal TotalDurationSeconds { get; set; }
+
+    /// <summary>
+    /// Timestamp when the print job started (UTC).
+    /// </summary>
+    public DateTime? StartTime { get; set; }
+
+    /// <summary>
+    /// Timestamp when the print job ended (UTC). Null if still in progress.
+    /// </summary>
+    public DateTime? EndTime { get; set; }
+
+    /// <summary>
+    /// Metadata dictionary from Moonraker. May contain filament_type,
+    /// filament_name, nozzle_diameter, and other slicer-provided fields.
+    /// </summary>
+    public Dictionary<string, object> Metadata { get; set; } = new();
+}

backend/Domain/DTOs/Moonraker/MoonrakerPrintStats.cs

@@ -0,0 +1,36 @@
+namespace Extrudex.Domain.DTOs.Moonraker;
+
+/// <summary>
+/// Response DTO for Moonraker /printer/objects/query?print_stats endpoint.
+/// Contains real-time print statistics including current job state,
+    /// filament consumed, and file being printed.
+/// </summary>
+public class MoonrakerPrintStats
+{
+    /// <summary>
+    /// Current print state: "standby", "printing", "paused", "complete", "error", "cancelled".
+    /// </summary>
+    public string State { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Total filament used in millimeters for the current print session.
+    /// </summary>
+    public decimal FilamentUsedMm { get; set; }
+
+    /// <summary>
+    /// Total print duration in seconds for the current print session.
+    /// </summary>
+    public decimal PrintDurationSeconds { get; set; }
+
+    /// <summary>
+    /// Filename of the G-code file currently being printed.
+    /// Null if no print is active.
+    /// </summary>
+    public string? Filename { get; set; }
+
+    /// <summary>
+    /// Detailed message from Klipper about the current print state.
+    /// May contain error details when state is "error".
+    /// </summary>
+    public string? Message { get; set; }
+}

backend/Domain/DTOs/Moonraker/MoonrakerPrinterInfo.cs

@@ -0,0 +1,26 @@
+namespace Extrudex.Domain.DTOs.Moonraker;
+
+/// <summary>
+/// Response DTO for the Moonraker /printer/info endpoint.
+/// Contains the current operational state of the Klipper printer.
+/// Used to determine whether the printer is idle, printing, paused, or in error.
+/// </summary>
+public class MoonrakerPrinterInfo
+{
+    /// <summary>
+    /// Current Klipper state: "ready", "startup", "shutdown", "error", "cancelled".
+    /// A "ready" state means the printer is connected and idle.
+    /// </summary>
+    public string State { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Detailed state message from Klipper. May contain error details
+    /// when the state is "error" or "shutdown".
+    /// </summary>
+    public string StateMessage { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Whether the Klipper firmware is currently connected and responsive.
+    /// </summary>
+    public bool KlippyReady { get; set; }
+}

backend/Domain/DTOs/Moonraker/MoonrakerRequest.cs

@@ -0,0 +1,25 @@
+namespace Extrudex.Domain.DTOs.Moonraker;
+
+/// <summary>
+/// Request DTO for querying the Moonraker API.
+/// Encapsulates the connection parameters needed to reach a specific
+/// Moonraker instance on a Klipper-based printer.
+/// </summary>
+public class MoonrakerRequest
+{
+    /// <summary>
+    /// Hostname or IP address of the Moonraker printer.
+    /// </summary>
+    public string HostnameOrIp { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Port number for the Moonraker API. Default: 7125.
+    /// </summary>
+    public int Port { get; set; } = 7125;
+
+    /// <summary>
+    /// Optional API key for authenticating with Moonraker.
+    /// Required when the server has API key authentication enabled.
+    /// </summary>
+    public string? ApiKey { get; set; }
+}

backend/Domain/DTOs/Moonraker/MoonrakerServerInfo.cs

@@ -0,0 +1,44 @@
+namespace Extrudex.Domain.DTOs.Moonraker;
+
+/// <summary>
+/// Response DTO for the Moonraker /server/info endpoint.
+/// Contains server identification and operational state.
+/// Used to verify connectivity and determine Moonraker version.
+/// </summary>
+public class MoonrakerServerInfo
+{
+    /// <summary>
+    /// The hostname of the Moonraker server (e.g., "mainsail").
+    /// </summary>
+    public string Hostname { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Moonraker software version string (e.g., "0.8.0-89ee464").
+    /// </summary>
+    public string SoftwareVersion { get; set; } = string.Empty;
+
+    /// <summary>
+    /// CPU model string reported by the host system.
+    /// </summary>
+    public string CpuInfo { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Whether Klipper is currently connected to the MCU.
+    /// </summary>
+    public bool KlippyConnected { get; set; }
+
+    /// <summary>
+    /// The current Klipper state (e.g., "ready", "startup", "error").
+    /// </summary>
+    public string KlippyState { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Whether the Moonraker API requires an authentication token.
+    /// </summary>
+    public bool ApiKeyRequired { get; set; }
+
+    /// <summary>
+    /// List of registered Moonraker plugin names.
+    /// </summary>
+    public List<string> Plugins { get; set; } = [];
+}

backend/Domain/Entities/Spool.cs

@@ -93,6 +93,20 @@ public class Spool : AuditableEntity
     /// </summary>
     public bool IsActive { get; set; } = true;
 
+    /// <summary>
+    /// Whether the spool has been archived (removed from active inventory).
+    /// Archived spools are retained for historical records but hidden from
+    /// default inventory views. Distinguishes long-term archival from
+    /// temporary inactivity (e.g., spool swapped out of AMS).
+    /// </summary>
+    public bool IsArchived { get; set; } = false;
+
+    /// <summary>
+    /// Physical storage location of the spool (e.g., "Shelf A", "Drawer 3", "AMS Tray 2").
+    /// Optional — not every spool has a designated storage location.
+    /// </summary>
+    public string? StorageLocation { get; set; }
+
     /// <summary>
     /// Navigation collection of AMS slots where this spool is loaded.
     /// </summary>

backend/Domain/Interfaces/IFilamentUsageService.cs

@@ -0,0 +1,50 @@
+using Extrudex.Domain.Entities;
+
+namespace Extrudex.Domain.Interfaces;
+
+/// <summary>
+/// Service for persisting and querying filament usage records.
+/// Tracks consumption per print job and per spool for COGS and inventory tracking.
+/// </summary>
+public interface IFilamentUsageService
+{
+    /// <summary>
+    /// Records a new filament usage entry for a print job.
+    /// </summary>
+    /// <param name="printJobId">The print job that consumed the filament.</param>
+    /// <param name="spoolId">The spool that provided the filament.</param>
+    /// <param name="printerId">The printer that executed the print.</param>
+    /// <param name="gramsUsed">Grams of filament consumed.</param>
+    /// <param name="mmExtruded">Millimeters of filament extruded.</param>
+    /// <param name="notes">Optional notes about this usage record.</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    /// <returns>The created FilamentUsage entity.</returns>
+    Task<FilamentUsage> RecordUsageAsync(
+        Guid printJobId,
+        Guid spoolId,
+        Guid printerId,
+        decimal gramsUsed,
+        decimal mmExtruded,
+        string? notes = null,
+        CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Retrieves all filament usage records for a specific print job.
+    /// </summary>
+    /// <param name="printJobId">The print job ID.</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    /// <returns>Collection of filament usage records for the print job.</returns>
+    Task<IReadOnlyList<FilamentUsage>> GetByPrintJobAsync(
+        Guid printJobId,
+        CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Retrieves all filament usage records for a specific spool.
+    /// </summary>
+    /// <param name="spoolId">The spool ID.</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    /// <returns>Collection of filament usage records for the spool.</returns>
+    Task<IReadOnlyList<FilamentUsage>> GetBySpoolAsync(
+        Guid spoolId,
+        CancellationToken cancellationToken = default);
+}

backend/Domain/Interfaces/IMoonrakerClient.cs

@@ -0,0 +1,131 @@
+using Extrudex.Domain.DTOs.Moonraker;
+
+namespace Extrudex.Domain.Interfaces;
+
+/// <summary>
+/// Client interface for communicating with Moonraker REST API endpoints
+/// on Klipper-based printers (e.g., Elegoo Centauri Carbon).
+/// Provides strongly-typed methods for server discovery, printer status,
+/// print job history, and real-time telemetry.
+/// </summary>
+public interface IMoonrakerClient
+{
+    /// <summary>
+    /// Checks whether the Moonraker server is reachable and responding.
+    /// Calls the /server/info endpoint and returns the server information
+    /// if successful, or null if the server is unreachable.
+    /// </summary>
+    /// <param name="hostnameOrIp">The printer's hostname or IP address.</param>
+    /// <param name="port">The Moonraker API port (default: 7125).</param>
+    /// <param name="apiKey">Optional API key for authentication.</param>
+    /// <param name="cancellationToken">Cancellation token for the HTTP request.</param>
+    /// <returns>Server info if reachable; <c>null</c> if unreachable.</returns>
+    Task<MoonrakerServerInfo?> GetServerInfoAsync(
+        string hostnameOrIp,
+        int port,
+        string? apiKey,
+        CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Checks whether the Moonraker server is reachable and responding.
+    /// This is a convenience method equivalent to calling GetServerInfoAsync
+    /// and checking for a non-null result.
+    /// </summary>
+    /// <param name="hostnameOrIp">The printer's hostname or IP address.</param>
+    /// <param name="port">The Moonraker API port (default: 7125).</param>
+    /// <param name="apiKey">Optional API key for authentication.</param>
+    /// <param name="cancellationToken">Cancellation token for the HTTP request.</param>
+    /// <returns><c>true</c> if the server responded successfully; otherwise <c>false</c>.</returns>
+    Task<bool> IsReachableAsync(
+        string hostnameOrIp,
+        int port,
+        string? apiKey,
+        CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Fetches the current printer info from the /printer/info endpoint.
+    /// Returns the Klipper state and readiness status.
+    /// </summary>
+    /// <param name="hostnameOrIp">The printer's hostname or IP address.</param>
+    /// <param name="port">The Moonraker API port (default: 7125).</param>
+    /// <param name="apiKey">Optional API key for authentication.</param>
+    /// <param name="cancellationToken">Cancellation token for the HTTP request.</param>
+    /// <returns>Printer info if successful; <c>null</c> if the request failed.</returns>
+    Task<MoonrakerPrinterInfo?> GetPrinterInfoAsync(
+        string hostnameOrIp,
+        int port,
+        string? apiKey,
+        CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Fetches print job history from the /server/history/items endpoint.
+    /// Returns the most recent print jobs with filament usage data,
+    /// print duration, and completion status.
+    /// </summary>
+    /// <param name="hostnameOrIp">The printer's hostname or IP address.</param>
+    /// <param name="port">The Moonraker API port (default: 7125).</param>
+    /// <param name="apiKey">Optional API key for authentication.</param>
+    /// <param name="limit">Maximum number of history items to return. Default: 50.</param>
+    /// <param name="cancellationToken">Cancellation token for the HTTP request.</param>
+    /// <returns>History response with print jobs; empty list if request failed.</returns>
+    Task<MoonrakerHistoryResponse> GetPrintHistoryAsync(
+        string hostnameOrIp,
+        int port,
+        string? apiKey,
+        int limit = 50,
+        CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Fetches the current print statistics from the /printer/objects/query endpoint.
+    /// Returns real-time data including filament used, print duration,
+    /// and current print state for the active or most recent print.
+    /// </summary>
+    /// <param name="hostnameOrIp">The printer's hostname or IP address.</param>
+    /// <param name="port">The Moonraker API port (default: 7125).</param>
+    /// <param name="apiKey">Optional API key for authentication.</param>
+    /// <param name="cancellationToken">Cancellation token for the HTTP request.</param>
+    /// <returns>Print stats if successful; <c>null</c> if the request failed.</returns>
+    Task<MoonrakerPrintStats?> GetPrintStatsAsync(
+        string hostnameOrIp,
+        int port,
+        string? apiKey,
+        CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Fetches the current display status from the /printer/objects/query endpoint.
+    /// Returns progress percentage and status message for the active print.
+    /// Used by SignalR to push real-time progress updates to connected clients.
+    /// </summary>
+    /// <param name="hostnameOrIp">The printer's hostname or IP address.</param>
+    /// <param name="port">The Moonraker API port (default: 7125).</param>
+    /// <param name="apiKey">Optional API key for authentication.</param>
+    /// <param name="cancellationToken">Cancellation token for the HTTP request.</param>
+    /// <returns>Display status if successful; <c>null</c> if the request failed.</returns>
+    Task<MoonrakerDisplayStatus?> GetDisplayStatusAsync(
+        string hostnameOrIp,
+        int port,
+        string? apiKey,
+        CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Fetches the current filament usage data from the Moonraker server.
+    /// Returns a dictionary of usage metrics reported by the printer.
+    /// 
+    /// <para>
+    /// <b>Prefer GetPrintHistoryAsync or GetPrintStatsAsync for new code.</b>
+    /// This method is retained for backward compatibility with the
+    /// FilamentUsageSyncService and returns a dictionary of metric names
+    /// to their decimal values for callers that don't need typed DTOs.
+    /// </para>
+    /// </summary>
+    /// <param name="hostnameOrIp">The printer's hostname or IP address.</param>
+    /// <param name="port">The Moonraker API port (default: 7125).</param>
+    /// <param name="apiKey">Optional API key for authentication.</param>
+    /// <param name="cancellationToken">Cancellation token for the HTTP request.</param>
+    /// <returns>A dictionary of usage metric names to their decimal values.</returns>
+    Task<Dictionary<string, decimal>> GetFilamentUsageAsync(
+        string hostnameOrIp,
+        int port,
+        string? apiKey,
+        CancellationToken cancellationToken = default);
+}

backend/Infrastructure/Data/Configurations/SpoolConfiguration.cs

@@ -68,6 +68,15 @@ public class SpoolConfiguration : BaseEntityConfiguration<Spool>
             .HasDefaultValue(true)
             .IsRequired();
 
+        builder.Property(e => e.IsArchived)
+            .HasColumnName("is_archived")
+            .HasDefaultValue(false)
+            .IsRequired();
+
+        builder.Property(e => e.StorageLocation)
+            .HasColumnName("storage_location")
+            .HasMaxLength(200);
+
         // Unique index on spool_serial — critical for barcode/QR scanning
         builder.HasIndex(e => e.SpoolSerial)
             .IsUnique()
@@ -89,6 +98,14 @@ public class SpoolConfiguration : BaseEntityConfiguration<Spool>
         builder.HasIndex(e => e.IsActive)
             .HasDatabaseName("ix_spools_is_active");
 
+        // Index on is_archived for inventory filtering (exclude archived from default views)
+        builder.HasIndex(e => e.IsArchived)
+            .HasDatabaseName("ix_spools_is_archived");
+
+        // Composite index on is_active + is_archived for common inventory queries
+        builder.HasIndex(e => new { e.IsActive, e.IsArchived })
+            .HasDatabaseName("ix_spools_active_archived");
+
         // Relationships
         builder.HasOne(e => e.MaterialBase)
             .WithMany(e => e.Spools)

backend/Infrastructure/Services/FilamentUsageService.cs

@@ -0,0 +1,79 @@
+using Extrudex.Domain.Entities;
+using Extrudex.Domain.Interfaces;
+using Extrudex.Infrastructure.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+
+namespace Extrudex.Infrastructure.Services;
+
+/// <summary>
+/// EF Core–backed implementation of the filament usage service.
+/// Persists usage records to the database and provides query methods
+/// for retrieving usage by print job or spool.
+/// </summary>
+public class FilamentUsageService : IFilamentUsageService
+{
+    private readonly ExtrudexDbContext _dbContext;
+    private readonly ILogger<FilamentUsageService> _logger;
+
+    public FilamentUsageService(
+        ExtrudexDbContext dbContext,
+        ILogger<FilamentUsageService> logger)
+    {
+        _dbContext = dbContext;
+        _logger = logger;
+    }
+
+    /// <inheritdoc />
+    public async Task<FilamentUsage> RecordUsageAsync(
+        Guid printJobId,
+        Guid spoolId,
+        Guid printerId,
+        decimal gramsUsed,
+        decimal mmExtruded,
+        string? notes = null,
+        CancellationToken cancellationToken = default)
+    {
+        var usage = new FilamentUsage
+        {
+            PrintJobId = printJobId,
+            SpoolId = spoolId,
+            PrinterId = printerId,
+            GramsUsed = gramsUsed,
+            MmExtruded = mmExtruded,
+            RecordedAt = DateTime.UtcNow,
+            Notes = notes
+        };
+
+        _dbContext.FilamentUsages.Add(usage);
+        await _dbContext.SaveChangesAsync(cancellationToken);
+
+        _logger.LogInformation(
+            "Recorded filament usage: {Grams}g / {Mm}mm for print job {JobId} on spool {SpoolId}",
+            gramsUsed, mmExtruded, printJobId, spoolId);
+
+        return usage;
+    }
+
+    /// <inheritdoc />
+    public async Task<IReadOnlyList<FilamentUsage>> GetByPrintJobAsync(
+        Guid printJobId,
+        CancellationToken cancellationToken = default)
+    {
+        return await _dbContext.FilamentUsages
+            .Where(u => u.PrintJobId == printJobId)
+            .OrderByDescending(u => u.RecordedAt)
+            .ToListAsync(cancellationToken);
+    }
+
+    /// <inheritdoc />
+    public async Task<IReadOnlyList<FilamentUsage>> GetBySpoolAsync(
+        Guid spoolId,
+        CancellationToken cancellationToken = default)
+    {
+        return await _dbContext.FilamentUsages
+            .Where(u => u.SpoolId == spoolId)
+            .OrderByDescending(u => u.RecordedAt)
+            .ToListAsync(cancellationToken);
+    }
+}

backend/Infrastructure/Services/MoonrakerClient.cs

@@ -0,0 +1,447 @@
+using System.Net.Http.Json;
+using System.Text.Json;
+using Extrudex.Domain.DTOs.Moonraker;
+using Extrudex.Domain.Interfaces;
+using Microsoft.Extensions.Logging;
+
+namespace Extrudex.Infrastructure.Configuration;
+
+/// <summary>
+/// HTTP client for communicating with Moonraker REST API endpoints
+/// on Klipper-based printers (e.g., Elegoo Centauri Carbon).
+/// Provides strongly-typed methods for server discovery, printer status,
+/// print job history, and real-time telemetry.
+/// </summary>
+public class MoonrakerClient : IMoonrakerClient
+{
+    private readonly HttpClient _httpClient;
+    private readonly ILogger<MoonrakerClient> _logger;
+
+    /// <summary>
+    /// Creates a new MoonrakerClient with the configured HTTP client and logger.
+    /// </summary>
+    /// <param name="httpClient">The HTTP client for making requests to Moonraker endpoints.</param>
+    /// <param name="logger">Logger for diagnostic output.</param>
+    public MoonrakerClient(HttpClient httpClient, ILogger<MoonrakerClient> logger)
+    {
+        _httpClient = httpClient;
+        _logger = logger;
+    }
+
+    /// <inheritdoc />
+    public async Task<MoonrakerServerInfo?> GetServerInfoAsync(
+        string hostnameOrIp,
+        int port,
+        string? apiKey,
+        CancellationToken cancellationToken = default)
+    {
+        var baseUrl = BuildBaseUrl(hostnameOrIp, port);
+
+        try
+        {
+            using var request = CreateRequest(HttpMethod.Get, $"{baseUrl}/server/info", apiKey);
+            using var response = await _httpClient.SendAsync(request, cancellationToken);
+            response.EnsureSuccessStatusCode();
+
+            var json = await response.Content.ReadFromJsonAsync<JsonElement>(cancellationToken: cancellationToken);
+
+            var serverInfo = new MoonrakerServerInfo();
+
+            if (json.TryGetProperty("result", out var result))
+            {
+                if (result.TryGetProperty("hostname", out var hostname))
+                    serverInfo.Hostname = hostname.GetString() ?? string.Empty;
+                if (result.TryGetProperty("software_version", out var version))
+                    serverInfo.SoftwareVersion = version.GetString() ?? string.Empty;
+                if (result.TryGetProperty("cpu_info", out var cpuInfo))
+                    serverInfo.CpuInfo = cpuInfo.GetString() ?? string.Empty;
+                if (result.TryGetProperty("klippy_connected", out var klippyConnected))
+                    serverInfo.KlippyConnected = klippyConnected.GetBoolean();
+                if (result.TryGetProperty("klippy_state", out var klippyState))
+                    serverInfo.KlippyState = klippyState.GetString() ?? string.Empty;
+                if (result.TryGetProperty("api_key_required", out var apiKeyRequired))
+                    serverInfo.ApiKeyRequired = apiKeyRequired.GetBoolean();
+                if (result.TryGetProperty("plugins", out var plugins))
+                    serverInfo.Plugins = plugins.EnumerateArray()
+                        .Select(p => p.GetString() ?? string.Empty)
+                        .Where(s => !string.IsNullOrEmpty(s))
+                        .ToList();
+            }
+
+            _logger.LogDebug(
+                "Retrieved server info from Moonraker at {Host}:{Port} — version {Version}, klippy {State}",
+                hostnameOrIp, port, serverInfo.SoftwareVersion, serverInfo.KlippyState);
+
+            return serverInfo;
+        }
+        catch (HttpRequestException ex)
+        {
+            _logger.LogWarning(ex,
+                "Failed to retrieve server info from Moonraker at {Host}:{Port}",
+                hostnameOrIp, port);
+            return null;
+        }
+        catch (JsonException ex)
+        {
+            _logger.LogWarning(ex,
+                "Failed to parse Moonraker server info response from {Host}:{Port}",
+                hostnameOrIp, port);
+            return null;
+        }
+    }
+
+    /// <inheritdoc />
+    public async Task<bool> IsReachableAsync(
+        string hostnameOrIp,
+        int port,
+        string? apiKey,
+        CancellationToken cancellationToken = default)
+    {
+        var serverInfo = await GetServerInfoAsync(hostnameOrIp, port, apiKey, cancellationToken);
+        return serverInfo is not null;
+    }
+
+    /// <inheritdoc />
+    public async Task<MoonrakerPrinterInfo?> GetPrinterInfoAsync(
+        string hostnameOrIp,
+        int port,
+        string? apiKey,
+        CancellationToken cancellationToken = default)
+    {
+        var baseUrl = BuildBaseUrl(hostnameOrIp, port);
+
+        try
+        {
+            using var request = CreateRequest(HttpMethod.Get, $"{baseUrl}/printer/info", apiKey);
+            using var response = await _httpClient.SendAsync(request, cancellationToken);
+            response.EnsureSuccessStatusCode();
+
+            var json = await response.Content.ReadFromJsonAsync<JsonElement>(cancellationToken: cancellationToken);
+
+            var printerInfo = new MoonrakerPrinterInfo();
+
+            if (json.TryGetProperty("result", out var result))
+            {
+                if (result.TryGetProperty("state", out var state))
+                    printerInfo.State = state.GetString() ?? string.Empty;
+                if (result.TryGetProperty("state_message", out var stateMessage))
+                    printerInfo.StateMessage = stateMessage.GetString() ?? string.Empty;
+                if (result.TryGetProperty("klippy_ready", out var klippyReady))
+                    printerInfo.KlippyReady = klippyReady.GetBoolean();
+            }
+
+            _logger.LogDebug(
+                "Retrieved printer info from Moonraker at {Host}:{Port} — state: {State}",
+                hostnameOrIp, port, printerInfo.State);
+
+            return printerInfo;
+        }
+        catch (HttpRequestException ex)
+        {
+            _logger.LogWarning(ex,
+                "Failed to retrieve printer info from Moonraker at {Host}:{Port}",
+                hostnameOrIp, port);
+            return null;
+        }
+        catch (JsonException ex)
+        {
+            _logger.LogWarning(ex,
+                "Failed to parse Moonraker printer info response from {Host}:{Port}",
+                hostnameOrIp, port);
+            return null;
+        }
+    }
+
+    /// <inheritdoc />
+    public async Task<MoonrakerHistoryResponse> GetPrintHistoryAsync(
+        string hostnameOrIp,
+        int port,
+        string? apiKey,
+        int limit = 50,
+        CancellationToken cancellationToken = default)
+    {
+        var baseUrl = BuildBaseUrl(hostnameOrIp, port);
+        var historyResponse = new MoonrakerHistoryResponse();
+
+        try
+        {
+            using var request = CreateRequest(
+                HttpMethod.Get,
+                $"{baseUrl}/server/history/items?limit={limit}",
+                apiKey);
+
+            using var response = await _httpClient.SendAsync(request, cancellationToken);
+            response.EnsureSuccessStatusCode();
+
+            var json = await response.Content.ReadFromJsonAsync<JsonElement>(cancellationToken: cancellationToken);
+
+            if (json.TryGetProperty("result", out var result))
+            {
+                if (result.TryGetProperty("count", out var count))
+                    historyResponse.TotalCount = count.GetInt32();
+
+                if (result.TryGetProperty("items", out var items))
+                {
+                    foreach (var item in items.EnumerateArray())
+                    {
+                        var job = MapPrintJob(item);
+                        historyResponse.Items.Add(job);
+                    }
+                }
+            }
+
+            _logger.LogDebug(
+                "Retrieved {JobCount} print history items from Moonraker at {Host}:{Port}",
+                historyResponse.Items.Count, hostnameOrIp, port);
+        }
+        catch (HttpRequestException ex)
+        {
+            _logger.LogWarning(ex,
+                "Failed to retrieve print history from Moonraker at {Host}:{Port}",
+                hostnameOrIp, port);
+        }
+        catch (JsonException ex)
+        {
+            _logger.LogWarning(ex,
+                "Failed to parse Moonraker history response from {Host}:{Port}",
+                hostnameOrIp, port);
+        }
+
+        return historyResponse;
+    }
+
+    /// <inheritdoc />
+    public async Task<MoonrakerPrintStats?> GetPrintStatsAsync(
+        string hostnameOrIp,
+        int port,
+        string? apiKey,
+        CancellationToken cancellationToken = default)
+    {
+        var baseUrl = BuildBaseUrl(hostnameOrIp, port);
+
+        try
+        {
+            using var request = CreateRequest(
+                HttpMethod.Get,
+                $"{baseUrl}/printer/objects/query?print_stats",
+                apiKey);
+
+            using var response = await _httpClient.SendAsync(request, cancellationToken);
+            response.EnsureSuccessStatusCode();
+
+            var json = await response.Content.ReadFromJsonAsync<JsonElement>(cancellationToken: cancellationToken);
+
+            if (json.TryGetProperty("result", out var result)
+                && result.TryGetProperty("status", out var status)
+                && status.TryGetProperty("print_stats", out var printStats))
+            {
+                var stats = MapPrintStats(printStats);
+
+                _logger.LogDebug(
+                    "Retrieved print stats from Moonraker at {Host}:{Port} — state: {State}, filament: {FilamentMm}mm",
+                    hostnameOrIp, port, stats.State, stats.FilamentUsedMm);
+
+                return stats;
+            }
+
+            _logger.LogWarning(
+                "Moonraker print_stats not found in response from {Host}:{Port}",
+                hostnameOrIp, port);
+            return null;
+        }
+        catch (HttpRequestException ex)
+        {
+            _logger.LogWarning(ex,
+                "Failed to retrieve print stats from Moonraker at {Host}:{Port}",
+                hostnameOrIp, port);
+            return null;
+        }
+        catch (JsonException ex)
+        {
+            _logger.LogWarning(ex,
+                "Failed to parse Moonraker print stats response from {Host}:{Port}",
+                hostnameOrIp, port);
+            return null;
+        }
+    }
+
+    /// <inheritdoc />
+    public async Task<MoonrakerDisplayStatus?> GetDisplayStatusAsync(
+        string hostnameOrIp,
+        int port,
+        string? apiKey,
+        CancellationToken cancellationToken = default)
+    {
+        var baseUrl = BuildBaseUrl(hostnameOrIp, port);
+
+        try
+        {
+            using var request = CreateRequest(
+                HttpMethod.Get,
+                $"{baseUrl}/printer/objects/query?display_status",
+                apiKey);
+
+            using var response = await _httpClient.SendAsync(request, cancellationToken);
+            response.EnsureSuccessStatusCode();
+
+            var json = await response.Content.ReadFromJsonAsync<JsonElement>(cancellationToken: cancellationToken);
+
+            if (json.TryGetProperty("result", out var result)
+                && result.TryGetProperty("status", out var status)
+                && status.TryGetProperty("display_status", out var displayStatus))
+            {
+                var ds = new MoonrakerDisplayStatus();
+
+                if (displayStatus.TryGetProperty("progress", out var progress))
+                    ds.Progress = progress.GetDecimal();
+                if (displayStatus.TryGetProperty("message", out var message))
+                    ds.Message = message.GetString() ?? string.Empty;
+
+                _logger.LogDebug(
+                    "Retrieved display status from Moonraker at {Host}:{Port} — progress: {Progress:P0}",
+                    hostnameOrIp, port, ds.Progress);
+
+                return ds;
+            }
+
+            _logger.LogWarning(
+                "Moonraker display_status not found in response from {Host}:{Port}",
+                hostnameOrIp, port);
+            return null;
+        }
+        catch (HttpRequestException ex)
+        {
+            _logger.LogWarning(ex,
+                "Failed to retrieve display status from Moonraker at {Host}:{Port}",
+                hostnameOrIp, port);
+            return null;
+        }
+        catch (JsonException ex)
+        {
+            _logger.LogWarning(ex,
+                "Failed to parse Moonraker display status response from {Host}:{Port}",
+                hostnameOrIp, port);
+            return null;
+        }
+    }
+
+    /// <inheritdoc />
+    public async Task<Dictionary<string, decimal>> GetFilamentUsageAsync(
+        string hostnameOrIp,
+        int port,
+        string? apiKey,
+        CancellationToken cancellationToken = default)
+    {
+        // Delegate to the typed GetPrintHistoryAsync and extract metrics
+        var history = await GetPrintHistoryAsync(hostnameOrIp, port, apiKey, limit: 1, cancellationToken);
+        var result = new Dictionary<string, decimal>();
+
+        if (history.Items.Count > 0)
+        {
+            var latestJob = history.Items[0];
+            result["mm_extruded"] = latestJob.FilamentUsedMm;
+            result["print_duration_seconds"] = latestJob.PrintDurationSeconds;
+        }
+
+        _logger.LogDebug(
+            "Retrieved filament usage from Moonraker at {Host}:{Port}: {MetricCount} metrics",
+            hostnameOrIp, port, result.Count);
+
+        return result;
+    }
+
+    /// <summary>
+    /// Builds the base URL for Moonraker API calls from hostname and port.
+    /// </summary>
+    private static string BuildBaseUrl(string hostnameOrIp, int port)
+    {
+        return $"http://{hostnameOrIp}:{port}";
+    }
+
+    /// <summary>
+    /// Creates an HttpRequestMessage with the optional API key header.
+    /// </summary>
+    private static HttpRequestMessage CreateRequest(HttpMethod method, string url, string? apiKey)
+    {
+        var request = new HttpRequestMessage(method, url);
+        if (!string.IsNullOrEmpty(apiKey))
+        {
+            request.Headers.Add("X-Api-Key", apiKey);
+        }
+        return request;
+    }
+
+    /// <summary>
+    /// Maps a JSON element representing a Moonraker print job history item
+    /// to a <see cref="MoonrakerPrintJob"/> DTO.
+    /// </summary>
+    private static MoonrakerPrintJob MapPrintJob(JsonElement item)
+    {
+        var job = new MoonrakerPrintJob();
+
+        if (item.TryGetProperty("job_id", out var jobId))
+            job.JobId = jobId.GetString() ?? string.Empty;
+        if (item.TryGetProperty("filename", out var filename))
+            job.Filename = filename.GetString() ?? string.Empty;
+        if (item.TryGetProperty("status", out var status))
+            job.Status = status.GetString() ?? string.Empty;
+        if (item.TryGetProperty("filament_used", out var filamentUsed))
+            job.FilamentUsedMm = filamentUsed.GetDecimal();
+        if (item.TryGetProperty("print_duration", out var printDuration))
+            job.PrintDurationSeconds = printDuration.GetDecimal();
+        if (item.TryGetProperty("total_duration", out var totalDuration))
+            job.TotalDurationSeconds = totalDuration.GetDecimal();
+
+        if (item.TryGetProperty("start_time", out var startTime) && startTime.ValueKind != JsonValueKind.Null)
+        {
+            if (startTime.TryGetInt64(out var startTimeSeconds))
+                job.StartTime = DateTimeOffset.FromUnixTimeSeconds(startTimeSeconds).UtcDateTime;
+        }
+
+        if (item.TryGetProperty("end_time", out var endTime) && endTime.ValueKind != JsonValueKind.Null)
+        {
+            if (endTime.TryGetInt64(out var endTimeSeconds))
+                job.EndTime = DateTimeOffset.FromUnixTimeSeconds(endTimeSeconds).UtcDateTime;
+        }
+
+        if (item.TryGetProperty("metadata", out var metadata) && metadata.ValueKind == JsonValueKind.Object)
+        {
+            foreach (var prop in metadata.EnumerateObject())
+            {
+                object value = prop.Value.ValueKind switch
+                {
+                    JsonValueKind.String => prop.Value.GetString() ?? string.Empty,
+                    JsonValueKind.Number => prop.Value.GetDecimal(),
+                    JsonValueKind.True => true,
+                    JsonValueKind.False => false,
+                    _ => prop.Value.ToString() ?? string.Empty
+                };
+                job.Metadata[prop.Name] = value;
+            }
+        }
+
+        return job;
+    }
+
+    /// <summary>
+    /// Maps a JSON element representing Moonraker print_stats
+    /// to a <see cref="MoonrakerPrintStats"/> DTO.
+    /// </summary>
+    private static MoonrakerPrintStats MapPrintStats(JsonElement printStats)
+    {
+        var stats = new MoonrakerPrintStats();
+
+        if (printStats.TryGetProperty("state", out var state))
+            stats.State = state.GetString() ?? string.Empty;
+        if (printStats.TryGetProperty("filament_used", out var filamentUsed))
+            stats.FilamentUsedMm = filamentUsed.GetDecimal();
+        if (printStats.TryGetProperty("print_duration", out var printDuration))
+            stats.PrintDurationSeconds = printDuration.GetDecimal();
+        if (printStats.TryGetProperty("filename", out var filename) && filename.ValueKind != JsonValueKind.Null)
+            stats.Filename = filename.GetString();
+        if (printStats.TryGetProperty("message", out var message) && message.ValueKind != JsonValueKind.Null)
+            stats.Message = message.GetString();
+
+        return stats;
+    }
+}

backend/Infrastructure/Services/MoonrakerUsagePoller.cs

@@ -0,0 +1,431 @@
+using Extrudex.Domain.Entities;
+using Extrudex.Domain.Enums;
+using Extrudex.Domain.Interfaces;
+using Extrudex.Infrastructure.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+
+namespace Extrudex.Infrastructure.Services;
+
+/// <summary>
+/// Configuration options for the Moonraker usage polling service.
+/// </summary>
+public class MoonrakerPollerOptions
+{
+    /// <summary>
+    /// How often to poll each Moonraker printer for filament usage data.
+    /// Default: 30 seconds.
+    /// </summary>
+    public TimeSpan PollInterval { get; set; } = TimeSpan.FromSeconds(30);
+
+    /// <summary>
+    /// Timeout for individual Moonraker HTTP requests.
+    /// Default: 10 seconds.
+    /// </summary>
+    public TimeSpan RequestTimeout { get; set; } = TimeSpan.FromSeconds(10);
+
+    /// <summary>
+    /// Whether the polling service is enabled. Default: true.
+    /// Set to false to disable polling (e.g., in development or testing).
+    /// </summary>
+    public bool Enabled { get; set; } = true;
+}
+
+/// <summary>
+/// Background service that periodically polls Moonraker-connected printers
+/// for filament usage data. When a print job is detected as complete,
+/// the usage data is persisted to the FilamentUsage table via
+/// <see cref="IFilamentUsageService"/>.
+///
+/// <para>Polling logic:</para>
+/// <list type="number">
+///   <item>Query the database for all active printers with ConnectionType == Moonraker.</item>
+///   <item>For each printer, call <see cref="IMoonrakerClient.GetFilamentUsageAsync"/>.</item>
+///   <item>If usage data is available and the print state is "complete",
+///         create or update a FilamentUsage record.</item>
+///   <item>If the printer is unreachable or returns malformed data, log a warning
+///         and continue to the next printer (no crash).</item>
+/// </list>
+///
+/// <para>Error handling:</para>
+/// <list type="bullet">
+///   <item>API unreachable: logged as warning, poller continues for other printers.</item>
+///   <item>Malformed response: logged as warning, poller continues.</item>
+///   <item>Database errors: logged as error, poller continues.</item>
+/// </list>
+/// </summary>
+public class MoonrakerUsagePoller : BackgroundService
+{
+    private readonly IServiceScopeFactory _scopeFactory;
+    private readonly ILogger<MoonrakerUsagePoller> _logger;
+    private readonly MoonrakerPollerOptions _options;
+
+    /// <summary>
+    /// Tracks which Moonraker print jobs have already been recorded,
+    /// keyed by "printerId:gcodeFileName" to avoid duplicate recording.
+    /// </summary>
+    private readonly HashSet<string> _recordedJobs = new();
+
+    public MoonrakerUsagePoller(
+        IServiceScopeFactory scopeFactory,
+        ILogger<MoonrakerUsagePoller> logger,
+        IOptions<MoonrakerPollerOptions> options)
+    {
+        _scopeFactory = scopeFactory;
+        _logger = logger;
+        _options = options.Value;
+    }
+
+    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
+    {
+        if (!_options.Enabled)
+        {
+            _logger.LogInformation("Moonraker usage poller is disabled via configuration.");
+            return;
+        }
+
+        _logger.LogInformation(
+            "Moonraker usage poller starting. Poll interval: {Interval}",
+            _options.PollInterval);
+
+        while (!stoppingToken.IsCancellationRequested)
+        {
+            try
+            {
+                await PollAllPrintersAsync(stoppingToken);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex,
+                    "Unexpected error in Moonraker usage poller cycle. Continuing.");
+            }
+
+            await Task.Delay(_options.PollInterval, stoppingToken);
+        }
+
+        _logger.LogInformation("Moonraker usage poller stopping.");
+    }
+
+    /// <summary>
+    /// Polls all active Moonraker printers for filament usage data
+    /// and persists any completed print usage records.
+    /// </summary>
+    private async Task PollAllPrintersAsync(CancellationToken cancellationToken)
+    {
+        using var scope = _scopeFactory.CreateScope();
+        var dbContext = scope.ServiceProvider.GetRequiredService<ExtrudexDbContext>();
+        var moonrakerClient = scope.ServiceProvider.GetRequiredService<IMoonrakerClient>();
+        var usageService = scope.ServiceProvider.GetRequiredService<IFilamentUsageService>();
+
+        // Get all active Moonraker printers
+        var printers = await dbContext.Printers
+            .Where(p => p.IsActive && p.ConnectionType == ConnectionType.Moonraker)
+            .ToListAsync(cancellationToken);
+
+        if (printers.Count == 0)
+        {
+            _logger.LogDebug("No active Moonraker printers found.");
+            return;
+        }
+
+        _logger.LogDebug("Polling {Count} Moonraker printer(s).", printers.Count);
+
+        foreach (var printer in printers)
+        {
+            await PollPrinterAsync(
+                printer, moonrakerClient, usageService, dbContext, cancellationToken);
+        }
+    }
+
+    /// <summary>
+    /// Polls a single Moonraker printer for filament usage data.
+    /// If a completed print job is detected with usage data, it is persisted.
+    /// </summary>
+    private async Task PollPrinterAsync(
+        Printer printer,
+        IMoonrakerClient moonrakerClient,
+        IFilamentUsageService usageService,
+        ExtrudexDbContext dbContext,
+        CancellationToken cancellationToken)
+    {
+        _logger.LogDebug(
+            "Polling Moonraker printer {PrinterName} ({Host}:{Port})",
+            printer.Name, printer.HostnameOrIp, printer.Port);
+
+        try
+        {
+            // Update last-seen timestamp regardless of usage data
+            var usageData = await moonrakerClient.GetFilamentUsageAsync(
+                printer.HostnameOrIp,
+                printer.Port,
+                printer.ApiKey,
+                cancellationToken);
+
+            if (usageData is null)
+            {
+                _logger.LogDebug(
+                    "No filament usage data from printer {PrinterName}.",
+                    printer.Name);
+                return;
+            }
+
+            // Update printer last-seen timestamp
+            printer.LastSeenAt = DateTime.UtcNow;
+            await dbContext.SaveChangesAsync(cancellationToken);
+
+            _logger.LogDebug(
+                "Printer {PrinterName}: state={State}, mm={Mm}, file={File}",
+                printer.Name, usageData.PrintState, usageData.MmExtruded,
+                usageData.GcodeFileName);
+
+            // Only record usage for completed prints
+            if (usageData.MmExtruded <= 0)
+            {
+                _logger.LogDebug(
+                    "Printer {PrinterName} has no filament usage to record.",
+                    printer.Name);
+                return;
+            }
+
+            if (!IsCompleteState(usageData.PrintState))
+            {
+                _logger.LogDebug(
+                    "Printer {PrinterName} print state '{State}' is not complete; skipping.",
+                    printer.Name, usageData.PrintState);
+                return;
+            }
+
+            // Deduplicate: avoid recording the same completed job twice
+            var deduplicationKey = $"{printer.Id}:{usageData.GcodeFileName}";
+            if (_recordedJobs.Contains(deduplicationKey))
+            {
+                _logger.LogDebug(
+                    "Printer {PrinterName} job '{File}' already recorded; skipping.",
+                    printer.Name, usageData.GcodeFileName);
+                return;
+            }
+
+            // Find or create a PrintJob for this usage
+            var printJob = await FindOrCreatePrintJobAsync(
+                dbContext, printer, usageData, cancellationToken);
+
+            if (printJob is null)
+            {
+                _logger.LogWarning(
+                    "Could not find or create print job for printer {PrinterName}. " +
+                    "No active spool found.",
+                    printer.Name);
+                return;
+            }
+
+            // Calculate grams from mm extruded using spool properties
+            var spool = await dbContext.Spools.FindAsync(
+                new object[] { printJob.SpoolId }, cancellationToken);
+
+            var gramsUsed = CalculateGramsUsed(usageData.MmExtruded, spool);
+
+            await usageService.RecordUsageAsync(
+                printJobId: printJob.Id,
+                spoolId: printJob.SpoolId,
+                printerId: printer.Id,
+                gramsUsed: gramsUsed,
+                mmExtruded: usageData.MmExtruded,
+                notes: $"Moonraker auto-recorded: {usageData.GcodeFileName}",
+                cancellationToken: cancellationToken);
+
+            // Mark job as recorded to prevent duplicates
+            _recordedJobs.Add(deduplicationKey);
+
+            _logger.LogInformation(
+                "Recorded Moonraker usage for printer {PrinterName}: " +
+                "{Mm}mm / {Grams}g, job '{File}'",
+                printer.Name, usageData.MmExtruded, gramsUsed,
+                usageData.GcodeFileName);
+        }
+        catch (HttpRequestException ex)
+        {
+            _logger.LogWarning(ex,
+                "Moonraker API unreachable for printer {PrinterName} ({Host}:{Port}). " +
+                "Will retry next cycle.",
+                printer.Name, printer.HostnameOrIp, printer.Port);
+        }
+        catch (TaskCanceledException) when (cancellationToken.IsCancellationRequested)
+        {
+            // Shutdown requested — rethrow to exit the poll loop
+            throw;
+        }
+        catch (TaskCanceledException ex)
+        {
+            _logger.LogWarning(ex,
+                "Moonraker request timed out for printer {PrinterName} ({Host}:{Port}).",
+                printer.Name, printer.HostnameOrIp, printer.Port);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex,
+                "Unexpected error polling Moonraker printer {PrinterName}. " +
+                "Continuing to next printer.",
+                printer.Name);
+        }
+    }
+
+    /// <summary>
+    /// Determines if a Moonraker print state indicates a completed job
+    /// that should have its usage recorded.
+    /// </summary>
+    private static bool IsCompleteState(string state) =>
+        state.Equals("complete", StringComparison.OrdinalIgnoreCase) ||
+        state.Equals("completed", StringComparison.OrdinalIgnoreCase);
+
+    /// <summary>
+    /// Finds an existing PrintJob for the current g-code file on this printer,
+    /// or creates a new one. Returns null if no spool is available.
+    /// </summary>
+    private async Task<PrintJob?> FindOrCreatePrintJobAsync(
+        ExtrudexDbContext dbContext,
+        Printer printer,
+        MoonrakerFilamentUsage usageData,
+        CancellationToken cancellationToken)
+    {
+        // Try to find an existing print job for this g-code file on this printer
+        if (!string.IsNullOrEmpty(usageData.GcodeFileName))
+        {
+            var existingJob = await dbContext.PrintJobs
+                .Where(j => j.PrinterId == printer.Id &&
+                            j.GcodeFilePath == usageData.GcodeFileName &&
+                            j.DataSource == DataSource.Moonraker &&
+                            j.Status != JobStatus.Cancelled)
+                .OrderByDescending(j => j.CreatedAt)
+                .FirstOrDefaultAsync(cancellationToken);
+
+            if (existingJob is not null)
+            {
+                // Update the existing job with completion data
+                existingJob.MmExtruded = usageData.MmExtruded;
+                existingJob.GramsDerived = CalculateGramsUsed(
+                    usageData.MmExtruded,
+                    await dbContext.Spools.FindAsync(
+                        new object[] { existingJob.SpoolId }, cancellationToken));
+                existingJob.Status = JobStatus.Completed;
+                existingJob.CompletedAt = usageData.CompletedAt ?? DateTime.UtcNow;
+                existingJob.StartedAt ??= usageData.StartedAt;
+
+                await dbContext.SaveChangesAsync(cancellationToken);
+                return existingJob;
+            }
+        }
+
+        // No existing job — find the first active spool for this printer
+        // via AMS slots, or fall back to any active spool
+        var spool = await FindActiveSpoolForPrinterAsync(dbContext, printer, cancellationToken);
+
+        if (spool is null)
+        {
+            return null;
+        }
+
+        var gramsDerived = CalculateGramsUsed(usageData.MmExtruded, spool);
+
+        var newJob = new PrintJob
+        {
+            PrinterId = printer.Id,
+            SpoolId = spool.Id,
+            PrintName = usageData.GcodeFileName ?? "Moonraker Print",
+            GcodeFilePath = usageData.GcodeFileName,
+            MmExtruded = usageData.MmExtruded,
+            GramsDerived = gramsDerived,
+            FilamentDiameterAtPrintMm = spool.FilamentDiameterMm,
+            MaterialDensityAtPrint = GetMaterialDensity(spool),
+            DataSource = DataSource.Moonraker,
+            Status = JobStatus.Completed,
+            StartedAt = usageData.StartedAt ?? DateTime.UtcNow,
+            CompletedAt = usageData.CompletedAt ?? DateTime.UtcNow,
+            Notes = "Auto-created by Moonraker usage poller"
+        };
+
+        dbContext.PrintJobs.Add(newJob);
+        await dbContext.SaveChangesAsync(cancellationToken);
+
+        return newJob;
+    }
+
+    /// <summary>
+    /// Finds an active spool associated with the printer via AMS slots,
+    /// or falls back to any active spool in the system.
+    /// </summary>
+    private static async Task<Spool?> FindActiveSpoolForPrinterAsync(
+        ExtrudexDbContext dbContext,
+        Printer printer,
+        CancellationToken cancellationToken)
+    {
+        // Try to find a spool loaded in the printer's AMS
+        var amsSpool = await dbContext.AmsSlots
+            .Include(s => s.Spool)
+            .ThenInclude(s => s!.MaterialBase)
+            .Include(s => s.AmsUnit)
+            .Where(s => s.AmsUnit.PrinterId == printer.Id && s.Spool != null && s.Spool.IsActive)
+            .Select(s => s.Spool)
+            .FirstOrDefaultAsync(cancellationToken);
+
+        if (amsSpool is not null)
+            return amsSpool;
+
+        // Fallback: any active spool (for non-AMS printers)
+        return await dbContext.Spools
+            .Include(s => s.MaterialBase)
+            .Where(s => s.IsActive)
+            .OrderByDescending(s => s.WeightRemainingGrams)
+            .FirstOrDefaultAsync(cancellationToken);
+    }
+
+    /// <summary>
+    /// Calculates grams used from mm extruded using the spool's filament
+    /// diameter and the material density.
+    /// Formula: grams = mm × π × (diameter/2)² × density
+    /// Where density is in g/cm³, diameter in mm, giving grams.
+    /// </summary>
+    private static decimal CalculateGramsUsed(decimal mmExtruded, Spool? spool)
+    {
+        if (spool is null)
+            return 0m;
+
+        var diameterMm = spool.FilamentDiameterMm;
+        var densityGcm3 = GetMaterialDensity(spool);
+
+        // Cross-section area (mm²) = π × (diameter/2)²
+        var radiusMm = diameterMm / 2m;
+        var crossSectionArea = Math.PI * (double)radiusMm * (double)radiusMm;
+
+        // Volume (mm³) = mm_extruded × cross_section_area
+        // Convert mm³ to cm³: 1 cm³ = 1000 mm³
+        // Weight (g) = volume_cm³ × density (g/cm³)
+        var volumeMm3 = (double)mmExtruded * crossSectionArea;
+        var volumeCm3 = volumeMm3 / 1000.0;
+        var grams = volumeCm3 * (double)densityGcm3;
+
+        return Math.Round((decimal)grams, 2);
+    }
+
+    /// <summary>
+    /// Returns the material density for the spool's material base.
+    /// Falls back to 1.24 g/cm³ (typical PLA density) if not available.
+    /// </summary>
+    private static decimal GetMaterialDensity(Spool? spool)
+    {
+        // Standard material densities (g/cm³)
+        // These would ideally come from the MaterialBase entity,
+        // but we use sensible defaults for the initial integration.
+        return spool?.MaterialBase?.Name?.ToUpperInvariant() switch
+        {
+            "PLA" => 1.24m,
+            "PETG" => 1.27m,
+            "ABS" => 1.04m,
+            "ASA" => 1.07m,
+            "TPU" => 1.21m,
+            "NYLON" or "PA" => 1.13m,
+            "PC" => 1.20m,
+            _ => 1.24m // Default to PLA density
+        };
+    }
+}

backend/Program.cs

@@ -1,4 +1,5 @@
 using System.Reflection;
+using System.Net.Http.Headers;
 using Extrudex.API.Filters;
 using Extrudex.API.Hubs;
 using Extrudex.Domain.Interfaces;
@@ -50,6 +51,23 @@ builder.Services.AddSwaggerGen(c =>
 // ── QR Code Generation ──────────────────────────────────────
 builder.Services.AddSingleton<IQrCodeService, QrCodeService>();
 
+// ── Filament Usage Service ──────────────────────────────────
+builder.Services.AddScoped<IFilamentUsageService, FilamentUsageService>();
+
+// ── Moonraker Client ───────────────────────────────────────
+// Named HttpClient for Moonraker API calls with configurable timeout.
+// Poller timeout is driven by MoonrakerPollerOptions.RequestTimeout.
+builder.Services.AddHttpClient<IMoonrakerClient, MoonrakerClient>(client =>
+{
+    client.DefaultRequestHeaders.Accept.Add(
+        new MediaTypeWithQualityHeaderValue("application/json"));
+});
+
+// ── Moonraker Usage Poller (Background Service) ─────────────
+builder.Services.Configure<MoonrakerPollerOptions>(
+    builder.Configuration.GetSection("MoonrakerPoller"));
+builder.Services.AddHostedService<MoonrakerUsagePoller>();
+
 // ── FluentValidation ──────────────────────────────────────
 // Registers all validators from the API assembly into DI.
 builder.Services.AddValidatorsFromAssembly(Assembly.GetExecutingAssembly());

backend/appsettings.json

@@ -9,5 +9,10 @@
   "AllowedHosts": "*",
   "ConnectionStrings": {
     "ExtrudexDb": "Host=localhost;Port=5432;Database=extrudex;Username=extrudex;Password=changeme"
+  },
+  "MoonrakerPoller": {
+    "Enabled": true,
+    "PollInterval": "00:00:30",
+    "RequestTimeout": "00:00:10"
   }
 }

frontend/.dockerignore

@@ -0,0 +1,11 @@
+node_modules
+dist
+.git
+.gitignore
+.angular
+.vscode
+*.md
+.editorconfig
+.prettierrc
+src/test.ts
+**/*.spec.ts

frontend/Dockerfile

@@ -0,0 +1,28 @@
+# Stage 1: Build the Angular application
+FROM node:22-alpine AS build
+
+WORKDIR /app
+
+# Copy package files first for better layer caching
+COPY package.json package-lock.json ./
+RUN npm ci
+
+# Copy source and build
+COPY . .
+RUN npx ng build --configuration production
+
+# Stage 2: Serve static files with nginx
+FROM nginx:alpine
+
+# Remove default nginx config
+RUN rm /etc/nginx/conf.d/default.conf
+
+# Copy custom nginx config
+COPY nginx.conf /etc/nginx/conf.d/default.conf
+
+# Copy built Angular artifacts from build stage
+COPY --from=build /app/dist/frontend/browser /usr/share/nginx/html
+
+EXPOSE 80
+
+CMD ["nginx", "-g", "daemon off;"]

frontend/nginx.conf

@@ -0,0 +1,42 @@
+server {
+    listen 80;
+    server_name _;
+    root /usr/share/nginx/html;
+    index index.html;
+
+    # Gzip compression
+    gzip on;
+    gzip_types text/plain text/css application/json application/javascript text/xml application/xml text/javascript;
+    gzip_min_length 256;
+
+    # Angular SPA — fallback to index.html for client-side routing
+    location / {
+        try_files $uri $uri/ /index.html;
+    }
+
+    # Cache static assets aggressively
+    location ~* \.(js|css|png|jpg|jpeg|gif|ico|svg|woff2?|ttf|eot)$ {
+        expires 1y;
+        add_header Cache-Control "public, immutable";
+    }
+
+    # Proxy API requests to backend
+    # Uses resolver so nginx doesn't crash if backend isn't available at startup
+    resolver 127.0.0.11 valid=30s ipv6=off;
+    set $backend "extrudex-api:8080";
+
+    location /api/ {
+        proxy_pass http://$backend;
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+    }
+
+    # Health check endpoint
+    location /health {
+        access_log off;
+        return 200 "ok";
+        add_header Content-Type text/plain;
+    }
+}

frontend/package-lock.json

@@ -8,6 +8,7 @@
       "name": "frontend",
       "version": "0.0.0",
       "dependencies": {
+        "@angular/animations": "^21.2.10",
         "@angular/cdk": "^21.2.8",
         "@angular/common": "^21.2.0",
         "@angular/compiler": "^21.2.0",
@@ -326,6 +327,21 @@
         "yarn": ">= 1.13.0"
       }
     },
+    "node_modules/@angular/animations": {
+      "version": "21.2.10",
+      "resolved": "https://registry.npmjs.org/@angular/animations/-/animations-21.2.10.tgz",
+      "integrity": "sha512-sIzAcxwtRCJ/fu0tK4mo1ooiEaDxJ+Nl6s9nK1D1NP1em12VX03Jx8CMixp/kVtgh4mZnm1x6psBB0FUz3U3Ug==",
+      "license": "MIT",
+      "dependencies": {
+        "tslib": "^2.3.0"
+      },
+      "engines": {
+        "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
+      },
+      "peerDependencies": {
+        "@angular/core": "21.2.10"
+      }
+    },
     "node_modules/@angular/build": {
       "version": "21.2.8",
       "resolved": "https://registry.npmjs.org/@angular/build/-/build-21.2.8.tgz",

frontend/package.json

@@ -11,6 +11,7 @@
   "private": true,
   "packageManager": "npm@11.11.0",
   "dependencies": {
+    "@angular/animations": "^21.2.10",
     "@angular/cdk": "^21.2.8",
     "@angular/common": "^21.2.0",
     "@angular/compiler": "^21.2.0",

frontend/src/app/app.config.ts

@@ -1,11 +1,15 @@
 import { ApplicationConfig, provideBrowserGlobalErrorListeners } from '@angular/core';
 import { provideRouter } from '@angular/router';
+import { provideHttpClient, withFetch } from '@angular/common/http';
+import { provideAnimationsAsync } from '@angular/platform-browser/animations/async';
 
 import { routes } from './app.routes';
 
 export const appConfig: ApplicationConfig = {
   providers: [
     provideBrowserGlobalErrorListeners(),
-    provideRouter(routes)
+    provideRouter(routes),
+    provideHttpClient(withFetch()),
+    provideAnimationsAsync(),
   ]
 };

frontend/src/app/components/delete-filament-dialog/delete-filament-dialog.component.html

@@ -0,0 +1,78 @@
+<!-- Delete Filament Confirmation Dialog -->
+<h2 mat-dialog-title>
+  <mat-icon aria-hidden="true">warning</mat-icon>
+  Delete Filament Spool?
+</h2>
+
+<mat-dialog-content>
+  <p class="dialog-description">
+    You are about to permanently remove this filament spool from inventory.
+  </p>
+
+  <!-- Spool details card -->
+  <div class="spool-details" role="list" aria-label="Spool details">
+    <div class="detail-row" role="listitem">
+      <span class="detail-label">Material</span>
+      <span class="detail-value">{{ filament.materialBaseName }}{{ filament.materialFinishName ? ' — ' + filament.materialFinishName : '' }}{{ filament.materialModifierName ? ' (' + filament.materialModifierName + ')' : '' }}</span>
+    </div>
+
+    <div class="detail-row" role="listitem">
+      <span class="detail-label">Brand</span>
+      <span class="detail-value">{{ filament.brand }}</span>
+    </div>
+
+    <div class="detail-row" role="listitem">
+      <span class="detail-label">Color</span>
+      <span class="detail-value color-value">
+        <span class="color-swatch-inline"
+              [style.background-color]="filament.colorHex"
+              [attr.aria-label]="filament.colorName">
+        </span>
+        {{ filament.colorName }}
+      </span>
+    </div>
+
+    <div class="detail-row" role="listitem">
+      <span class="detail-label">Serial</span>
+      <span class="detail-value serial-value">{{ filament.spoolSerial }}</span>
+    </div>
+
+    <div class="detail-row" role="listitem">
+      <span class="detail-label">Remaining</span>
+      <span class="detail-value">{{ formatWeight(filament.weightRemainingGrams) }} / {{ formatWeight(filament.weightTotalGrams) }}</span>
+    </div>
+
+    <div class="detail-row" role="listitem">
+      <span class="detail-label">Status</span>
+      <span class="detail-value">
+        <span class="status-badge"
+              [class.active]="filament.isActive"
+              [class.inactive]="!filament.isActive">
+          {{ filament.isActive ? 'Active' : 'Inactive' }}
+        </span>
+      </span>
+    </div>
+  </div>
+
+  <p class="dialog-warning">
+    <mat-icon aria-hidden="true">info</mat-icon>
+    This action cannot be undone.
+  </p>
+</mat-dialog-content>
+
+<mat-dialog-actions align="end">
+  <button mat-button
+          type="button"
+          (click)="onCancel()"
+          class="cancel-button">
+    Cancel
+  </button>
+  <button mat-flat-button
+          type="button"
+          color="warn"
+          (click)="onConfirm()"
+          class="confirm-button">
+    <mat-icon aria-hidden="true">delete</mat-icon>
+    Delete Spool
+  </button>
+</mat-dialog-actions>

frontend/src/app/components/delete-filament-dialog/delete-filament-dialog.component.scss

@@ -0,0 +1,150 @@
+/**
+ * Delete Filament Dialog Styles
+ * Touch-optimized confirmation dialog for spool removal
+ */
+
+$spacing-unit: 8px;
+$color-critical: #ef4444;
+$color-inactive: #94a3b8;
+$color-active: #22c55e;
+
+// Dialog title
+h2[mat-dialog-title] {
+  display: flex;
+  align-items: center;
+  gap: $spacing-unit;
+  color: $color-critical;
+
+  mat-icon {
+    font-size: 24px !important;
+    width: 24px !important;
+    height: 24px !important;
+  }
+}
+
+// Description text
+.dialog-description {
+  margin: 0 0 $spacing-unit * 2;
+  font-size: 14px;
+  line-height: 1.5;
+  color: var(--mat-sys-on-surface);
+}
+
+// Spool details card
+.spool-details {
+  display: flex;
+  flex-direction: column;
+  gap: $spacing-unit;
+  padding: $spacing-unit * 1.5;
+  background-color: var(--mat-sys-surface-container);
+  border-radius: 8px;
+  margin-bottom: $spacing-unit * 2;
+}
+
+.detail-row {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  padding: $spacing-unit * 0.5 0;
+  font-size: 14px;
+
+  &:not(:last-child) {
+    border-bottom: 1px solid var(--mat-sys-outline-variant);
+    padding-bottom: $spacing-unit;
+  }
+}
+
+.detail-label {
+  font-weight: 500;
+  color: var(--mat-sys-on-surface-variant);
+  flex-shrink: 0;
+}
+
+.detail-value {
+  font-weight: 400;
+  color: var(--mat-sys-on-surface);
+  text-align: right;
+}
+
+// Color swatch inline
+.color-swatch-inline {
+  display: inline-block;
+  width: 18px;
+  height: 18px;
+  border-radius: 50%;
+  border: 1.5px solid rgba(0, 0, 0, 0.12);
+  vertical-align: middle;
+  margin-right: 4px;
+}
+
+.color-value {
+  display: flex;
+  align-items: center;
+  justify-content: flex-end;
+  gap: 4px;
+}
+
+// Serial value — monospace
+.serial-value {
+  font-family: 'JetBrains Mono', 'Roboto Mono', monospace;
+  font-size: 13px;
+  letter-spacing: 0.02em;
+}
+
+// Status badge — matches filament table styling
+.status-badge {
+  display: inline-flex;
+  align-items: center;
+  padding: 2px 8px;
+  border-radius: 10px;
+  font-size: 11px;
+  font-weight: 600;
+  text-transform: uppercase;
+  letter-spacing: 0.04em;
+
+  &.active {
+    background-color: rgba($color-active, 0.12);
+    color: $color-active;
+  }
+
+  &.inactive {
+    background-color: rgba($color-inactive, 0.12);
+    color: $color-inactive;
+  }
+}
+
+// Warning text
+.dialog-warning {
+  display: flex;
+  align-items: center;
+  gap: $spacing-unit;
+  margin: 0;
+  font-size: 13px;
+  color: $color-critical;
+
+  mat-icon {
+    font-size: 18px !important;
+    width: 18px !important;
+    height: 18px !important;
+  }
+}
+
+// Dialog action buttons
+mat-dialog-actions {
+  padding-top: $spacing-unit * 2;
+
+  .cancel-button {
+    min-width: 80px;
+  }
+
+  .confirm-button {
+    min-width: 120px;
+
+    mat-icon {
+      font-size: 18px !important;
+      width: 18px !important;
+      height: 18px !important;
+      margin-right: 4px;
+    }
+  }
+}

frontend/src/app/components/delete-filament-dialog/delete-filament-dialog.component.ts

@@ -0,0 +1,68 @@
+import { ChangeDetectionStrategy, Component, inject } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import {
+  MAT_DIALOG_DATA,
+  MatDialogRef,
+  MatDialogModule,
+} from '@angular/material/dialog';
+import { MatButtonModule } from '@angular/material/button';
+import { MatIconModule } from '@angular/material/icon';
+import { MatChipsModule } from '@angular/material/chips';
+
+import { Filament } from '../../models/filament.model';
+
+/**
+ * Data passed into the delete confirmation dialog.
+ */
+export interface DeleteFilamentDialogData {
+  filament: Filament;
+}
+
+/**
+ * Delete confirmation dialog for filament spool removal.
+ *
+ * Displays spool details (material, brand, color, serial, remaining weight)
+ * and requires the user to confirm before deletion proceeds.
+ * Cancel dismisses the dialog with no action.
+ */
+@Component({
+  selector: 'app-delete-filament-dialog',
+  standalone: true,
+  imports: [
+    CommonModule,
+    MatDialogModule,
+    MatButtonModule,
+    MatIconModule,
+    MatChipsModule,
+  ],
+  templateUrl: './delete-filament-dialog.component.html',
+  styleUrl: './delete-filament-dialog.component.scss',
+  changeDetection: ChangeDetectionStrategy.OnPush,
+})
+export class DeleteFilamentDialogComponent {
+  private readonly dialogRef = inject(
+    MatDialogRef<DeleteFilamentDialogComponent, boolean>
+  );
+  readonly data: DeleteFilamentDialogData = inject(MAT_DIALOG_DATA);
+
+  /** The filament spool being considered for deletion */
+  readonly filament = this.data.filament;
+
+  /** Format weight for display in dialog */
+  formatWeight(grams: number): string {
+    if (grams >= 1000) {
+      return `${(grams / 1000).toFixed(1)}kg`;
+    }
+    return `${Math.round(grams)}g`;
+  }
+
+  /** Cancel — close dialog with false (no deletion) */
+  onCancel(): void {
+    this.dialogRef.close(false);
+  }
+
+  /** Confirm — close dialog with true (proceed with deletion) */
+  onConfirm(): void {
+    this.dialogRef.close(true);
+  }
+}

frontend/src/app/components/filament-table/filament-table.component.html

@@ -1,4 +1,4 @@
-<!-- Filament Inventory Table — with low stock indicators -->
+<!-- Filament Inventory Table — with low stock indicators and delete actions -->
 <div class="filament-table-container" role="region" aria-label="Filament inventory">
 
   <!-- Low Stock Alert Banner — shown when critical or low stock spools exist -->
@@ -106,10 +106,32 @@
       </td>
     </ng-container>
 
+    <!-- Actions Column — delete button -->
+    <ng-container matColumnDef="actions">
+      <th mat-header-cell *matHeaderCellDef>Actions</th>
+      <td mat-cell *matCellDef="let filament">
+        <button mat-icon-button
+                type="button"
+                color="warn"
+                [attr.aria-label]="'Delete ' + filament.materialBaseName + ' — ' + filament.colorName"
+                matTooltip="Delete spool"
+                matTooltipPosition="above"
+                [disabled]="deleting() === filament.id"
+                (click)="onDeleteClick(filament)">
+          @if (deleting() === filament.id) {
+            <mat-icon aria-hidden="true">hourglass_empty</mat-icon>
+          } @else {
+            <mat-icon aria-hidden="true">delete</mat-icon>
+          }
+        </button>
+      </td>
+    </ng-container>
+
     <tr mat-header-row *matHeaderRowDef="columns()"></tr>
     <tr mat-row *matRowDef="let row; columns: columns();"
         [class.row-critical]="classifyStockLevel(row) === 'critical'"
-        [class.row-low]="classifyStockLevel(row) === 'low'">
+        [class.row-low]="classifyStockLevel(row) === 'low'"
+        [class.row-deleting]="deleting() === row.id">
     </tr>
   </table>
 

frontend/src/app/components/filament-table/filament-table.component.scss

@@ -235,6 +235,20 @@ mat-chip {
   }
 }
 
+// Actions column
+.actions-cell {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+}
+
+// Row being deleted — subtle fade
+:host ::ng-deep .row-deleting {
+  opacity: 0.5;
+  pointer-events: none;
+  transition: opacity 0.3s ease;
+}
+
 // Empty state
 .empty-state {
   display: flex;

frontend/src/app/components/filament-table/filament-table.component.ts

@@ -3,6 +3,7 @@ import {
   Component,
   Input,
   computed,
+  inject,
   signal,
 } from '@angular/core';
 import { CommonModule } from '@angular/common';
@@ -12,12 +13,21 @@ import { MatIconModule } from '@angular/material/icon';
 import { MatProgressBarModule } from '@angular/material/progress-bar';
 import { MatTooltipModule } from '@angular/material/tooltip';
 import { MatSortModule, Sort } from '@angular/material/sort';
+import { MatButtonModule } from '@angular/material/button';
+import { MatDialog, MatDialogModule } from '@angular/material/dialog';
+import { MatSnackBar, MatSnackBarModule } from '@angular/material/snack-bar';
+
 import {
   Filament,
   StockLevel,
   getRemainingPercent,
   classifyStockLevel,
 } from '../../models/filament.model';
+import { FilamentService } from '../../services/filament.service';
+import {
+  DeleteFilamentDialogComponent,
+  DeleteFilamentDialogData,
+} from '../delete-filament-dialog/delete-filament-dialog.component';
 
 /** Display column definitions for the filament table */
 export type FilamentColumn =
@@ -27,7 +37,8 @@ export type FilamentColumn =
   | 'serial'
   | 'remaining'
   | 'stockLevel'
-  | 'status';
+  | 'status'
+  | 'actions';
 
 @Component({
   selector: 'app-filament-table',
@@ -40,16 +51,26 @@ export type FilamentColumn =
     MatProgressBarModule,
     MatTooltipModule,
     MatSortModule,
+    MatButtonModule,
+    MatDialogModule,
+    MatSnackBarModule,
   ],
   templateUrl: './filament-table.component.html',
   styleUrl: './filament-table.component.scss',
   changeDetection: ChangeDetectionStrategy.OnPush,
 })
 export class FilamentTableComponent {
+  private readonly dialog = inject(MatDialog);
+  private readonly snackBar = inject(MatSnackBar);
+  private readonly filamentService = inject(FilamentService);
+
   /** Filament data input — reactive signal for live updates */
   readonly filaments = signal<Filament[]>([]);
 
-  /** Columns to display — defaults to all columns */
+  /** Whether a delete operation is in progress */
+  readonly deleting = signal<string | null>(null);
+
+  /** Columns to display — defaults to all columns including actions */
   @Input()
   set displayedColumns(cols: FilamentColumn[]) {
     this._displayedColumns.set(cols);
@@ -65,6 +86,7 @@ export class FilamentTableComponent {
     'remaining',
     'stockLevel',
     'status',
+    'actions',
   ]);
 
   /** Default columns for template binding */
@@ -252,6 +274,52 @@ export class FilamentTableComponent {
     this.sortedFilaments.set(sorted);
   }
 
+  /**
+   * Open the delete confirmation dialog for a filament spool.
+   * On confirm: calls DELETE endpoint and removes the row on success.
+   * On cancel: dialog dismissed, no action taken.
+   */
+  onDeleteClick(filament: Filament): void {
+    const dialogData: DeleteFilamentDialogData = { filament };
+    const dialogRef = this.dialog.open(DeleteFilamentDialogComponent, {
+      data: dialogData,
+      width: '480px',
+      disableClose: true,
+    });
+
+    dialogRef.afterClosed().subscribe((confirmed: boolean | undefined) => {
+      if (!confirmed) {
+        return; // User cancelled — no action
+      }
+
+      // Mark as deleting for UI feedback
+      this.deleting.set(filament.id);
+
+      this.filamentService.deleteFilament(filament.id).subscribe({
+        next: () => {
+          // Remove the deleted filament from local data
+          const updated = this.filaments().filter((f) => f.id !== filament.id);
+          this.updateFilaments(updated);
+          this.deleting.set(null);
+
+          this.snackBar.open(
+            `Deleted ${filament.materialBaseName} — ${filament.colorName}`,
+            'Dismiss',
+            { duration: 4000 }
+          );
+        },
+        error: () => {
+          this.deleting.set(null);
+          this.snackBar.open(
+            `Failed to delete ${filament.materialBaseName} — ${filament.colorName}. Please try again.`,
+            'Dismiss',
+            { duration: 6000 }
+          );
+        },
+      });
+    });
+  }
+
   /** Template helper: get remaining percent */
   getRemainingPercent = getRemainingPercent;
 

frontend/src/app/services/filament.service.ts

@@ -0,0 +1,37 @@
+import { Injectable, inject } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+
+import { Filament } from '../models/filament.model';
+
+/**
+ * API base URL — matches the Extrudex backend default.
+ * TODO: Move to environment config when multi-environment support is added.
+ */
+const API_BASE_URL = '/api';
+
+/**
+ * Service for CRUD operations on filament spools.
+ * Communicates with the Extrudex backend SpoolsController.
+ */
+@Injectable({ providedIn: 'root' })
+export class FilamentService {
+  private readonly http = inject(HttpClient);
+
+  /**
+   * Fetch all filament spools from the backend.
+   * GET /api/spools
+   */
+  getFilaments(): Observable<Filament[]> {
+    return this.http.get<Filament[]>(`${API_BASE_URL}/spools`);
+  }
+
+  /**
+   * Soft-delete a filament spool by ID.
+   * DELETE /api/spools/{id}
+   * Returns 204 No Content on success.
+   */
+  deleteFilament(id: string): Observable<void> {
+    return this.http.delete<void>(`${API_BASE_URL}/spools/${id}`);
+  }
+}