CUB-43: Add inventory dashboard summary component

- Expanded IMoonrakerClient interface with 6 strongly-typed methods:
  - GetServerInfoAsync (Moonraker /server/info)
  - IsReachableAsync (connectivity check)
  - GetPrinterInfoAsync (Moonraker /printer/info)
  - GetPrintHistoryAsync (Moonraker /server/history/items)
  - GetPrintStatsAsync (Moonraker /printer/objects/query?print_stats)
  - GetDisplayStatusAsync (Moonraker /printer/objects/query?display_status)
  - GetFilamentUsageAsync (retained for backward compatibility)

- Created Domain/DTOs/Moonraker/ with 7 DTOs:
  - MoonrakerServerInfo, MoonrakerPrinterInfo, MoonrakerPrintJob
  - MoonrakerHistoryResponse, MoonrakerPrintStats
  - MoonrakerDisplayStatus, MoonrakerRequest

- Updated MoonrakerClient implementation to support all new methods
  with proper JSON parsing and mapping helpers

- Full XML doc comments on all public members

.gitea/workflows/dev.yml

@@ -20,12 +20,15 @@ jobs:
 
       - name: Restore backend
         run: dotnet restore
+        working-directory: ./backend
 
       - name: Build backend
         run: dotnet build --no-restore --configuration Release
+        working-directory: ./backend
 
       - name: Test backend
         run: dotnet test --no-build --configuration Release
+        working-directory: ./backend
 
       - name: Setup Node
         uses: actions/setup-node@v4
@@ -39,39 +42,3 @@ jobs:
       - name: Build frontend
         run: npm run build
         working-directory: ./frontend
-
-  deploy-dev:
-    needs: build-test
-    if: gitea.event_name == 'push'
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Deploy dev
-        run: |
-          echo "${{ secrets.DEV_DEPLOY_SSH_KEY }}" > /tmp/dev_key
-          chmod 600 /tmp/dev_key
-          ssh -i /tmp/dev_key -o StrictHostKeyChecking=no \
-            ${{ secrets.DEV_DEPLOY_USER }}@${{ secrets.DEV_DEPLOY_HOST }} \
-            "${{ secrets.DEV_DEPLOY_PATH }}/deploy.sh"
-
-  notify-success:
-    needs: [build-test, deploy-dev]
-    if: success() && gitea.event_name == 'push'
-    runs-on: ubuntu-latest
-    steps:
-      - name: Notify Slack success
-        run: |
-          curl -X POST -H 'Content-type: application/json' \
-            --data "{\"text\":\"✅ Extrudex dev deployed successfully from dev branch.\"}" \
-            "${{ secrets.SLACK_WEBHOOK_URL }}"
-
-  notify-failure:
-    needs: [build-test, deploy-dev]
-    if: failure()
-    runs-on: ubuntu-latest
-    steps:
-      - name: Notify Slack failure
-        run: |
-          curl -X POST -H 'Content-type: application/json' \
-            --data "{\"text\":\"🚨 Extrudex dev pipeline failed. Check Gitea Actions for details.\"}" \
-            "${{ secrets.SLACK_WEBHOOK_URL }}"

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/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/Jobs/MoonrakerPrinterSyncJob.cs

@@ -0,0 +1,80 @@
+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 service that periodically syncs Moonraker printer status
+/// and print job history into the Extrudex database. Runs as a hosted
+/// service and polls all active Moonraker printers on a configurable
+/// interval to update printer state and map completed print jobs
+/// to PrintJob and FilamentUsage entities.
+///
+/// Configuration is bound from the "MoonrakerPrinterSync" section in
+/// appsettings.json. Set Enabled=false to disable without removing
+/// the service registration.
+/// </summary>
+public class MoonrakerPrinterSyncJob : BackgroundService
+{
+    private readonly IMoonrakerPrinterSyncService _syncService;
+    private readonly MoonrakerPrinterSyncOptions _options;
+    private readonly ILogger<MoonrakerPrinterSyncJob> _logger;
+
+    /// <summary>
+    /// Creates a new MoonrakerPrinterSyncJob.
+    /// </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 MoonrakerPrinterSyncJob(
+        IMoonrakerPrinterSyncService syncService,
+        IOptions<MoonrakerPrinterSyncOptions> options,
+        ILogger<MoonrakerPrinterSyncJob> logger)
+    {
+        _syncService = syncService;
+        _options = options.Value;
+        _logger = logger;
+    }
+
+    /// <inheritdoc />
+    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
+    {
+        if (!_options.Enabled)
+        {
+            _logger.LogInformation("Moonraker printer sync job is disabled via configuration — exiting");
+            return;
+        }
+
+        _logger.LogInformation(
+            "Moonraker printer 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(15), stoppingToken);
+
+        while (!stoppingToken.IsCancellationRequested)
+        {
+            try
+            {
+                var syncedCount = await _syncService.SyncAllAsync(stoppingToken);
+
+                _logger.LogInformation(
+                    "Moonraker printer 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 Moonraker printer sync cycle — will retry in {Interval}",
+                    _options.PollingInterval);
+            }
+
+            await Task.Delay(_options.PollingInterval, stoppingToken);
+        }
+
+        _logger.LogInformation("Moonraker printer sync job shutting down");
+    }
+}

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

@@ -1,23 +1,26 @@
+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).
-/// Used to retrieve filament usage data, print job status, and
-/// remaining spool weight from the printer.
+/// Provides strongly-typed methods for server discovery, printer status,
+/// print job history, and real-time telemetry.
 /// </summary>
 public interface IMoonrakerClient
 {
     /// <summary>
-    /// Fetches the current filament usage data from the Moonraker server.
-    /// Returns a dictionary of usage metrics reported by the printer.
+    /// 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>A dictionary of usage metric names to their decimal values.</returns>
-    Task<Dictionary<string, decimal>> GetFilamentUsageAsync(
+    /// <returns>Server info if reachable; <c>null</c> if unreachable.</returns>
+    Task<MoonrakerServerInfo?> GetServerInfoAsync(
         string hostnameOrIp,
         int port,
         string? apiKey,
@@ -25,6 +28,8 @@ public interface IMoonrakerClient
 
     /// <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>
@@ -36,4 +41,91 @@ public interface IMoonrakerClient
         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/Domain/Interfaces/IMoonrakerPrinterSyncService.cs

@@ -0,0 +1,20 @@
+using Extrudex.Domain.DTOs.Moonraker;
+
+namespace Extrudex.Domain.Interfaces;
+
+/// <summary>
+/// Service interface for syncing Moonraker printer data into the Extrudex database.
+/// Handles periodic polling of printer status and mapping print job history
+/// to PrintJob and FilamentUsage entities.
+/// </summary>
+public interface IMoonrakerPrinterSyncService
+{
+    /// <summary>
+    /// Performs a single sync cycle: queries all active Moonraker printers,
+    /// fetches their current status and print job history, 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/MoonrakerPrinterSyncOptions.cs

@@ -0,0 +1,41 @@
+namespace Extrudex.Infrastructure.Configuration;
+
+/// <summary>
+/// Configuration options for the MoonrakerPrinterSync background service.
+/// Bound from appsettings.json under the "MoonrakerPrinterSync" section.
+/// Controls polling interval, timeouts, and feature toggles for the
+/// printer status and print job mapping service.
+/// </summary>
+public class MoonrakerPrinterSyncOptions
+{
+    /// <summary>
+    /// The section name in appsettings.json where these options are bound.
+    /// </summary>
+    public const string SectionName = "MoonrakerPrinterSync";
+
+    /// <summary>
+    /// How often the background service polls Moonraker printers for status
+    /// and print job data. Default: 1 minute.
+    /// </summary>
+    public TimeSpan PollingInterval { get; set; } = TimeSpan.FromMinutes(1);
+
+    /// <summary>
+    /// Timeout for individual HTTP requests to a Moonraker printer.
+    /// Default: 15 seconds.
+    /// </summary>
+    public TimeSpan RequestTimeout { get; set; } = TimeSpan.FromSeconds(15);
+
+    /// <summary>
+    /// Whether the Moonraker printer sync service is enabled.
+    /// Set to false to disable without removing the service registration.
+    /// Default: true.
+    /// </summary>
+    public bool Enabled { get; set; } = true;
+
+    /// <summary>
+    /// Maximum number of print history items to fetch per printer per sync cycle.
+    /// Controls the batch size when syncing print jobs from Moonraker.
+    /// Default: 25.
+    /// </summary>
+    public int HistoryBatchSize { get; set; } = 25;
+}

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

@@ -1,15 +1,16 @@
 using System.Net.Http.Json;
 using System.Text.Json;
+using Extrudex.Domain.DTOs.Moonraker;
 using Extrudex.Domain.Interfaces;
 using Microsoft.Extensions.Logging;
-using Microsoft.Extensions.Options;
 
-namespace Extrudex.Infrastructure.Configuration;
+namespace Extrudex.Infrastructure.Services;
 
 /// <summary>
 /// HTTP client for communicating with Moonraker REST API endpoints
 /// on Klipper-based printers (e.g., Elegoo Centauri Carbon).
-/// Retrieves filament usage data and printer status information.
+/// Provides strongly-typed methods for server discovery, printer status,
+/// print job history, and real-time telemetry.
 /// </summary>
 public class MoonrakerClient : IMoonrakerClient
 {
@@ -28,69 +29,65 @@ public class MoonrakerClient : IMoonrakerClient
     }
 
     /// <inheritdoc />
-    public async Task<Dictionary<string, decimal>> GetFilamentUsageAsync(
+    public async Task<MoonrakerServerInfo?> GetServerInfoAsync(
         string hostnameOrIp,
         int port,
         string? apiKey,
         CancellationToken cancellationToken = default)
     {
         var baseUrl = BuildBaseUrl(hostnameOrIp, port);
-        var result = new Dictionary<string, decimal>();
 
         try
         {
-            // Query Moonraker server info endpoint for filament usage data
-            using var request = new HttpRequestMessage(HttpMethod.Get, $"{baseUrl}/server/history/items?limit=1");
-            if (!string.IsNullOrEmpty(apiKey))
-            {
-                request.Headers.Add("X-Api-Key", apiKey);
-            }
-
+            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);
 
-            // Extract filament usage from the response
-            // Moonraker returns job history with filament_used and similar fields
-            if (json.TryGetProperty("result", out var resultElement))
-            {
-                if (resultElement.TryGetProperty("items", out var items) && items.GetArrayLength() > 0)
-                {
-                    var job = items[0];
+            var serverInfo = new MoonrakerServerInfo();
 
-                    // Moonraker tracks filament_used in millimeters
-                    if (job.TryGetProperty("filament_used", out var filamentUsed))
+            if (json.TryGetProperty("result", out var result))
             {
-                        result["mm_extruded"] = filamentUsed.GetDecimal();
-                    }
-
-                    // Total duration in seconds
-                    if (job.TryGetProperty("print_duration", out var duration))
-                    {
-                        result["print_duration_seconds"] = duration.GetDecimal();
-                    }
-                }
+                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 filament usage from Moonraker at {Host}:{Port}: {MetricCount} metrics",
-                hostnameOrIp, port, result.Count);
+                "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 filament usage from Moonraker at {Host}:{Port}",
+                "Failed to retrieve server info from Moonraker at {Host}:{Port}",
                 hostnameOrIp, port);
+            return null;
         }
         catch (JsonException ex)
         {
             _logger.LogWarning(ex,
-                "Failed to parse Moonraker response from {Host}:{Port}",
+                "Failed to parse Moonraker server info response from {Host}:{Port}",
                 hostnameOrIp, port);
+            return null;
         }
-
-        return result;
     }
 
     /// <inheritdoc />
@@ -99,25 +96,258 @@ public class MoonrakerClient : IMoonrakerClient
         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 = new HttpRequestMessage(HttpMethod.Get, $"{baseUrl}/server/info");
-            if (!string.IsNullOrEmpty(apiKey))
+            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))
             {
-                request.Headers.Add("X-Api-Key", apiKey);
+                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();
             }
 
-            using var response = await _httpClient.SendAsync(request, cancellationToken);
-            return response.IsSuccessStatusCode;
+            _logger.LogDebug(
+                "Retrieved printer info from Moonraker at {Host}:{Port} — state: {State}",
+                hostnameOrIp, port, printerInfo.State);
+
+            return printerInfo;
         }
-        catch (HttpRequestException)
+        catch (HttpRequestException ex)
         {
-            _logger.LogDebug("Moonraker at {Host}:{Port} is not reachable", hostnameOrIp, port);
-            return false;
+            _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>
@@ -127,4 +357,91 @@ public class MoonrakerClient : IMoonrakerClient
     {
         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/MoonrakerPrinterSyncService.cs

@@ -0,0 +1,320 @@
+using Extrudex.Domain.DTOs.Moonraker;
+using Extrudex.Domain.Entities;
+using Extrudex.Domain.Enums;
+using Extrudex.Domain.Interfaces;
+using Extrudex.Infrastructure.Configuration;
+using Extrudex.Infrastructure.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+
+namespace Extrudex.Infrastructure.Services;
+
+/// <summary>
+/// Service that syncs Moonraker printer status and print job history into the
+/// Extrudex database. Queries all active Moonraker printers, fetches their
+/// current operational state, and maps completed print jobs to PrintJob and
+/// FilamentUsage entities with derived gram calculations.
+/// </summary>
+public class MoonrakerPrinterSyncService : IMoonrakerPrinterSyncService
+{
+    private readonly ExtrudexDbContext _dbContext;
+    private readonly IMoonrakerClient _moonrakerClient;
+    private readonly ILogger<MoonrakerPrinterSyncService> _logger;
+
+    /// <summary>
+    /// Creates a new MoonrakerPrinterSyncService.
+    /// </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 MoonrakerPrinterSyncService(
+        ExtrudexDbContext dbContext,
+        IMoonrakerClient moonrakerClient,
+        ILogger<MoonrakerPrinterSyncService> logger)
+    {
+        _dbContext = dbContext;
+        _moonrakerClient = moonrakerClient;
+        _logger = logger;
+    }
+
+    /// <inheritdoc />
+    public async Task<int> SyncAllAsync(CancellationToken cancellationToken = default)
+    {
+        _logger.LogInformation("Starting Moonraker printer 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)
+                        .ThenInclude(s => s.MaterialBase)
+            .Include(p => p.PrintJobs)
+            .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
+            {
+                await SyncPrinterAsync(printer, cancellationToken);
+                syncedCount++;
+            }
+            catch (Exception ex) when (ex is not OperationCanceledException)
+            {
+                _logger.LogError(ex,
+                    "Error syncing printer {PrinterName} ({Host}:{Port})",
+                    printer.Name, printer.HostnameOrIp, printer.Port);
+
+                // Mark printer as offline if we can't reach it
+                printer.Status = PrinterStatus.Offline;
+            }
+        }
+
+        await _dbContext.SaveChangesAsync(cancellationToken);
+
+        _logger.LogInformation(
+            "Moonraker printer sync cycle complete — {SyncedCount}/{TotalCount} printers synced",
+            syncedCount, printers.Count);
+
+        return syncedCount;
+    }
+
+    /// <summary>
+    /// Syncs a single Moonraker printer: updates its status, fetches print history,
+    /// and maps new print jobs to database entities.
+    /// </summary>
+    private async Task SyncPrinterAsync(Printer printer, CancellationToken cancellationToken)
+    {
+        // Step 1: Fetch printer status
+        var printerInfo = await _moonrakerClient.GetPrinterInfoAsync(
+            printer.HostnameOrIp, printer.Port, printer.ApiKey, cancellationToken);
+
+        var printStats = await _moonrakerClient.GetPrintStatsAsync(
+            printer.HostnameOrIp, printer.Port, printer.ApiKey, cancellationToken);
+
+        // Step 2: Update printer status
+        UpdatePrinterStatus(printer, printerInfo, printStats);
+        printer.LastSeenAt = DateTime.UtcNow;
+
+        _logger.LogDebug(
+            "Printer {PrinterName} status updated to {Status}",
+            printer.Name, printer.Status);
+
+        // Step 3: Fetch and map print job history
+        var history = await _moonrakerClient.GetPrintHistoryAsync(
+            printer.HostnameOrIp, printer.Port, printer.ApiKey,
+            limit: 25,
+            cancellationToken);
+
+        if (history.Items.Count == 0)
+        {
+            _logger.LogDebug("No print history returned for printer {PrinterName}", printer.Name);
+            return;
+        }
+
+        var newJobsCount = await MapPrintJobsAsync(printer, history.Items, cancellationToken);
+
+        if (newJobsCount > 0)
+        {
+            _logger.LogInformation(
+                "Mapped {NewJobsCount} new print job(s) from printer {PrinterName}",
+                newJobsCount, printer.Name);
+        }
+    }
+
+    /// <summary>
+    /// Updates the printer's operational status based on Moonraker telemetry.
+    /// Maps Klipper/Moonraker state strings to the PrinterStatus enum.
+    /// </summary>
+    private void UpdatePrinterStatus(
+        Printer printer,
+        MoonrakerPrinterInfo? printerInfo,
+        MoonrakerPrintStats? printStats)
+    {
+        // Prefer print_stats state — it's the most authoritative
+        if (printStats != null)
+        {
+            printer.Status = printStats.State.ToLowerInvariant() switch
+            {
+                "printing" => PrinterStatus.Printing,
+                "paused" => PrinterStatus.Paused,
+                "complete" => PrinterStatus.Idle,
+                "standby" => PrinterStatus.Idle,
+                "cancelled" => PrinterStatus.Idle,
+                "error" => PrinterStatus.Error,
+                _ => PrinterStatus.Idle
+            };
+            return;
+        }
+
+        // Fall back to printer_info state
+        if (printerInfo != null)
+        {
+            printer.Status = printerInfo.State.ToLowerInvariant() switch
+            {
+                "ready" => PrinterStatus.Idle,
+                "startup" => PrinterStatus.Idle,
+                "shutdown" => PrinterStatus.Offline,
+                "error" => PrinterStatus.Error,
+                "cancelled" => PrinterStatus.Idle,
+                _ => printer.Status // Preserve existing status if unknown
+            };
+        }
+    }
+
+    /// <summary>
+    /// Maps Moonraker print job history items to Extrudex PrintJob and FilamentUsage entities.
+    /// Only creates records for jobs not already tracked (by Moonraker JobId stored in GcodeFilePath).
+    /// </summary>
+    private async Task<int> MapPrintJobsAsync(
+        Printer printer,
+        List<MoonrakerPrintJob> historyItems,
+        CancellationToken cancellationToken)
+    {
+        // Build a set of already-tracked Moonraker JobIds for this printer
+        // We store the Moonraker JobId in the GcodeFilePath field with a "moonraker:" prefix
+        var trackedJobIds = await _dbContext.PrintJobs
+            .Where(pj => pj.PrinterId == printer.Id && pj.GcodeFilePath != null && pj.GcodeFilePath.StartsWith("moonraker:"))
+            .Select(pj => pj.GcodeFilePath!)
+            .ToListAsync(cancellationToken);
+
+        var trackedIdSet = new HashSet<string>(trackedJobIds);
+        var newJobsCount = 0;
+
+        // Find the default spool for this printer (first active spool in AMS, or first active spool overall)
+        var defaultSpool = FindDefaultSpool(printer);
+
+        foreach (var moonrakerJob in historyItems)
+        {
+            var jobIdKey = $"moonraker:{moonrakerJob.JobId}";
+
+            if (trackedIdSet.Contains(jobIdKey))
+            {
+                continue; // Already tracked — skip
+            }
+
+            // Only map completed, cancelled, or errored jobs (not in_progress)
+            // In-progress jobs will be captured on the next cycle once they finish
+            if (moonrakerJob.Status == "in_progress")
+            {
+                continue;
+            }
+
+            // Map Moonraker job status to JobStatus enum
+            var jobStatus = moonrakerJob.Status.ToLowerInvariant() switch
+            {
+                "completed" => JobStatus.Completed,
+                "cancelled" => JobStatus.Cancelled,
+                "error" => JobStatus.Failed,
+                _ => JobStatus.Completed
+            };
+
+            // Calculate derived grams if we have a spool and filament data
+            decimal gramsDerived = 0m;
+            decimal filamentDiameterMm = 1.75m;
+            decimal materialDensity = 1.24m; // PLA default
+
+            if (defaultSpool != null)
+            {
+                filamentDiameterMm = defaultSpool.FilamentDiameterMm;
+                materialDensity = defaultSpool.MaterialBase.DensityGperCm3;
+                gramsDerived = CalculateGrams(moonrakerJob.FilamentUsedMm, filamentDiameterMm, materialDensity);
+            }
+            else if (moonrakerJob.FilamentUsedMm > 0)
+            {
+                gramsDerived = CalculateGrams(moonrakerJob.FilamentUsedMm, 1.75m, 1.24m);
+                _logger.LogWarning(
+                    "No default spool found for printer {PrinterName} — using PLA defaults for grams derivation on job {JobId}",
+                    printer.Name, moonrakerJob.JobId);
+            }
+
+            var printJob = new PrintJob
+            {
+                PrinterId = printer.Id,
+                SpoolId = defaultSpool?.Id ?? Guid.Empty,
+                PrintName = moonrakerJob.Filename,
+                GcodeFilePath = jobIdKey,
+                MmExtruded = moonrakerJob.FilamentUsedMm,
+                GramsDerived = gramsDerived,
+                StartedAt = moonrakerJob.StartTime,
+                CompletedAt = moonrakerJob.EndTime,
+                Status = jobStatus,
+                DataSource = DataSource.Moonraker,
+                FilamentDiameterAtPrintMm = filamentDiameterMm,
+                MaterialDensityAtPrint = materialDensity,
+                Notes = $"Auto-imported from Moonraker (JobId: {moonrakerJob.JobId})"
+            };
+
+            _dbContext.PrintJobs.Add(printJob);
+
+            // Create a FilamentUsage record if filament was consumed
+            if (moonrakerJob.FilamentUsedMm > 0 && defaultSpool != null)
+            {
+                var usage = new FilamentUsage
+                {
+                    PrintJob = printJob,
+                    SpoolId = defaultSpool.Id,
+                    PrinterId = printer.Id,
+                    GramsUsed = gramsDerived,
+                    MmExtruded = moonrakerJob.FilamentUsedMm,
+                    RecordedAt = DateTime.UtcNow,
+                    Notes = $"Auto-imported from Moonraker history (JobId: {moonrakerJob.JobId})"
+                };
+
+                _dbContext.FilamentUsages.Add(usage);
+            }
+
+            newJobsCount++;
+            trackedIdSet.Add(jobIdKey); // Prevent duplicates within this batch
+        }
+
+        return newJobsCount;
+    }
+
+    /// <summary>
+    /// Finds the default spool for a printer. Returns the first spool loaded
+    /// in an AMS slot, or null if no spool is available.
+    /// </summary>
+    private static Spool? FindDefaultSpool(Printer printer)
+    {
+        // Prefer the first active spool in an AMS slot
+        foreach (var amsUnit in printer.AmsUnits)
+        {
+            foreach (var slot in amsUnit.Slots)
+            {
+                if (slot.Spool != null && slot.Spool.IsActive && !slot.Spool.IsArchived)
+                {
+                    return slot.Spool;
+                }
+            }
+        }
+
+        return null;
+    }
+
+    /// <summary>
+    /// Calculates derived grams from millimeters extruded using the standard formula:
+    /// grams = mm_extruded × cross_section_area × material_density
+    /// where cross_section_area = π × (diameter / 2)²
+    /// </summary>
+    private static decimal CalculateGrams(decimal mmExtruded, decimal diameterMm, decimal densityGperCm3)
+    {
+        if (mmExtruded <= 0) return 0m;
+
+        var radiusCm = (double)diameterMm / 2.0 / 10.0; // mm to cm
+        var crossSectionAreaCm2 = Math.PI * radiusCm * radiusCm;
+        var mmToCm = (double)mmExtruded / 10.0;
+
+        var grams = mmToCm * crossSectionAreaCm2 * (double)densityGperCm3;
+        return (decimal)grams;
+    }
+}

backend/Program.cs

@@ -92,6 +92,12 @@ builder.Services.AddHttpClient<IMoonrakerClient, MoonrakerClient>(client =>
 builder.Services.AddScoped<IFilamentUsageSyncService, FilamentUsageSyncService>();
 builder.Services.AddHostedService<FilamentUsageSyncJob>();
 
+// ── Moonraker Printer Sync (Background Service) ──────────
+builder.Services.Configure<MoonrakerPrinterSyncOptions>(
+    builder.Configuration.GetSection(MoonrakerPrinterSyncOptions.SectionName));
+builder.Services.AddScoped<IMoonrakerPrinterSyncService, MoonrakerPrinterSyncService>();
+builder.Services.AddHostedService<MoonrakerPrinterSyncJob>();
+
 // ── Health Checks ───────────────────────────────────────────
 builder.Services.AddHealthChecks()
     .AddNpgSql(connectionString);

backend/appsettings.json

@@ -14,5 +14,11 @@
     "PollingInterval": "00:05:00",
     "RequestTimeout": "00:00:30",
     "Enabled": true
+  },
+  "MoonrakerPrinterSync": {
+    "PollingInterval": "00:01:00",
+    "RequestTimeout": "00:00:15",
+    "Enabled": true,
+    "HistoryBatchSize": 25
   }
 }

frontend/src/app/app.config.ts

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

frontend/src/app/app.html

@@ -5,7 +5,7 @@
   <!-- Status Summary Bar — fleet-wide health at a glance -->
   <app-dashboard-summary></app-dashboard-summary>
 
-  <!-- Inventory Summary Bar — filament metrics at a glance -->
+  <!-- Inventory Summary — filament metrics at a glance -->
   <app-inventory-summary></app-inventory-summary>
 
   <!-- Filament Inventory — routed view -->

frontend/src/app/components/inventory-summary/inventory-summary.component.html

@@ -1,28 +1,108 @@
-<!-- Inventory Summary Bar — filament metrics at a glance -->
-<section class="inventory-summary" role="status" aria-label="Inventory summary">
+<!-- Inventory Dashboard Summary — filament metrics at a glance -->
+<section class="inventory-summary" role="region" aria-label="Inventory summary">
 
-  <!-- Total Filament Count -->
-  <div class="summary-item" matTooltip="Total active spools in inventory" matTooltipPosition="below">
-    <mat-icon aria-hidden="true">inventory_2</mat-icon>
-    <span class="metric-value">{{ totalFilamentCount() }}</span>
-    <span class="metric-label">Spools</span>
+  <!-- Loading State -->
+  @if (loading()) {
+    <div class="summary-loading" role="status" aria-live="polite">
+      <mat-icon aria-hidden="true" class="spin">sync</mat-icon>
+      <span>Loading inventory...</span>
+    </div>
+  }
+
+  <!-- Error State -->
+  @else if (error()) {
+    <div class="summary-error" role="alert" aria-live="assertive">
+      <mat-icon aria-hidden="true">error_outline</mat-icon>
+      <span>{{ error() }}</span>
+      <button class="retry-btn" (click)="refresh()" aria-label="Retry loading inventory">
+        <mat-icon aria-hidden="true">refresh</mat-icon>
+        Retry
+      </button>
+    </div>
+  }
+
+  <!-- Loaded State -->
+  @else {
+    <!-- Health Status Indicator -->
+    <div class="summary-item health-status"
+         [class]="healthClass()"
+         [matTooltip]="healthLabel()"
+         matTooltipPosition="below">
+      <mat-icon aria-hidden="true">
+        @switch (healthClass()) {
+          @case ('critical') { error }
+          @case ('low') { warning }
+          @default { check_circle }
+        }
+      </mat-icon>
+      <span class="health-text">{{ healthLabel() }}</span>
+    </div>
+
+    <!-- Total Spool Count -->
+    <div class="summary-item metric-card"
+         matTooltip="Total filament spools in inventory"
+         matTooltipPosition="below">
+      <mat-icon aria-hidden="true" class="metric-icon">inventory_2</mat-icon>
+      <div class="metric-content">
+        <span class="metric-value">{{ totalCount() }}</span>
+        <span class="metric-label">Total Spools</span>
+      </div>
+      @if (activeCount() < totalCount()) {
+        <span class="metric-detail">{{ activeCount() }} active</span>
+      }
     </div>
 
     <!-- Low Stock Count -->
-  <div class="summary-item low-stock"
-       [class.has-alerts]="hasLowStock()"
-       [class.has-critical]="hasCriticalStock()"
-       matTooltip="Spools below 25% remaining" matTooltipPosition="below">
-    <mat-icon aria-hidden="true">{{ hasCriticalStock() ? 'error' : hasLowStock() ? 'warning' : 'check_circle' }}</mat-icon>
+    <div class="summary-item metric-card"
+         [class.has-alert]="hasLowStock()"
+         [class.has-critical]="hasCritical()"
+         [matTooltip]="hasCritical()
+           ? criticalCount() + ' critical, ' + (lowStockCount() - criticalCount()) + ' low'
+           : hasLowStock()
+             ? lowStockCount() + ' spools at or below 25% remaining'
+             : 'All spools above 25% remaining'"
+         matTooltipPosition="below">
+      <mat-icon aria-hidden="true" class="metric-icon">
+        @if (hasCritical()) { error }
+        @else if (hasLowStock()) { warning }
+        @else { check_circle }
+      </mat-icon>
+      <div class="metric-content">
         <span class="metric-value">{{ lowStockCount() }}</span>
         <span class="metric-label">Low Stock</span>
       </div>
-
-  <!-- Estimated Total Value -->
-  <div class="summary-item" matTooltip="Estimated total value of active spools" matTooltipPosition="below">
-    <mat-icon aria-hidden="true">payments</mat-icon>
-    <span class="metric-value">{{ formatCurrency(estimatedTotalValue()) }}</span>
-    <span class="metric-label">Value</span>
+      @if (hasCritical()) {
+        <span class="metric-detail critical-detail">{{ criticalCount() }} critical</span>
+      }
     </div>
 
+    <!-- Estimated Total Value -->
+    <div class="summary-item metric-card"
+         matTooltip="Estimated total value of active spools"
+         matTooltipPosition="below">
+      <mat-icon aria-hidden="true" class="metric-icon">payments</mat-icon>
+      <div class="metric-content">
+        <span class="metric-value">{{ formatCurrency(totalValue()) }}</span>
+        <span class="metric-label">Est. Value</span>
+      </div>
+    </div>
+
+    <!-- Overall Remaining Stock Bar -->
+    <div class="summary-item metric-card stock-bar-card"
+         matTooltip="{{ formatWeight(totalRemainingGrams()) }} of {{ formatWeight(totalCapacityGrams()) }} remaining"
+         matTooltipPosition="below">
+      <mat-icon aria-hidden="true" class="metric-icon">line_weight</mat-icon>
+      <div class="metric-content stock-bar-content">
+        <div class="stock-bar-header">
+          <span class="metric-value">{{ overallRemainingPercent() }}%</span>
+          <span class="metric-label">Remaining</span>
+        </div>
+        <mat-progress-bar
+          mode="determinate"
+          [value]="overallRemainingPercent()"
+          [ngClass]="healthClass()">
+        </mat-progress-bar>
+      </div>
+    </div>
+  }
 </section>

frontend/src/app/components/inventory-summary/inventory-summary.component.scss

@@ -1,60 +1,142 @@
 /**
  * Inventory Summary Component Styles
  * Touch-optimized for kiosk (Raspberry Pi 5) and mobile PWA
- * Consistent with dashboard-summary component styling
+ * Matches the existing dark theme from app.scss
  */
 
 // Touch-optimized sizing
 $touch-target-min: 48px;
-$kiosk-font-primary: 20px;
-$mobile-font-primary: 16px;
+$kiosk-font-primary: 24px;
+$mobile-font-primary: 18px;
 $spacing-unit: 8px;
 
 // Status colors — high contrast for workshop/bright environments
-$color-healthy: #4ade70;      // Green — stock OK
-$color-low: #facc15;         // Amber — low stock
-$color-critical: #f87171;    // Red — critical stock
+$color-healthy: #4ade70;    // Green
+$color-low: #fbbf24;        // Amber/Yellow
+$color-critical: #f87171;   // Red
+$color-bg: #1a1a2e;         // Matches app.scss
+$color-text: #e0e0e0;
+$color-text-muted: rgba(255, 255, 255, 0.7);
+$color-card-bg: rgba(255, 255, 255, 0.05);
+$color-card-border: rgba(255, 255, 255, 0.1);
 
 .inventory-summary {
   display: flex;
-  align-items: center;
+  align-items: stretch;
   gap: $spacing-unit * 2;
   padding: $spacing-unit * 2;
   overflow-x: auto;
   -webkit-overflow-scrolling: touch;
+  scrollbar-width: thin;
 
-  @media (max-width: 480px) {
+  @media (max-width: 600px) {
+    flex-wrap: wrap;
     padding: $spacing-unit;
     gap: $spacing-unit;
   }
 }
 
-.summary-item {
+// Health status indicator
+.health-status {
   display: flex;
   align-items: center;
   gap: $spacing-unit;
-  min-height: $touch-target-min;
   padding: $spacing-unit $spacing-unit * 2;
-  border-radius: 12px;
-  background-color: rgba(255, 255, 255, 0.05);
+  border-radius: 24px;
+  min-height: $touch-target-min;
   white-space: nowrap;
   transition: background-color 0.3s ease;
 
+  &.healthy {
+    background-color: rgba($color-healthy, 0.15);
+    color: $color-healthy;
+  }
+
+  &.low {
+    background-color: rgba($color-low, 0.15);
+    color: $color-low;
+  }
+
+  &.critical {
+    background-color: rgba($color-critical, 0.15);
+    color: $color-critical;
+  }
+
+  .health-text {
+    font-size: 14px;
+    font-weight: 600;
+    letter-spacing: 0.02em;
+
     @media (max-width: 480px) {
-    padding: $spacing-unit;
-    border-radius: 8px;
+      font-size: 12px;
+    }
   }
 
   mat-icon {
+    font-size: 20px !important;
+    width: 20px !important;
+    height: 20px !important;
+  }
+}
+
+// Metric card
+.metric-card {
+  display: flex;
+  align-items: center;
+  gap: $spacing-unit;
+  padding: $spacing-unit $spacing-unit * 2;
+  background-color: $color-card-bg;
+  border: 1px solid $color-card-border;
+  border-radius: 12px;
+  min-height: $touch-target-min;
+  white-space: nowrap;
+  transition: border-color 0.2s ease, background-color 0.2s ease;
+
+  &:hover {
+    border-color: rgba(255, 255, 255, 0.2);
+    background-color: rgba(255, 255, 255, 0.08);
+  }
+
+  @media (max-width: 480px) {
+    padding: $spacing-unit;
+  }
+
+  &.has-alert {
+    border-color: rgba($color-low, 0.4);
+  }
+
+  &.has-critical {
+    border-color: rgba($color-critical, 0.5);
+    background-color: rgba($color-critical, 0.08);
+  }
+}
+
+.metric-icon {
+  color: $color-text-muted;
   font-size: 22px !important;
   width: 22px !important;
   height: 22px !important;
+
+  .has-alert & {
+    color: $color-low;
+  }
+
+  .has-critical & {
+    color: $color-critical;
+  }
+}
+
+.metric-content {
+  display: flex;
+  flex-direction: column;
+  gap: 2px;
 }
 
 .metric-value {
   font-size: $kiosk-font-primary;
-    font-weight: 600;
+  font-weight: 700;
   line-height: 1.2;
+  color: $color-text;
 
   @media (max-width: 480px) {
     font-size: $mobile-font-primary;
@@ -62,32 +144,114 @@ $color-critical: #f87171;    // Red — critical stock
 }
 
 .metric-label {
-    font-size: 12px;
-    color: rgba(255, 255, 255, 0.7);
+  font-size: 11px;
+  color: $color-text-muted;
   text-transform: uppercase;
-    letter-spacing: 0.05em;
-
-    @media (max-width: 480px) {
-      font-size: 10px;
-    }
-  }
+  letter-spacing: 0.08em;
 }
 
-// Low stock states
-.low-stock {
-  &.has-alerts {
-    background-color: rgba($color-low, 0.15);
+.metric-detail {
+  font-size: 11px;
+  color: $color-text-muted;
+  margin-left: $spacing-unit;
 
-    mat-icon {
-      color: $color-low;
-    }
-  }
-
-  &.has-critical {
-    background-color: rgba($color-critical, 0.15);
-
-    mat-icon {
+  &.critical-detail {
     color: $color-critical;
+    font-weight: 600;
+  }
+}
+
+// Stock bar card
+.stock-bar-card {
+  flex: 1 1 200px;
+  min-width: 180px;
+}
+
+.stock-bar-content {
+  flex: 1;
+  min-width: 0;
+}
+
+.stock-bar-header {
+  display: flex;
+  align-items: baseline;
+  gap: $spacing-unit;
+  margin-bottom: 4px;
+}
+
+// Progress bar color classes
+::ng-deep .mat-mdc-progress-bar {
+  &.healthy .mdc-linear-progress__bar-inner {
+    background-color: $color-healthy !important;
+  }
+
+  &.low .mdc-linear-progress__bar-inner {
+    background-color: $color-low !important;
+  }
+
+  &.critical .mdc-linear-progress__bar-inner {
+    background-color: $color-critical !important;
+  }
+}
+
+// Loading state
+.summary-loading {
+  display: flex;
+  align-items: center;
+  gap: $spacing-unit;
+  padding: $spacing-unit * 2;
+  color: $color-text-muted;
+  font-size: 14px;
+
+  .spin {
+    animation: spin 1s linear infinite;
+  }
+}
+
+@keyframes spin {
+  0% { transform: rotate(0deg); }
+  100% { transform: rotate(360deg); }
+}
+
+// Error state
+.summary-error {
+  display: flex;
+  align-items: center;
+  gap: $spacing-unit;
+  padding: $spacing-unit * 2;
+  background-color: rgba($color-critical, 0.1);
+  border: 1px solid rgba($color-critical, 0.3);
+  border-radius: 12px;
+  color: $color-critical;
+  font-size: 14px;
+
+  .retry-btn {
+    display: flex;
+    align-items: center;
+    gap: 4px;
+    background: transparent;
+    border: 1px solid rgba($color-critical, 0.4);
+    color: $color-critical;
+    padding: 4px 12px;
+    border-radius: 8px;
+    cursor: pointer;
+    font-size: 13px;
+    min-height: $touch-target-min - 8px;
+    transition: background-color 0.2s ease;
+
+    &:hover {
+      background-color: rgba($color-critical, 0.15);
+    }
+
+    mat-icon {
+      font-size: 16px !important;
+      width: 16px !important;
+      height: 16px !important;
     }
   }
 }
+
+// Summary item base
+.summary-item {
+  flex-shrink: 0;
+}

frontend/src/app/components/inventory-summary/inventory-summary.component.ts

@@ -1,24 +1,33 @@
 import {
   ChangeDetectionStrategy,
   Component,
+  OnDestroy,
+  OnInit,
   computed,
   inject,
+  signal,
 } from '@angular/core';
 import { CommonModule } from '@angular/common';
 import { MatIconModule } from '@angular/material/icon';
+import { MatChipsModule } from '@angular/material/chips';
 import { MatTooltipModule } from '@angular/material/tooltip';
+import { MatProgressBarModule } from '@angular/material/progress-bar';
 import { FilamentService } from '../../services/filament.service';
-import { classifyStockLevel } from '../../models/filament.model';
+import {
+  classifyStockLevel,
+} from '../../models/filament.model';
+import { Subscription } from 'rxjs';
 
 /**
- * InventorySummaryComponent — dashboard summary for filament inventory metrics.
+ * Inventory Dashboard Summary — shows filament inventory at a glance.
  *
- * Displays three key metrics driven by FilamentService:
- * - Total filament count (active spools)
- * - Low stock count (spools classified as 'low' or 'critical')
+ * Displays:
+ * - Total filament spool count
+ * - Low stock count (spools ≤25% remaining, i.e. "low" or "critical")
  * - Estimated total filament value (sum of purchase prices for active spools)
  *
- * All values update dynamically whenever FilamentService data changes.
+ * Data is sourced from the shared FilamentService signal,
+ * which is loaded on init and can be refreshed via refresh().
  */
 @Component({
   selector: 'app-inventory-summary',
@@ -26,56 +35,142 @@ import { classifyStockLevel } from '../../models/filament.model';
   imports: [
     CommonModule,
     MatIconModule,
+    MatChipsModule,
     MatTooltipModule,
+    MatProgressBarModule,
   ],
   templateUrl: './inventory-summary.component.html',
-  styleUrl: './inventory-summary.component.scss',
+  styleUrls: ['./inventory-summary.component.scss'],
   changeDetection: ChangeDetectionStrategy.OnPush,
 })
-export class InventorySummaryComponent {
+export class InventorySummaryComponent implements OnInit, OnDestroy {
   private readonly filamentService = inject(FilamentService);
+  private subscription: Subscription | null = null;
 
-  /** Computed: total number of active filament spools */
-  readonly totalFilamentCount = computed(() =>
-    this.filamentService.filaments().filter((f) => f.isActive).length
+  /** All filament data — reactive signal from shared service */
+  readonly filaments = this.filamentService.filaments;
+
+  /** Loading state */
+  readonly loading = signal<boolean>(true);
+
+  /** Error state */
+  readonly error = signal<string | null>(null);
+
+  /** Computed: total number of filament spools */
+  readonly totalCount = computed(() => this.filaments().length);
+
+  /** Computed: count of active spools */
+  readonly activeCount = computed(
+    () => this.filaments().filter((f) => f.isActive).length
   );
 
-  /** Computed: count of spools at low or critical stock levels */
-  readonly lowStockCount = computed(() =>
-    this.filamentService.filaments().filter((f) => {
-      const level = classifyStockLevel(f);
-      return level === 'low' || level === 'critical';
-    }).length
-  );
-
-  /** Computed: count of spools at critical stock level only */
-  readonly criticalStockCount = computed(() =>
-    this.filamentService.filaments().filter(
-      (f) => classifyStockLevel(f) === 'critical'
+  /** Computed: count of low/critical stock spools (≤25% remaining) */
+  readonly lowStockCount = computed(
+    () =>
+      this.filaments().filter(
+        (f) =>
+          classifyStockLevel(f) === 'low' ||
+          classifyStockLevel(f) === 'critical'
       ).length
   );
 
-  /** Computed: estimated total value of all active spools with a recorded price */
-  readonly estimatedTotalValue = computed(() =>
-    this.filamentService
-      .filaments()
+  /** Computed: count of critically low spools (≤10% remaining) */
+  readonly criticalCount = computed(
+    () =>
+      this.filaments().filter((f) => classifyStockLevel(f) === 'critical')
+        .length
+  );
+
+  /** Computed: estimated total value of active spools */
+  readonly totalValue = computed(() =>
+    this.filaments()
       .filter((f) => f.isActive && f.purchasePrice !== null)
       .reduce((sum, f) => sum + (f.purchasePrice ?? 0), 0)
   );
 
-  /** Computed: whether there are low-stock spools to highlight */
+  /** Computed: total remaining weight across all spools in grams */
+  readonly totalRemainingGrams = computed(() =>
+    this.filaments().reduce((sum, f) => sum + f.weightRemainingGrams, 0)
+  );
+
+  /** Computed: total capacity weight across all spools in grams */
+  readonly totalCapacityGrams = computed(() =>
+    this.filaments().reduce((sum, f) => sum + f.weightTotalGrams, 0)
+  );
+
+  /** Computed: overall remaining percentage */
+  readonly overallRemainingPercent = computed(() => {
+    const capacity = this.totalCapacityGrams();
+    if (capacity <= 0) return 0;
+    return Math.round(
+      (this.totalRemainingGrams() / capacity) * 100
+    );
+  });
+
+  /** Computed: whether to show a low-stock alert */
   readonly hasLowStock = computed(() => this.lowStockCount() > 0);
 
-  /** Computed: whether there are critical-stock spools */
-  readonly hasCriticalStock = computed(() => this.criticalStockCount() > 0);
+  /** Computed: whether to show a critical-stock alert */
+  readonly hasCritical = computed(() => this.criticalCount() > 0);
 
-  /** Format a currency value for display */
+  /** Computed: status label for the inventory health */
+  readonly healthLabel = computed(() => {
+    if (this.hasCritical()) return 'Critical Stock';
+    if (this.hasLowStock()) return 'Low Stock Alert';
+    return 'Stock Healthy';
+  });
+
+  /** Computed: health status color class */
+  readonly healthClass = computed(() => {
+    if (this.hasCritical()) return 'critical';
+    if (this.hasLowStock()) return 'low';
+    return 'healthy';
+  });
+
+  ngOnInit(): void {
+    this.loadFilaments();
+  }
+
+  ngOnDestroy(): void {
+    this.subscription?.unsubscribe();
+  }
+
+  /** Load filament data from the API via FilamentService */
+  loadFilaments(): void {
+    this.loading.set(true);
+    this.error.set(null);
+    this.subscription = this.filamentService.getFilaments().subscribe({
+      next: () => {
+        this.loading.set(false);
+      },
+      error: (err) => {
+        console.error('Failed to load filaments:', err);
+        this.error.set('Failed to load inventory data');
+        this.loading.set(false);
+      },
+    });
+  }
+
+  /** Refresh data — called externally when data changes (e.g., SignalR notification) */
+  refresh(): void {
+    this.loadFilaments();
+  }
+
+  /** Format weight for display */
+  formatWeight(grams: number): string {
+    if (grams >= 1000) {
+      return `${(grams / 1000).toFixed(1)}kg`;
+    }
+    return `${Math.round(grams)}g`;
+  }
+
+  /** Format currency for display */
   formatCurrency(value: number): string {
     return new Intl.NumberFormat('en-US', {
       style: 'currency',
       currency: 'USD',
       minimumFractionDigits: 0,
-      maximumFractionDigits: 2,
+      maximumFractionDigits: 0,
     }).format(value);
   }
 }

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

@@ -1,176 +1,52 @@
-import { Injectable, signal, computed } from '@angular/core';
-import { Filament, classifyStockLevel } from '../models/filament.model';
+import { Injectable, inject } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import { Observable, Subscription } from 'rxjs';
+import { signal } from '@angular/core';
+import { Filament } from '../models/filament.model';
 
 /**
- * FilamentService — shared reactive state for filament inventory.
+ * API base URL — matches the Extrudex backend.
+ * TODO: Move to environment config when environments are set up.
+ */
+const API_BASE_URL = '/api/filaments';
+
+/**
+ * Service for managing filament inventory data.
  *
- * Provides a single source of truth for filament data across components.
- * Both FilamentTableComponent and InventorySummaryComponent read from this service.
- * Data is updated via setFilaments() — called by SignalR handlers or HTTP load.
+ * Provides:
+ * - A reactive `filaments` signal for components to bind to
+ * - REST methods for GET, POST, DELETE endpoints
+ * - Real-time updates via SignalR should be layered on top when the hub is ready
  */
-@Injectable({
-  providedIn: 'root',
-})
+@Injectable({ providedIn: 'root' })
 export class FilamentService {
-  /** Primary data store — reactive signal */
-  private readonly _filaments = signal<Filament[]>([
-    {
-      id: '1',
-      materialBaseId: 'm1',
-      materialBaseName: 'PLA',
-      materialFinishId: 'f1',
-      materialFinishName: 'Basic',
-      materialModifierId: null,
-      materialModifierName: null,
-      brand: 'Bambu Lab',
-      colorName: 'White',
-      colorHex: '#F5F5F5',
-      weightTotalGrams: 1000,
-      weightRemainingGrams: 850,
-      filamentDiameterMm: 1.75,
-      spoolSerial: 'SN-001',
-      purchasePrice: 25.00,
-      purchaseDate: '2026-01-15T00:00:00Z',
-      isActive: true,
-      createdAt: '2026-01-15T00:00:00Z',
-      updatedAt: '2026-04-20T00:00:00Z',
-      qrCodeUrl: '',
-    },
-    {
-      id: '2',
-      materialBaseId: 'm2',
-      materialBaseName: 'PETG',
-      materialFinishId: 'f2',
-      materialFinishName: 'Matte',
-      materialModifierId: 'mod1',
-      materialModifierName: 'Carbon Fiber',
-      brand: 'Polymaker',
-      colorName: 'Fire Engine Red',
-      colorHex: '#FF0000',
-      weightTotalGrams: 1000,
-      weightRemainingGrams: 80,
-      filamentDiameterMm: 1.75,
-      spoolSerial: 'SN-002',
-      purchasePrice: 35.00,
-      purchaseDate: '2026-02-01T00:00:00Z',
-      isActive: true,
-      createdAt: '2026-02-01T00:00:00Z',
-      updatedAt: '2026-04-25T00:00:00Z',
-      qrCodeUrl: '',
-    },
-    {
-      id: '3',
-      materialBaseId: 'm1',
-      materialBaseName: 'PLA',
-      materialFinishId: 'f1',
-      materialFinishName: 'Basic',
-      materialModifierId: null,
-      materialModifierName: null,
-      brand: 'eSun',
-      colorName: 'Sky Blue',
-      colorHex: '#87CEEB',
-      weightTotalGrams: 1000,
-      weightRemainingGrams: 200,
-      filamentDiameterMm: 1.75,
-      spoolSerial: 'SN-003',
-      purchasePrice: 20.00,
-      purchaseDate: '2026-03-10T00:00:00Z',
-      isActive: true,
-      createdAt: '2026-03-10T00:00:00Z',
-      updatedAt: '2026-04-26T00:00:00Z',
-      qrCodeUrl: '',
-    },
-    {
-      id: '4',
-      materialBaseId: 'm3',
-      materialBaseName: 'ABS',
-      materialFinishId: 'f1',
-      materialFinishName: 'Basic',
-      materialModifierId: null,
-      materialModifierName: null,
-      brand: 'Hatchbox',
-      colorName: 'Black',
-      colorHex: '#1A1A1A',
-      weightTotalGrams: 1000,
-      weightRemainingGrams: 450,
-      filamentDiameterMm: 1.75,
-      spoolSerial: 'SN-004',
-      purchasePrice: 22.00,
-      purchaseDate: null,
-      isActive: true,
-      createdAt: '2026-01-20T00:00:00Z',
-      updatedAt: '2026-04-18T00:00:00Z',
-      qrCodeUrl: '',
-    },
-    {
-      id: '5',
-      materialBaseId: 'm1',
-      materialBaseName: 'PLA',
-      materialFinishId: 'f3',
-      materialFinishName: 'Silk',
-      materialModifierId: null,
-      materialModifierName: null,
-      brand: 'Overturn',
-      colorName: 'Gold',
-      colorHex: '#FFD700',
-      weightTotalGrams: 500,
-      weightRemainingGrams: 15,
-      filamentDiameterMm: 1.75,
-      spoolSerial: 'SN-005',
-      purchasePrice: 28.00,
-      purchaseDate: null,
-      isActive: false,
-      createdAt: '2025-12-01T00:00:00Z',
-      updatedAt: '2026-04-01T00:00:00Z',
-      qrCodeUrl: '',
-    },
-  ]);
+  private readonly http = inject(HttpClient);
 
-  /** Public read-only view of all filaments */
-  readonly filaments = this._filaments.asReadonly();
+  /** Reactive filament data — components read from this signal */
+  readonly filaments = signal<Filament[]>([]);
 
-  /**
-   * Replace the full filament list.
-   * Called by SignalR handlers, HTTP responses, or test setup.
-   */
-  setFilaments(data: Filament[]): void {
-    this._filaments.set(data);
-  }
-
-  /**
-   * Update or insert a single filament by id.
-   * Called when a real-time SignalR update arrives for one spool.
-   */
-  upsertFilament(updated: Filament): void {
-    this._filaments.update((current) => {
-      const idx = current.findIndex((f) => f.id === updated.id);
-      if (idx === -1) {
-        return [...current, updated];
-      }
-      const copy = [...current];
-      copy[idx] = updated;
-      return copy;
+  /** Fetch all filament spools and update the signal */
+  getFilaments(): Observable<Filament[]> {
+    const req = this.http.get<Filament[]>(API_BASE_URL);
+    req.subscribe({
+      next: (data) => this.filaments.set(data),
+      error: (err) => console.error('Failed to load filaments:', err),
     });
+    return req;
   }
 
-  /**
-   * Remove a filament by id.
-   * Called when a spool is deleted via real-time event.
-   */
-  removeFilament(id: string): void {
-    this._filaments.update((current) => current.filter((f) => f.id !== id));
+  /** Fetch a single filament by ID */
+  getFilament(id: string): Observable<Filament> {
+    return this.http.get<Filament>(`${API_BASE_URL}/${id}`);
   }
 
-  /** Computed: count of active spools */
-  readonly activeCount = computed(() =>
-    this._filaments().filter((f) => f.isActive).length
-  );
-
-  /** Computed: count of low or critical stock spools */
-  readonly lowStockCount = computed(() =>
-    this._filaments().filter((f) => {
-      const level = classifyStockLevel(f);
-      return level === 'low' || level === 'critical';
-    }).length
-  );
+  /** Set filament data directly — used by components or SignalR handlers */
+  setFilaments(data: Filament[]): void {
+    this.filaments.set(data);
+  }
+
+  /** Delete a filament spool by ID */
+  deleteFilament(id: string): Observable<void> {
+    return this.http.delete<void>(`${API_BASE_URL}/${id}`);
+  }
 }