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

backend/API/Controllers/CostAnalysisController.cs

@@ -1,108 +0,0 @@
-using Extrudex.API.DTOs.PrintJobs;
-using Extrudex.Domain.Interfaces;
-using Microsoft.AspNetCore.Mvc;
-
-namespace Extrudex.API.Controllers;
-
-/// <summary>
-/// Controller for cost analysis endpoints. Provides spool-level
-/// cost breakdowns and aggregated COGS reporting.
-/// </summary>
-[ApiController]
-[Route("api/cost-analysis")]
-public class CostAnalysisController : ControllerBase
-{
-    private readonly ICostPerPrintService _costService;
-    private readonly ILogger<CostAnalysisController> _logger;
-
-    /// <summary>
-    /// Initializes a new instance of the <see cref="CostAnalysisController"/> class.
-    /// </summary>
-    /// <param name="costService">The cost-per-print calculation service.</param>
-    /// <param name="logger">The logger for diagnostic output.</param>
-    public CostAnalysisController(
-        ICostPerPrintService costService,
-        ILogger<CostAnalysisController> logger)
-    {
-        _costService = costService;
-        _logger = logger;
-    }
-
-    // ── POST /api/cost-analysis/spool ────────────────────────────
-
-    /// <summary>
-    /// Calculates cost breakdowns for all print jobs associated with a specific spool.
-    /// Returns per-job costs plus an aggregated total. Jobs with missing cost data
-    /// include warnings and null cost fields — the endpoint never throws for missing data.
-    /// </summary>
-    /// <param name="request">The request containing the spool identifier.</param>
-    /// <returns>A spool-level cost summary with per-job breakdowns.</returns>
-    /// <response code="200">Returns the spool cost breakdown with per-job details.</response>
-    /// <response code="404">If the spool has no print jobs.</response>
-    [HttpPost("spool")]
-    [ProducesResponseType(typeof(SpoolCostResponse), StatusCodes.Status200OK)]
-    [ProducesResponseType(StatusCodes.Status404NotFound)]
-    public async Task<ActionResult<SpoolCostResponse>> CalculateSpoolCost([FromBody] SpoolCostRequest request)
-    {
-        _logger.LogDebug("Calculating cost breakdown for spool {SpoolId}", request.SpoolId);
-
-        var results = await _costService.CalculateBySpoolAsync(request.SpoolId);
-
-        if (results.Count == 0)
-        {
-            return NotFound(new { error = $"No print jobs found for spool with ID '{request.SpoolId}'." });
-        }
-
-        // Build the spool-level summary
-        var firstResult = results[0];
-        var jobResponses = results.Select(MapCostToResponse).ToList();
-
-        // Aggregate total cost and grams — only include jobs that have a valid cost
-        var calculableJobs = results.Where(r => r.CostPerPrint.HasValue).ToList();
-        var totalCost = calculableJobs.Count == results.Count
-            ? Math.Round(calculableJobs.Sum(r => r.CostPerPrint!.Value), 4)
-            : (decimal?)null;
-
-        var aggregateWarnings = new List<string>();
-        if (calculableJobs.Count < results.Count)
-        {
-            aggregateWarnings.Add(
-                $"{results.Count - calculableJobs.Count} of {results.Count} print jobs have missing cost data. " +
-                "Total cost reflects only jobs with complete data.");
-        }
-
-        var response = new SpoolCostResponse
-        {
-            SpoolId = request.SpoolId,
-            SpoolSerial = firstResult.SpoolSerial,
-            PurchasePrice = firstResult.PurchasePrice,
-            WeightTotalGrams = firstResult.WeightTotalGrams,
-            CostPerGram = firstResult.CostPerGram,
-            TotalGramsConsumed = results.Sum(r => r.GramsDerived),
-            TotalCost = totalCost,
-            JobCount = results.Count,
-            Jobs = jobResponses,
-            Warnings = aggregateWarnings
-        };
-
-        return Ok(response);
-    }
-
-    /// <summary>
-    /// Maps a domain CostPerPrintResult to an API CostPerPrintResponse DTO.
-    /// </summary>
-    private static CostPerPrintResponse MapCostToResponse(CostPerPrintResult r) => new()
-    {
-        PrintJobId = r.PrintJobId,
-        PrintName = r.PrintName,
-        SpoolId = r.SpoolId,
-        SpoolSerial = r.SpoolSerial,
-        MmExtruded = r.MmExtruded,
-        GramsDerived = r.GramsDerived,
-        PurchasePrice = r.PurchasePrice,
-        WeightTotalGrams = r.WeightTotalGrams,
-        CostPerGram = r.CostPerGram,
-        CostPerPrint = r.CostPerPrint,
-        Warnings = r.Warnings
-    };
-}

backend/API/DTOs/PrintJobs/CostPerPrintDtos.cs

@@ -1,99 +0,0 @@
-using System.ComponentModel.DataAnnotations;
-
-namespace Extrudex.API.DTOs.PrintJobs;
-
-/// <summary>
-/// Response DTO for cost-per-print calculation. Contains the full cost
-/// breakdown and any warnings about missing or incomplete data.
-/// </summary>
-public class CostPerPrintResponse
-{
-    /// <summary>The print job identifier this result belongs to.</summary>
-    public Guid PrintJobId { get; set; }
-
-    /// <summary>Human-readable name of the print job.</summary>
-    public string PrintName { get; set; } = string.Empty;
-
-    /// <summary>The spool identifier that provided filament.</summary>
-    public Guid SpoolId { get; set; }
-
-    /// <summary>Serial number of the spool.</summary>
-    public string SpoolSerial { get; set; } = string.Empty;
-
-    /// <summary>Total millimeters of filament extruded.</summary>
-    public decimal MmExtruded { get; set; }
-
-    /// <summary>Derived grams consumed for this print.</summary>
-    public decimal GramsDerived { get; set; }
-
-    /// <summary>The spool's purchase price. Null if not recorded.</summary>
-    public decimal? PurchasePrice { get; set; }
-
-    /// <summary>The spool's total weight in grams when full.</summary>
-    public decimal? WeightTotalGrams { get; set; }
-
-    /// <summary>Cost per gram of filament. Null if purchase price or total weight is missing.</summary>
-    public decimal? CostPerGram { get; set; }
-
-    /// <summary>Calculated cost of this print job. Null if cost data is incomplete.</summary>
-    public decimal? CostPerPrint { get; set; }
-
-    /// <summary>
-    /// Warnings about missing or incomplete data. Empty when all data is available
-    /// and the calculation succeeded.
-    /// </summary>
-    public List<string> Warnings { get; set; } = new();
-}
-
-/// <summary>
-/// Request DTO for batch cost calculation by spool. Returns cost breakdowns
-/// for all print jobs associated with the specified spool.
-/// </summary>
-public class SpoolCostRequest
-{
-    /// <summary>The unique identifier of the spool to calculate costs for.</summary>
-    [Required(ErrorMessage = "SpoolId is required.")]
-    public Guid SpoolId { get; set; }
-}
-
-/// <summary>
-/// Response DTO for spool-level cost calculation. Contains cost breakdowns
-/// for all print jobs on the spool, plus a total cost summary.
-/// </summary>
-public class SpoolCostResponse
-{
-    /// <summary>The spool identifier.</summary>
-    public Guid SpoolId { get; set; }
-
-    /// <summary>Serial number of the spool.</summary>
-    public string SpoolSerial { get; set; } = string.Empty;
-
-    /// <summary>The spool's purchase price. Null if not recorded.</summary>
-    public decimal? PurchasePrice { get; set; }
-
-    /// <summary>The spool's total weight in grams when full.</summary>
-    public decimal? WeightTotalGrams { get; set; }
-
-    /// <summary>Cost per gram of filament. Null if cost data is incomplete.</summary>
-    public decimal? CostPerGram { get; set; }
-
-    /// <summary>Total grams consumed across all print jobs on this spool.</summary>
-    public decimal TotalGramsConsumed { get; set; }
-
-    /// <summary>Total calculated cost across all print jobs. Null if any job has missing data.</summary>
-    public decimal? TotalCost { get; set; }
-
-    /// <summary>Number of print jobs included in this calculation.</summary>
-    public int JobCount { get; set; }
-
-    /// <summary>
-    /// Individual cost breakdowns per print job. Jobs with missing data
-    /// will have null cost fields and populated warnings.
-    /// </summary>
-    public List<CostPerPrintResponse> Jobs { get; set; } = new();
-
-    /// <summary>
-    /// Aggregate warnings about missing data across all jobs.
-    /// </summary>
-    public List<string> Warnings { get; set; } = new();
-}

backend/API/Jobs/FilamentUsageSyncJob.cs

@@ -1,79 +0,0 @@
-using Extrudex.Domain.Interfaces;
-using Extrudex.Infrastructure.Configuration;
-using Microsoft.Extensions.Hosting;
-using Microsoft.Extensions.Logging;
-using Microsoft.Extensions.Options;
-
-namespace Extrudex.API.Jobs;
-
-/// <summary>
-/// Background job that periodically syncs filament usage data from
-/// Moonraker printers. Runs as a hosted service and polls all active
-/// Moonraker printers on a configurable interval to persist usage
-/// data to the Extrudex database.
-/// 
-/// Configuration is bound from the "FilamentUsageSync" section in
-/// appsettings.json. Set Enabled=false to disable without removing
-/// the service registration.
-/// </summary>
-public class FilamentUsageSyncJob : BackgroundService
-{
-    private readonly IFilamentUsageSyncService _syncService;
-    private readonly FilamentUsageSyncOptions _options;
-    private readonly ILogger<FilamentUsageSyncJob> _logger;
-
-    /// <summary>
-    /// Creates a new FilamentUsageSyncJob.
-    /// </summary>
-    /// <param name="syncService">The service that performs the actual sync logic.</param>
-    /// <param name="options">Configuration options for polling interval and timeouts.</param>
-    /// <param name="logger">Logger for diagnostic output.</param>
-    public FilamentUsageSyncJob(
-        IFilamentUsageSyncService syncService,
-        IOptions<FilamentUsageSyncOptions> options,
-        ILogger<FilamentUsageSyncJob> logger)
-    {
-        _syncService = syncService;
-        _options = options.Value;
-        _logger = logger;
-    }
-
-    /// <inheritdoc />
-    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
-    {
-        if (!_options.Enabled)
-        {
-            _logger.LogInformation("Filament usage sync job is disabled via configuration — exiting");
-            return;
-        }
-
-        _logger.LogInformation(
-            "Filament usage sync job starting — polling every {Interval}",
-            _options.PollingInterval);
-
-        // Delay briefly on startup to allow the web host to fully initialize
-        await Task.Delay(TimeSpan.FromSeconds(10), stoppingToken);
-
-        while (!stoppingToken.IsCancellationRequested)
-        {
-            try
-            {
-                var syncedCount = await _syncService.SyncAllAsync(stoppingToken);
-
-                _logger.LogInformation(
-                    "Filament usage sync completed — {SyncedCount} printer(s) synced. Next sync in {Interval}",
-                    syncedCount, _options.PollingInterval);
-            }
-            catch (Exception ex) when (ex is not OperationCanceledException)
-            {
-                _logger.LogError(ex,
-                    "Error during filament usage sync cycle — will retry in {Interval}",
-                    _options.PollingInterval);
-            }
-
-            await Task.Delay(_options.PollingInterval, stoppingToken);
-        }
-
-        _logger.LogInformation("Filament usage sync job shutting down");
-    }
-}

backend/Dockerfile

@@ -17,9 +17,6 @@ RUN dotnet publish Extrudex.csproj \
 FROM mcr.microsoft.com/dotnet/aspnet:9.0 AS runtime
 WORKDIR /app
 
-# Install curl for health check (not included in aspnet base image)
-RUN apt-get update && apt-get install -y --no-install-recommends curl && rm -rf /var/lib/apt/lists/*
-
 # Non-root user for security
 RUN adduser --disabled-password --gecos "" appuser
 USER appuser

backend/Domain/Interfaces/ICostPerPrintService.cs

@@ -1,76 +0,0 @@
-namespace Extrudex.Domain.Interfaces;
-
-/// <summary>
-/// Service interface for calculating the cost of goods sold (COGS) per print job.
-/// Uses the spool's purchase price and the print job's derived grams consumed
-/// to produce a cost breakdown. Handles missing cost data gracefully by returning
-/// warnings rather than throwing exceptions.
-/// </summary>
-public interface ICostPerPrintService
-{
-    /// <summary>
-    /// Calculates the cost per print for a specific print job.
-    /// </summary>
-    /// <param name="printJobId">The unique identifier of the print job.</param>
-    /// <param name="cancellationToken">Optional cancellation token.</param>
-    /// <returns>
-    /// A <see cref="CostPerPrintResult"/> containing the cost breakdown,
-    /// or warnings if cost data is missing or incomplete.
-    /// </returns>
-    Task<CostPerPrintResult> CalculateAsync(Guid printJobId, CancellationToken cancellationToken = default);
-
-    /// <summary>
-    /// Calculates cost breakdowns for all print jobs associated with a specific spool.
-    /// Useful for spool-level COGS reporting.
-    /// </summary>
-    /// <param name="spoolId">The unique identifier of the spool.</param>
-    /// <param name="cancellationToken">Optional cancellation token.</param>
-    /// <returns>
-    /// A list of <see cref="CostPerPrintResult"/> for each print job on the spool.
-    /// Jobs with missing cost data will include warnings.
-    /// </returns>
-    Task<IReadOnlyList<CostPerPrintResult>> CalculateBySpoolAsync(Guid spoolId, CancellationToken cancellationToken = default);
-}
-
-/// <summary>
-/// Result of a cost-per-print calculation. Contains the cost breakdown
-/// and any warnings about missing or incomplete cost data.
-/// </summary>
-public class CostPerPrintResult
-{
-    /// <summary>The print job identifier this result belongs to.</summary>
-    public Guid PrintJobId { get; set; }
-
-    /// <summary>Human-readable name of the print job.</summary>
-    public string PrintName { get; set; } = string.Empty;
-
-    /// <summary>The spool identifier that provided filament.</summary>
-    public Guid SpoolId { get; set; }
-
-    /// <summary>Serial number of the spool.</summary>
-    public string SpoolSerial { get; set; } = string.Empty;
-
-    /// <summary>Total millimeters of filament extruded.</summary>
-    public decimal MmExtruded { get; set; }
-
-    /// <summary>Derived grams consumed for this print.</summary>
-    public decimal GramsDerived { get; set; }
-
-    /// <summary>The spool's purchase price. Null if not recorded.</summary>
-    public decimal? PurchasePrice { get; set; }
-
-    /// <summary>The spool's total weight in grams when full.</summary>
-    public decimal? WeightTotalGrams { get; set; }
-
-    /// <summary>Cost per gram of filament. Null if purchase price or total weight is missing.</summary>
-    public decimal? CostPerGram { get; set; }
-
-    /// <summary>Calculated cost of this print job. Null if cost data is incomplete.</summary>
-    public decimal? CostPerPrint { get; set; }
-
-    /// <summary>
-    /// Warnings about missing or incomplete data that prevented a full calculation.
-    /// Empty when all data is available and the calculation succeeded.
-    /// </summary>
-    public List<string> Warnings { get; set; } = new();
-}

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/IFilamentUsageSyncService.cs

@@ -1,19 +0,0 @@
-namespace Extrudex.Domain.Interfaces;
-
-/// <summary>
-/// Service interface for syncing filament usage data from printers
-/// into the Extrudex database. Handles querying Moonraker printers,
-/// computing derived usage metrics, and persisting updates to spools
-/// and print job records.
-/// </summary>
-public interface IFilamentUsageSyncService
-{
-    /// <summary>
-    /// Performs a single sync cycle: queries all active Moonraker printers,
-    /// fetches their current filament usage data, and persists updates to
-    /// the database.
-    /// </summary>
-    /// <param name="cancellationToken">Cancellation token for graceful shutdown.</param>
-    /// <returns>The number of printers successfully synced.</returns>
-    Task<int> SyncAllAsync(CancellationToken cancellationToken = default);
-}

backend/Infrastructure/Configuration/FilamentUsageSyncOptions.cs

@@ -1,33 +0,0 @@
-namespace Extrudex.Infrastructure.Configuration;
-
-/// <summary>
-/// Configuration options for the FilamentUsageSync background job.
-/// Bound from appsettings.json under the "FilamentUsageSync" section.
-/// Controls polling interval and per-printer timeout settings.
-/// </summary>
-public class FilamentUsageSyncOptions
-{
-    /// <summary>
-    /// The section name in appsettings.json where these options are bound.
-    /// </summary>
-    public const string SectionName = "FilamentUsageSync";
-
-    /// <summary>
-    /// How often the background job polls printers for usage data.
-    /// Default: 5 minutes. Minimum recommended: 1 minute.
-    /// </summary>
-    public TimeSpan PollingInterval { get; set; } = TimeSpan.FromMinutes(5);
-
-    /// <summary>
-    /// Timeout for individual HTTP requests to a Moonraker printer.
-    /// Default: 30 seconds.
-    /// </summary>
-    public TimeSpan RequestTimeout { get; set; } = TimeSpan.FromSeconds(30);
-
-    /// <summary>
-    /// Whether the sync job is enabled. Set to false to disable
-    /// the background job without removing its registration.
-    /// Default: true.
-    /// </summary>
-    public bool Enabled { get; set; } = true;
-}

backend/Infrastructure/Services/CostPerPrintService.cs

@@ -1,158 +0,0 @@
-using Extrudex.Domain.Interfaces;
-using Extrudex.Infrastructure.Data;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.Extensions.Logging;
-
-namespace Extrudex.Infrastructure.Services;
-
-/// <summary>
-/// Calculates the cost of goods sold (COGS) per print job using the spool's
-/// purchase price and the print job's derived grams consumed.
-///
-/// Formula:
-///   cost_per_gram = purchase_price / weight_total_grams
-///   cost_per_print = grams_derived × cost_per_gram
-///
-/// Handles missing data gracefully — if the spool has no purchase price or
-/// weight recorded, the result includes warnings and null cost fields
-/// instead of throwing exceptions.
-/// </summary>
-public class CostPerPrintService : ICostPerPrintService
-{
-    private readonly ExtrudexDbContext _dbContext;
-    private readonly ILogger<CostPerPrintService> _logger;
-
-    /// <summary>
-    /// Initializes a new instance of the <see cref="CostPerPrintService"/> class.
-    /// </summary>
-    /// <param name="dbContext">The database context for data access.</param>
-    /// <param name="logger">The logger for diagnostic output.</param>
-    public CostPerPrintService(ExtrudexDbContext dbContext, ILogger<CostPerPrintService> logger)
-    {
-        _dbContext = dbContext;
-        _logger = logger;
-    }
-
-    /// <inheritdoc />
-    public async Task<CostPerPrintResult> CalculateAsync(Guid printJobId, CancellationToken cancellationToken = default)
-    {
-        _logger.LogDebug("Calculating cost per print for job {PrintJobId}", printJobId);
-
-        var job = await _dbContext.PrintJobs
-            .Include(j => j.Spool)
-            .ThenInclude(s => s!.MaterialBase)
-            .FirstOrDefaultAsync(j => j.Id == printJobId, cancellationToken);
-
-        if (job is null)
-        {
-            _logger.LogWarning("Print job {PrintJobId} not found for cost calculation", printJobId);
-            return new CostPerPrintResult
-            {
-                PrintJobId = printJobId,
-                Warnings = new List<string> { $"Print job with ID '{printJobId}' not found." }
-            };
-        }
-
-        return BuildResult(job);
-    }
-
-    /// <inheritdoc />
-    public async Task<IReadOnlyList<CostPerPrintResult>> CalculateBySpoolAsync(
-        Guid spoolId, CancellationToken cancellationToken = default)
-    {
-        _logger.LogDebug("Calculating cost per print for all jobs on spool {SpoolId}", spoolId);
-
-        var jobs = await _dbContext.PrintJobs
-            .Include(j => j.Spool)
-            .ThenInclude(s => s!.MaterialBase)
-            .Where(j => j.SpoolId == spoolId)
-            .OrderByDescending(j => j.CreatedAt)
-            .ToListAsync(cancellationToken);
-
-        if (jobs.Count == 0)
-        {
-            _logger.LogDebug("No print jobs found for spool {SpoolId}", spoolId);
-            return Array.Empty<CostPerPrintResult>();
-        }
-
-        return jobs.Select(BuildResult).ToList();
-    }
-
-    /// <summary>
-    /// Builds a <see cref="CostPerPrintResult"/> from a print job entity.
-    /// Computes cost_per_gram and cost_per_print when all required data is available.
-    /// Populates warnings when data is missing or incomplete.
-    /// </summary>
-    /// <param name="job">The print job entity with Spool navigation loaded.</param>
-    /// <returns>A cost calculation result with breakdown and any warnings.</returns>
-    private CostPerPrintResult BuildResult(Domain.Entities.PrintJob job)
-    {
-        var warnings = new List<string>();
-        var spool = job.Spool;
-
-        // Map what we always have
-        var result = new CostPerPrintResult
-        {
-            PrintJobId = job.Id,
-            PrintName = job.PrintName,
-            SpoolId = job.SpoolId,
-            SpoolSerial = spool?.SpoolSerial ?? string.Empty,
-            MmExtruded = job.MmExtruded,
-            GramsDerived = job.GramsDerived,
-        };
-
-        // Guard: spool must be loaded
-        if (spool is null)
-        {
-            warnings.Add("Spool data is not available for this print job.");
-            result.Warnings = warnings;
-            return result;
-        }
-
-        // Capture purchase price
-        result.PurchasePrice = spool.PurchasePrice;
-        result.WeightTotalGrams = spool.WeightTotalGrams;
-
-        // Check for missing purchase price
-        if (!spool.PurchasePrice.HasValue)
-        {
-            warnings.Add(
-                "Spool purchase price is not recorded. Cost calculation requires a purchase price on the spool.");
-        }
-
-        // Check for zero or negative weight — prevents division by zero
-        if (spool.WeightTotalGrams <= 0)
-        {
-            warnings.Add(
-                "Spool total weight is zero or not recorded. Cost calculation requires a positive weight_total_grams on the spool.");
-        }
-
-        // Check for zero grams derived
-        if (job.GramsDerived <= 0)
-        {
-            warnings.Add(
-                "Derived grams consumed is zero. Ensure mm_extruded, filament diameter, and material density are recorded for this print job.");
-        }
-
-        // If all data is present and valid, compute the cost
-        if (spool.PurchasePrice.HasValue && spool.WeightTotalGrams > 0 && job.GramsDerived > 0)
-        {
-            var costPerGram = spool.PurchasePrice.Value / spool.WeightTotalGrams;
-            result.CostPerGram = Math.Round(costPerGram, 6);
-            result.CostPerPrint = Math.Round(job.GramsDerived * costPerGram, 4);
-
-            _logger.LogDebug(
-                "Cost calculated for job {PrintJobId}: {GramsDerived}g × {CostPerGram:C}/g = {CostPerPrint:C}",
-                job.Id, job.GramsDerived, result.CostPerGram, result.CostPerPrint);
-        }
-        else
-        {
-            _logger.LogDebug(
-                "Cost calculation incomplete for job {PrintJobId}: missing data (warnings: {WarningCount})",
-                job.Id, warnings.Count);
-        }
-
-        result.Warnings = warnings;
-        return result;
-    }
-}

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/FilamentUsageSyncService.cs

@@ -1,139 +0,0 @@
-using Extrudex.Domain.Enums;
-using Extrudex.Domain.Interfaces;
-using Extrudex.Infrastructure.Data;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.Extensions.Logging;
-
-namespace Extrudex.Infrastructure.Configuration;
-
-/// <summary>
-/// Service that syncs filament usage data from Moonraker printers into the
-/// Extrudex database. Queries all active Moonraker printers, fetches their
-/// current filament usage metrics, and updates spool remaining weights and
-/// print job records.
-/// </summary>
-public class FilamentUsageSyncService : IFilamentUsageSyncService
-{
-    private readonly ExtrudexDbContext _dbContext;
-    private readonly IMoonrakerClient _moonrakerClient;
-    private readonly ILogger<FilamentUsageSyncService> _logger;
-
-    /// <summary>
-    /// Creates a new FilamentUsageSyncService.
-    /// </summary>
-    /// <param name="dbContext">The EF Core database context for persisting updates.</param>
-    /// <param name="moonrakerClient">The Moonraker HTTP client for fetching printer data.</param>
-    /// <param name="logger">Logger for diagnostic output.</param>
-    public FilamentUsageSyncService(
-        ExtrudexDbContext dbContext,
-        IMoonrakerClient moonrakerClient,
-        ILogger<FilamentUsageSyncService> logger)
-    {
-        _dbContext = dbContext;
-        _moonrakerClient = moonrakerClient;
-        _logger = logger;
-    }
-
-    /// <inheritdoc />
-    public async Task<int> SyncAllAsync(CancellationToken cancellationToken = default)
-    {
-        _logger.LogInformation("Starting filament usage sync cycle");
-
-        var printers = await _dbContext.Printers
-            .Where(p => p.IsActive && p.ConnectionType == ConnectionType.Moonraker)
-            .Include(p => p.AmsUnits)
-                .ThenInclude(u => u.Slots)
-                    .ThenInclude(s => s.Spool)
-            .ToListAsync(cancellationToken);
-
-        if (printers.Count == 0)
-        {
-            _logger.LogInformation("No active Moonraker printers found — skipping sync");
-            return 0;
-        }
-
-        _logger.LogInformation("Found {PrinterCount} active Moonraker printer(s) to sync", printers.Count);
-
-        var syncedCount = 0;
-
-        foreach (var printer in printers)
-        {
-            try
-            {
-                var usageData = await _moonrakerClient.GetFilamentUsageAsync(
-                    printer.HostnameOrIp,
-                    printer.Port,
-                    printer.ApiKey,
-                    cancellationToken);
-
-                if (usageData.Count == 0)
-                {
-                    _logger.LogWarning(
-                        "No usage data returned from printer {PrinterName} ({Host}:{Port})",
-                        printer.Name, printer.HostnameOrIp, printer.Port);
-                    continue;
-                }
-
-                // Update spool remaining weights from AMS data
-                UpdateSpoolWeights(printer, usageData);
-
-                // Mark printer as seen and idle (reachable = idle, not printing)
-                printer.LastSeenAt = DateTime.UtcNow;
-                printer.Status = PrinterStatus.Idle;
-
-                syncedCount++;
-                _logger.LogInformation(
-                    "Successfully synced filament usage from printer {PrinterName}",
-                    printer.Name);
-            }
-            catch (Exception ex)
-            {
-                _logger.LogError(ex,
-                    "Error syncing filament usage from printer {PrinterName} ({Host}:{Port})",
-                    printer.Name, printer.HostnameOrIp, printer.Port);
-            }
-        }
-
-        await _dbContext.SaveChangesAsync(cancellationToken);
-
-        _logger.LogInformation(
-            "Filament usage sync cycle complete — {SyncedCount}/{TotalCount} printers synced",
-            syncedCount, printers.Count);
-
-        return syncedCount;
-    }
-
-    /// <summary>
-    /// Updates spool remaining weights based on usage data received from Moonraker.
-    /// For printers with AMS units, updates the remaining weight on each slot's spool.
-    /// </summary>
-    private void UpdateSpoolWeights(
-        Domain.Entities.Printer printer,
-        Dictionary<string, decimal> usageData)
-    {
-        // Update AMS slot remaining weights if available
-        foreach (var amsUnit in printer.AmsUnits)
-        {
-            foreach (var slot in amsUnit.Slots)
-            {
-                if (slot.Spool != null && slot.RemainingWeightG.HasValue)
-                {
-                    // Sync the AMS-reported remaining weight to the spool
-                    slot.Spool.WeightRemainingGrams = slot.RemainingWeightG.Value;
-
-                    _logger.LogDebug(
-                        "Updated spool {SpoolSerial} remaining weight to {Weight}g",
-                        slot.Spool.SpoolSerial, slot.RemainingWeightG.Value);
-                }
-            }
-        }
-
-        // If usage data contains extruded mm, log it for observability
-        if (usageData.TryGetValue("mm_extruded", out var mmExtruded) && mmExtruded > 0)
-        {
-            _logger.LogInformation(
-                "Printer {PrinterName} reports {MmExtruded}mm filament extruded in latest job",
-                printer.Name, mmExtruded);
-        }
-    }
-}

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,9 +1,8 @@
 using System.Reflection;
+using System.Net.Http.Headers;
 using Extrudex.API.Filters;
 using Extrudex.API.Hubs;
-using Extrudex.API.Jobs;
 using Extrudex.Domain.Interfaces;
-using Extrudex.Infrastructure.Configuration;
 using Extrudex.Infrastructure.Data;
 using Extrudex.Infrastructure.Services;
 using FluentValidation;
@@ -52,8 +51,22 @@ builder.Services.AddSwaggerGen(c =>
 // ── QR Code Generation ──────────────────────────────────────
 builder.Services.AddSingleton<IQrCodeService, QrCodeService>();
 
-// ── Cost Per Print Calculation ─────────────────────────────
-builder.Services.AddScoped<ICostPerPrintService, CostPerPrintService>();
+// ── 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.
@@ -82,16 +95,6 @@ builder.Services.AddCors(options =>
 // ── SignalR (real-time printer updates) ────────────────────
 builder.Services.AddSignalR();
 
-// ── Filament Usage Sync (Background Job) ──────────────────
-builder.Services.Configure<FilamentUsageSyncOptions>(
-    builder.Configuration.GetSection(FilamentUsageSyncOptions.SectionName));
-builder.Services.AddHttpClient<IMoonrakerClient, MoonrakerClient>(client =>
-{
-    client.DefaultRequestHeaders.Add("User-Agent", "Extrudex/1.0");
-});
-builder.Services.AddScoped<IFilamentUsageSyncService, FilamentUsageSyncService>();
-builder.Services.AddHostedService<FilamentUsageSyncJob>();
-
 // ── Health Checks ───────────────────────────────────────────
 builder.Services.AddHealthChecks()
     .AddNpgSql(connectionString);

backend/appsettings.Development.json

@@ -8,10 +8,5 @@
   },
   "ConnectionStrings": {
     "ExtrudexDb": "Host=localhost;Port=5432;Database=extrudex_dev;Username=extrudex;Password=changeme"
-  },
-  "FilamentUsageSync": {
-    "PollingInterval": "00:01:00",
-    "RequestTimeout": "00:00:30",
-    "Enabled": true
   }
 }

backend/appsettings.json

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

deploy.sh

@@ -18,14 +18,13 @@ echo "📦 Building and starting services..."
 $COMPOSE_CMD -f docker-compose.dev.yml up -d --build
 
 echo "⏳ Waiting for services to become healthy..."
-sleep 15
+sleep 10
 
 echo "✅ Deployment complete!"
 echo ""
 echo "Services running:"
-echo "  • PostgreSQL:    localhost:5433"
 echo "  • Extrudex API: http://localhost:5080"
-echo "  • Extrudex Web: http://localhost:5081"
+echo "  • Control Center Web: http://localhost:5081"
 echo ""
 echo "To view logs:"
 echo "  $COMPOSE_CMD -f docker-compose.dev.yml logs -f"

docker-compose.dev.yml

@@ -1,25 +1,6 @@
-services:
-  extrudex-db:
-    image: postgres:16-alpine
-    container_name: extrudex-db
-    environment:
-      POSTGRES_USER: extrudex
-      POSTGRES_PASSWORD: changeme
-      POSTGRES_DB: extrudex
-    ports:
-      - "5433:5432"
-    volumes:
-      - extrudex-db-data:/var/lib/postgresql/data
-    healthcheck:
-      test: ["CMD-SHELL", "pg_isready -U extrudex"]
-      interval: 10s
-      timeout: 5s
-      retries: 5
-      start_period: 10s
-    restart: unless-stopped
-    networks:
-      - extrudex-network
+version: '3.8'
 
+services:
   extrudex-api:
     build:
       context: ./backend
@@ -30,14 +11,6 @@ services:
     environment:
       - ASPNETCORE_ENVIRONMENT=Development
       - ASPNETCORE_URLS=http://+:8080
-      - EXTRUDEX_DB_HOST=extrudex-db
-      - EXTRUDEX_DB_PORT=5432
-      - EXTRUDEX_DB_NAME=extrudex
-      - EXTRUDEX_DB_USER=extrudex
-      - EXTRUDEX_DB_PASSWORD=changeme
-    depends_on:
-      extrudex-db:
-        condition: service_healthy
     restart: unless-stopped
     healthcheck:
       test: ["CMD", "curl", "-f", "http://localhost:8080/health"]
@@ -48,11 +21,11 @@ services:
     networks:
       - extrudex-network
 
-  extrudex-web:
+  control-center-web:
     build:
-      context: ./frontend
+      context: ../Control-Center/frontend
       dockerfile: Dockerfile
-    container_name: extrudex-web
+    container_name: control-center-web
     ports:
       - "5081:80"
     depends_on:
@@ -62,9 +35,6 @@ services:
     networks:
       - extrudex-network
 
-volumes:
-  extrudex-db-data:
-
 networks:
   extrudex-network:
     driver: bridge

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-filter/filament-filter.component.html

@@ -1,76 +0,0 @@
-<!-- Filament Filter Bar — material type, color search, low stock, active-only -->
-<div class="filament-filter-bar" role="search" aria-label="Filter filament inventory">
-
-  <!-- Material Type Multi-Select -->
-  <mat-form-field appearance="outline" class="filter-field material-filter">
-    <mat-label>Material</mat-label>
-    <mat-select multiple
-                [value]="selectedMaterials()"
-                (selectionChange)="onMaterialChange($event.value)"
-                aria-label="Filter by material type">
-      @for (material of materialOptions(); track material) {
-        <mat-option [value]="material">{{ material }}</mat-option>
-      }
-    </mat-select>
-    @if (selectedMaterials().length > 0) {
-      <mat-chip-set class="selected-chips" matSuffix>
-        @for (mat of selectedMaterials(); track mat) {
-          <mat-chip (removed)="removeMaterial(mat)"
-                    class="filter-chip">
-            <span>{{ mat }}</span>
-            <mat-icon matChipRemove>cancel</mat-icon>
-          </mat-chip>
-        }
-      </mat-chip-set>
-    }
-  </mat-form-field>
-
-  <!-- Color Search -->
-  <mat-form-field appearance="outline" class="filter-field color-filter">
-    <mat-label>Color</mat-label>
-    <input matInput
-           type="text"
-           [value]="colorSearch()"
-           (input)="onColorSearchChange($any($event.target).value)"
-           placeholder="Search color..."
-           aria-label="Filter by color name" />
-    @if (colorSearch().trim()) {
-      <mat-icon matSuffix class="filter-active-icon">filter_list</mat-icon>
-    }
-  </mat-form-field>
-
-  <!-- Low Stock Toggle -->
-  <mat-checkbox [checked]="lowStockOnly()"
-                (change)="onLowStockToggle($event.checked)"
-                class="filter-checkbox"
-                aria-label="Show low stock only"
-                matTooltip="Show only spools at 25% or less remaining"
-                matTooltipPosition="below">
-    <mat-icon class="checkbox-icon" [class.active]="lowStockOnly()">warning</mat-icon>
-    Low Stock
-  </mat-checkbox>
-
-  <!-- Active Only Toggle -->
-  <mat-checkbox [checked]="activeOnly()"
-                (change)="onActiveOnlyToggle($event.checked)"
-                class="filter-checkbox"
-                aria-label="Show active spools only"
-                matTooltip="Show only spools currently in use"
-                matTooltipPosition="below">
-    <mat-icon class="checkbox-icon" [class.active]="activeOnly()">check_circle</mat-icon>
-    Active Only
-  </mat-checkbox>
-
-  <!-- Clear All Filters -->
-  @if (hasActiveFilters()) {
-    <button mat-button
-            class="clear-filters-btn"
-            (click)="clearAll()"
-            aria-label="Clear all filters"
-            matTooltip="Remove all filters"
-            matTooltipPosition="below">
-      <mat-icon>filter_alt_off</mat-icon>
-      Clear
-    </button>
-  }
-</div>

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

@@ -1,134 +0,0 @@
-/**
- * Filament Filter Bar Styles
- * Responsive filter layout for kiosk and mobile
- */
-
-$spacing-unit: 8px;
-
-.filament-filter-bar {
-  display: flex;
-  align-items: center;
-  gap: $spacing-unit * 2;
-  flex-wrap: wrap;
-  padding: $spacing-unit * 2 0;
-  margin-bottom: $spacing-unit * 2;
-}
-
-// Form field sizing
-.filter-field {
-  flex: 0 1 auto;
-  min-width: 160px;
-
-  &.material-filter {
-    min-width: 200px;
-  }
-
-  &.color-filter {
-    min-width: 180px;
-  }
-
-  // Reduce vertical spacing inside filter fields
-  .mat-mdc-form-field-subscript-wrapper {
-    display: none; // No hint/error text needed for filters
-  }
-}
-
-// Selected material chips
-.selected-chips {
-  flex-wrap: wrap;
-  gap: 4px;
-}
-
-.filter-chip {
-  font-size: 12px !important;
-  min-height: 24px !important;
-
-  mat-icon {
-    font-size: 14px !important;
-    width: 14px !important;
-    height: 14px !important;
-  }
-}
-
-// Active filter icon
-.filter-active-icon {
-  color: var(--mat-sys-primary);
-  font-size: 18px !important;
-  width: 18px !important;
-  height: 18px !important;
-}
-
-// Checkbox styling
-.filter-checkbox {
-  display: flex;
-  align-items: center;
-  gap: 4px;
-  white-space: nowrap;
-  user-select: none;
-  touch-action: manipulation; // Prevent zoom on double-tap
-
-  .checkbox-icon {
-    font-size: 18px !important;
-    width: 18px !important;
-    height: 18px !important;
-    color: var(--mat-sys-on-surface-variant);
-    transition: color 0.2s ease;
-
-    &.active {
-      color: var(--mat-sys-primary);
-    }
-  }
-}
-
-// Clear filters button
-.clear-filters-btn {
-  display: flex;
-  align-items: center;
-  gap: 4px;
-  font-size: 13px;
-
-  mat-icon {
-    font-size: 18px !important;
-    width: 18px !important;
-    height: 18px !important;
-  }
-}
-
-// Responsive: stack filters vertically on small screens
-@media (max-width: 768px) {
-  .filament-filter-bar {
-    flex-direction: column;
-    align-items: stretch;
-    gap: $spacing-unit;
-  }
-
-  .filter-field {
-    width: 100%;
-    min-width: unset;
-
-    &.material-filter,
-    &.color-filter {
-      min-width: unset;
-    }
-  }
-
-  .filter-checkbox {
-    padding: $spacing-unit 0;
-  }
-
-  .clear-filters-btn {
-    align-self: flex-start;
-  }
-}
-
-// Extra-small screens (phone portrait)
-@media (max-width: 480px) {
-  .filament-filter-bar {
-    padding: $spacing-unit 0;
-    margin-bottom: $spacing-unit;
-  }
-
-  .filter-checkbox {
-    font-size: 13px;
-  }
-}

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

@@ -1,158 +0,0 @@
-import {
-  ChangeDetectionStrategy,
-  Component,
-  EventEmitter,
-  Input,
-  Output,
-  computed,
-  signal,
-} from '@angular/core';
-import { CommonModule } from '@angular/common';
-import { FormsModule } from '@angular/forms';
-import { MatFormFieldModule } from '@angular/material/form-field';
-import { MatSelectModule } from '@angular/material/select';
-import { MatInputModule } from '@angular/material/input';
-import { MatCheckboxModule } from '@angular/material/checkbox';
-import { MatIconModule } from '@angular/material/icon';
-import { MatChipsModule } from '@angular/material/chips';
-import { MatButtonModule } from '@angular/material/button';
-import { MatTooltipModule } from '@angular/material/tooltip';
-import {
-  Filament,
-  StockLevel,
-  classifyStockLevel,
-} from '../../models/filament.model';
-
-/** Filter state emitted by the filament filter component */
-export interface FilamentFilterState {
-  /** Selected material base names — empty means all */
-  materialBaseNames: string[];
-
-  /** Color search text — empty string means all */
-  colorSearch: string;
-
-  /** Whether to show only low/critical stock */
-  lowStockOnly: boolean;
-
-  /** Whether to show only active spools */
-  activeOnly: boolean;
-}
-
-/**
- * FilamentFilterComponent — Filter bar for the filament inventory list.
- *
- * Provides:
- * - Material type multi-select filter
- * - Color name text search
- * - Low stock toggle (shows only critical/low spools)
- * - Active-only toggle
- * - Clear all filters action
- */
-@Component({
-  selector: 'app-filament-filter',
-  standalone: true,
-  imports: [
-    CommonModule,
-    FormsModule,
-    MatFormFieldModule,
-    MatSelectModule,
-    MatInputModule,
-    MatCheckboxModule,
-    MatIconModule,
-    MatChipsModule,
-    MatButtonModule,
-    MatTooltipModule,
-  ],
-  templateUrl: './filament-filter.component.html',
-  styleUrl: './filament-filter.component.scss',
-  changeDetection: ChangeDetectionStrategy.OnPush,
-})
-export class FilamentFilterComponent {
-  /** Filament data input — used to derive material options */
-  @Input() set filaments(value: Filament[]) {
-    this._filaments.set(value);
-    const materials = [...new Set(value.map((f) => f.materialBaseName))].sort();
-    this.materialOptions.set(materials);
-  }
-  get filaments(): Filament[] {
-    return this._filaments();
-  }
-  private readonly _filaments = signal<Filament[]>([]);
-
-  /** Available material base names derived from filament data */
-  readonly materialOptions = signal<string[]>([]);
-
-  /** Selected material base names */
-  readonly selectedMaterials = signal<string[]>([]);
-
-  /** Color search text */
-  readonly colorSearch = signal('');
-
-  /** Low stock only toggle */
-  readonly lowStockOnly = signal(false);
-
-  /** Active only toggle */
-  readonly activeOnly = signal(false);
-
-  /** Computed: whether any filters are active */
-  readonly hasActiveFilters = computed(
-    () =>
-      this.selectedMaterials().length > 0 ||
-      this.colorSearch().trim().length > 0 ||
-      this.lowStockOnly() ||
-      this.activeOnly()
-  );
-
-  /** Emits the current filter state whenever filters change */
-  @Output() readonly filterChange = new EventEmitter<FilamentFilterState>();
-
-  /** Handle material selection change */
-  onMaterialChange(selected: string[]): void {
-    this.selectedMaterials.set(selected);
-    this.emitFilterState();
-  }
-
-  /** Handle color search input */
-  onColorSearchChange(value: string): void {
-    this.colorSearch.set(value);
-    this.emitFilterState();
-  }
-
-  /** Handle low stock toggle */
-  onLowStockToggle(checked: boolean): void {
-    this.lowStockOnly.set(checked);
-    this.emitFilterState();
-  }
-
-  /** Handle active-only toggle */
-  onActiveOnlyToggle(checked: boolean): void {
-    this.activeOnly.set(checked);
-    this.emitFilterState();
-  }
-
-  /** Remove a single material chip */
-  removeMaterial(material: string): void {
-    const updated = this.selectedMaterials().filter((m) => m !== material);
-    this.selectedMaterials.set(updated);
-    this.emitFilterState();
-  }
-
-  /** Clear all filters */
-  clearAll(): void {
-    this.selectedMaterials.set([]);
-    this.colorSearch.set('');
-    this.lowStockOnly.set(false);
-    this.activeOnly.set(false);
-    this.emitFilterState();
-  }
-
-  /** Emit the current filter state */
-  private emitFilterState(): void {
-    this.filterChange.emit({
-      materialBaseNames: this.selectedMaterials(),
-      colorSearch: this.colorSearch().trim().toLowerCase(),
-      lowStockOnly: this.lowStockOnly(),
-      activeOnly: this.activeOnly(),
-    });
-  }
-}

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

@@ -1,12 +1,6 @@
-<!-- Filament Inventory Table — with filters and low stock indicators -->
+<!-- Filament Inventory Table — with low stock indicators and delete actions -->
 <div class="filament-table-container" role="region" aria-label="Filament inventory">
 
-  <!-- Filter Bar -->
-  <app-filament-filter
-    [filaments]="allFilaments()"
-    (filterChange)="onFilterChange($event)"
-    aria-label="Filter filament inventory" />
-
   <!-- Low Stock Alert Banner — shown when critical or low stock spools exist -->
   @if (criticalCount() > 0) {
     <div class="alert-banner critical" role="alert">
@@ -22,7 +16,7 @@
 
   <!-- Filament Table -->
   <table mat-table
-         [dataSource]="filteredFilaments()"
+         [dataSource]="sortedFilaments()"
          matSort
          (matSortChange)="sortData($event)"
          class="filament-table"
@@ -112,22 +106,36 @@
       </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>
 
-  <!-- Filtered empty state -->
-  @if (filteredFilaments().length === 0 && filaments().length > 0) {
-    <div class="empty-state" role="status">
-      <mat-icon aria-hidden="true">filter_alt_off</mat-icon>
-      <p>No filaments match the current filters</p>
-    </div>
-  }
-
-  <!-- No data empty state -->
+  <!-- Empty state -->
   @if (filaments().length === 0) {
     <div class="empty-state" role="status">
       <mat-icon aria-hidden="true">inventory_2</mat-icon>

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,13 +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 { FilamentFilterComponent, FilamentFilterState } from '../filament-filter/filament-filter.component';
+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 =
@@ -28,7 +37,8 @@ export type FilamentColumn =
   | 'serial'
   | 'remaining'
   | 'stockLevel'
-  | 'status';
+  | 'status'
+  | 'actions';
 
 @Component({
   selector: 'app-filament-table',
@@ -41,17 +51,26 @@ export type FilamentColumn =
     MatProgressBarModule,
     MatTooltipModule,
     MatSortModule,
-    FilamentFilterComponent,
+    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);
@@ -67,29 +86,15 @@ export class FilamentTableComponent {
     'remaining',
     'stockLevel',
     'status',
+    'actions',
   ]);
 
   /** Default columns for template binding */
   readonly columns = this._displayedColumns;
 
-  /** Current filter state */
-  readonly filterState = signal<FilamentFilterState>({
-    materialBaseNames: [],
-    colorSearch: '',
-    lowStockOnly: false,
-    activeOnly: false,
-  });
-
   /** Sorted filament data */
   readonly sortedFilaments = signal<Filament[]>([]);
 
-  /** Computed: filtered + sorted filament data for display */
-  readonly filteredFilaments = computed(() => {
-    const data = this.sortedFilaments();
-    const filters = this.filterState();
-    return data.filter((f) => this.matchesFilter(f, filters));
-  });
-
   /** Computed: count of low/critical spools */
   readonly lowStockCount = computed(() =>
     this.filaments().filter(
@@ -228,9 +233,6 @@ export class FilamentTableComponent {
     this.sortedFilaments.set([...data]);
   }
 
-  /** All filament data — for the filter component to derive material options */
-  readonly allFilaments = this.filaments;
-
   /** Handle sort changes from MatSort */
   sortData(sort: Sort): void {
     const data = [...this.filaments()];
@@ -272,44 +274,50 @@ export class FilamentTableComponent {
     this.sortedFilaments.set(sorted);
   }
 
-  /** Handle filter changes from FilamentFilterComponent */
-  onFilterChange(state: FilamentFilterState): void {
-    this.filterState.set(state);
+  /**
+   * 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
       }
 
-  /** Check if a filament matches the current filter state */
-  private matchesFilter(filament: Filament, filters: FilamentFilterState): boolean {
-    // Material filter — empty means all
-    if (
-      filters.materialBaseNames.length > 0 &&
-      !filters.materialBaseNames.includes(filament.materialBaseName)
-    ) {
-      return false;
-    }
+      // Mark as deleting for UI feedback
+      this.deleting.set(filament.id);
 
-    // Color search — empty means all
-    if (
-      filters.colorSearch &&
-      !filament.colorName.toLowerCase().includes(filters.colorSearch) &&
-      !filament.colorHex.toLowerCase().includes(filters.colorSearch)
-    ) {
-      return false;
-    }
+      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);
 
-    // Low stock filter — show only critical/low
-    if (filters.lowStockOnly) {
-      const level = classifyStockLevel(filament);
-      if (level !== 'critical' && level !== 'low') {
-        return false;
-      }
-    }
-
-    // Active only filter
-    if (filters.activeOnly && !filament.isActive) {
-      return false;
-    }
-
-    return true;
+          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 */

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}`);
+  }
+}