removed all migration updated

Reviewed-on: #23

.gitignore

@@ -31,8 +31,11 @@ Thumbs.db
 .idea/
 
 # ── Migrations ─────────────────────────────────────────────────────────
-# New EF Core migrations are not committed. Note the 4 migrations already in
-# Backend/ERPCore/Infra/Persistence/Migrations/ stay tracked — .gitignore does
-# not apply to tracked files — so edits to those still get committed as normal.
-# Untracking them too takes `git rm --cached`.
-**/Migrations/
+# Reverted 2026-07-31: excluding new EF Core migrations while
+# ErpDbContextModelSnapshot.cs stayed tracked meant every `dotnet ef
+# migrations add` after the initial 4 silently produced a migration git would
+# never see, while the (tracked) snapshot's changes committed normally —
+# so the snapshot kept claiming tables existed that no migration in git
+# history ever created them. Confirmed live: 25 HRM tables + 11 Manufacturing
+# tables were missing from the actual database for exactly this reason.
+# Migrations now stay tracked like any other source file — commit them.

Backend/ERPCore/Controllers/CustomersController.cs

@@ -0,0 +1,69 @@
+using ERPCore.Domain.Enums;
+using ERPCore.Dtos.Common;
+using ERPCore.Dtos.Customers;
+using ERPCore.Services.Interfaces;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ERPCore.Controllers;
+
+/// <summary>Customer master endpoints for Phase 1 sales.</summary>
+[Route("api/v1/customers")]
+public sealed class CustomersController : ApiControllerBase
+{
+    private readonly ICustomerService _customers;
+
+    public CustomersController(ICustomerService customers) => _customers = customers;
+
+    [HttpGet]
+    [ProducesResponseType(typeof(PagedResponse<CustomerDto>), StatusCodes.Status200OK)]
+    public async Task<ActionResult<PagedResponse<CustomerDto>>> List(
+        [FromQuery] PageQuery query,
+        [FromQuery] EntityStatus? status,
+        [FromQuery] CustomerType? customerType,
+        CancellationToken ct)
+        => Ok(await _customers.ListAsync(query, status, customerType, ct));
+
+    [HttpGet("{customerId:int}")]
+    [ProducesResponseType(typeof(CustomerDto), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    public async Task<ActionResult<CustomerDto>> GetById(int customerId, CancellationToken ct)
+    {
+        var result = await _customers.GetAsync(customerId, ct);
+        if (result is null) return NotFound();
+
+        SetETag(result.RowVersion);
+        return Ok(result.Value);
+    }
+
+    [HttpPost]
+    [ProducesResponseType(typeof(CustomerDto), StatusCodes.Status201Created)]
+    [ProducesResponseType(StatusCodes.Status409Conflict)]
+    public async Task<ActionResult<CustomerDto>> Create([FromBody] CreateCustomerRequest request, CancellationToken ct)
+    {
+        var result = await _customers.CreateAsync(request, ct);
+        SetETag(result.RowVersion);
+        return Created($"/api/v1/customers/{result.Value.CustomerId}", result.Value);
+    }
+
+    [HttpPut("{customerId:int}")]
+    [ProducesResponseType(typeof(CustomerDto), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    [ProducesResponseType(StatusCodes.Status409Conflict)]
+    [ProducesResponseType(StatusCodes.Status412PreconditionFailed)]
+    public async Task<ActionResult<CustomerDto>> Update(int customerId, [FromBody] UpdateCustomerRequest request, CancellationToken ct)
+    {
+        var expected = RequireIfMatch();
+        var result = await _customers.UpdateAsync(customerId, request, expected, ct);
+        SetETag(result.RowVersion);
+        return Ok(result.Value);
+    }
+
+    [HttpPatch("{customerId:int}/status")]
+    [ProducesResponseType(StatusCodes.Status204NoContent)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    public async Task<IActionResult> SetStatus(int customerId, [FromBody] UpdateCustomerStatusRequest request, CancellationToken ct)
+    {
+        await _customers.SetStatusAsync(customerId, request.Status, ct);
+        return NoContent();
+    }
+}

Backend/ERPCore/Controllers/DashboardController.cs

@@ -0,0 +1,20 @@
+using ERPCore.Dtos.Dashboard;
+using ERPCore.Services.Interfaces;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ERPCore.Controllers;
+
+/// <summary>Dashboard overview stats — cross-domain counts, not a stored entity.</summary>
+[Route("api/v1/dashboard")]
+public sealed class DashboardController : ApiControllerBase
+{
+    private readonly IDashboardService _dashboard;
+
+    public DashboardController(IDashboardService dashboard) => _dashboard = dashboard;
+
+    /// <summary>Aggregate counts for stock, GRN, and procurement.</summary>
+    [HttpGet("stats")]
+    [ProducesResponseType(typeof(DashboardStatsDto), StatusCodes.Status200OK)]
+    public async Task<ActionResult<DashboardStatsDto>> GetStats(CancellationToken ct)
+        => Ok(await _dashboard.GetStatsAsync(ct));
+}

Backend/ERPCore/Controllers/GeneralLedgerController.cs

@@ -0,0 +1,43 @@
+using ERPCore.Services.Interfaces;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ERPCore.Controllers;
+
+/// <summary>
+/// Generic reverse proxy into the external General Ledger service — forwards every
+/// method/path/query/body under this prefix verbatim via
+/// <see cref="IGeneralLedgerService"/> and returns GL's response (status, content-type,
+/// body) unchanged. No endpoint-specific shape lives here; see
+/// docs/12-GENERAL-LEDGER-INTEGRATION.md for the full GL contract and what this proxy
+/// does and doesn't do. Gated by the same ERP door policy as every other v1 endpoint
+/// (<see cref="ApiControllerBase"/>) — the shared GL API key is attached server-side
+/// only and is never exposed to the frontend.
+/// </summary>
+[Route("api/v1/gl")]
+public sealed class GeneralLedgerController : ApiControllerBase
+{
+    private readonly IGeneralLedgerService _gl;
+
+    public GeneralLedgerController(IGeneralLedgerService gl) => _gl = gl;
+
+    [HttpGet("{**path}")]
+    public Task<IActionResult> Get(string path, CancellationToken ct) => ForwardAsync(HttpMethod.Get, path, ct);
+
+    [HttpPost("{**path}")]
+    public Task<IActionResult> Post(string path, CancellationToken ct) => ForwardAsync(HttpMethod.Post, path, ct);
+
+    [HttpPut("{**path}")]
+    public Task<IActionResult> Put(string path, CancellationToken ct) => ForwardAsync(HttpMethod.Put, path, ct);
+
+    private async Task<IActionResult> ForwardAsync(HttpMethod method, string path, CancellationToken ct)
+    {
+        var body = method == HttpMethod.Get ? null : Request.Body;
+        var result = await _gl.ForwardAsync(method, path, Request.QueryString.Value, Request.ContentType, body, ct);
+        return new ContentResult
+        {
+            StatusCode = result.StatusCode,
+            Content = result.Body,
+            ContentType = result.ContentType ?? "application/json"
+        };
+    }
+}

Backend/ERPCore/Controllers/ProductionRunsController.cs

@@ -0,0 +1,157 @@
+using ERPCore.Domain.Enums;
+using ERPCore.Dtos.Common;
+using ERPCore.Dtos.Production;
+using ERPCore.Services.Interfaces;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ERPCore.Controllers;
+
+/// <summary>Production run endpoints (docs/30-BACKEND-PHASE2.md §D.2–D.3).</summary>
+[Route("api/v1/production-runs")]
+public sealed class ProductionRunsController : ApiControllerBase
+{
+    private readonly IProductionRunService _runs;
+
+    public ProductionRunsController(IProductionRunService runs) => _runs = runs;
+
+    [HttpGet]
+    [ProducesResponseType(typeof(PagedResponse<RunSummaryDto>), StatusCodes.Status200OK)]
+    public async Task<ActionResult<PagedResponse<RunSummaryDto>>> List(
+        [FromQuery] PageQuery query,
+        [FromQuery] ProductionRunStatus? status,
+        [FromQuery] int? templateId,
+        [FromQuery] int? warehouseId,
+        CancellationToken ct)
+        => Ok(await _runs.ListAsync(query, status, templateId, warehouseId, ct));
+
+    [HttpGet("{runId:int}")]
+    [ProducesResponseType(typeof(RunGraphDto), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    public async Task<ActionResult<RunGraphDto>> GetById(int runId, CancellationToken ct)
+    {
+        var result = await _runs.GetAsync(runId, ct);
+        if (result is null) return NotFound();
+
+        SetETag(result.RowVersion);
+        return Ok(result.Value);
+    }
+
+    [HttpPost]
+    [ProducesResponseType(typeof(RunGraphDto), StatusCodes.Status201Created)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    [ProducesResponseType(StatusCodes.Status422UnprocessableEntity)]
+    public async Task<ActionResult<RunGraphDto>> Create([FromBody] CreateRunRequest request, CancellationToken ct)
+    {
+        var result = await _runs.CreateAsync(request, ct);
+
+        SetETag(result.RowVersion);
+        return Created($"/api/v1/production-runs/{result.Value.RunId}", result.Value);
+    }
+
+    [HttpPut("{runId:int}/stages/{runStageId:int}/quantities")]
+    [ProducesResponseType(typeof(RunStageDto), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    [ProducesResponseType(StatusCodes.Status409Conflict)]
+    [ProducesResponseType(StatusCodes.Status422UnprocessableEntity)]
+    public async Task<ActionResult<RunStageDto>> UpdateQuantities(
+        int runId, int runStageId, [FromBody] UpdateStageQuantitiesRequest request, CancellationToken ct)
+        => Ok(await _runs.UpdateStageQuantitiesAsync(runId, runStageId, request, ct));
+
+    // --- stage actions (docs/30 §D.3) ---------------------------------------
+    //
+    // Idempotency-Key is accepted on every action to match the Phase-1 contract (docs/11
+    // §1.6) but, as in GrnService.ConfirmAsync, it is not stored. Replay safety comes from
+    // the status guards instead: a double-fire finds the stage already moved on and gets a
+    // 409, which docs/21 §6 tells the client to treat as a silent refetch. Recorded as a
+    // deviation from §D.3's "idempotency-key honored".
+
+    [HttpPost("{runId:int}/stages/{runStageId:int}/start")]
+    [ProducesResponseType(typeof(StartStageResultDto), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    [ProducesResponseType(StatusCodes.Status409Conflict)]
+    [ProducesResponseType(StatusCodes.Status422UnprocessableEntity)]
+    public async Task<ActionResult<StartStageResultDto>> Start(
+        int runId, int runStageId,
+        [FromHeader(Name = "Idempotency-Key")] string? idempotencyKey,
+        CancellationToken ct)
+        => Ok(await _runs.StartStageAsync(runId, runStageId, ct));
+
+    [HttpPost("{runId:int}/stages/{runStageId:int}/complete")]
+    [ProducesResponseType(typeof(RunStageDto), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status400BadRequest)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    [ProducesResponseType(StatusCodes.Status409Conflict)]
+    [ProducesResponseType(StatusCodes.Status422UnprocessableEntity)]
+    public async Task<ActionResult<RunStageDto>> Complete(
+        int runId, int runStageId, [FromBody] CompleteStageRequest request,
+        [FromHeader(Name = "Idempotency-Key")] string? idempotencyKey,
+        CancellationToken ct)
+        => Ok(await _runs.CompleteStageAsync(runId, runStageId, request, ct));
+
+    [HttpPost("{runId:int}/stages/{runStageId:int}/approve")]
+    [ProducesResponseType(typeof(ApproveStageResultDto), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    [ProducesResponseType(StatusCodes.Status409Conflict)]
+    [ProducesResponseType(StatusCodes.Status422UnprocessableEntity)]
+    public async Task<ActionResult<ApproveStageResultDto>> Approve(
+        int runId, int runStageId, [FromBody] ApproveStageRequest? request,
+        [FromHeader(Name = "Idempotency-Key")] string? idempotencyKey,
+        CancellationToken ct)
+        => Ok(await _runs.ApproveStageAsync(runId, runStageId, request ?? new ApproveStageRequest(), ct));
+
+    [HttpPost("{runId:int}/stages/{runStageId:int}/transfer")]
+    [ProducesResponseType(typeof(TransferResultDto), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    [ProducesResponseType(StatusCodes.Status409Conflict)]
+    [ProducesResponseType(StatusCodes.Status422UnprocessableEntity)]
+    public async Task<ActionResult<TransferResultDto>> Transfer(
+        int runId, int runStageId, [FromBody] TransferRemainderRequest request,
+        [FromHeader(Name = "Idempotency-Key")] string? idempotencyKey,
+        CancellationToken ct)
+        => Ok(await _runs.TransferAsync(runId, runStageId, request, ct));
+
+    [HttpPost("{runId:int}/inputs/{runInputId:int}/return-leftover")]
+    [ProducesResponseType(typeof(ReturnLeftoverResultDto), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status400BadRequest)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    [ProducesResponseType(StatusCodes.Status409Conflict)]
+    [ProducesResponseType(StatusCodes.Status422UnprocessableEntity)]
+    public async Task<ActionResult<ReturnLeftoverResultDto>> ReturnLeftover(
+        int runId, int runInputId, [FromBody] ReturnLeftoverRequest request,
+        [FromHeader(Name = "Idempotency-Key")] string? idempotencyKey,
+        CancellationToken ct)
+        => Ok(await _runs.ReturnLeftoverAsync(runId, runInputId, request, ct));
+
+    [HttpPost("{runId:int}/stages/{runStageId:int}/reject-intake")]
+    [ProducesResponseType(typeof(RejectIntakeResultDto), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    [ProducesResponseType(StatusCodes.Status409Conflict)]
+    public async Task<ActionResult<RejectIntakeResultDto>> RejectIntake(
+        int runId, int runStageId, [FromBody] RejectRequest? request,
+        [FromHeader(Name = "Idempotency-Key")] string? idempotencyKey,
+        CancellationToken ct)
+        => Ok(await _runs.RejectIntakeAsync(runId, runStageId, request ?? new RejectRequest(), ct));
+
+    /// <summary>Terminal reject — resets the whole run for a rework pass (FR-MFG-16).</summary>
+    [HttpPost("{runId:int}/stages/{runStageId:int}/reject")]
+    [ProducesResponseType(typeof(TerminalRejectResultDto), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    [ProducesResponseType(StatusCodes.Status409Conflict)]
+    public async Task<ActionResult<TerminalRejectResultDto>> Reject(
+        int runId, int runStageId, [FromBody] RejectRequest? request,
+        [FromHeader(Name = "Idempotency-Key")] string? idempotencyKey,
+        CancellationToken ct)
+        => Ok(await _runs.RejectTerminalAsync(runId, runStageId, request ?? new RejectRequest(), ct));
+
+    [HttpPost("{runId:int}/cancel")]
+    [ProducesResponseType(typeof(CancelRunResultDto), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status400BadRequest)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    [ProducesResponseType(StatusCodes.Status409Conflict)]
+    [ProducesResponseType(StatusCodes.Status422UnprocessableEntity)]
+    public async Task<ActionResult<CancelRunResultDto>> Cancel(
+        int runId, [FromBody] CancelRunRequest request,
+        [FromHeader(Name = "Idempotency-Key")] string? idempotencyKey,
+        CancellationToken ct)
+        => Ok(await _runs.CancelAsync(runId, request, ct));
+}

Backend/ERPCore/Controllers/ProductionTemplatesController.cs

@@ -0,0 +1,73 @@
+using ERPCore.Domain.Enums;
+using ERPCore.Dtos.Common;
+using ERPCore.Dtos.Production;
+using ERPCore.Services.Interfaces;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ERPCore.Controllers;
+
+/// <summary>Production template endpoints (docs/30-BACKEND-PHASE2.md §D.1).</summary>
+[Route("api/v1/production-templates")]
+public sealed class ProductionTemplatesController : ApiControllerBase
+{
+    private readonly IProductionTemplateService _templates;
+
+    public ProductionTemplatesController(IProductionTemplateService templates) => _templates = templates;
+
+    [HttpGet]
+    [ProducesResponseType(typeof(PagedResponse<TemplateSummaryDto>), StatusCodes.Status200OK)]
+    public async Task<ActionResult<PagedResponse<TemplateSummaryDto>>> List(
+        [FromQuery] PageQuery query, [FromQuery] EntityStatus? status, CancellationToken ct)
+        => Ok(await _templates.ListAsync(query, status, ct));
+
+    [HttpGet("{templateId:int}")]
+    [ProducesResponseType(typeof(TemplateGraphDto), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    public async Task<ActionResult<TemplateGraphDto>> GetById(int templateId, CancellationToken ct)
+    {
+        var result = await _templates.GetAsync(templateId, ct);
+        if (result is null) return NotFound();
+
+        SetETag(result.RowVersion);
+        return Ok(result.Value);
+    }
+
+    [HttpPost]
+    [ProducesResponseType(typeof(TemplateGraphDto), StatusCodes.Status201Created)]
+    [ProducesResponseType(StatusCodes.Status409Conflict)]
+    [ProducesResponseType(StatusCodes.Status422UnprocessableEntity)]
+    public async Task<ActionResult<TemplateGraphDto>> Create(
+        [FromBody] SaveTemplateRequest request, CancellationToken ct)
+    {
+        var result = await _templates.CreateAsync(request, ct);
+
+        SetETag(result.RowVersion);
+        return Created($"/api/v1/production-templates/{result.Value.TemplateId}", result.Value);
+    }
+
+    [HttpPut("{templateId:int}")]
+    [ProducesResponseType(typeof(TemplateGraphDto), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    [ProducesResponseType(StatusCodes.Status409Conflict)]
+    [ProducesResponseType(StatusCodes.Status412PreconditionFailed)]
+    [ProducesResponseType(StatusCodes.Status422UnprocessableEntity)]
+    public async Task<ActionResult<TemplateGraphDto>> Update(
+        int templateId, [FromBody] SaveTemplateRequest request, CancellationToken ct)
+    {
+        var expected = RequireIfMatch();
+        var result = await _templates.UpdateAsync(templateId, request, expected, ct);
+
+        SetETag(result.RowVersion);
+        return Ok(result.Value);
+    }
+
+    [HttpPatch("{templateId:int}/status")]
+    [ProducesResponseType(StatusCodes.Status204NoContent)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    public async Task<IActionResult> SetStatus(
+        int templateId, [FromBody] UpdateTemplateStatusRequest request, CancellationToken ct)
+    {
+        await _templates.SetStatusAsync(templateId, request.Status, ct);
+        return NoContent();
+    }
+}

Backend/ERPCore/Controllers/SalesInvoicesController.cs

@@ -0,0 +1,67 @@
+using ERPCore.Domain.Enums;
+using ERPCore.Dtos.Common;
+using ERPCore.Dtos.Sales;
+using ERPCore.Services.Interfaces;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ERPCore.Controllers;
+
+[Route("api/v1/sales-invoices")]
+public sealed class SalesInvoicesController : ApiControllerBase
+{
+    private readonly ISalesInvoiceService _invoices;
+
+    public SalesInvoicesController(ISalesInvoiceService invoices) => _invoices = invoices;
+
+    [HttpGet]
+    [ProducesResponseType(typeof(PagedResponse<SalesInvoiceSummaryDto>), StatusCodes.Status200OK)]
+    public async Task<ActionResult<PagedResponse<SalesInvoiceSummaryDto>>> List(
+        [FromQuery] PageQuery query,
+        [FromQuery] SalesInvoiceStatus? status,
+        [FromQuery] int? customerId,
+        [FromQuery] int? warehouseId,
+        CancellationToken ct)
+        => Ok(await _invoices.ListAsync(query, status, customerId, warehouseId, ct));
+
+    [HttpGet("{salesInvoiceId:int}")]
+    [ProducesResponseType(typeof(SalesInvoiceDto), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    public async Task<ActionResult<SalesInvoiceDto>> GetById(int salesInvoiceId, CancellationToken ct)
+    {
+        var result = await _invoices.GetAsync(salesInvoiceId, ct);
+        if (result is null) return NotFound();
+        SetETag(result.RowVersion);
+        return Ok(result.Value);
+    }
+
+    [HttpPost]
+    [ProducesResponseType(typeof(SalesInvoiceDto), StatusCodes.Status201Created)]
+    public async Task<ActionResult<SalesInvoiceDto>> Create([FromBody] CreateSalesInvoiceRequest request, CancellationToken ct)
+    {
+        var result = await _invoices.CreateAsync(request, ct);
+        SetETag(result.RowVersion);
+        return Created($"/api/v1/sales-invoices/{result.Value.SalesInvoiceId}", result.Value);
+    }
+
+    [HttpPut("{salesInvoiceId:int}")]
+    [ProducesResponseType(typeof(SalesInvoiceDto), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    [ProducesResponseType(StatusCodes.Status412PreconditionFailed)]
+    public async Task<ActionResult<SalesInvoiceDto>> Update(int salesInvoiceId, [FromBody] UpdateSalesInvoiceRequest request, CancellationToken ct)
+    {
+        var expected = RequireIfMatch();
+        var result = await _invoices.UpdateAsync(salesInvoiceId, request, expected, ct);
+        SetETag(result.RowVersion);
+        return Ok(result.Value);
+    }
+
+    [HttpPost("{salesInvoiceId:int}/post")]
+    [ProducesResponseType(typeof(SalesInvoiceDto), StatusCodes.Status200OK)]
+    public async Task<ActionResult<SalesInvoiceDto>> Post(int salesInvoiceId, CancellationToken ct)
+        => Ok(await _invoices.PostAsync(salesInvoiceId, ct));
+
+    [HttpPost("{salesInvoiceId:int}/cancel")]
+    [ProducesResponseType(typeof(SalesInvoiceDto), StatusCodes.Status200OK)]
+    public async Task<ActionResult<SalesInvoiceDto>> Cancel(int salesInvoiceId, CancellationToken ct)
+        => Ok(await _invoices.CancelAsync(salesInvoiceId, ct));
+}

Backend/ERPCore/Controllers/SalesReportsController.cs

@@ -0,0 +1,49 @@
+using ERPCore.Dtos.Sales;
+using ERPCore.Services.Interfaces;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ERPCore.Controllers;
+
+[Route("api/v1/reports/sales")]
+public sealed class SalesReportsController : ApiControllerBase
+{
+    private readonly ISalesReportService _reports;
+
+    public SalesReportsController(ISalesReportService reports) => _reports = reports;
+
+    [HttpGet("daily-summary")]
+    [ProducesResponseType(typeof(IReadOnlyList<SalesDailySummaryRowDto>), StatusCodes.Status200OK)]
+    public async Task<ActionResult<IReadOnlyList<SalesDailySummaryRowDto>>> DailySummary(
+        [FromQuery] DateOnly from, [FromQuery] DateOnly to, CancellationToken ct)
+        => Ok(await _reports.DailySummaryAsync(from, to, ct));
+
+    [HttpGet("item-wise")]
+    [ProducesResponseType(typeof(IReadOnlyList<SalesItemSummaryRowDto>), StatusCodes.Status200OK)]
+    public async Task<ActionResult<IReadOnlyList<SalesItemSummaryRowDto>>> ItemWise(
+        [FromQuery] DateOnly from, [FromQuery] DateOnly to, [FromQuery] int? itemId, [FromQuery] int? warehouseId, CancellationToken ct)
+        => Ok(await _reports.ItemSummaryAsync(from, to, itemId, warehouseId, ct));
+
+    [HttpGet("customer-wise")]
+    [ProducesResponseType(typeof(IReadOnlyList<SalesCustomerSummaryRowDto>), StatusCodes.Status200OK)]
+    public async Task<ActionResult<IReadOnlyList<SalesCustomerSummaryRowDto>>> CustomerWise(
+        [FromQuery] DateOnly from, [FromQuery] DateOnly to, [FromQuery] int? customerId, CancellationToken ct)
+        => Ok(await _reports.CustomerSummaryAsync(from, to, customerId, ct));
+
+    [HttpGet("warehouse-wise")]
+    [ProducesResponseType(typeof(IReadOnlyList<SalesWarehouseSummaryRowDto>), StatusCodes.Status200OK)]
+    public async Task<ActionResult<IReadOnlyList<SalesWarehouseSummaryRowDto>>> WarehouseWise(
+        [FromQuery] DateOnly from, [FromQuery] DateOnly to, [FromQuery] int? warehouseId, CancellationToken ct)
+        => Ok(await _reports.WarehouseSummaryAsync(from, to, warehouseId, ct));
+
+    [HttpGet("discount-summary")]
+    [ProducesResponseType(typeof(IReadOnlyList<SalesDiscountSummaryRowDto>), StatusCodes.Status200OK)]
+    public async Task<ActionResult<IReadOnlyList<SalesDiscountSummaryRowDto>>> DiscountSummary(
+        [FromQuery] DateOnly from, [FromQuery] DateOnly to, CancellationToken ct)
+        => Ok(await _reports.DiscountSummaryAsync(from, to, ct));
+
+    [HttpGet("free-issue-summary")]
+    [ProducesResponseType(typeof(IReadOnlyList<SalesFreeIssueSummaryRowDto>), StatusCodes.Status200OK)]
+    public async Task<ActionResult<IReadOnlyList<SalesFreeIssueSummaryRowDto>>> FreeIssueSummary(
+        [FromQuery] DateOnly from, [FromQuery] DateOnly to, CancellationToken ct)
+        => Ok(await _reports.FreeIssueSummaryAsync(from, to, ct));
+}

Backend/ERPCore/Controllers/SalesSlipsController.cs

@@ -0,0 +1,67 @@
+using ERPCore.Domain.Enums;
+using ERPCore.Dtos.Common;
+using ERPCore.Dtos.Sales;
+using ERPCore.Services.Interfaces;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ERPCore.Controllers;
+
+[Route("api/v1/sales-slips")]
+public sealed class SalesSlipsController : ApiControllerBase
+{
+    private readonly ISalesSlipService _slips;
+
+    public SalesSlipsController(ISalesSlipService slips) => _slips = slips;
+
+    [HttpGet]
+    [ProducesResponseType(typeof(PagedResponse<SalesSlipSummaryDto>), StatusCodes.Status200OK)]
+    public async Task<ActionResult<PagedResponse<SalesSlipSummaryDto>>> List(
+        [FromQuery] PageQuery query,
+        [FromQuery] SalesSlipStatus? status,
+        [FromQuery] int? customerId,
+        [FromQuery] int? warehouseId,
+        CancellationToken ct)
+        => Ok(await _slips.ListAsync(query, status, customerId, warehouseId, ct));
+
+    [HttpGet("{salesSlipId:int}")]
+    [ProducesResponseType(typeof(SalesSlipDto), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    public async Task<ActionResult<SalesSlipDto>> GetById(int salesSlipId, CancellationToken ct)
+    {
+        var result = await _slips.GetAsync(salesSlipId, ct);
+        if (result is null) return NotFound();
+        SetETag(result.RowVersion);
+        return Ok(result.Value);
+    }
+
+    [HttpPost]
+    [ProducesResponseType(typeof(SalesSlipDto), StatusCodes.Status201Created)]
+    public async Task<ActionResult<SalesSlipDto>> Create([FromBody] CreateSalesSlipRequest request, CancellationToken ct)
+    {
+        var result = await _slips.CreateAsync(request, ct);
+        SetETag(result.RowVersion);
+        return Created($"/api/v1/sales-slips/{result.Value.SalesSlipId}", result.Value);
+    }
+
+    [HttpPut("{salesSlipId:int}")]
+    [ProducesResponseType(typeof(SalesSlipDto), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    [ProducesResponseType(StatusCodes.Status412PreconditionFailed)]
+    public async Task<ActionResult<SalesSlipDto>> Update(int salesSlipId, [FromBody] UpdateSalesSlipRequest request, CancellationToken ct)
+    {
+        var expected = RequireIfMatch();
+        var result = await _slips.UpdateAsync(salesSlipId, request, expected, ct);
+        SetETag(result.RowVersion);
+        return Ok(result.Value);
+    }
+
+    [HttpPost("{salesSlipId:int}/post")]
+    [ProducesResponseType(typeof(SalesSlipDto), StatusCodes.Status200OK)]
+    public async Task<ActionResult<SalesSlipDto>> Post(int salesSlipId, CancellationToken ct)
+        => Ok(await _slips.PostAsync(salesSlipId, ct));
+
+    [HttpPost("{salesSlipId:int}/cancel")]
+    [ProducesResponseType(typeof(SalesSlipDto), StatusCodes.Status200OK)]
+    public async Task<ActionResult<SalesSlipDto>> Cancel(int salesSlipId, CancellationToken ct)
+        => Ok(await _slips.CancelAsync(salesSlipId, ct));
+}

Backend/ERPCore/Domain/DocumentTypes.cs

@@ -14,4 +14,9 @@ public static class DocumentTypes
     public const string Adjustment = "ADJ";
     public const string Count = "CNT";
     public const string PurchaseReturn = "PRET";
+
+    /// <summary>Production run (docs/30 FR-MFG-08) — <c>PRD-2026-00001</c>.</summary>
+    public const string Production = "PRD";
+    public const string SalesInvoice = "SI";
+    public const string SalesSlip = "SSL";
 }

Backend/ERPCore/Domain/Entities/Customer.cs

@@ -0,0 +1,38 @@
+using ERPCore.Domain.Enums;
+
+namespace ERPCore.Domain.Entities;
+
+/// <summary>
+/// Customer master for both B2B and B2C sales.
+/// Phase 1 keeps this lean: identity, contact, tax, credit, and default warehouse.
+/// </summary>
+public class Customer
+{
+    public int CustomerId { get; set; }
+    public string CustomerCode { get; set; } = string.Empty;
+    public CustomerType CustomerType { get; set; } = CustomerType.B2C;
+
+    public string Name { get; set; } = string.Empty;
+    public string? DisplayName { get; set; }
+    public string? Phone { get; set; }
+    public string? Email { get; set; }
+
+    public string? AddressLine1 { get; set; }
+    public string? AddressLine2 { get; set; }
+    public string? City { get; set; }
+    public string? Country { get; set; }
+
+    public string? TaxRegistrationNo { get; set; }
+    public decimal CreditLimit { get; set; }
+    public int CreditDays { get; set; }
+
+    public int? DefaultWarehouseId { get; set; }
+    public Warehouse? DefaultWarehouse { get; set; }
+
+    public EntityStatus Status { get; set; } = EntityStatus.Active;
+    public DateTime CreatedAt { get; set; }
+    public DateTime? UpdatedAt { get; set; }
+
+    /// <summary>PostgreSQL xmin-backed optimistic concurrency token (ETag source).</summary>
+    public uint RowVersion { get; set; }
+}

Backend/ERPCore/Domain/Entities/ProductionRun.cs

@@ -0,0 +1,59 @@
+using ERPCore.Domain.Enums;
+
+namespace ERPCore.Domain.Entities;
+
+/// <summary>
+/// One execution instance of a template (FR-MFG-08), numbered <c>PRD-2026-00001</c>.
+/// Every stage, input, output and edge is <b>copied</b> from the template at creation
+/// with quantities scaled by <see cref="ScaleFactor"/>, so a completed run stays
+/// readable even if the template is later edited (FR-MFG-06).
+/// <para>The run's <b>cost pool</b> is derived, never stored:
+/// <c>Σ RunStageInput.ConsumedValue − Σ RunStageInput.ReturnedValue</c>. The terminal
+/// approve divides it by the good quantity to cost the finished layer, then closes it
+/// (FR-MFG-13, <c>409 RUN_COST_CLOSED</c>).</para>
+/// Mutable aggregate with a <see cref="RowVersion"/> token. Model: docs/30 Part C.
+/// </summary>
+public class ProductionRun
+{
+    public int RunId { get; set; }
+    public string DocNo { get; set; } = string.Empty;
+
+    public int TemplateId { get; set; }
+    public ProductionTemplate? Template { get; set; }
+
+    /// <summary>Stock inputs are consumed from, and the finished good received into, this warehouse.</summary>
+    public int WarehouseId { get; set; }
+    public Warehouse? Warehouse { get; set; }
+
+    /// <summary>Optional destination bin for the finished goods. Reaches the ledger only — stock layers carry no bin.</summary>
+    public int? OutputBinId { get; set; }
+    public Bin? OutputBin { get; set; }
+
+    /// <summary>Target quantity of the finished item; drives <see cref="ScaleFactor"/>.</summary>
+    public decimal TargetQty { get; set; }
+
+    /// <summary><c>TargetQty / terminalOutput.QtyPerBatch</c>, applied to every copied quantity.</summary>
+    public decimal ScaleFactor { get; set; }
+
+    public ProductionRunStatus Status { get; set; } = ProductionRunStatus.InProgress;
+
+    /// <summary>Incremented by each terminal reject (FR-MFG-16); prior figures live in the event history.</summary>
+    public int ReworkCount { get; set; }
+
+    public int? CancelReasonCodeId { get; set; }
+    public ReasonCode? CancelReason { get; set; }
+
+    public int CreatedBy { get; set; }
+    public User? Creator { get; set; }
+
+    public DateTime CreatedAt { get; set; }
+
+    /// <summary>Set by the terminal approve only. A cancelled run leaves this null.</summary>
+    public DateTime? CompletedAt { get; set; }
+
+    public uint RowVersion { get; set; }
+
+    public ICollection<RunStage> Stages { get; set; } = new List<RunStage>();
+    public ICollection<RunEdge> Edges { get; set; } = new List<RunEdge>();
+    public ICollection<RunStageEvent> Events { get; set; } = new List<RunStageEvent>();
+}

Backend/ERPCore/Domain/Entities/ProductionTemplate.cs

@@ -0,0 +1,43 @@
+using ERPCore.Domain.Enums;
+
+namespace ERPCore.Domain.Entities;
+
+/// <summary>
+/// A reusable production-line definition — the stage graph designed on the canvas
+/// (FR-MFG-01). Never hard-deleted once referenced by a run; deactivated instead
+/// (FR-MD-08 posture). Editing is locked while any run of it is InProgress
+/// (FR-MFG-06, <c>409 TEMPLATE_IN_USE</c>) — edit-lock replaces versioning, which is
+/// why runs copy display fields at creation. Mutable aggregate with a
+/// <see cref="RowVersion"/> token. Model: docs/30 Part C.
+/// </summary>
+public class ProductionTemplate
+{
+    public int TemplateId { get; set; }
+    public string Code { get; set; } = string.Empty;
+    public string Name { get; set; } = string.Empty;
+    public string? Description { get; set; }
+
+    public EntityStatus Status { get; set; } = EntityStatus.Active;
+
+    /// <summary>
+    /// Canvas-only annotations (grouping boxes and divider lines) as a jsonb array, stored
+    /// verbatim and never interpreted server-side.
+    /// </summary>
+    /// <remarks>
+    /// Not in docs/30 Part C — added because the builder canvas already draws these and
+    /// without somewhere to keep them a save would silently discard the user's layout notes.
+    /// They carry no graph semantics: no ports, no edges, and the validator never sees them.
+    /// Nullable so a template that has none stores nothing rather than an empty array.
+    /// </remarks>
+    public string? Annotations { get; set; }
+
+    public int CreatedBy { get; set; }
+    public User? Creator { get; set; }
+
+    public DateTime CreatedAt { get; set; }
+    public uint RowVersion { get; set; }
+
+    public ICollection<TemplateStage> Stages { get; set; } = new List<TemplateStage>();
+    public ICollection<StageEdge> Edges { get; set; } = new List<StageEdge>();
+    public ICollection<ProductionRun> Runs { get; set; } = new List<ProductionRun>();
+}

Backend/ERPCore/Domain/Entities/RunEdge.cs

@@ -0,0 +1,28 @@
+namespace ERPCore.Domain.Entities;
+
+/// <summary>
+/// A parent → child arrow copied from the template's <see cref="StageEdge"/> set at run
+/// creation.
+/// <para><b>Addition to docs/30 Part C (recorded).</b> The doc's entity model has no run
+/// edge table, but the run graph needs its own copy: deriving edges at read time through
+/// <c>RunStage.TemplateStageId → STAGE_EDGE</c> would let a later template edit silently
+/// rewrite completed-run history — the exact thing FR-MFG-06 exists to prevent — and
+/// breaks outright once that link is nulled by a stage deletion.</para>
+/// <para>Used for the run canvas, child-readiness evaluation and reject-intake's
+/// "delivering parents". Note that <b>WIP delivery is routed by
+/// <c>RunStageInput.FromRunOutputId</c>, not by these edges</b> — an edge is display and
+/// validation only.</para>
+/// </summary>
+public class RunEdge
+{
+    public int RunEdgeId { get; set; }
+
+    public int RunId { get; set; }
+    public ProductionRun? Run { get; set; }
+
+    public int ParentRunStageId { get; set; }
+    public RunStage? ParentRunStage { get; set; }
+
+    public int ChildRunStageId { get; set; }
+    public RunStage? ChildRunStage { get; set; }
+}

Backend/ERPCore/Domain/Entities/RunStage.cs

@@ -0,0 +1,59 @@
+using ERPCore.Domain.Enums;
+
+namespace ERPCore.Domain.Entities;
+
+/// <summary>
+/// One stage of a run — a copy of a <see cref="TemplateStage"/> taken at run creation
+/// (FR-MFG-06), carrying its own live status and actual timings. Model: docs/30 Part C.
+/// <para><b>Whether this stage is terminal is derived</b>, never stored: a stage is
+/// terminal when it has no outbound <see cref="RunEdge"/>. Storing it would let it
+/// drift from the edge set.</para>
+/// </summary>
+public class RunStage
+{
+    public int RunStageId { get; set; }
+
+    public int RunId { get; set; }
+    public ProductionRun? Run { get; set; }
+
+    /// <summary>
+    /// Provenance link back to the template stage. <b>Nullable</b>: a template PUT may
+    /// delete a stage while completed/cancelled runs still reference it (the edit-lock
+    /// only blocks edits during InProgress runs), so the FK is <c>SET NULL</c> rather
+    /// than blocking the edit forever. Everything needed to display a historical run is
+    /// copied below, which is exactly what FR-MFG-06 anticipates.
+    /// </summary>
+    public int? TemplateStageId { get; set; }
+    public TemplateStage? TemplateStage { get; set; }
+
+    // --- copied from the template at run creation (FR-MFG-06) ---
+    public string Name { get; set; } = string.Empty;
+    public string? RoleLabel { get; set; }
+    public int EstimatedMinutes { get; set; }
+    public decimal PosX { get; set; }
+    public decimal PosY { get; set; }
+
+    public ProductionStageStatus Status { get; set; } = ProductionStageStatus.Waiting;
+
+    /// <summary>Stamped at start; preserved across a reject-intake rework so the original start stands (FR-MFG-19).</summary>
+    public DateTime? ActualStartAt { get; set; }
+    public DateTime? ActualEndAt { get; set; }
+
+    /// <summary>Copied from the template stage; definitions survive a rework.</summary>
+    public string FieldDefs { get; set; } = "[]";
+
+    /// <summary>Captured at complete as a jsonb object; cleared by a terminal reject so required fields are re-answered.</summary>
+    public string? FieldValues { get; set; }
+
+    /// <summary>
+    /// Concurrency token. Stage actions re-read the stage inside their transaction and
+    /// let this xmin check serialize concurrent requests — it is what stops two
+    /// simultaneous terminal approves from both reading <c>Done</c> and posting two
+    /// receipts. See the idempotency note in <c>ProductionRunService</c>.
+    /// </summary>
+    public uint RowVersion { get; set; }
+
+    public ICollection<RunStageInput> Inputs { get; set; } = new List<RunStageInput>();
+    public ICollection<RunStageOutput> Outputs { get; set; } = new List<RunStageOutput>();
+    public ICollection<RunStageEvent> Events { get; set; } = new List<RunStageEvent>();
+}

Backend/ERPCore/Domain/Entities/RunStageEvent.cs

@@ -0,0 +1,40 @@
+using ERPCore.Domain.Enums;
+
+namespace ERPCore.Domain.Entities;
+
+/// <summary>
+/// Immutable history of everything that happened to a run (docs/30 Part C). Written by
+/// every mutating action and never updated or deleted, so a run's story — including the
+/// figures discarded by each rework — survives in full.
+/// <para><b>Addition to docs/30 Part C (recorded):</b> <see cref="RunId"/>. The doc hangs
+/// events off the stage only, which leaves run-level events (cancel, terminal reject)
+/// with no home and forces the detail timeline to join through stages. Keeping both
+/// links makes <see cref="RunStageId"/> optional and the timeline a single query.</para>
+/// </summary>
+public class RunStageEvent
+{
+    public int EventId { get; set; }
+
+    public int RunId { get; set; }
+    public ProductionRun? Run { get; set; }
+
+    /// <summary>Null for run-level events (Cancel).</summary>
+    public int? RunStageId { get; set; }
+    public RunStage? RunStage { get; set; }
+
+    public RunStageEventType EventType { get; set; }
+
+    public string? Note { get; set; }
+
+    /// <summary>
+    /// Event-specific detail as jsonb — consumed layers on a Start, pulled-back
+    /// quantities on a RejectIntake, the full pre-rework snapshot on a TerminalReject.
+    /// Pre-serialized string, written only through <c>ProductionJson</c>.
+    /// </summary>
+    public string? Payload { get; set; }
+
+    public int UserId { get; set; }
+    public User? User { get; set; }
+
+    public DateTime CreatedAt { get; set; }
+}

Backend/ERPCore/Domain/Entities/RunStageInput.cs

@@ -0,0 +1,55 @@
+using ERPCore.Domain.Enums;
+
+namespace ERPCore.Domain.Entities;
+
+/// <summary>
+/// One input line of a run stage — a copy of a <see cref="StageInput"/> with its
+/// quantity scaled at creation, plus the live consumption/delivery figures.
+/// Model: docs/30 Part C.
+/// <para><b>Stock inputs</b> accumulate <see cref="ConsumedQty"/>/<see cref="ConsumedValue"/>
+/// at each start and <see cref="ReturnedQty"/>/<see cref="ReturnedValue"/> on leftover
+/// return or run cancel. Those four columns are the whole cost pool
+/// (<c>Σ consumed − Σ returned</c>) and are deliberately <b>not</b> reset by a terminal
+/// reject — already-consumed material stays in the pool (FR-MFG-16).</para>
+/// <para><b>Upstream inputs</b> accumulate <see cref="DeliveredQty"/> as parent stages
+/// transfer WIP in. The stage becomes Ready only when every upstream input has
+/// <c>DeliveredQty &gt;= PlannedQty</c> (FR-MFG-09, an all-parents join).</para>
+/// </summary>
+public class RunStageInput
+{
+    public int RunInputId { get; set; }
+
+    public int RunStageId { get; set; }
+    public RunStage? RunStage { get; set; }
+
+    public StageInputSource Source { get; set; }
+
+    public int? ItemId { get; set; }
+    public Item? Item { get; set; }
+
+    /// <summary>The parent output feeding this input. This — not <see cref="RunEdge"/> — is what routes a transfer.</summary>
+    public int? FromRunOutputId { get; set; }
+    public RunStageOutput? FromRunOutput { get; set; }
+
+    public int UomId { get; set; }
+    public Uom? Uom { get; set; }
+
+    /// <summary>Scaled at creation; per-run editable until the stage starts (FR-MFG-08, <c>409 STAGE_NOT_EDITABLE</c>).</summary>
+    public decimal PlannedQty { get; set; }
+
+    /// <summary>
+    /// Stock inputs only, in the item's <b>base</b> UOM. A start consumes
+    /// <c>max(0, PlannedQty − ConsumedQty)</c> and adds to these, so a rework restart
+    /// with an unchanged planned quantity consumes nothing and one with a raised planned
+    /// quantity consumes only the delta (FR-MFG-16).
+    /// </summary>
+    public decimal ConsumedQty { get; set; }
+    public decimal ConsumedValue { get; set; }
+
+    /// <summary>Upstream inputs only: accumulated by parent transfers.</summary>
+    public decimal DeliveredQty { get; set; }
+
+    /// <summary>Leftover returns (FR-MFG-14) and cancel returns (FR-MFG-17), at the consumed weighted cost.</summary>
+    public decimal ReturnedQty { get; set; }
+    public decimal ReturnedValue { get; set; }
+}

Backend/ERPCore/Domain/Entities/RunStageOutput.cs

@@ -0,0 +1,43 @@
+namespace ERPCore.Domain.Entities;
+
+/// <summary>
+/// One output line of a run stage — a copy of a <see cref="StageOutput"/> with its
+/// quantity scaled at creation, plus the live produced/scrapped/transferred figures.
+/// Model: docs/30 Part C.
+/// <para><b>Available to transfer is derived, never stored:</b>
+/// <c>ProducedQty − ScrappedQty − TransferredQty</c>. Every transfer path checks it and
+/// raises <c>422 TRANSFER_EXCEEDS_AVAILABLE</c> (FR-MFG-12).</para>
+/// <para>Scrap cost is <b>absorbed</b> into the run cost pool as normal yield loss — no
+/// write-off ledger entry is posted (FR-MFG-11).</para>
+/// </summary>
+public class RunStageOutput
+{
+    public int RunOutputId { get; set; }
+
+    public int RunStageId { get; set; }
+    public RunStage? RunStage { get; set; }
+
+    /// <summary>Null on intermediate (WIP) outputs; set on the terminal output — the finished good.</summary>
+    public int? ItemId { get; set; }
+    public Item? Item { get; set; }
+
+    public string Name { get; set; } = string.Empty;
+
+    public int UomId { get; set; }
+    public Uom? Uom { get; set; }
+
+    /// <summary>Scaled at creation; per-run editable until the stage starts.</summary>
+    public decimal PlannedQty { get; set; }
+
+    /// <summary>Recorded at complete. A re-complete after a rework <b>overwrites</b> this, never adds to it.</summary>
+    public decimal ProducedQty { get; set; }
+
+    public decimal ScrappedQty { get; set; }
+
+    /// <summary>Mandatory when <see cref="ScrappedQty"/> &gt; 0, context <c>Production</c> (FR-MFG-11).</summary>
+    public int? ScrapReasonCodeId { get; set; }
+    public ReasonCode? ScrapReason { get; set; }
+
+    /// <summary>Total WIP handed to children so far, across approve and any later partial transfers.</summary>
+    public decimal TransferredQty { get; set; }
+}

Backend/ERPCore/Domain/Entities/SalesInvoice.cs

@@ -0,0 +1,41 @@
+using ERPCore.Domain.Enums;
+
+namespace ERPCore.Domain.Entities;
+
+public class SalesInvoice
+{
+    public int SalesInvoiceId { get; set; }
+    public string InvoiceNo { get; set; } = string.Empty;
+    public DateTime InvoiceDate { get; set; }
+
+    public int CustomerId { get; set; }
+    public Customer? Customer { get; set; }
+
+    public string CustomerSnapshotName { get; set; } = string.Empty;
+    public string? CustomerSnapshotTaxNo { get; set; }
+
+    public int WarehouseId { get; set; }
+    public Warehouse? Warehouse { get; set; }
+
+    public SalesInvoiceType InvoiceType { get; set; } = SalesInvoiceType.B2C;
+    public SalesInvoiceStatus Status { get; set; } = SalesInvoiceStatus.Draft;
+
+    public decimal Subtotal { get; set; }
+    public decimal DiscountTotal { get; set; }
+    public decimal TaxTotal { get; set; }
+    public decimal GrandTotal { get; set; }
+    public decimal RoundOff { get; set; }
+    public decimal NetPayable { get; set; }
+    public decimal PaidAmount { get; set; }
+    public decimal BalanceAmount { get; set; }
+
+    public int CreatedBy { get; set; }
+    public User? Creator { get; set; }
+
+    public DateTime CreatedAt { get; set; }
+    public DateTime? UpdatedAt { get; set; }
+
+    public uint RowVersion { get; set; }
+
+    public ICollection<SalesInvoiceLine> Lines { get; set; } = new List<SalesInvoiceLine>();
+}

Backend/ERPCore/Domain/Entities/SalesInvoiceLine.cs

@@ -0,0 +1,38 @@
+using ERPCore.Domain.Enums;
+
+namespace ERPCore.Domain.Entities;
+
+public class SalesInvoiceLine
+{
+    public int SalesInvoiceLineId { get; set; }
+
+    public int SalesInvoiceId { get; set; }
+    public SalesInvoice? SalesInvoice { get; set; }
+
+    public int ItemId { get; set; }
+    public Item? Item { get; set; }
+
+    public string Description { get; set; } = string.Empty;
+
+    public decimal Qty { get; set; }
+    public decimal FreeQty { get; set; }
+    public int UomId { get; set; }
+    public Uom? Uom { get; set; }
+    public int WarehouseId { get; set; }
+    public Warehouse? Warehouse { get; set; }
+
+    public decimal UnitPrice { get; set; }
+    public decimal BaseCost { get; set; }
+    public string PriceSource { get; set; } = string.Empty;
+    public SalesDiscountMode DiscountMode { get; set; } = SalesDiscountMode.Percentage;
+    public decimal DiscountPct { get; set; }
+    public decimal DiscountAmount { get; set; }
+    public decimal NetUnitPrice { get; set; }
+    public decimal LineTotal { get; set; }
+    public decimal TaxPct { get; set; }
+    public decimal TaxAmount { get; set; }
+    public bool IsFreeIssue { get; set; }
+    public int? ParentLineId { get; set; }
+
+    public uint RowVersion { get; set; }
+}

Backend/ERPCore/Domain/Entities/SalesSlip.cs

@@ -0,0 +1,36 @@
+using ERPCore.Domain.Enums;
+
+namespace ERPCore.Domain.Entities;
+
+public class SalesSlip
+{
+    public int SalesSlipId { get; set; }
+    public string SlipNo { get; set; } = string.Empty;
+    public DateTime SlipDate { get; set; }
+
+    public int CustomerId { get; set; }
+    public Customer? Customer { get; set; }
+
+    public string CustomerSnapshotName { get; set; } = string.Empty;
+    public int WarehouseId { get; set; }
+    public Warehouse? Warehouse { get; set; }
+
+    public int CashierUserId { get; set; }
+    public User? CashierUser { get; set; }
+
+    public SalesSlipStatus Status { get; set; } = SalesSlipStatus.Draft;
+
+    public decimal Subtotal { get; set; }
+    public decimal DiscountTotal { get; set; }
+    public decimal TaxTotal { get; set; }
+    public decimal GrandTotal { get; set; }
+    public decimal PaidAmount { get; set; }
+    public decimal BalanceAmount { get; set; }
+
+    public DateTime CreatedAt { get; set; }
+    public DateTime? UpdatedAt { get; set; }
+
+    public uint RowVersion { get; set; }
+
+    public ICollection<SalesSlipLine> Lines { get; set; } = new List<SalesSlipLine>();
+}

Backend/ERPCore/Domain/Entities/SalesSlipLine.cs

@@ -0,0 +1,38 @@
+using ERPCore.Domain.Enums;
+
+namespace ERPCore.Domain.Entities;
+
+public class SalesSlipLine
+{
+    public int SalesSlipLineId { get; set; }
+
+    public int SalesSlipId { get; set; }
+    public SalesSlip? SalesSlip { get; set; }
+
+    public int ItemId { get; set; }
+    public Item? Item { get; set; }
+
+    public string Description { get; set; } = string.Empty;
+
+    public decimal Qty { get; set; }
+    public decimal FreeQty { get; set; }
+    public int UomId { get; set; }
+    public Uom? Uom { get; set; }
+    public int WarehouseId { get; set; }
+    public Warehouse? Warehouse { get; set; }
+
+    public decimal UnitPrice { get; set; }
+    public decimal BaseCost { get; set; }
+    public string PriceSource { get; set; } = string.Empty;
+    public SalesDiscountMode DiscountMode { get; set; } = SalesDiscountMode.Percentage;
+    public decimal DiscountPct { get; set; }
+    public decimal DiscountAmount { get; set; }
+    public decimal NetUnitPrice { get; set; }
+    public decimal LineTotal { get; set; }
+    public decimal TaxPct { get; set; }
+    public decimal TaxAmount { get; set; }
+    public bool IsFreeIssue { get; set; }
+    public int? ParentLineId { get; set; }
+
+    public uint RowVersion { get; set; }
+}

Backend/ERPCore/Domain/Entities/StageEdge.cs

@@ -0,0 +1,21 @@
+namespace ERPCore.Domain.Entities;
+
+/// <summary>
+/// A parent → child arrow on the template canvas. The edge set must form a DAG with
+/// at least one entry stage and exactly one terminal stage; that is enforced in
+/// <c>ProductionGraphValidator</c> on every save, not by the database (FR-MFG-02).
+/// Model: docs/30 Part C.
+/// </summary>
+public class StageEdge
+{
+    public int EdgeId { get; set; }
+
+    public int TemplateId { get; set; }
+    public ProductionTemplate? Template { get; set; }
+
+    public int ParentStageId { get; set; }
+    public TemplateStage? ParentStage { get; set; }
+
+    public int ChildStageId { get; set; }
+    public TemplateStage? ChildStage { get; set; }
+}

Backend/ERPCore/Domain/Entities/StageInput.cs

@@ -0,0 +1,39 @@
+using ERPCore.Domain.Enums;
+
+namespace ERPCore.Domain.Entities;
+
+/// <summary>
+/// One line of a stage's input formula (FR-MFG-04). Exactly one of the two source
+/// shapes applies, enforced by <c>ProductionGraphValidator</c>:
+/// <list type="bullet">
+/// <item><see cref="StageInputSource.Stock"/> — <see cref="ItemId"/> set,
+/// <see cref="FromOutputId"/> null. FIFO-consumed from the run warehouse at stage
+/// start. Allowed on <i>any</i> stage, e.g. packaging added late.</item>
+/// <item><see cref="StageInputSource.Upstream"/> — <see cref="FromOutputId"/> set to
+/// an output of a <b>direct parent</b> stage, <see cref="ItemId"/> null. Flows as
+/// internal WIP and never touches stock or the ledger.</item>
+/// </list>
+/// Model: docs/30 Part C.
+/// </summary>
+public class StageInput
+{
+    public int InputId { get; set; }
+
+    public int StageId { get; set; }
+    public TemplateStage? Stage { get; set; }
+
+    public StageInputSource Source { get; set; }
+
+    /// <summary>Required when <see cref="Source"/> is Stock; null when Upstream.</summary>
+    public int? ItemId { get; set; }
+    public Item? Item { get; set; }
+
+    /// <summary>Required when <see cref="Source"/> is Upstream; must belong to a direct parent.</summary>
+    public int? FromOutputId { get; set; }
+    public StageOutput? FromOutput { get; set; }
+
+    public int UomId { get; set; }
+    public Uom? Uom { get; set; }
+
+    public decimal QtyPerBatch { get; set; }
+}

Backend/ERPCore/Domain/Entities/StageOutput.cs

@@ -0,0 +1,27 @@
+namespace ERPCore.Domain.Entities;
+
+/// <summary>
+/// A named quantity produced by a stage (FR-MFG-05). Intermediate outputs are
+/// <b>internal WIP only</b> — <see cref="ItemId"/> is null, no stock and no ledger row
+/// is ever written for them. The terminal stage is the exception: it has exactly one
+/// output and that output <b>must</b> reference a real Item (the finished good), which
+/// is what the production receipt creates a layer for. Model: docs/30 Part C.
+/// </summary>
+public class StageOutput
+{
+    public int OutputId { get; set; }
+
+    public int StageId { get; set; }
+    public TemplateStage? Stage { get; set; }
+
+    /// <summary>Null on intermediate stages; required on the terminal stage.</summary>
+    public int? ItemId { get; set; }
+    public Item? Item { get; set; }
+
+    public string Name { get; set; } = string.Empty;
+
+    public int UomId { get; set; }
+    public Uom? Uom { get; set; }
+
+    public decimal QtyPerBatch { get; set; }
+}

Backend/ERPCore/Domain/Entities/TemplateStage.cs

@@ -0,0 +1,36 @@
+namespace ERPCore.Domain.Entities;
+
+/// <summary>
+/// One box on the template canvas (FR-MFG-03): a named step with a role label, an
+/// estimated duration, a formula (<see cref="Inputs"/> + <see cref="Outputs"/>) and
+/// custom field definitions. Model: docs/30 Part C.
+/// </summary>
+public class TemplateStage
+{
+    public int StageId { get; set; }
+
+    public int TemplateId { get; set; }
+    public ProductionTemplate? Template { get; set; }
+
+    public string Name { get; set; } = string.Empty;
+
+    /// <summary>Free text (e.g. "QA"). Informational only this phase — never enforced (FR-X-01).</summary>
+    public string? RoleLabel { get; set; }
+
+    public int EstimatedMinutes { get; set; }
+
+    /// <summary>Canvas coordinates — stored verbatim, never interpreted server-side (FR-MFG-03).</summary>
+    public decimal PosX { get; set; }
+    public decimal PosY { get; set; }
+
+    /// <summary>
+    /// Custom field definitions as jsonb: <c>[{ key, label, type, options?, required }]</c>
+    /// (FR-MFG-07). Held as a pre-serialized string, matching the <c>AuditLog.ChangeSet</c>
+    /// precedent; always written through <c>ProductionJson</c> so the column can only ever
+    /// hold canonical JSON.
+    /// </summary>
+    public string FieldDefs { get; set; } = "[]";
+
+    public ICollection<StageInput> Inputs { get; set; } = new List<StageInput>();
+    public ICollection<StageOutput> Outputs { get; set; } = new List<StageOutput>();
+}

Backend/ERPCore/Domain/Enums/CustomFieldType.cs

@@ -0,0 +1,16 @@
+namespace ERPCore.Domain.Enums;
+
+/// <summary>
+/// Input type of a stage custom field (FR-MFG-07; docs/30 §D.5 <c>fieldType</c>).
+/// Lives inside the <c>field_defs</c> jsonb rather than a column, but is modelled as an
+/// enum so a bad value is rejected at the DTO boundary instead of reaching the database.
+/// <see cref="Select"/> is the only type that reads <c>options</c>.
+/// </summary>
+public enum CustomFieldType
+{
+    Text,
+    Number,
+    Checkbox,
+    Date,
+    Select
+}

Backend/ERPCore/Domain/Enums/CustomerType.cs

@@ -0,0 +1,8 @@
+namespace ERPCore.Domain.Enums;
+
+public enum CustomerType
+{
+    B2B = 1,
+    B2C = 2,
+    WalkIn = 3
+}

Backend/ERPCore/Domain/Enums/ProductionRunStatus.cs

@@ -0,0 +1,14 @@
+namespace ERPCore.Domain.Enums;
+
+/// <summary>
+/// Lifecycle of a production run (docs/30 §B.4, §D.5). A run is created
+/// <see cref="InProgress"/> and reaches exactly one final state: it completes at the
+/// terminal stage's approve (production receipt, FR-MFG-13) or is cancelled with a
+/// stock return (FR-MFG-17). Stored as a string.
+/// </summary>
+public enum ProductionRunStatus
+{
+    InProgress,
+    Completed,
+    Cancelled
+}

Backend/ERPCore/Domain/Enums/ProductionStageStatus.cs

@@ -0,0 +1,22 @@
+namespace ERPCore.Domain.Enums;
+
+/// <summary>
+/// Status of one stage within a production run (docs/30 §B.4, §D.5).
+/// <code>
+/// Waiting ──(all upstream inputs fully delivered)──▶ Ready
+/// Ready ──start (FIFO-consume Stock inputs)──▶ InProgress
+/// InProgress ──complete (produced/scrap/fields)──▶ Done
+/// Done ──approve──▶ Approved   (non-terminal: WIP transfers out; terminal: receipt)
+/// </code>
+/// Rejection is not a resting state (FR-MFG-15/16): a reject immediately produces a
+/// rework transition back into this set and is recorded as a
+/// <see cref="RunStageEventType"/> instead. Stored as a string.
+/// </summary>
+public enum ProductionStageStatus
+{
+    Waiting,
+    Ready,
+    InProgress,
+    Done,
+    Approved
+}

Backend/ERPCore/Domain/Enums/ReasonContext.cs

@@ -5,5 +5,8 @@ public enum ReasonContext
 {
     Adjustment,
     Return,
-    Count
+    Count,
+
+    /// <summary>Manufacturing: scrap, leftover return, run cancel (docs/30 §A.2).</summary>
+    Production
 }

Backend/ERPCore/Domain/Enums/RunStageEventType.cs

@@ -0,0 +1,20 @@
+namespace ERPCore.Domain.Enums;
+
+/// <summary>
+/// Kind of entry in a run's immutable history (docs/30 Part C, <c>RUN_STAGE_EVENT</c>).
+/// Every mutating action on a run writes exactly one event carrying who/when plus a
+/// jsonb payload; <see cref="TerminalReject"/> additionally snapshots the whole run's
+/// figures for the rework pass being discarded (FR-MFG-16). Stored as a string.
+/// </summary>
+public enum RunStageEventType
+{
+    Start,
+    Complete,
+    Approve,
+    Transfer,
+    RejectIntake,
+    TerminalReject,
+    LeftoverReturn,
+    Cancel,
+    QuantityEdit
+}

Backend/ERPCore/Domain/Enums/SalesDiscountMode.cs

@@ -0,0 +1,7 @@
+namespace ERPCore.Domain.Enums;
+
+public enum SalesDiscountMode
+{
+    Percentage = 1,
+    FixedAmount = 2
+}

Backend/ERPCore/Domain/Enums/SalesInvoiceStatus.cs

@@ -0,0 +1,8 @@
+namespace ERPCore.Domain.Enums;
+
+public enum SalesInvoiceStatus
+{
+    Draft = 1,
+    Posted = 2,
+    Cancelled = 3
+}

Backend/ERPCore/Domain/Enums/SalesInvoiceType.cs

@@ -0,0 +1,9 @@
+namespace ERPCore.Domain.Enums;
+
+public enum SalesInvoiceType
+{
+    B2B = 1,
+    B2C = 2,
+    Cash = 3,
+    Credit = 4
+}

Backend/ERPCore/Domain/Enums/SalesSlipStatus.cs

@@ -0,0 +1,8 @@
+namespace ERPCore.Domain.Enums;
+
+public enum SalesSlipStatus
+{
+    Draft = 1,
+    Posted = 2,
+    Cancelled = 3
+}

Backend/ERPCore/Domain/Enums/StageInputSource.cs

@@ -0,0 +1,14 @@
+namespace ERPCore.Domain.Enums;
+
+/// <summary>
+/// Where a stage input's material comes from (FR-MFG-04; docs/30 §D.5).
+/// <see cref="Stock"/> inputs reference an Item and are FIFO-consumed from the run
+/// warehouse when the stage starts. <see cref="Upstream"/> inputs reference a direct
+/// parent stage's output and flow as internal WIP — they never touch the ledger.
+/// Stored as a string.
+/// </summary>
+public enum StageInputSource
+{
+    Stock,
+    Upstream
+}

Backend/ERPCore/Domain/LedgerSourceTypes.cs

@@ -0,0 +1,34 @@
+namespace ERPCore.Domain;
+
+/// <summary>
+/// Additional <c>STOCK_LEDGER.source_doc_type</c> values for manufacturing movements
+/// (docs/30 §A.2). <c>source_doc_id</c> is always the <c>run_id</c>, so
+/// <c>LIKE 'PRD%'</c> traces every stock movement a run caused.
+/// </summary>
+/// <remarks>
+/// <para><b>Deviation from docs/30 §A.2 (recorded).</b> The doc proposes the long names
+/// <c>ProductionIssue</c>/<c>ProductionReceipt</c>/<c>ProductionReturn</c>/
+/// <c>ProductionCancelReturn</c>, but both <c>stock_ledger.SourceDocType</c> and
+/// <c>journal_entry_stubs.SourceDocType</c> are <c>varchar(10)</c> and every existing
+/// value is a short prefix (<c>GRN</c>, <c>TRF</c>, <c>ADJ</c>, <c>PRET</c>). Widening
+/// those columns would be a second Phase-1 schema change beyond the single deviation
+/// §A.1 declares (NFR-08), so the short codes below extend the existing convention
+/// instead. docs/30 §A.2 and §D.5 are amended to match.</para>
+/// <para>These are <b>not</b> <see cref="DocumentTypes"/> entries — production issues no
+/// document per movement. The run's own document number uses
+/// <see cref="DocumentTypes.Production"/> (<c>PRD-2026-00001</c>).</para>
+/// </remarks>
+public static class LedgerSourceTypes
+{
+    /// <summary>Stock consumed by a stage start (FR-MFG-10). Outbound.</summary>
+    public const string ProductionIssue = "PRDI";
+
+    /// <summary>Finished goods received at the terminal approve (FR-MFG-13). Inbound.</summary>
+    public const string ProductionReceipt = "PRDR";
+
+    /// <summary>Unconsumed material returned before receipt (FR-MFG-14). Inbound.</summary>
+    public const string ProductionReturn = "PRDL";
+
+    /// <summary>Net consumed stock returned when a run is cancelled (FR-MFG-17). Inbound.</summary>
+    public const string ProductionCancelReturn = "PRDC";
+}

Backend/ERPCore/Dtos/Customers/CustomerDtos.cs

@@ -0,0 +1,66 @@
+using System.ComponentModel.DataAnnotations;
+using ERPCore.Domain.Enums;
+
+namespace ERPCore.Dtos.Customers;
+
+/// <summary>Customer resource used by sales documents.</summary>
+public sealed record CustomerDto(
+    int CustomerId,
+    string CustomerCode,
+    CustomerType CustomerType,
+    string Name,
+    string? DisplayName,
+    string? Phone,
+    string? Email,
+    string? AddressLine1,
+    string? AddressLine2,
+    string? City,
+    string? Country,
+    string? TaxRegistrationNo,
+    decimal CreditLimit,
+    int CreditDays,
+    int? DefaultWarehouseId,
+    EntityStatus Status,
+    DateTime CreatedAt,
+    DateTime? UpdatedAt);
+
+public sealed class CreateCustomerRequest
+{
+    [Required, StringLength(50)] public string CustomerCode { get; set; } = string.Empty;
+    [Required, EnumDataType(typeof(CustomerType))] public CustomerType CustomerType { get; set; } = CustomerType.B2C;
+    [Required, StringLength(200)] public string Name { get; set; } = string.Empty;
+    [StringLength(200)] public string? DisplayName { get; set; }
+    [StringLength(30)] public string? Phone { get; set; }
+    [StringLength(100)] public string? Email { get; set; }
+    [StringLength(250)] public string? AddressLine1 { get; set; }
+    [StringLength(250)] public string? AddressLine2 { get; set; }
+    [StringLength(100)] public string? City { get; set; }
+    [StringLength(100)] public string? Country { get; set; }
+    [StringLength(50)] public string? TaxRegistrationNo { get; set; }
+    [Range(0, double.MaxValue)] public decimal CreditLimit { get; set; }
+    [Range(0, int.MaxValue)] public int CreditDays { get; set; }
+    public int? DefaultWarehouseId { get; set; }
+}
+
+public sealed class UpdateCustomerRequest
+{
+    [Required, StringLength(50)] public string CustomerCode { get; set; } = string.Empty;
+    [Required, EnumDataType(typeof(CustomerType))] public CustomerType CustomerType { get; set; } = CustomerType.B2C;
+    [Required, StringLength(200)] public string Name { get; set; } = string.Empty;
+    [StringLength(200)] public string? DisplayName { get; set; }
+    [StringLength(30)] public string? Phone { get; set; }
+    [StringLength(100)] public string? Email { get; set; }
+    [StringLength(250)] public string? AddressLine1 { get; set; }
+    [StringLength(250)] public string? AddressLine2 { get; set; }
+    [StringLength(100)] public string? City { get; set; }
+    [StringLength(100)] public string? Country { get; set; }
+    [StringLength(50)] public string? TaxRegistrationNo { get; set; }
+    [Range(0, double.MaxValue)] public decimal CreditLimit { get; set; }
+    [Range(0, int.MaxValue)] public int CreditDays { get; set; }
+    public int? DefaultWarehouseId { get; set; }
+}
+
+public sealed class UpdateCustomerStatusRequest
+{
+    [Required, EnumDataType(typeof(EntityStatus))] public EntityStatus Status { get; set; }
+}

Backend/ERPCore/Dtos/Dashboard/DashboardDtos.cs

@@ -0,0 +1,24 @@
+namespace ERPCore.Dtos.Dashboard;
+
+/// <summary>
+/// Aggregate counts for the dashboard overview — mirrors the widget set in
+/// docs/dashboard-implementation.pdf: reorder alerts, on-hand summary, stock valuation,
+/// pending-approval POs, pending GRNs, open requisitions, open counts awaiting posting,
+/// and open RFQs. Recent movements isn't here — it's just GET /stock/ledger with a small
+/// pageSize, no aggregation needed. A single computed-on-read object, not a stored
+/// entity — same as reorder alerts (docs/11 §5.7).
+/// </summary>
+public sealed record DashboardStatsDto(
+    int LowStockAlerts,
+    decimal OnHandTotal,
+    int OnHandWarehouses,
+    decimal StockValuationTotal,
+    IReadOnlyList<WarehouseValuationDto> StockValuationByWarehouse,
+    int PendingApprovalPurchaseOrders,
+    int PendingGrns,
+    int OpenRequisitions,
+    int PendingCounts,
+    int OpenRfqs);
+
+/// <summary>One bar in the Stock Valuation chart — total FIFO layer value for a warehouse.</summary>
+public sealed record WarehouseValuationDto(int WarehouseId, decimal Total);

Backend/ERPCore/Dtos/Production/RunDtos.cs

@@ -0,0 +1,113 @@
+using System.ComponentModel.DataAnnotations;
+using System.Text.Json;
+using ERPCore.Domain.Enums;
+
+namespace ERPCore.Dtos.Production;
+
+// Production run contract (docs/30-BACKEND-PHASE2.md §D.2–D.3).
+//
+// Statuses are never client-settable (02-SECURITY §B.6): a run's status and every stage
+// status move only through the stage-action endpoints. Requests here carry quantities and
+// references, nothing else.
+
+// --- responses ---------------------------------------------------------------
+
+/// <summary>Per-status stage counts driving the board's progress strip (FR-MFG-18, docs/21 §3).</summary>
+public sealed record StageSummaryDto(int Waiting, int Ready, int InProgress, int Done, int Approved);
+
+/// <summary>Row on the run board (docs/30 §D.2 <c>GET /production-runs</c>).</summary>
+public sealed record RunSummaryDto(
+    int RunId, string DocNo, int TemplateId, string TemplateName,
+    decimal TargetQty, ProductionRunStatus Status, int ReworkCount,
+    StageSummaryDto StageSummary, int WarehouseId,
+    int? FinishedItemId, string? FinishedItemName,
+    int CreatedBy, DateTime CreatedAt, DateTime? CompletedAt);
+
+/// <summary>
+/// The run cost pool (FR-MFG-13). Always derived from the stage inputs, never stored —
+/// surfaced so the UI can preview the finished unit cost before approving the terminal.
+/// </summary>
+public sealed record CostPoolDto(decimal Consumed, decimal Returned, decimal Net);
+
+public sealed record RunStageInputDto(
+    int RunInputId, StageInputSource Source, int? ItemId, int? FromRunOutputId, int UomId,
+    decimal PlannedQty, decimal ConsumedQty, decimal ConsumedValue,
+    decimal DeliveredQty, decimal ReturnedQty, decimal ReturnedValue);
+
+/// <summary>
+/// One output of a run stage. <c>AvailableToTransfer</c> is derived — produced − scrapped −
+/// transferred (FR-MFG-12) — and never stored.
+/// </summary>
+public sealed record RunStageOutputDto(
+    int RunOutputId, int? ItemId, string Name, int UomId,
+    decimal PlannedQty, decimal ProducedQty, decimal ScrappedQty, int? ScrapReasonCodeId,
+    decimal TransferredQty, decimal AvailableToTransfer);
+
+/// <summary>
+/// One stage of a run. <c>IsTerminal</c> (no outbound edge) and <c>IsEntry</c> (no inbound
+/// edge) are derived from the run edge set rather than stored, so they cannot drift from it.
+/// <c>ActualMinutes</c> is the elapsed whole minutes once the stage has finished, null while
+/// it is still running (FR-MFG-19). <c>FieldValues</c> is the raw jsonb captured at complete,
+/// passed through verbatim.
+/// </summary>
+public sealed record RunStageDto(
+    int RunStageId, int? TemplateStageId, string Name, string? RoleLabel,
+    int EstimatedMinutes, decimal PosX, decimal PosY,
+    ProductionStageStatus Status, bool IsTerminal, bool IsEntry,
+    DateTime? ActualStartAt, DateTime? ActualEndAt, int? ActualMinutes,
+    IReadOnlyList<FieldDefDto> FieldDefs, JsonElement? FieldValues,
+    IReadOnlyList<RunStageInputDto> Inputs, IReadOnlyList<RunStageOutputDto> Outputs);
+
+public sealed record RunEdgeDto(int RunEdgeId, int ParentRunStageId, int ChildRunStageId);
+
+public sealed record RunEventDto(
+    int EventId, int? RunStageId, RunStageEventType EventType, string? Note,
+    JsonElement? Payload, int UserId, DateTime CreatedAt);
+
+/// <summary>Full run graph (docs/30 §D.2 <c>GET /production-runs/{id}</c>).</summary>
+public sealed record RunGraphDto(
+    int RunId, string DocNo, int TemplateId, string TemplateName,
+    int WarehouseId, int? OutputBinId,
+    decimal TargetQty, decimal ScaleFactor,
+    ProductionRunStatus Status, int ReworkCount, int? CancelReasonCodeId,
+    CostPoolDto CostPool,
+    IReadOnlyList<RunStageDto> Stages, IReadOnlyList<RunEdgeDto> Edges, IReadOnlyList<RunEventDto> Events,
+    int CreatedBy, DateTime CreatedAt, DateTime? CompletedAt);
+
+// --- requests ----------------------------------------------------------------
+
+public sealed class CreateRunRequest
+{
+    [Range(1, int.MaxValue)]
+    public int TemplateId { get; set; }
+
+    /// <summary>Quantity of the finished item; drives the whole graph's scale factor (FR-MFG-08).</summary>
+    [Range(0.0001, double.MaxValue)]
+    public decimal TargetQty { get; set; }
+
+    [Range(1, int.MaxValue)]
+    public int WarehouseId { get; set; }
+
+    /// <summary>Optional bin for the finished goods; must belong to <see cref="WarehouseId"/>.</summary>
+    public int? OutputBinId { get; set; }
+}
+
+/// <summary>
+/// Per-run scaling override (FR-MFG-08). Only accepted while the stage has not started
+/// (<c>409 STAGE_NOT_EDITABLE</c>).
+/// </summary>
+public sealed class UpdateStageQuantitiesRequest
+{
+    public List<StageQuantityLine> Inputs { get; set; } = new();
+    public List<StageQuantityLine> Outputs { get; set; } = new();
+}
+
+public sealed class StageQuantityLine
+{
+    /// <summary>The <c>runInputId</c> or <c>runOutputId</c> being adjusted.</summary>
+    [Range(1, int.MaxValue)]
+    public int Id { get; set; }
+
+    [Range(0.0001, double.MaxValue)]
+    public decimal PlannedQty { get; set; }
+}

Backend/ERPCore/Dtos/Production/StageActionDtos.cs

@@ -0,0 +1,177 @@
+using System.ComponentModel.DataAnnotations;
+using System.Text.Json;
+using ERPCore.Domain.Enums;
+
+namespace ERPCore.Dtos.Production;
+
+// Stage-action contract (docs/30-BACKEND-PHASE2.md §D.3). Every action is transactional,
+// guards on the stage's current status, and returns the refreshed stage plus whatever
+// stock effects it caused.
+
+// --- start -------------------------------------------------------------------
+
+/// <summary>One FIFO layer a stage start drew from, at that layer's cost.</summary>
+public sealed record ConsumedLayerDto(int LayerId, decimal Qty, decimal UnitCost);
+
+/// <summary>What a single Stock input consumed at start (FR-MFG-10).</summary>
+public sealed record ConsumedInputDto(
+    int RunInputId, int ItemId, decimal Qty, decimal Value, IReadOnlyList<ConsumedLayerDto> ConsumedLayers);
+
+public sealed record StartStageResultDto(
+    int RunStageId, ProductionStageStatus Status, DateTime? ActualStartAt,
+    IReadOnlyList<ConsumedInputDto> Consumed, IReadOnlyList<int> LedgerRefs,
+    RunStageDto Stage);
+
+// --- complete ----------------------------------------------------------------
+
+public sealed class CompleteStageRequest
+{
+    [Required, MinLength(1)]
+    public List<CompleteOutputLine> Outputs { get; set; } = new();
+
+    /// <summary>
+    /// Values for the stage's custom fields, keyed by <c>fieldDefs[].key</c>. Every field
+    /// marked required must be present and non-empty (<c>400 REQUIRED_FIELD_MISSING</c>).
+    /// </summary>
+    public JsonElement? FieldValues { get; set; }
+}
+
+public sealed class CompleteOutputLine
+{
+    [Range(1, int.MaxValue)]
+    public int RunOutputId { get; set; }
+
+    [Range(0, double.MaxValue)]
+    public decimal ProducedQty { get; set; }
+
+    [Range(0, double.MaxValue)]
+    public decimal ScrappedQty { get; set; }
+
+    /// <summary>Mandatory once <see cref="ScrappedQty"/> &gt; 0; must be a Production reason.</summary>
+    public int? ScrapReasonCodeId { get; set; }
+}
+
+// --- approve / transfer ------------------------------------------------------
+
+/// <summary>
+/// One WIP hand-off from a parent output to a child input. Deliveries route by
+/// <c>fromRunOutputId</c>, not by edge — see the note on <c>RunEdge</c>.
+/// </summary>
+public sealed record TransferDto(
+    int RunOutputId, int RunInputId, int ChildRunStageId, decimal Qty,
+    decimal ChildDeliveredQty, ProductionStageStatus ChildStatus);
+
+/// <summary>The finished-goods layer a terminal approve created (FR-MFG-13).</summary>
+public sealed record ReceiptDto(
+    int LayerId, int ItemId, int WarehouseId, int? BinId,
+    decimal QtyReceived, decimal UnitCost, decimal Value);
+
+public sealed record ApproveStageResultDto(
+    int RunStageId, ProductionStageStatus Status, ProductionRunStatus RunStatus,
+    IReadOnlyList<TransferDto> Transfers,
+    ReceiptDto? Receipt, CostPoolDto? CostPool, IReadOnlyList<int> LedgerRefs,
+    RunStageDto Stage);
+
+public sealed class ApproveStageRequest
+{
+    /// <summary>
+    /// Optional partial transfers. Omitted or empty means transfer the full available
+    /// quantity of every output (FR-MFG-12).
+    /// </summary>
+    public List<TransferLine> Transfers { get; set; } = new();
+}
+
+public sealed class TransferLine
+{
+    [Range(1, int.MaxValue)]
+    public int RunOutputId { get; set; }
+
+    [Range(0.0001, double.MaxValue)]
+    public decimal Qty { get; set; }
+
+    /// <summary>
+    /// Optional explicit target. When an output feeds several child inputs the server
+    /// otherwise fills them in <c>runInputId</c> order; naming one removes the ambiguity.
+    /// </summary>
+    public int? RunInputId { get; set; }
+}
+
+public sealed class TransferRemainderRequest
+{
+    [Range(1, int.MaxValue)]
+    public int RunOutputId { get; set; }
+
+    [Range(0.0001, double.MaxValue)]
+    public decimal Qty { get; set; }
+
+    public int? RunInputId { get; set; }
+}
+
+public sealed record TransferResultDto(
+    int RunStageId, IReadOnlyList<TransferDto> Transfers, RunStageDto Stage);
+
+// --- leftover return ---------------------------------------------------------
+
+public sealed class ReturnLeftoverRequest
+{
+    /// <summary>
+    /// Quantity to return, in the item's <b>base</b> UOM — the same unit
+    /// <c>consumedQty</c>/<c>returnedQty</c> are stored in, since the return posts straight
+    /// to stock. Cannot exceed consumed − already returned.
+    /// </summary>
+    [Range(0.0001, double.MaxValue)]
+    public decimal Qty { get; set; }
+
+    /// <summary>Mandatory, and must be a Production-context reason (FR-MFG-14).</summary>
+    public int? ReasonCodeId { get; set; }
+}
+
+public sealed record ProductionCreatedLayerDto(int LayerId, decimal UnitCost);
+
+public sealed record ReturnLeftoverResultDto(
+    int RunInputId, decimal ReturnedQty, decimal ReturnedValue,
+    ProductionCreatedLayerDto CreatedLayer, IReadOnlyList<int> LedgerRefs, CostPoolDto CostPool);
+
+// --- rejection / rework ------------------------------------------------------
+
+public sealed class RejectRequest
+{
+    [StringLength(500)]
+    public string? Note { get; set; }
+}
+
+/// <summary>One parent whose delivered work was pulled back by a reject-intake (FR-MFG-15).</summary>
+public sealed record PulledBackDto(
+    int RunInputId, int ParentRunStageId, int ParentRunOutputId,
+    decimal Qty, ProductionStageStatus PriorParentStatus, ProductionStageStatus ParentStatus);
+
+public sealed record RejectIntakeResultDto(
+    int RunStageId, ProductionStageStatus Status,
+    IReadOnlyList<PulledBackDto> PulledBack, RunGraphDto Run);
+
+public sealed record TerminalRejectResultDto(
+    int RunStageId, int ReworkCount, RunGraphDto Run);
+
+// --- cancel ------------------------------------------------------------------
+
+public sealed class CancelRunRequest
+{
+    public int? ReasonCodeId { get; set; }
+
+    [StringLength(500)]
+    public string? Note { get; set; }
+}
+
+public sealed record CancelReturnDto(int ItemId, decimal Qty, decimal UnitCost, int LayerId);
+
+/// <summary>
+/// Scrapped output quantities written off by a cancel. Recorded on the event only — scrap
+/// sits on outputs, which never entered stock, so there is nothing to return (FR-MFG-17).
+/// </summary>
+public sealed record ScrapWriteOffDto(int RunOutputId, string Name, decimal Qty);
+
+public sealed record CancelRunResultDto(
+    int RunId, ProductionRunStatus Status,
+    IReadOnlyList<CancelReturnDto> Returns,
+    IReadOnlyList<ScrapWriteOffDto> ScrappedWrittenOff,
+    IReadOnlyList<int> LedgerRefs);

Backend/ERPCore/Dtos/Production/TemplateDtos.cs

@@ -0,0 +1,177 @@
+using System.ComponentModel.DataAnnotations;
+using ERPCore.Domain.Enums;
+
+namespace ERPCore.Dtos.Production;
+
+// Production template contract (docs/30-BACKEND-PHASE2.md §D.1).
+//
+// The `Key` vocabulary: every stage and every output carries a client-facing string key
+// alongside its database id. On a GET the key IS the stringified id; on a save the client
+// echoes those keys back for rows it kept and mints "tmp-<uuid>" keys for rows it just
+// drew. Edges and Upstream inputs then reference stages/outputs *by key* only, which is
+// what lets one payload shape — and one validator — serve both POST (nothing has an id
+// yet) and PUT (most things do).
+
+// --- responses ---------------------------------------------------------------
+
+/// <summary>
+/// Row on the template list (docs/30 §D.1 <c>GET /production-templates</c>).
+/// </summary>
+/// <remarks>
+/// <c>StageNames</c> is an addition to the documented shape. The template overview is a
+/// canvas showing every template as a production line with its stages left-to-right
+/// (docs/21 §1), so it needs the names for every listed row — without them the client would
+/// have to fetch each template's full graph just to label the boxes. Ordered by stage id,
+/// matching the graph endpoint.
+/// </remarks>
+public sealed record TemplateSummaryDto(
+    int TemplateId, string Code, string Name, EntityStatus Status,
+    int StageCount, IReadOnlyList<string> StageNames,
+    int ActiveRunCount, int CreatedBy, DateTime CreatedAt);
+
+/// <summary>One custom field definition, serialized verbatim into the stage's <c>field_defs</c> jsonb.</summary>
+public sealed record FieldDefDto(
+    string Key, string Label, CustomFieldType Type, IReadOnlyList<string>? Options, bool Required);
+
+public sealed record StageInputDto(
+    int InputId, StageInputSource Source, int? ItemId,
+    int? FromOutputId, string? FromOutputKey, int UomId, decimal QtyPerBatch);
+
+public sealed record StageOutputDto(
+    int OutputId, string Key, int? ItemId, string Name, int UomId, decimal QtyPerBatch);
+
+public sealed record TemplateStageDto(
+    int StageId, string Key, string Name, string? RoleLabel, int EstimatedMinutes,
+    decimal PosX, decimal PosY, IReadOnlyList<FieldDefDto> FieldDefs,
+    IReadOnlyList<StageInputDto> Inputs, IReadOnlyList<StageOutputDto> Outputs);
+
+public sealed record TemplateEdgeDto(
+    int EdgeId, int ParentStageId, int ChildStageId, string ParentKey, string ChildKey);
+
+/// <summary>
+/// A canvas-only grouping box or divider line. Round-tripped verbatim: no server-side
+/// meaning whatsoever, and invisible to the graph validator.
+/// </summary>
+public sealed record CanvasAnnotationDto(
+    string Kind, decimal PosX, decimal PosY, decimal Width, decimal Height,
+    string? Label, decimal? Rotation);
+
+/// <summary>Full graph (docs/30 §D.1 <c>GET /production-templates/{id}</c>).</summary>
+/// <remarks>
+/// <c>ActiveRunCount</c> and <c>Annotations</c> are additions to the documented shape.
+/// The first is what puts the builder into its edit-locked state (docs/21 §2) and mirrors
+/// the condition <c>UpdateAsync</c> enforces — without it the builder would need a second
+/// request to the list endpoint just to know whether to disable itself.
+/// </remarks>
+public sealed record TemplateGraphDto(
+    int TemplateId, string Code, string Name, string? Description, EntityStatus Status,
+    IReadOnlyList<TemplateStageDto> Stages, IReadOnlyList<TemplateEdgeDto> Edges,
+    IReadOnlyList<CanvasAnnotationDto> Annotations, int ActiveRunCount,
+    int CreatedBy, DateTime CreatedAt);
+
+// --- requests ----------------------------------------------------------------
+// Narrow by design (02-SECURITY §B.6): no status, no ids, no createdBy, no timestamps.
+// POST and PUT share this shape; PUT replaces the whole graph.
+
+public sealed class SaveTemplateRequest
+{
+    [Required, StringLength(30, MinimumLength = 1)]
+    public string Code { get; set; } = string.Empty;
+
+    [Required, StringLength(150, MinimumLength = 1)]
+    public string Name { get; set; } = string.Empty;
+
+    [StringLength(500)]
+    public string? Description { get; set; }
+
+    [Required, MinLength(1)]
+    public List<SaveStageRequest> Stages { get; set; } = new();
+
+    /// <summary>Empty is legal — a single-stage template is both entry and terminal.</summary>
+    public List<SaveEdgeRequest> Edges { get; set; } = new();
+
+    /// <summary>
+    /// Canvas boxes/lines. Capped because this is free-form client state going into a jsonb
+    /// column — a hand-rolled request should not be able to store an unbounded blob.
+    /// </summary>
+    [MaxLength(200)]
+    public List<CanvasAnnotationDto> Annotations { get; set; } = new();
+}
+
+public sealed class SaveStageRequest
+{
+    /// <summary>Existing stage id as a string, or a client-minted <c>tmp-*</c> key for a new stage.</summary>
+    [Required, StringLength(60, MinimumLength = 1)]
+    public string Key { get; set; } = string.Empty;
+
+    [Required, StringLength(150, MinimumLength = 1)]
+    public string Name { get; set; } = string.Empty;
+
+    [StringLength(60)]
+    public string? RoleLabel { get; set; }
+
+    [Range(0, 1_000_000)]
+    public int EstimatedMinutes { get; set; }
+
+    /// <summary>Canvas coordinates, stored verbatim and never interpreted server-side.</summary>
+    public decimal PosX { get; set; }
+    public decimal PosY { get; set; }
+
+    public List<FieldDefDto> FieldDefs { get; set; } = new();
+    public List<SaveInputRequest> Inputs { get; set; } = new();
+    public List<SaveOutputRequest> Outputs { get; set; } = new();
+}
+
+public sealed class SaveInputRequest
+{
+    [Required]
+    public StageInputSource Source { get; set; }
+
+    /// <summary>Required when <see cref="Source"/> is Stock; must be null when Upstream.</summary>
+    public int? ItemId { get; set; }
+
+    /// <summary>Required when <see cref="Source"/> is Upstream; must name an output of a direct parent.</summary>
+    [StringLength(60)]
+    public string? FromOutputKey { get; set; }
+
+    [Range(1, int.MaxValue)]
+    public int UomId { get; set; }
+
+    [Range(0.0001, double.MaxValue)]
+    public decimal QtyPerBatch { get; set; }
+}
+
+public sealed class SaveOutputRequest
+{
+    /// <summary>Existing output id as a string, or a <c>tmp-*</c> key. Referenced by Upstream inputs.</summary>
+    [Required, StringLength(60, MinimumLength = 1)]
+    public string Key { get; set; } = string.Empty;
+
+    /// <summary>Required on the terminal stage's single output; must be null on every other output.</summary>
+    public int? ItemId { get; set; }
+
+    [Required, StringLength(150, MinimumLength = 1)]
+    public string Name { get; set; } = string.Empty;
+
+    [Range(1, int.MaxValue)]
+    public int UomId { get; set; }
+
+    [Range(0.0001, double.MaxValue)]
+    public decimal QtyPerBatch { get; set; }
+}
+
+public sealed class SaveEdgeRequest
+{
+    [Required, StringLength(60, MinimumLength = 1)]
+    public string ParentKey { get; set; } = string.Empty;
+
+    [Required, StringLength(60, MinimumLength = 1)]
+    public string ChildKey { get; set; } = string.Empty;
+}
+
+/// <summary>Body of <c>PATCH /production-templates/{id}/status</c> (docs/30 §D.1).</summary>
+public sealed class UpdateTemplateStatusRequest
+{
+    [Required]
+    public EntityStatus Status { get; set; }
+}

Backend/ERPCore/Dtos/Sales/SalesInvoiceDtos.cs

@@ -0,0 +1,59 @@
+using System.ComponentModel.DataAnnotations;
+using ERPCore.Domain.Enums;
+
+namespace ERPCore.Dtos.Sales;
+
+public sealed record SalesInvoiceLineDto(
+    int SalesInvoiceLineId, int ItemId, string Description, decimal Qty, decimal FreeQty, int UomId,
+    int WarehouseId, decimal UnitPrice, decimal BaseCost, string PriceSource, decimal DiscountPct,
+    decimal DiscountAmount, SalesDiscountMode DiscountMode, decimal NetUnitPrice, decimal LineTotal,
+    decimal TaxPct, decimal TaxAmount, bool IsFreeIssue, int? ParentLineId);
+
+public sealed record SalesInvoiceTotalsDto(
+    decimal Subtotal, decimal DiscountTotal, decimal FreeQtyTotal, decimal TaxTotal, decimal GrandTotal,
+    decimal RoundOff, decimal NetPayable, decimal PaidAmount, decimal BalanceAmount);
+
+public sealed record SalesInvoiceDto(
+    int SalesInvoiceId, string InvoiceNo, DateTime InvoiceDate, int CustomerId,
+    string CustomerSnapshotName, string? CustomerSnapshotTaxNo, int WarehouseId,
+    SalesInvoiceType InvoiceType, SalesInvoiceStatus Status, int CreatedBy, DateTime CreatedAt,
+    DateTime? UpdatedAt, SalesInvoiceTotalsDto Totals, IReadOnlyList<SalesInvoiceLineDto> Lines);
+
+public sealed record SalesInvoiceSummaryDto(
+    int SalesInvoiceId, string InvoiceNo, DateTime InvoiceDate, int CustomerId,
+    string CustomerSnapshotName, int WarehouseId, SalesInvoiceType InvoiceType,
+    SalesInvoiceStatus Status, SalesInvoiceTotalsDto Totals, DateTime CreatedAt);
+
+public sealed class CreateSalesInvoiceLineRequest
+{
+    [Required] public int ItemId { get; set; }
+    [Required] public int UomId { get; set; }
+    [Required] public int WarehouseId { get; set; }
+    [Range(0.0001, double.MaxValue)] public decimal Qty { get; set; }
+    [Range(0, double.MaxValue)] public decimal FreeQty { get; set; }
+    [Range(0, double.MaxValue)] public decimal? UnitPrice { get; set; }
+    public bool AllowManualPriceOverride { get; set; }
+    [Required, EnumDataType(typeof(SalesDiscountMode))] public SalesDiscountMode DiscountMode { get; set; } = SalesDiscountMode.Percentage;
+    [Range(0, 100)] public decimal DiscountPct { get; set; }
+    [Range(0, double.MaxValue)] public decimal DiscountAmount { get; set; }
+    [Range(0, double.MaxValue)] public decimal DiscountValue { get; set; }
+    [Range(0, 100)] public decimal TaxPct { get; set; }
+    public bool IsFreeIssue { get; set; }
+    public int? ParentLineId { get; set; }
+}
+
+public sealed class CreateSalesInvoiceRequest
+{
+    [Required] public int CustomerId { get; set; }
+    [Required] public int WarehouseId { get; set; }
+    [Required, EnumDataType(typeof(SalesInvoiceType))] public SalesInvoiceType InvoiceType { get; set; } = SalesInvoiceType.B2C;
+    [Required, MinLength(1)] public List<CreateSalesInvoiceLineRequest> Lines { get; set; } = new();
+}
+
+public sealed class UpdateSalesInvoiceRequest
+{
+    [Required] public int CustomerId { get; set; }
+    [Required] public int WarehouseId { get; set; }
+    [Required, EnumDataType(typeof(SalesInvoiceType))] public SalesInvoiceType InvoiceType { get; set; } = SalesInvoiceType.B2C;
+    [Required, MinLength(1)] public List<CreateSalesInvoiceLineRequest> Lines { get; set; } = new();
+}

Backend/ERPCore/Dtos/Sales/SalesReportDtos.cs

@@ -0,0 +1,68 @@
+namespace ERPCore.Dtos.Sales;
+
+public sealed record SalesDailySummaryRowDto(
+    DateOnly Date,
+    int InvoiceCount,
+    int SlipCount,
+    decimal InvoiceSubtotal,
+    decimal SlipSubtotal,
+    decimal DiscountTotal,
+    decimal FreeQtyTotal,
+    decimal TaxTotal,
+    decimal GrandTotal);
+
+public sealed record SalesItemSummaryRowDto(
+    int ItemId,
+    string ItemName,
+    decimal SoldQty,
+    decimal FreeQty,
+    decimal GrossAmount,
+    decimal DiscountTotal,
+    decimal TaxTotal,
+    decimal NetAmount);
+
+public sealed record SalesCustomerSummaryRowDto(
+    int CustomerId,
+    string CustomerName,
+    int InvoiceCount,
+    int SlipCount,
+    decimal SoldQty,
+    decimal FreeQty,
+    decimal GrossAmount,
+    decimal DiscountTotal,
+    decimal TaxTotal,
+    decimal NetAmount);
+
+public sealed record SalesWarehouseSummaryRowDto(
+    int WarehouseId,
+    string WarehouseName,
+    int InvoiceCount,
+    int SlipCount,
+    decimal SoldQty,
+    decimal FreeQty,
+    decimal GrossAmount,
+    decimal DiscountTotal,
+    decimal TaxTotal,
+    decimal NetAmount);
+
+public sealed record SalesDiscountSummaryRowDto(
+    string DocumentType,
+    string DocumentNo,
+    DateTime DocumentDate,
+    string CustomerName,
+    decimal Subtotal,
+    decimal DiscountTotal,
+    decimal TaxTotal,
+    decimal NetAmount);
+
+public sealed record SalesFreeIssueSummaryRowDto(
+    string DocumentType,
+    string DocumentNo,
+    DateTime DocumentDate,
+    string CustomerName,
+    int ItemId,
+    string ItemName,
+    decimal FreeQty,
+    decimal FreeValue,
+    int WarehouseId,
+    string WarehouseName);

Backend/ERPCore/Dtos/Sales/SalesSlipDtos.cs

@@ -0,0 +1,58 @@
+using System.ComponentModel.DataAnnotations;
+using ERPCore.Domain.Enums;
+
+namespace ERPCore.Dtos.Sales;
+
+public sealed record SalesSlipLineDto(
+    int SalesSlipLineId, int ItemId, string Description, decimal Qty, decimal FreeQty, int UomId,
+    int WarehouseId, decimal UnitPrice, decimal BaseCost, string PriceSource, decimal DiscountPct,
+    decimal DiscountAmount, SalesDiscountMode DiscountMode, decimal NetUnitPrice, decimal LineTotal,
+    decimal TaxPct, decimal TaxAmount, bool IsFreeIssue, int? ParentLineId);
+
+public sealed record SalesSlipTotalsDto(
+    decimal Subtotal, decimal DiscountTotal, decimal FreeQtyTotal, decimal TaxTotal, decimal GrandTotal,
+    decimal PaidAmount, decimal BalanceAmount);
+
+public sealed record SalesSlipDto(
+    int SalesSlipId, string SlipNo, DateTime SlipDate, int CustomerId,
+    string CustomerSnapshotName, int WarehouseId, int CashierUserId, SalesSlipStatus Status,
+    DateTime CreatedAt, DateTime? UpdatedAt, SalesSlipTotalsDto Totals, IReadOnlyList<SalesSlipLineDto> Lines);
+
+public sealed record SalesSlipSummaryDto(
+    int SalesSlipId, string SlipNo, DateTime SlipDate, int CustomerId,
+    string CustomerSnapshotName, int WarehouseId, SalesSlipStatus Status,
+    SalesSlipTotalsDto Totals, DateTime CreatedAt);
+
+public sealed class CreateSalesSlipLineRequest
+{
+    [Required] public int ItemId { get; set; }
+    [Required] public int UomId { get; set; }
+    [Required] public int WarehouseId { get; set; }
+    [Range(0.0001, double.MaxValue)] public decimal Qty { get; set; }
+    [Range(0, double.MaxValue)] public decimal FreeQty { get; set; }
+    [Range(0, double.MaxValue)] public decimal? UnitPrice { get; set; }
+    public bool AllowManualPriceOverride { get; set; }
+    [Required, EnumDataType(typeof(SalesDiscountMode))] public SalesDiscountMode DiscountMode { get; set; } = SalesDiscountMode.Percentage;
+    [Range(0, 100)] public decimal DiscountPct { get; set; }
+    [Range(0, double.MaxValue)] public decimal DiscountAmount { get; set; }
+    [Range(0, double.MaxValue)] public decimal DiscountValue { get; set; }
+    [Range(0, 100)] public decimal TaxPct { get; set; }
+    public bool IsFreeIssue { get; set; }
+    public int? ParentLineId { get; set; }
+}
+
+public sealed class CreateSalesSlipRequest
+{
+    [Required] public int CustomerId { get; set; }
+    [Required] public int WarehouseId { get; set; }
+    [Required] public int CashierUserId { get; set; }
+    [Required, MinLength(1)] public List<CreateSalesSlipLineRequest> Lines { get; set; } = new();
+}
+
+public sealed class UpdateSalesSlipRequest
+{
+    [Required] public int CustomerId { get; set; }
+    [Required] public int WarehouseId { get; set; }
+    [Required] public int CashierUserId { get; set; }
+    [Required, MinLength(1)] public List<CreateSalesSlipLineRequest> Lines { get; set; } = new();
+}

Backend/ERPCore/Infra/Gl/GeneralLedgerClient.cs

@@ -0,0 +1,55 @@
+using ERPCore.System.Errors;
+
+namespace ERPCore.Infra.Gl;
+
+/// <summary>
+/// HTTP implementation of <see cref="IGeneralLedgerClient"/>. Registered as a typed
+/// client (`AddHttpClient&lt;IGeneralLedgerClient, GeneralLedgerClient&gt;`) with its
+/// `BaseAddress` bound from `GeneralLedgerService:BaseUrl`. Every call attaches the
+/// shared `GeneralLedgerService:ApiKey` as `X-Api-Key` and streams the request/response
+/// body straight through, unparsed — GL's own response (status, content-type, body) is
+/// returned exactly as received; nothing here reshapes it.
+/// </summary>
+public sealed class GeneralLedgerClient(HttpClient http, IConfiguration configuration) : IGeneralLedgerClient
+{
+    private readonly HttpClient _http = http;
+    private readonly string _apiKey = configuration["GeneralLedgerService:ApiKey"] ?? string.Empty;
+
+    public async Task<GeneralLedgerResponse> SendAsync(
+        HttpMethod method, string path, string? queryString, string? contentType, Stream? body, CancellationToken ct)
+    {
+        var relativeUri = path.TrimStart('/') + queryString;
+        using var request = new HttpRequestMessage(method, relativeUri);
+        request.Headers.TryAddWithoutValidation("X-Api-Key", _apiKey);
+
+        if (body is not null && method != HttpMethod.Get)
+        {
+            var content = new StreamContent(body);
+            if (!string.IsNullOrEmpty(contentType))
+                content.Headers.TryAddWithoutValidation("Content-Type", contentType);
+            request.Content = content;
+        }
+
+        HttpResponseMessage response;
+        try
+        {
+            response = await _http.SendAsync(request, ct);
+        }
+        catch (HttpRequestException)
+        {
+            throw new DomainException(ErrorCodes.GlServiceUnavailable, "The General Ledger service is unreachable.", 503);
+        }
+        catch (TaskCanceledException) when (!ct.IsCancellationRequested)
+        {
+            throw new DomainException(ErrorCodes.GlServiceUnavailable, "The General Ledger service timed out.", 503);
+        }
+
+        var responseBody = await response.Content.ReadAsStringAsync(ct);
+        return new GeneralLedgerResponse
+        {
+            StatusCode = (int)response.StatusCode,
+            ContentType = response.Content.Headers.ContentType?.ToString(),
+            Body = responseBody
+        };
+    }
+}

Backend/ERPCore/Infra/Gl/GeneralLedgerResponse.cs

@@ -0,0 +1,15 @@
+namespace ERPCore.Infra.Gl;
+
+/// <summary>
+/// Raw HTTP result from the external General Ledger service — status code, content
+/// type, and body exactly as GL returned them. Deliberately un-reshaped: GL's own
+/// envelope (see the GL service's own API reference) is passed through byte-for-byte
+/// so its camelCase-success/PascalCase-error inconsistency and full decimal precision
+/// survive the hop unchanged (docs/12-GENERAL-LEDGER-INTEGRATION.md).
+/// </summary>
+public sealed class GeneralLedgerResponse
+{
+    public int StatusCode { get; init; }
+    public string? ContentType { get; init; }
+    public string Body { get; init; } = string.Empty;
+}

Backend/ERPCore/Infra/Gl/IGeneralLedgerClient.cs

@@ -0,0 +1,13 @@
+namespace ERPCore.Infra.Gl;
+
+/// <summary>
+/// Typed HTTP transport to the external General Ledger service. Injects the shared
+/// `X-Api-Key` secret and forwards method/path/query/body/content-type verbatim —
+/// see docs/12-GENERAL-LEDGER-INTEGRATION.md. Internal: only
+/// <see cref="ERPCore.Services.Interfaces.IGeneralLedgerService"/> consumes this.
+/// </summary>
+public interface IGeneralLedgerClient
+{
+    Task<GeneralLedgerResponse> SendAsync(
+        HttpMethod method, string path, string? queryString, string? contentType, Stream? body, CancellationToken ct);
+}

Backend/ERPCore/Infra/Persistence/Configurations/CustomerConfiguration.cs

@@ -0,0 +1,50 @@
+using ERPCore.Domain.Entities;
+using ERPCore.Domain.Enums;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace ERPCore.Infra.Persistence.Configurations;
+
+public sealed class CustomerConfiguration : IEntityTypeConfiguration<Customer>
+{
+    public void Configure(EntityTypeBuilder<Customer> builder)
+    {
+        builder.ToTable("customers");
+        builder.HasKey(c => c.CustomerId);
+
+        builder.Property(c => c.CustomerCode).IsRequired().HasMaxLength(50);
+        builder.HasIndex(c => c.CustomerCode).IsUnique();
+
+        builder.Property(c => c.CustomerType)
+            .HasConversion<string>().HasMaxLength(20).IsRequired()
+            .HasDefaultValue(CustomerType.B2C);
+
+        builder.Property(c => c.Name).IsRequired().HasMaxLength(200);
+        builder.Property(c => c.DisplayName).HasMaxLength(200);
+        builder.Property(c => c.Phone).HasMaxLength(30);
+        builder.Property(c => c.Email).HasMaxLength(100);
+        builder.Property(c => c.AddressLine1).HasMaxLength(250);
+        builder.Property(c => c.AddressLine2).HasMaxLength(250);
+        builder.Property(c => c.City).HasMaxLength(100);
+        builder.Property(c => c.Country).HasMaxLength(100);
+        builder.Property(c => c.TaxRegistrationNo).HasMaxLength(50);
+
+        builder.Property(c => c.CreditLimit).HasPrecision(18, 4);
+        builder.Property(c => c.CreditDays).IsRequired();
+
+        builder.HasOne(c => c.DefaultWarehouse)
+            .WithMany()
+            .HasForeignKey(c => c.DefaultWarehouseId)
+            .OnDelete(DeleteBehavior.SetNull);
+
+        builder.Property(c => c.Status)
+            .HasConversion<string>().HasMaxLength(20).IsRequired()
+            .HasDefaultValue(EntityStatus.Active);
+
+        builder.Property(c => c.CreatedAt).IsRequired();
+        builder.Property(c => c.RowVersion).IsRowVersion();
+
+        builder.HasIndex(c => c.Status);
+        builder.HasIndex(c => c.CustomerType);
+    }
+}

Backend/ERPCore/Infra/Persistence/Configurations/NavItemConfiguration.cs

@@ -36,7 +36,9 @@ public sealed class NavItemConfiguration : IEntityTypeConfiguration<NavItem>
             new NavItem { NavItemId = 7, Code = "warehouses", Label = "Warehouses", Href = "/dashboard/warehouse", SortOrder = 7 },
             new NavItem { NavItemId = 8, Code = "orders", Label = "Orders", Href = "/dashboard/orders", SortOrder = 8 },
             new NavItem { NavItemId = 9, Code = "settings", Label = "Settings", Href = "/dashboard/settings", SortOrder = 9 },
-            new NavItem { NavItemId = 10, Code = "help", Label = "Help", Href = "/dashboard/help", SortOrder = 10 }
+            new NavItem { NavItemId = 10, Code = "help", Label = "Help", Href = "/dashboard/help", SortOrder = 10 },
+            new NavItem { NavItemId = 11, Code = "ledgers", Label = "Ledgers", Href = "/dashboard/ledgers", SortOrder = 11 },
+            new NavItem { NavItemId = 12, Code = "accounts", Label = "Accounts", Href = "/dashboard/accounts", SortOrder = 12 }
         );
     }
 }

Backend/ERPCore/Infra/Persistence/Configurations/PermissionConfiguration.cs

@@ -42,10 +42,26 @@ public sealed class PermissionConfiguration : IEntityTypeConfiguration<Permissio
             new Permission { PermissionId = 16, Code = "NAV:products.configuration", SubNavItemId = 6 },
             new Permission { PermissionId = 17, Code = "NAV:settings.roles", SubNavItemId = 7 },
             new Permission { PermissionId = 18, Code = "NAV:settings.users", SubNavItemId = 8 },
-            new Permission { PermissionId = 19, Code = "NAV:procurement.requisitions", SubNavItemId = 9 },
-            new Permission { PermissionId = 20, Code = "NAV:procurement.rfqs", SubNavItemId = 10 },
-            new Permission { PermissionId = 21, Code = "NAV:procurement.purchase-orders", SubNavItemId = 11 },
-            new Permission { PermissionId = 22, Code = "NAV:procurement.purchase-returns", SubNavItemId = 12 }
+            // IDs 28-31 (not 19-22): 19-22 were already claimed by the Ledgers permissions below;
+            // these procurement rows were never actually migrated into the database before now.
+            new Permission { PermissionId = 28, Code = "NAV:procurement.requisitions", SubNavItemId = 17 },
+            new Permission { PermissionId = 29, Code = "NAV:procurement.rfqs", SubNavItemId = 18 },
+            new Permission { PermissionId = 30, Code = "NAV:procurement.purchase-orders", SubNavItemId = 19 },
+            new Permission { PermissionId = 31, Code = "NAV:procurement.purchase-returns", SubNavItemId = 20 },
+            new Permission { PermissionId = 19, Code = "NAV:ledgers", NavItemId = 11 },
+            new Permission { PermissionId = 20, Code = "NAV:ledgers.trial-balance", SubNavItemId = 9 },
+            new Permission { PermissionId = 21, Code = "NAV:ledgers.balance-sheet", SubNavItemId = 10 },
+            new Permission { PermissionId = 22, Code = "NAV:ledgers.general-ledger", SubNavItemId = 11 },
+            new Permission { PermissionId = 23, Code = "NAV:ledgers.profit-and-loss", SubNavItemId = 12 },
+            new Permission { PermissionId = 24, Code = "NAV:ledgers.cash-flow", SubNavItemId = 13 },
+            new Permission { PermissionId = 25, Code = "NAV:ledgers.budget-vs-actual", SubNavItemId = 14 },
+            new Permission { PermissionId = 27, Code = "NAV:ledgers.tax-report", SubNavItemId = 16 },
+            // Moved under the new Accounts nav item (2026-07-31) — same PermissionId (26), just a
+            // renamed Code, so any role already granted this permission keeps it.
+            new Permission { PermissionId = 26, Code = "NAV:accounts.bank-accounts", SubNavItemId = 15 },
+            new Permission { PermissionId = 32, Code = "NAV:accounts", NavItemId = 12 },
+            new Permission { PermissionId = 33, Code = "NAV:accounts.cheque-books", SubNavItemId = 21 },
+            new Permission { PermissionId = 34, Code = "NAV:accounts.received-cheques", SubNavItemId = 22 }
         );
     }
 }

Backend/ERPCore/Infra/Persistence/Configurations/ProductionConfiguration.cs

@@ -0,0 +1,277 @@
+using ERPCore.Domain.Entities;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace ERPCore.Infra.Persistence.Configurations;
+
+// Manufacturing / Production Lines (docs/30 Part C). All eleven tables live in this one
+// file, following the StockConfiguration.cs precedent of grouping an aggregate's
+// configurations together.
+//
+// Cascade shape (deliberate): the two aggregate roots cascade to their own children —
+// template → stages/edges → inputs/outputs, run → stages/edges/events → inputs/outputs.
+// Every *cross* reference is Restrict, because making them cascade would give EF two
+// delete paths to the same table and the model validator rejects that. The consequence
+// is an ordering rule for the service layer: when replacing a graph, delete edges before
+// stages and inputs before outputs.
+
+public sealed class ProductionTemplateConfiguration : IEntityTypeConfiguration<ProductionTemplate>
+{
+    public void Configure(EntityTypeBuilder<ProductionTemplate> builder)
+    {
+        builder.ToTable("production_templates");
+        builder.HasKey(t => t.TemplateId);
+
+        builder.Property(t => t.Code).IsRequired().HasMaxLength(30);
+        builder.HasIndex(t => t.Code).IsUnique();
+
+        builder.Property(t => t.Name).IsRequired().HasMaxLength(150);
+        builder.Property(t => t.Description).HasMaxLength(500);
+
+        builder.Property(t => t.Status).HasConversion<string>().HasMaxLength(20).IsRequired();
+
+        // Same jsonb-as-string mapping as TemplateStage.FieldDefs and AuditLog.ChangeSet: a
+        // typed/owned mapping would make AuditScribe emit audit rows for the nested entries.
+        builder.Property(t => t.Annotations).HasColumnType("jsonb");
+
+        builder.Property(t => t.CreatedAt).IsRequired();
+
+        // PostgreSQL xmin system column as the optimistic concurrency token (ETag).
+        builder.Property(t => t.RowVersion).IsRowVersion();
+
+        builder.HasOne(t => t.Creator).WithMany().HasForeignKey(t => t.CreatedBy).OnDelete(DeleteBehavior.Restrict);
+
+        builder.HasIndex(t => t.Status);
+    }
+}
+
+public sealed class TemplateStageConfiguration : IEntityTypeConfiguration<TemplateStage>
+{
+    public void Configure(EntityTypeBuilder<TemplateStage> builder)
+    {
+        builder.ToTable("template_stages");
+        builder.HasKey(s => s.StageId);
+
+        builder.Property(s => s.Name).IsRequired().HasMaxLength(150);
+        builder.Property(s => s.RoleLabel).HasMaxLength(60);
+        builder.Property(s => s.PosX).HasPrecision(18, 4);
+        builder.Property(s => s.PosY).HasPrecision(18, 4);
+        builder.Property(s => s.FieldDefs).IsRequired().HasColumnType("jsonb");
+
+        builder.HasOne(s => s.Template).WithMany(t => t.Stages)
+            .HasForeignKey(s => s.TemplateId).OnDelete(DeleteBehavior.Cascade);
+    }
+}
+
+public sealed class StageEdgeConfiguration : IEntityTypeConfiguration<StageEdge>
+{
+    public void Configure(EntityTypeBuilder<StageEdge> builder)
+    {
+        builder.ToTable("stage_edges");
+        builder.HasKey(e => e.EdgeId);
+
+        builder.HasOne(e => e.Template).WithMany(t => t.Edges)
+            .HasForeignKey(e => e.TemplateId).OnDelete(DeleteBehavior.Cascade);
+
+        builder.HasOne(e => e.ParentStage).WithMany()
+            .HasForeignKey(e => e.ParentStageId).OnDelete(DeleteBehavior.Restrict);
+        builder.HasOne(e => e.ChildStage).WithMany()
+            .HasForeignKey(e => e.ChildStageId).OnDelete(DeleteBehavior.Restrict);
+
+        // One arrow per ordered pair; self-loops and cycles are rejected by the validator.
+        builder.HasIndex(e => new { e.ParentStageId, e.ChildStageId }).IsUnique();
+    }
+}
+
+public sealed class StageInputConfiguration : IEntityTypeConfiguration<StageInput>
+{
+    public void Configure(EntityTypeBuilder<StageInput> builder)
+    {
+        builder.ToTable("stage_inputs");
+        builder.HasKey(i => i.InputId);
+
+        builder.Property(i => i.Source).HasConversion<string>().HasMaxLength(20).IsRequired();
+        builder.Property(i => i.QtyPerBatch).HasPrecision(18, 4);
+
+        builder.HasOne(i => i.Stage).WithMany(s => s.Inputs)
+            .HasForeignKey(i => i.StageId).OnDelete(DeleteBehavior.Cascade);
+
+        builder.HasOne(i => i.Item).WithMany().HasForeignKey(i => i.ItemId).OnDelete(DeleteBehavior.Restrict);
+        builder.HasOne(i => i.Uom).WithMany().HasForeignKey(i => i.UomId).OnDelete(DeleteBehavior.Restrict);
+        builder.HasOne(i => i.FromOutput).WithMany()
+            .HasForeignKey(i => i.FromOutputId).OnDelete(DeleteBehavior.Restrict);
+    }
+}
+
+public sealed class StageOutputConfiguration : IEntityTypeConfiguration<StageOutput>
+{
+    public void Configure(EntityTypeBuilder<StageOutput> builder)
+    {
+        builder.ToTable("stage_outputs");
+        builder.HasKey(o => o.OutputId);
+
+        builder.Property(o => o.Name).IsRequired().HasMaxLength(150);
+        builder.Property(o => o.QtyPerBatch).HasPrecision(18, 4);
+
+        builder.HasOne(o => o.Stage).WithMany(s => s.Outputs)
+            .HasForeignKey(o => o.StageId).OnDelete(DeleteBehavior.Cascade);
+
+        builder.HasOne(o => o.Item).WithMany().HasForeignKey(o => o.ItemId).OnDelete(DeleteBehavior.Restrict);
+        builder.HasOne(o => o.Uom).WithMany().HasForeignKey(o => o.UomId).OnDelete(DeleteBehavior.Restrict);
+    }
+}
+
+public sealed class ProductionRunConfiguration : IEntityTypeConfiguration<ProductionRun>
+{
+    public void Configure(EntityTypeBuilder<ProductionRun> builder)
+    {
+        builder.ToTable("production_runs");
+        builder.HasKey(r => r.RunId);
+
+        builder.Property(r => r.DocNo).IsRequired().HasMaxLength(30);
+        builder.HasIndex(r => r.DocNo).IsUnique();
+
+        builder.Property(r => r.TargetQty).HasPrecision(18, 4);
+        builder.Property(r => r.ScaleFactor).HasPrecision(18, 6);
+        builder.Property(r => r.Status).HasConversion<string>().HasMaxLength(20).IsRequired();
+        builder.Property(r => r.CreatedAt).IsRequired();
+        builder.Property(r => r.RowVersion).IsRowVersion();
+
+        builder.HasOne(r => r.Template).WithMany(t => t.Runs)
+            .HasForeignKey(r => r.TemplateId).OnDelete(DeleteBehavior.Restrict);
+        builder.HasOne(r => r.Warehouse).WithMany().HasForeignKey(r => r.WarehouseId).OnDelete(DeleteBehavior.Restrict);
+        builder.HasOne(r => r.OutputBin).WithMany().HasForeignKey(r => r.OutputBinId).OnDelete(DeleteBehavior.Restrict);
+        builder.HasOne(r => r.CancelReason).WithMany().HasForeignKey(r => r.CancelReasonCodeId).OnDelete(DeleteBehavior.Restrict);
+        builder.HasOne(r => r.Creator).WithMany().HasForeignKey(r => r.CreatedBy).OnDelete(DeleteBehavior.Restrict);
+
+        // Run board filters (docs/30 §D.2) and the template edit-lock count (FR-MFG-06).
+        builder.HasIndex(r => r.Status);
+        builder.HasIndex(r => new { r.TemplateId, r.Status });
+    }
+}
+
+public sealed class RunStageConfiguration : IEntityTypeConfiguration<RunStage>
+{
+    public void Configure(EntityTypeBuilder<RunStage> builder)
+    {
+        builder.ToTable("run_stages");
+        builder.HasKey(s => s.RunStageId);
+
+        builder.Property(s => s.Name).IsRequired().HasMaxLength(150);
+        builder.Property(s => s.RoleLabel).HasMaxLength(60);
+        builder.Property(s => s.PosX).HasPrecision(18, 4);
+        builder.Property(s => s.PosY).HasPrecision(18, 4);
+        builder.Property(s => s.Status).HasConversion<string>().HasMaxLength(20).IsRequired();
+        builder.Property(s => s.FieldDefs).IsRequired().HasColumnType("jsonb");
+        builder.Property(s => s.FieldValues).HasColumnType("jsonb");
+        builder.Property(s => s.RowVersion).IsRowVersion();
+
+        builder.HasOne(s => s.Run).WithMany(r => r.Stages)
+            .HasForeignKey(s => s.RunId).OnDelete(DeleteBehavior.Cascade);
+
+        // SetNull, not Restrict: a template edit may delete a stage that completed or
+        // cancelled runs still point at. Everything needed to render such a run is copied
+        // onto this row, so losing the provenance link is the intended trade (FR-MFG-06).
+        builder.HasOne(s => s.TemplateStage).WithMany()
+            .HasForeignKey(s => s.TemplateStageId).OnDelete(DeleteBehavior.SetNull);
+
+        builder.HasIndex(s => new { s.RunId, s.Status });
+    }
+}
+
+public sealed class RunEdgeConfiguration : IEntityTypeConfiguration<RunEdge>
+{
+    public void Configure(EntityTypeBuilder<RunEdge> builder)
+    {
+        builder.ToTable("run_edges");
+        builder.HasKey(e => e.RunEdgeId);
+
+        builder.HasOne(e => e.Run).WithMany(r => r.Edges)
+            .HasForeignKey(e => e.RunId).OnDelete(DeleteBehavior.Cascade);
+
+        builder.HasOne(e => e.ParentRunStage).WithMany()
+            .HasForeignKey(e => e.ParentRunStageId).OnDelete(DeleteBehavior.Restrict);
+        builder.HasOne(e => e.ChildRunStage).WithMany()
+            .HasForeignKey(e => e.ChildRunStageId).OnDelete(DeleteBehavior.Restrict);
+
+        builder.HasIndex(e => new { e.ParentRunStageId, e.ChildRunStageId }).IsUnique();
+    }
+}
+
+public sealed class RunStageInputConfiguration : IEntityTypeConfiguration<RunStageInput>
+{
+    public void Configure(EntityTypeBuilder<RunStageInput> builder)
+    {
+        builder.ToTable("run_stage_inputs");
+        builder.HasKey(i => i.RunInputId);
+
+        builder.Property(i => i.Source).HasConversion<string>().HasMaxLength(20).IsRequired();
+        builder.Property(i => i.PlannedQty).HasPrecision(18, 4);
+        builder.Property(i => i.ConsumedQty).HasPrecision(18, 4);
+        builder.Property(i => i.ConsumedValue).HasPrecision(18, 4);
+        builder.Property(i => i.DeliveredQty).HasPrecision(18, 4);
+        builder.Property(i => i.ReturnedQty).HasPrecision(18, 4);
+        builder.Property(i => i.ReturnedValue).HasPrecision(18, 4);
+
+        builder.HasOne(i => i.RunStage).WithMany(s => s.Inputs)
+            .HasForeignKey(i => i.RunStageId).OnDelete(DeleteBehavior.Cascade);
+
+        builder.HasOne(i => i.Item).WithMany().HasForeignKey(i => i.ItemId).OnDelete(DeleteBehavior.Restrict);
+        builder.HasOne(i => i.Uom).WithMany().HasForeignKey(i => i.UomId).OnDelete(DeleteBehavior.Restrict);
+        builder.HasOne(i => i.FromRunOutput).WithMany()
+            .HasForeignKey(i => i.FromRunOutputId).OnDelete(DeleteBehavior.Restrict);
+
+        // Transfers route by the source output, so this is the hot lookup.
+        builder.HasIndex(i => i.FromRunOutputId);
+    }
+}
+
+public sealed class RunStageOutputConfiguration : IEntityTypeConfiguration<RunStageOutput>
+{
+    public void Configure(EntityTypeBuilder<RunStageOutput> builder)
+    {
+        builder.ToTable("run_stage_outputs");
+        builder.HasKey(o => o.RunOutputId);
+
+        builder.Property(o => o.Name).IsRequired().HasMaxLength(150);
+        builder.Property(o => o.PlannedQty).HasPrecision(18, 4);
+        builder.Property(o => o.ProducedQty).HasPrecision(18, 4);
+        builder.Property(o => o.ScrappedQty).HasPrecision(18, 4);
+        builder.Property(o => o.TransferredQty).HasPrecision(18, 4);
+
+        builder.HasOne(o => o.RunStage).WithMany(s => s.Outputs)
+            .HasForeignKey(o => o.RunStageId).OnDelete(DeleteBehavior.Cascade);
+
+        builder.HasOne(o => o.Item).WithMany().HasForeignKey(o => o.ItemId).OnDelete(DeleteBehavior.Restrict);
+        builder.HasOne(o => o.Uom).WithMany().HasForeignKey(o => o.UomId).OnDelete(DeleteBehavior.Restrict);
+        builder.HasOne(o => o.ScrapReason).WithMany().HasForeignKey(o => o.ScrapReasonCodeId).OnDelete(DeleteBehavior.Restrict);
+    }
+}
+
+public sealed class RunStageEventConfiguration : IEntityTypeConfiguration<RunStageEvent>
+{
+    public void Configure(EntityTypeBuilder<RunStageEvent> builder)
+    {
+        // Append-only history: the app never updates or deletes these rows.
+        builder.ToTable("run_stage_events");
+        builder.HasKey(e => e.EventId);
+
+        builder.Property(e => e.EventType).HasConversion<string>().HasMaxLength(20).IsRequired();
+        builder.Property(e => e.Note).HasMaxLength(500);
+        builder.Property(e => e.Payload).HasColumnType("jsonb");
+        builder.Property(e => e.CreatedAt).IsRequired();
+
+        builder.HasOne(e => e.Run).WithMany(r => r.Events)
+            .HasForeignKey(e => e.RunId).OnDelete(DeleteBehavior.Cascade);
+
+        // SetNull rather than Cascade: the run-level cascade above already removes these
+        // rows, and a second cascade path (run → stage → event) is what EF rejects.
+        builder.HasOne(e => e.RunStage).WithMany(s => s.Events)
+            .HasForeignKey(e => e.RunStageId).OnDelete(DeleteBehavior.SetNull);
+
+        builder.HasOne(e => e.User).WithMany().HasForeignKey(e => e.UserId).OnDelete(DeleteBehavior.Restrict);
+
+        // The run-detail timeline reads the whole run's history in one ordered pass.
+        builder.HasIndex(e => new { e.RunId, e.EventId });
+    }
+}

Backend/ERPCore/Infra/Persistence/Configurations/SalesInvoiceConfiguration.cs

@@ -0,0 +1,95 @@
+using ERPCore.Domain.Entities;
+using ERPCore.Domain.Enums;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace ERPCore.Infra.Persistence.Configurations;
+
+public sealed class SalesInvoiceConfiguration : IEntityTypeConfiguration<SalesInvoice>
+{
+    public void Configure(EntityTypeBuilder<SalesInvoice> builder)
+    {
+        builder.ToTable("sales_invoices");
+        builder.HasKey(x => x.SalesInvoiceId);
+
+        builder.Property(x => x.InvoiceNo).IsRequired().HasMaxLength(50);
+        builder.HasIndex(x => x.InvoiceNo).IsUnique();
+
+        builder.Property(x => x.InvoiceDate).IsRequired();
+
+        builder.HasOne(x => x.Customer)
+            .WithMany()
+            .HasForeignKey(x => x.CustomerId)
+            .OnDelete(DeleteBehavior.Restrict);
+
+        builder.Property(x => x.CustomerSnapshotName).IsRequired().HasMaxLength(200);
+        builder.Property(x => x.CustomerSnapshotTaxNo).HasMaxLength(50);
+
+        builder.HasOne(x => x.Warehouse)
+            .WithMany()
+            .HasForeignKey(x => x.WarehouseId)
+            .OnDelete(DeleteBehavior.Restrict);
+
+        builder.Property(x => x.InvoiceType)
+            .HasConversion<string>().HasMaxLength(20).IsRequired()
+            .HasDefaultValue(SalesInvoiceType.B2C);
+
+        builder.Property(x => x.Status)
+            .HasConversion<string>().HasMaxLength(20).IsRequired()
+            .HasDefaultValue(SalesInvoiceStatus.Draft);
+
+        foreach (var p in new[] { nameof(SalesInvoice.Subtotal), nameof(SalesInvoice.DiscountTotal), nameof(SalesInvoice.TaxTotal), nameof(SalesInvoice.GrandTotal), nameof(SalesInvoice.RoundOff), nameof(SalesInvoice.NetPayable), nameof(SalesInvoice.PaidAmount), nameof(SalesInvoice.BalanceAmount) })
+            builder.Property<decimal>(p).HasPrecision(18, 4);
+
+        builder.Property(x => x.CreatedAt).IsRequired();
+        builder.Property(x => x.RowVersion).IsRowVersion();
+
+        builder.HasIndex(x => x.Status);
+        builder.HasIndex(x => x.InvoiceDate);
+
+        builder.HasMany(x => x.Lines)
+            .WithOne(x => x.SalesInvoice)
+            .HasForeignKey(x => x.SalesInvoiceId)
+            .OnDelete(DeleteBehavior.Cascade);
+    }
+}
+
+public sealed class SalesInvoiceLineConfiguration : IEntityTypeConfiguration<SalesInvoiceLine>
+{
+    public void Configure(EntityTypeBuilder<SalesInvoiceLine> builder)
+    {
+        builder.ToTable("sales_invoice_lines");
+        builder.HasKey(x => x.SalesInvoiceLineId);
+
+        builder.HasOne(x => x.Item)
+            .WithMany()
+            .HasForeignKey(x => x.ItemId)
+            .OnDelete(DeleteBehavior.Restrict);
+
+        builder.Property(x => x.Description).IsRequired().HasMaxLength(200);
+
+        builder.Property(x => x.Qty).HasPrecision(18, 4);
+        builder.Property(x => x.FreeQty).HasPrecision(18, 4);
+        builder.Property(x => x.UnitPrice).HasPrecision(18, 4);
+        builder.Property(x => x.BaseCost).HasPrecision(18, 4);
+        builder.Property(x => x.DiscountPct).HasPrecision(9, 4);
+        builder.Property(x => x.DiscountAmount).HasPrecision(18, 4);
+        builder.Property(x => x.NetUnitPrice).HasPrecision(18, 4);
+        builder.Property(x => x.LineTotal).HasPrecision(18, 4);
+        builder.Property(x => x.TaxPct).HasPrecision(9, 4);
+        builder.Property(x => x.TaxAmount).HasPrecision(18, 4);
+
+        builder.HasOne(x => x.Uom)
+            .WithMany()
+            .HasForeignKey(x => x.UomId)
+            .OnDelete(DeleteBehavior.Restrict);
+
+        builder.HasOne(x => x.Warehouse)
+            .WithMany()
+            .HasForeignKey(x => x.WarehouseId)
+            .OnDelete(DeleteBehavior.Restrict);
+
+        builder.Property(x => x.PriceSource).HasMaxLength(50);
+        builder.Property(x => x.RowVersion).IsRowVersion();
+    }
+}

Backend/ERPCore/Infra/Persistence/Configurations/SalesSlipConfiguration.cs

@@ -0,0 +1,95 @@
+using ERPCore.Domain.Entities;
+using ERPCore.Domain.Enums;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace ERPCore.Infra.Persistence.Configurations;
+
+public sealed class SalesSlipConfiguration : IEntityTypeConfiguration<SalesSlip>
+{
+    public void Configure(EntityTypeBuilder<SalesSlip> builder)
+    {
+        builder.ToTable("sales_slips");
+        builder.HasKey(x => x.SalesSlipId);
+
+        builder.Property(x => x.SlipNo).IsRequired().HasMaxLength(50);
+        builder.HasIndex(x => x.SlipNo).IsUnique();
+
+        builder.Property(x => x.SlipDate).IsRequired();
+
+        builder.HasOne(x => x.Customer)
+            .WithMany()
+            .HasForeignKey(x => x.CustomerId)
+            .OnDelete(DeleteBehavior.Restrict);
+
+        builder.Property(x => x.CustomerSnapshotName).IsRequired().HasMaxLength(200);
+
+        builder.HasOne(x => x.Warehouse)
+            .WithMany()
+            .HasForeignKey(x => x.WarehouseId)
+            .OnDelete(DeleteBehavior.Restrict);
+
+        builder.HasOne(x => x.CashierUser)
+            .WithMany()
+            .HasForeignKey(x => x.CashierUserId)
+            .OnDelete(DeleteBehavior.Restrict);
+
+        builder.Property(x => x.Status)
+            .HasConversion<string>().HasMaxLength(20).IsRequired()
+            .HasDefaultValue(SalesSlipStatus.Draft);
+
+        foreach (var p in new[] { nameof(SalesSlip.Subtotal), nameof(SalesSlip.DiscountTotal), nameof(SalesSlip.TaxTotal), nameof(SalesSlip.GrandTotal), nameof(SalesSlip.PaidAmount), nameof(SalesSlip.BalanceAmount) })
+            builder.Property<decimal>(p).HasPrecision(18, 4);
+
+        builder.Property(x => x.CreatedAt).IsRequired();
+        builder.Property(x => x.RowVersion).IsRowVersion();
+
+        builder.HasIndex(x => x.Status);
+        builder.HasIndex(x => x.SlipDate);
+
+        builder.HasMany(x => x.Lines)
+            .WithOne(x => x.SalesSlip)
+            .HasForeignKey(x => x.SalesSlipId)
+            .OnDelete(DeleteBehavior.Cascade);
+    }
+}
+
+public sealed class SalesSlipLineConfiguration : IEntityTypeConfiguration<SalesSlipLine>
+{
+    public void Configure(EntityTypeBuilder<SalesSlipLine> builder)
+    {
+        builder.ToTable("sales_slip_lines");
+        builder.HasKey(x => x.SalesSlipLineId);
+
+        builder.HasOne(x => x.Item)
+            .WithMany()
+            .HasForeignKey(x => x.ItemId)
+            .OnDelete(DeleteBehavior.Restrict);
+
+        builder.Property(x => x.Description).IsRequired().HasMaxLength(200);
+
+        builder.Property(x => x.Qty).HasPrecision(18, 4);
+        builder.Property(x => x.FreeQty).HasPrecision(18, 4);
+        builder.Property(x => x.UnitPrice).HasPrecision(18, 4);
+        builder.Property(x => x.BaseCost).HasPrecision(18, 4);
+        builder.Property(x => x.DiscountPct).HasPrecision(9, 4);
+        builder.Property(x => x.DiscountAmount).HasPrecision(18, 4);
+        builder.Property(x => x.NetUnitPrice).HasPrecision(18, 4);
+        builder.Property(x => x.LineTotal).HasPrecision(18, 4);
+        builder.Property(x => x.TaxPct).HasPrecision(9, 4);
+        builder.Property(x => x.TaxAmount).HasPrecision(18, 4);
+
+        builder.HasOne(x => x.Uom)
+            .WithMany()
+            .HasForeignKey(x => x.UomId)
+            .OnDelete(DeleteBehavior.Restrict);
+
+        builder.HasOne(x => x.Warehouse)
+            .WithMany()
+            .HasForeignKey(x => x.WarehouseId)
+            .OnDelete(DeleteBehavior.Restrict);
+
+        builder.Property(x => x.PriceSource).HasMaxLength(50);
+        builder.Property(x => x.RowVersion).IsRowVersion();
+    }
+}

Backend/ERPCore/Infra/Persistence/Configurations/SubNavItemConfiguration.cs

@@ -34,10 +34,25 @@ public sealed class SubNavItemConfiguration : IEntityTypeConfiguration<SubNavIte
             new SubNavItem { SubNavItemId = 7, NavItemId = 9, Code = "settings.roles", Label = "Roles", Href = "/dashboard/settings/roles", SortOrder = 1 },
             new SubNavItem { SubNavItemId = 8, NavItemId = 9, Code = "settings.users", Label = "Users", Href = "/dashboard/settings/users", SortOrder = 2 },
             // Procurement (NavItemId 4) children — mirror the hub page order.
-            new SubNavItem { SubNavItemId = 9, NavItemId = 4, Code = "procurement.requisitions", Label = "Requisitions", Href = "/dashboard/procurement/requisitions", SortOrder = 1 },
-            new SubNavItem { SubNavItemId = 10, NavItemId = 4, Code = "procurement.rfqs", Label = "RFQs", Href = "/dashboard/procurement/rfqs", SortOrder = 2 },
-            new SubNavItem { SubNavItemId = 11, NavItemId = 4, Code = "procurement.purchase-orders", Label = "Purchase Orders", Href = "/dashboard/procurement/purchase-orders", SortOrder = 3 },
-            new SubNavItem { SubNavItemId = 12, NavItemId = 4, Code = "procurement.purchase-returns", Label = "Purchase Returns", Href = "/dashboard/procurement/purchase-returns", SortOrder = 4 }
+            // IDs 17-20 (not 9-12): 9-12 were already claimed by the Ledgers sub-items below;
+            // these procurement rows were never actually migrated into the database before now.
+            new SubNavItem { SubNavItemId = 17, NavItemId = 4, Code = "procurement.requisitions", Label = "Requisitions", Href = "/dashboard/procurement/requisitions", SortOrder = 1 },
+            new SubNavItem { SubNavItemId = 18, NavItemId = 4, Code = "procurement.rfqs", Label = "RFQs", Href = "/dashboard/procurement/rfqs", SortOrder = 2 },
+            new SubNavItem { SubNavItemId = 19, NavItemId = 4, Code = "procurement.purchase-orders", Label = "Purchase Orders", Href = "/dashboard/procurement/purchase-orders", SortOrder = 3 },
+            new SubNavItem { SubNavItemId = 20, NavItemId = 4, Code = "procurement.purchase-returns", Label = "Purchase Returns", Href = "/dashboard/procurement/purchase-returns", SortOrder = 4 },
+            new SubNavItem { SubNavItemId = 9, NavItemId = 11, Code = "ledgers.trial-balance", Label = "Trial Balance", Href = "/dashboard/ledgers/trial-balance", SortOrder = 1 },
+            new SubNavItem { SubNavItemId = 10, NavItemId = 11, Code = "ledgers.balance-sheet", Label = "Balance Sheet", Href = "/dashboard/ledgers/balance-sheet", SortOrder = 2 },
+            new SubNavItem { SubNavItemId = 11, NavItemId = 11, Code = "ledgers.general-ledger", Label = "General Ledger", Href = "/dashboard/ledgers/general-ledger", SortOrder = 3 },
+            new SubNavItem { SubNavItemId = 12, NavItemId = 11, Code = "ledgers.profit-and-loss", Label = "Profit & Loss", Href = "/dashboard/ledgers/profit-and-loss", SortOrder = 4 },
+            new SubNavItem { SubNavItemId = 13, NavItemId = 11, Code = "ledgers.cash-flow", Label = "Cash Flow", Href = "/dashboard/ledgers/cash-flow", SortOrder = 5 },
+            new SubNavItem { SubNavItemId = 14, NavItemId = 11, Code = "ledgers.budget-vs-actual", Label = "Budget vs Actual", Href = "/dashboard/ledgers/budget-vs-actual", SortOrder = 6 },
+            new SubNavItem { SubNavItemId = 16, NavItemId = 11, Code = "ledgers.tax-report", Label = "Tax Report", Href = "/dashboard/ledgers/tax-report", SortOrder = 7 },
+            // Moved under the new Accounts nav item (2026-07-31) — kept the same SubNavItemId (15)
+            // rather than delete+recreate, so any role that already had this permission granted
+            // doesn't silently lose it just because the section it lives under changed.
+            new SubNavItem { SubNavItemId = 15, NavItemId = 12, Code = "accounts.bank-accounts", Label = "Cash / Bank Accounts", Href = "/dashboard/accounts/bank-accounts", SortOrder = 1 },
+            new SubNavItem { SubNavItemId = 21, NavItemId = 12, Code = "accounts.cheque-books", Label = "Cheque Books", Href = "/dashboard/accounts/cheque-books", SortOrder = 2 },
+            new SubNavItem { SubNavItemId = 22, NavItemId = 12, Code = "accounts.received-cheques", Label = "Received Cheques", Href = "/dashboard/accounts/received-cheques", SortOrder = 3 }
         );
     }
 }

Backend/ERPCore/Infra/Persistence/DataSeeder.cs

@@ -30,6 +30,12 @@ public static class DataSeeder
         ("WRONG", "Wrong Item", ReasonContext.Return),
         ("OVER", "Over-supply", ReasonContext.Return),
         ("QREJ", "Quality Reject", ReasonContext.Return),
+        // Manufacturing (docs/30 §A.2) — scrap at stage complete, leftover return before
+        // receipt, and the mandatory reason on a run cancel.
+        ("PRD-SCRAP", "Production Scrap", ReasonContext.Production),
+        ("PRD-LEFTOVER", "Production Leftover Return", ReasonContext.Production),
+        ("PRD-CANCEL", "Production Run Cancelled", ReasonContext.Production),
+        ("PRD-REWORK-LOSS", "Production Rework Loss", ReasonContext.Production),
     ];
 
     public static async Task SeedAsync(ErpDbContext db, CancellationToken ct = default)

Backend/ERPCore/Infra/Persistence/ErpDbContext.cs

@@ -22,6 +22,7 @@ public class ErpDbContext : DbContext
     }
 
     // --- Master Data (docs/10 Part C.1) ---
+    public DbSet<Customer> Customers => Set<Customer>();
     public DbSet<Category> Categories => Set<Category>();
     public DbSet<SubCategory> SubCategories => Set<SubCategory>();
     public DbSet<Brand> Brands => Set<Brand>();
@@ -82,6 +83,12 @@ public class ErpDbContext : DbContext
     public DbSet<PurchaseReturn> PurchaseReturns => Set<PurchaseReturn>();
     public DbSet<PurchaseReturnLine> PurchaseReturnLines => Set<PurchaseReturnLine>();
 
+    // --- Sales (Phase 1) ---
+    public DbSet<SalesInvoice> SalesInvoices => Set<SalesInvoice>();
+    public DbSet<SalesInvoiceLine> SalesInvoiceLines => Set<SalesInvoiceLine>();
+    public DbSet<SalesSlip> SalesSlips => Set<SalesSlip>();
+    public DbSet<SalesSlipLine> SalesSlipLines => Set<SalesSlipLine>();
+
     // --- Reference data (docs/10 Part C.7) ---
     public DbSet<ReasonCode> ReasonCodes => Set<ReasonCode>();
 
@@ -126,6 +133,21 @@ public class ErpDbContext : DbContext
     public DbSet<PayrollLineComponent> PayrollLineComponents => Set<PayrollLineComponent>();
     public DbSet<Payslip> Payslips => Set<Payslip>();
 
+    // --- Manufacturing: production templates (docs/30-BACKEND-PHASE2.md Part C) ---
+    public DbSet<ProductionTemplate> ProductionTemplates => Set<ProductionTemplate>();
+    public DbSet<TemplateStage> TemplateStages => Set<TemplateStage>();
+    public DbSet<StageEdge> StageEdges => Set<StageEdge>();
+    public DbSet<StageInput> StageInputs => Set<StageInput>();
+    public DbSet<StageOutput> StageOutputs => Set<StageOutput>();
+
+    // --- Manufacturing: production runs (docs/30-BACKEND-PHASE2.md Part C) ---
+    public DbSet<ProductionRun> ProductionRuns => Set<ProductionRun>();
+    public DbSet<RunStage> RunStages => Set<RunStage>();
+    public DbSet<RunEdge> RunEdges => Set<RunEdge>();
+    public DbSet<RunStageInput> RunStageInputs => Set<RunStageInput>();
+    public DbSet<RunStageOutput> RunStageOutputs => Set<RunStageOutput>();
+    public DbSet<RunStageEvent> RunStageEvents => Set<RunStageEvent>();
+
     protected override void OnModelCreating(ModelBuilder modelBuilder)
     {
         base.OnModelCreating(modelBuilder);

Backend/ERPCore/Infra/Persistence/Migrations/20260716134938_AddBrandsSubcategoriesItemTypesAndProductConfig.cs

@@ -1,442 +0,0 @@
-using System;
-using Microsoft.EntityFrameworkCore.Migrations;
-using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
-
-#nullable disable
-
-namespace ERPCore.Infra.Persistence.Migrations
-{
-    /// <summary>
-    /// Adds the Brand / SubCategory / ItemType masters and the singleton product config,
-    /// and converts CATEGORY from a self-nesting tree into a fixed two-level
-    /// Category → SubCategory hierarchy (docs/10 Part C.1).
-    /// <para>
-    /// <b>This migration carries data, not just DDL.</b> The scaffolded version dropped
-    /// <c>categories.ParentId</c> outright, which would have silently flattened every
-    /// child category into a root and left items pointing at what is now a top-level
-    /// category — losing the parent entirely. The hand-written steps below (marked
-    /// "data migration") move child categories into <c>subcategories</c> and repoint items
-    /// onto the correct (category, subcategory) pair before the column goes away.
-    /// </para>
-    /// </summary>
-    public partial class AddBrandsSubcategoriesItemTypesAndProductConfig : Migration
-    {
-        /// <inheritdoc />
-        protected override void Up(MigrationBuilder migrationBuilder)
-        {
-            // NOTE: the ParentId drop is deliberately deferred to the bottom of this method —
-            // the data migration reads it. Order here is load-bearing.
-            migrationBuilder.RenameColumn(
-                name: "ItemType",
-                table: "items",
-                newName: "StockNature");
-
-            migrationBuilder.AddColumn<int>(
-                name: "BrandId",
-                table: "items",
-                type: "integer",
-                nullable: true);
-
-            migrationBuilder.AddColumn<int>(
-                name: "SubCategoryId",
-                table: "items",
-                type: "integer",
-                nullable: true);
-
-            migrationBuilder.AddColumn<DateTime>(
-                name: "CreatedAt",
-                table: "categories",
-                type: "timestamp with time zone",
-                nullable: false,
-                defaultValue: new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified));
-
-            migrationBuilder.AddColumn<string>(
-                name: "Status",
-                table: "categories",
-                type: "character varying(20)",
-                maxLength: 20,
-                nullable: false,
-                defaultValue: "Active");
-
-            migrationBuilder.AddColumn<DateTime>(
-                name: "UpdatedAt",
-                table: "categories",
-                type: "timestamp with time zone",
-                nullable: true);
-
-            migrationBuilder.AddColumn<uint>(
-                name: "xmin",
-                table: "categories",
-                type: "xid",
-                rowVersion: true,
-                nullable: false,
-                defaultValue: 0u);
-
-            migrationBuilder.CreateTable(
-                name: "brands",
-                columns: table => new
-                {
-                    BrandId = table.Column<int>(type: "integer", nullable: false)
-                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
-                    Name = table.Column<string>(type: "character varying(200)", maxLength: 200, nullable: false),
-                    Status = table.Column<string>(type: "character varying(20)", maxLength: 20, nullable: false, defaultValue: "Active"),
-                    CreatedAt = table.Column<DateTime>(type: "timestamp with time zone", nullable: false),
-                    UpdatedAt = table.Column<DateTime>(type: "timestamp with time zone", nullable: true),
-                    xmin = table.Column<uint>(type: "xid", rowVersion: true, nullable: false)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_brands", x => x.BrandId);
-                });
-
-            migrationBuilder.CreateTable(
-                name: "item_types",
-                columns: table => new
-                {
-                    ItemTypeId = table.Column<int>(type: "integer", nullable: false)
-                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
-                    Name = table.Column<string>(type: "character varying(200)", maxLength: 200, nullable: false),
-                    Status = table.Column<string>(type: "character varying(20)", maxLength: 20, nullable: false, defaultValue: "Active"),
-                    CreatedAt = table.Column<DateTime>(type: "timestamp with time zone", nullable: false),
-                    UpdatedAt = table.Column<DateTime>(type: "timestamp with time zone", nullable: true),
-                    xmin = table.Column<uint>(type: "xid", rowVersion: true, nullable: false)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_item_types", x => x.ItemTypeId);
-                });
-
-            migrationBuilder.CreateTable(
-                name: "product_config",
-                columns: table => new
-                {
-                    ConfigId = table.Column<int>(type: "integer", nullable: false),
-                    SubcategoriesEnabled = table.Column<bool>(type: "boolean", nullable: false, defaultValue: true),
-                    BrandsEnabled = table.Column<bool>(type: "boolean", nullable: false, defaultValue: true),
-                    ItemTypesEnabled = table.Column<bool>(type: "boolean", nullable: false, defaultValue: true),
-                    UpdatedAt = table.Column<DateTime>(type: "timestamp with time zone", nullable: true),
-                    UpdatedBy = table.Column<int>(type: "integer", nullable: true),
-                    xmin = table.Column<uint>(type: "xid", rowVersion: true, nullable: false)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_product_config", x => x.ConfigId);
-                    table.CheckConstraint("ck_product_config_singleton", "\"ConfigId\" = 1");
-                    table.ForeignKey(
-                        name: "FK_product_config_users_UpdatedBy",
-                        column: x => x.UpdatedBy,
-                        principalTable: "users",
-                        principalColumn: "UserId",
-                        onDelete: ReferentialAction.Restrict);
-                });
-
-            migrationBuilder.CreateTable(
-                name: "subcategories",
-                columns: table => new
-                {
-                    SubCategoryId = table.Column<int>(type: "integer", nullable: false)
-                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
-                    Name = table.Column<string>(type: "character varying(200)", maxLength: 200, nullable: false),
-                    CategoryId = table.Column<int>(type: "integer", nullable: false),
-                    Status = table.Column<string>(type: "character varying(20)", maxLength: 20, nullable: false, defaultValue: "Active"),
-                    CreatedAt = table.Column<DateTime>(type: "timestamp with time zone", nullable: false),
-                    UpdatedAt = table.Column<DateTime>(type: "timestamp with time zone", nullable: true),
-                    xmin = table.Column<uint>(type: "xid", rowVersion: true, nullable: false)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_subcategories", x => x.SubCategoryId);
-                    table.ForeignKey(
-                        name: "FK_subcategories_categories_CategoryId",
-                        column: x => x.CategoryId,
-                        principalTable: "categories",
-                        principalColumn: "CategoryId",
-                        onDelete: ReferentialAction.Restrict);
-                });
-
-            // ---------------------------------------------------------------------------
-            // DATA MIGRATION — must run before ParentId is dropped.
-            // ---------------------------------------------------------------------------
-
-            // Existing categories predate CreatedAt; the added column defaulted them to
-            // 0001-01-01. Stamp them with the migration time instead of a sentinel date.
-            migrationBuilder.Sql(@"
-                UPDATE categories SET ""CreatedAt"" = NOW() AT TIME ZONE 'utc';
-            ");
-
-            // Carry the old category id alongside each new subcategory so items can be
-            // repointed by join below. Dropped again once the repoint is done.
-            migrationBuilder.Sql(@"
-                ALTER TABLE subcategories ADD COLUMN legacy_category_id integer;
-            ");
-
-            // Walk the old tree to its roots. The previous model allowed unlimited nesting,
-            // but the new one is exactly two levels — so a category at any depth below the
-            // root collapses into a subcategory of its ROOT ancestor (a grandchild cannot
-            // become a subcategory of its immediate parent, since that parent is itself
-            // ceasing to be a category).
-            migrationBuilder.Sql(@"
-                WITH RECURSIVE tree AS (
-                    SELECT ""CategoryId"", ""ParentId"", ""Name"", ""CategoryId"" AS root_id
-                    FROM categories
-                    WHERE ""ParentId"" IS NULL
-                    UNION ALL
-                    SELECT c.""CategoryId"", c.""ParentId"", c.""Name"", t.root_id
-                    FROM categories c
-                    JOIN tree t ON c.""ParentId"" = t.""CategoryId""
-                )
-                INSERT INTO subcategories (""Name"", ""CategoryId"", ""Status"", ""CreatedAt"", legacy_category_id)
-                SELECT t.""Name"", t.root_id, 'Active', NOW() AT TIME ZONE 'utc', t.""CategoryId""
-                FROM tree t
-                WHERE t.""ParentId"" IS NOT NULL;
-            ");
-
-            // Repoint items: an item that pointed at a child category now carries the root
-            // category plus the subcategory it actually meant.
-            migrationBuilder.Sql(@"
-                UPDATE items i
-                SET ""SubCategoryId"" = s.""SubCategoryId"",
-                    ""CategoryId""    = s.""CategoryId""
-                FROM subcategories s
-                WHERE s.legacy_category_id = i.""CategoryId"";
-            ");
-
-            // The self-FK must go before the delete, or RESTRICT rejects removing a parent
-            // whose own child row is still present.
-            migrationBuilder.DropForeignKey(
-                name: "FK_categories_categories_ParentId",
-                table: "categories");
-
-            // Every non-root category now lives in `subcategories`, and no item references
-            // one any more (repointed above), so the rows can go.
-            migrationBuilder.Sql(@"
-                DELETE FROM categories WHERE ""ParentId"" IS NOT NULL;
-                ALTER TABLE subcategories DROP COLUMN legacy_category_id;
-            ");
-
-            migrationBuilder.DropIndex(
-                name: "IX_categories_ParentId",
-                table: "categories");
-
-            migrationBuilder.DropColumn(
-                name: "ParentId",
-                table: "categories");
-
-            // Seed the singleton config (FR-MD-11) — all features on. Item writes read this
-            // row, so it must exist before the app serves a single request.
-            migrationBuilder.Sql(@"
-                INSERT INTO product_config (""ConfigId"", ""SubcategoriesEnabled"", ""BrandsEnabled"", ""ItemTypesEnabled"")
-                VALUES (1, TRUE, TRUE, TRUE)
-                ON CONFLICT (""ConfigId"") DO NOTHING;
-            ");
-
-            // ---------------------------------------------------------------------------
-
-            migrationBuilder.CreateIndex(
-                name: "IX_items_BrandId",
-                table: "items",
-                column: "BrandId");
-
-            migrationBuilder.CreateIndex(
-                name: "IX_items_SubCategoryId",
-                table: "items",
-                column: "SubCategoryId");
-
-            migrationBuilder.CreateIndex(
-                name: "IX_categories_Name",
-                table: "categories",
-                column: "Name",
-                unique: true);
-
-            migrationBuilder.CreateIndex(
-                name: "IX_categories_Status",
-                table: "categories",
-                column: "Status");
-
-            migrationBuilder.CreateIndex(
-                name: "IX_brands_Name",
-                table: "brands",
-                column: "Name",
-                unique: true);
-
-            migrationBuilder.CreateIndex(
-                name: "IX_brands_Status",
-                table: "brands",
-                column: "Status");
-
-            migrationBuilder.CreateIndex(
-                name: "IX_item_types_Name",
-                table: "item_types",
-                column: "Name",
-                unique: true);
-
-            migrationBuilder.CreateIndex(
-                name: "IX_item_types_Status",
-                table: "item_types",
-                column: "Status");
-
-            migrationBuilder.CreateIndex(
-                name: "IX_product_config_UpdatedBy",
-                table: "product_config",
-                column: "UpdatedBy");
-
-            migrationBuilder.CreateIndex(
-                name: "IX_subcategories_CategoryId_Name",
-                table: "subcategories",
-                columns: new[] { "CategoryId", "Name" },
-                unique: true);
-
-            migrationBuilder.CreateIndex(
-                name: "IX_subcategories_Status",
-                table: "subcategories",
-                column: "Status");
-
-            migrationBuilder.AddForeignKey(
-                name: "FK_items_brands_BrandId",
-                table: "items",
-                column: "BrandId",
-                principalTable: "brands",
-                principalColumn: "BrandId",
-                onDelete: ReferentialAction.Restrict);
-
-            migrationBuilder.AddForeignKey(
-                name: "FK_items_subcategories_SubCategoryId",
-                table: "items",
-                column: "SubCategoryId",
-                principalTable: "subcategories",
-                principalColumn: "SubCategoryId",
-                onDelete: ReferentialAction.Restrict);
-        }
-
-        /// <summary>
-        /// Reverses the schema change and puts the subcategory data back where it came from.
-        /// <para>
-        /// The scaffolded version simply dropped <c>subcategories</c>, which would have
-        /// discarded exactly what <see cref="Up"/> preserved. Instead each subcategory is
-        /// restored as a child category and its items are repointed back onto it. This is
-        /// not perfectly lossless: the old tree's depth is gone (a former grandchild comes
-        /// back as a direct child of its root), and Brand data cannot survive a schema that
-        /// has nowhere to put it.
-        /// </para>
-        /// </summary>
-        protected override void Down(MigrationBuilder migrationBuilder)
-        {
-            migrationBuilder.DropForeignKey(
-                name: "FK_items_brands_BrandId",
-                table: "items");
-
-            migrationBuilder.DropForeignKey(
-                name: "FK_items_subcategories_SubCategoryId",
-                table: "items");
-
-            // Restore the parent column + self-FK first so subcategories have somewhere to
-            // land, then move them back before the table is dropped.
-            migrationBuilder.AddColumn<int>(
-                name: "ParentId",
-                table: "categories",
-                type: "integer",
-                nullable: true);
-
-            // ---------------------------------------------------------------------------
-            // DATA MIGRATION (reverse) — must run before `subcategories` is dropped.
-            // ---------------------------------------------------------------------------
-
-            migrationBuilder.Sql(@"
-                ALTER TABLE categories ADD COLUMN legacy_subcategory_id integer;
-            ");
-
-            // Each subcategory becomes a child category again under the same parent.
-            migrationBuilder.Sql(@"
-                INSERT INTO categories (""Name"", ""ParentId"", ""CreatedAt"", ""Status"", legacy_subcategory_id)
-                SELECT s.""Name"", s.""CategoryId"", s.""CreatedAt"", s.""Status"", s.""SubCategoryId""
-                FROM subcategories s;
-            ");
-
-            // Items that carried a subcategory point back at the restored child category.
-            migrationBuilder.Sql(@"
-                UPDATE items i
-                SET ""CategoryId"" = c.""CategoryId""
-                FROM categories c
-                WHERE c.legacy_subcategory_id = i.""SubCategoryId"";
-            ");
-
-            migrationBuilder.Sql(@"
-                ALTER TABLE categories DROP COLUMN legacy_subcategory_id;
-            ");
-
-            // ---------------------------------------------------------------------------
-
-            migrationBuilder.DropTable(
-                name: "brands");
-
-            migrationBuilder.DropTable(
-                name: "item_types");
-
-            migrationBuilder.DropTable(
-                name: "product_config");
-
-            migrationBuilder.DropTable(
-                name: "subcategories");
-
-            migrationBuilder.DropIndex(
-                name: "IX_items_BrandId",
-                table: "items");
-
-            migrationBuilder.DropIndex(
-                name: "IX_items_SubCategoryId",
-                table: "items");
-
-            migrationBuilder.DropIndex(
-                name: "IX_categories_Name",
-                table: "categories");
-
-            migrationBuilder.DropIndex(
-                name: "IX_categories_Status",
-                table: "categories");
-
-            migrationBuilder.DropColumn(
-                name: "BrandId",
-                table: "items");
-
-            migrationBuilder.DropColumn(
-                name: "SubCategoryId",
-                table: "items");
-
-            migrationBuilder.DropColumn(
-                name: "CreatedAt",
-                table: "categories");
-
-            migrationBuilder.DropColumn(
-                name: "Status",
-                table: "categories");
-
-            migrationBuilder.DropColumn(
-                name: "UpdatedAt",
-                table: "categories");
-
-            migrationBuilder.DropColumn(
-                name: "xmin",
-                table: "categories");
-
-            migrationBuilder.RenameColumn(
-                name: "StockNature",
-                table: "items",
-                newName: "ItemType");
-
-            // ParentId itself was re-added at the top of this method, ahead of the reverse
-            // data migration that populates it.
-            migrationBuilder.CreateIndex(
-                name: "IX_categories_ParentId",
-                table: "categories",
-                column: "ParentId");
-
-            migrationBuilder.AddForeignKey(
-                name: "FK_categories_categories_ParentId",
-                table: "categories",
-                column: "ParentId",
-                principalTable: "categories",
-                principalColumn: "CategoryId",
-                onDelete: ReferentialAction.Restrict);
-        }
-    }
-}

Backend/ERPCore/Infra/Persistence/Migrations/20260718081219_ini2.cs

@@ -1,22 +0,0 @@
-using Microsoft.EntityFrameworkCore.Migrations;
-
-#nullable disable
-
-namespace ERPCore.Infra.Persistence.Migrations
-{
-    /// <inheritdoc />
-    public partial class ini2 : Migration
-    {
-        /// <inheritdoc />
-        protected override void Up(MigrationBuilder migrationBuilder)
-        {
-
-        }
-
-        /// <inheritdoc />
-        protected override void Down(MigrationBuilder migrationBuilder)
-        {
-
-        }
-    }
-}

Backend/ERPCore/Infra/Persistence/Migrations/20260718092655_AddRolesNavPermissions.cs

@@ -1,303 +0,0 @@
-using System;
-using Microsoft.EntityFrameworkCore.Migrations;
-using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
-
-#nullable disable
-
-#pragma warning disable CA1814 // Prefer jagged arrays over multidimensional
-
-namespace ERPCore.Infra.Persistence.Migrations
-{
-    /// <inheritdoc />
-    public partial class AddRolesNavPermissions : Migration
-    {
-        /// <inheritdoc />
-        protected override void Up(MigrationBuilder migrationBuilder)
-        {
-            migrationBuilder.AddColumn<int>(
-                name: "RoleId",
-                table: "users",
-                type: "integer",
-                nullable: true);
-
-            migrationBuilder.CreateTable(
-                name: "nav_items",
-                columns: table => new
-                {
-                    NavItemId = table.Column<int>(type: "integer", nullable: false)
-                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
-                    Code = table.Column<string>(type: "character varying(50)", maxLength: 50, nullable: false),
-                    Label = table.Column<string>(type: "character varying(100)", maxLength: 100, nullable: false),
-                    Icon = table.Column<string>(type: "character varying(50)", maxLength: 50, nullable: true),
-                    Href = table.Column<string>(type: "character varying(200)", maxLength: 200, nullable: true),
-                    SortOrder = table.Column<int>(type: "integer", nullable: false),
-                    Status = table.Column<string>(type: "character varying(20)", maxLength: 20, nullable: false, defaultValue: "Active")
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_nav_items", x => x.NavItemId);
-                });
-
-            migrationBuilder.CreateTable(
-                name: "roles",
-                columns: table => new
-                {
-                    RoleId = table.Column<int>(type: "integer", nullable: false)
-                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
-                    auth_role_id = table.Column<Guid>(type: "uuid", nullable: false),
-                    Code = table.Column<string>(type: "character varying(50)", maxLength: 50, nullable: false),
-                    Name = table.Column<string>(type: "character varying(200)", maxLength: 200, nullable: false),
-                    IsSystemRole = table.Column<bool>(type: "boolean", nullable: false, defaultValue: false),
-                    Status = table.Column<string>(type: "character varying(20)", maxLength: 20, nullable: false, defaultValue: "Active"),
-                    CreatedAt = table.Column<DateTime>(type: "timestamp with time zone", nullable: false),
-                    UpdatedAt = table.Column<DateTime>(type: "timestamp with time zone", nullable: true),
-                    xmin = table.Column<uint>(type: "xid", rowVersion: true, nullable: false)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_roles", x => x.RoleId);
-                });
-
-            migrationBuilder.CreateTable(
-                name: "sub_nav_items",
-                columns: table => new
-                {
-                    SubNavItemId = table.Column<int>(type: "integer", nullable: false)
-                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
-                    NavItemId = table.Column<int>(type: "integer", nullable: false),
-                    Code = table.Column<string>(type: "character varying(50)", maxLength: 50, nullable: false),
-                    Label = table.Column<string>(type: "character varying(100)", maxLength: 100, nullable: false),
-                    Icon = table.Column<string>(type: "character varying(50)", maxLength: 50, nullable: true),
-                    Href = table.Column<string>(type: "character varying(200)", maxLength: 200, nullable: true),
-                    SortOrder = table.Column<int>(type: "integer", nullable: false),
-                    Status = table.Column<string>(type: "character varying(20)", maxLength: 20, nullable: false, defaultValue: "Active")
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_sub_nav_items", x => x.SubNavItemId);
-                    table.ForeignKey(
-                        name: "FK_sub_nav_items_nav_items_NavItemId",
-                        column: x => x.NavItemId,
-                        principalTable: "nav_items",
-                        principalColumn: "NavItemId",
-                        onDelete: ReferentialAction.Cascade);
-                });
-
-            migrationBuilder.CreateTable(
-                name: "permissions",
-                columns: table => new
-                {
-                    PermissionId = table.Column<int>(type: "integer", nullable: false)
-                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
-                    Code = table.Column<string>(type: "character varying(80)", maxLength: 80, nullable: false),
-                    NavItemId = table.Column<int>(type: "integer", nullable: true),
-                    SubNavItemId = table.Column<int>(type: "integer", nullable: true)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_permissions", x => x.PermissionId);
-                    table.ForeignKey(
-                        name: "FK_permissions_nav_items_NavItemId",
-                        column: x => x.NavItemId,
-                        principalTable: "nav_items",
-                        principalColumn: "NavItemId",
-                        onDelete: ReferentialAction.Cascade);
-                    table.ForeignKey(
-                        name: "FK_permissions_sub_nav_items_SubNavItemId",
-                        column: x => x.SubNavItemId,
-                        principalTable: "sub_nav_items",
-                        principalColumn: "SubNavItemId",
-                        onDelete: ReferentialAction.Cascade);
-                });
-
-            migrationBuilder.CreateTable(
-                name: "role_permissions",
-                columns: table => new
-                {
-                    RoleId = table.Column<int>(type: "integer", nullable: false),
-                    PermissionId = table.Column<int>(type: "integer", nullable: false)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_role_permissions", x => new { x.RoleId, x.PermissionId });
-                    table.ForeignKey(
-                        name: "FK_role_permissions_permissions_PermissionId",
-                        column: x => x.PermissionId,
-                        principalTable: "permissions",
-                        principalColumn: "PermissionId",
-                        onDelete: ReferentialAction.Cascade);
-                    table.ForeignKey(
-                        name: "FK_role_permissions_roles_RoleId",
-                        column: x => x.RoleId,
-                        principalTable: "roles",
-                        principalColumn: "RoleId",
-                        onDelete: ReferentialAction.Cascade);
-                });
-
-            migrationBuilder.InsertData(
-                table: "nav_items",
-                columns: new[] { "NavItemId", "Code", "Href", "Icon", "Label", "SortOrder" },
-                values: new object[,]
-                {
-                    { 1, "dashboard", "/dashboard", null, "Dashboard", 1 },
-                    { 2, "products", "/dashboard/products", null, "Products", 2 },
-                    { 3, "vendors", "/dashboard/vendors", null, "Vendors", 3 },
-                    { 4, "procurement", "/dashboard/procurement", null, "Procurement", 4 },
-                    { 5, "receiving", "/dashboard/receiving/grn", null, "Receiving", 5 },
-                    { 6, "stock", "/dashboard/stock", null, "Stock", 6 },
-                    { 7, "warehouses", "/dashboard/warehouse", null, "Warehouses", 7 },
-                    { 8, "orders", "/dashboard/orders", null, "Orders", 8 },
-                    { 9, "settings", "/dashboard/settings", null, "Settings", 9 },
-                    { 10, "help", "/dashboard/help", null, "Help", 10 }
-                });
-
-            migrationBuilder.UpdateData(
-                table: "users",
-                keyColumn: "UserId",
-                keyValue: 1,
-                column: "RoleId",
-                value: null);
-
-            migrationBuilder.InsertData(
-                table: "permissions",
-                columns: new[] { "PermissionId", "Code", "NavItemId", "SubNavItemId" },
-                values: new object[,]
-                {
-                    { 1, "NAV:dashboard", 1, null },
-                    { 2, "NAV:products", 2, null },
-                    { 3, "NAV:vendors", 3, null },
-                    { 4, "NAV:procurement", 4, null },
-                    { 5, "NAV:receiving", 5, null },
-                    { 6, "NAV:stock", 6, null },
-                    { 7, "NAV:warehouses", 7, null },
-                    { 8, "NAV:orders", 8, null },
-                    { 9, "NAV:settings", 9, null },
-                    { 10, "NAV:help", 10, null }
-                });
-
-            migrationBuilder.InsertData(
-                table: "sub_nav_items",
-                columns: new[] { "SubNavItemId", "Code", "Href", "Icon", "Label", "NavItemId", "SortOrder" },
-                values: new object[,]
-                {
-                    { 1, "products.item", "/dashboard/products", null, "Item", 2, 1 },
-                    { 2, "products.category", "/dashboard/products/categories", null, "Category", 2, 2 },
-                    { 3, "products.brand", "/dashboard/products/brands", null, "Brand", 2, 3 },
-                    { 4, "products.item-type", "/dashboard/products/item-types", null, "Item Type", 2, 4 },
-                    { 5, "products.uom", "/dashboard/products/uoms", null, "UOM", 2, 5 },
-                    { 6, "products.configuration", "/dashboard/products/settings", null, "Configuration", 2, 6 },
-                    { 7, "settings.roles", "/dashboard/settings/roles", null, "Roles", 9, 1 },
-                    { 8, "settings.users", "/dashboard/settings/users", null, "Users", 9, 2 }
-                });
-
-            migrationBuilder.InsertData(
-                table: "permissions",
-                columns: new[] { "PermissionId", "Code", "NavItemId", "SubNavItemId" },
-                values: new object[,]
-                {
-                    { 11, "NAV:products.item", null, 1 },
-                    { 12, "NAV:products.category", null, 2 },
-                    { 13, "NAV:products.brand", null, 3 },
-                    { 14, "NAV:products.item-type", null, 4 },
-                    { 15, "NAV:products.uom", null, 5 },
-                    { 16, "NAV:products.configuration", null, 6 },
-                    { 17, "NAV:settings.roles", null, 7 },
-                    { 18, "NAV:settings.users", null, 8 }
-                });
-
-            migrationBuilder.CreateIndex(
-                name: "IX_users_RoleId",
-                table: "users",
-                column: "RoleId");
-
-            migrationBuilder.CreateIndex(
-                name: "IX_nav_items_Code",
-                table: "nav_items",
-                column: "Code",
-                unique: true);
-
-            migrationBuilder.CreateIndex(
-                name: "IX_permissions_Code",
-                table: "permissions",
-                column: "Code",
-                unique: true);
-
-            migrationBuilder.CreateIndex(
-                name: "IX_permissions_NavItemId",
-                table: "permissions",
-                column: "NavItemId");
-
-            migrationBuilder.CreateIndex(
-                name: "IX_permissions_SubNavItemId",
-                table: "permissions",
-                column: "SubNavItemId");
-
-            migrationBuilder.CreateIndex(
-                name: "IX_role_permissions_PermissionId",
-                table: "role_permissions",
-                column: "PermissionId");
-
-            migrationBuilder.CreateIndex(
-                name: "IX_roles_auth_role_id",
-                table: "roles",
-                column: "auth_role_id",
-                unique: true);
-
-            migrationBuilder.CreateIndex(
-                name: "IX_roles_Code",
-                table: "roles",
-                column: "Code",
-                unique: true);
-
-            migrationBuilder.CreateIndex(
-                name: "IX_sub_nav_items_Code",
-                table: "sub_nav_items",
-                column: "Code",
-                unique: true);
-
-            migrationBuilder.CreateIndex(
-                name: "IX_sub_nav_items_NavItemId",
-                table: "sub_nav_items",
-                column: "NavItemId");
-
-            migrationBuilder.AddForeignKey(
-                name: "FK_users_roles_RoleId",
-                table: "users",
-                column: "RoleId",
-                principalTable: "roles",
-                principalColumn: "RoleId",
-                onDelete: ReferentialAction.Restrict);
-        }
-
-        /// <inheritdoc />
-        protected override void Down(MigrationBuilder migrationBuilder)
-        {
-            migrationBuilder.DropForeignKey(
-                name: "FK_users_roles_RoleId",
-                table: "users");
-
-            migrationBuilder.DropTable(
-                name: "role_permissions");
-
-            migrationBuilder.DropTable(
-                name: "permissions");
-
-            migrationBuilder.DropTable(
-                name: "roles");
-
-            migrationBuilder.DropTable(
-                name: "sub_nav_items");
-
-            migrationBuilder.DropTable(
-                name: "nav_items");
-
-            migrationBuilder.DropIndex(
-                name: "IX_users_RoleId",
-                table: "users");
-
-            migrationBuilder.DropColumn(
-                name: "RoleId",
-                table: "users");
-        }
-    }
-}

Backend/ERPCore/Program.cs

@@ -1,15 +1,18 @@
 using System.Text.Json.Serialization;
 using ERPCore.Infra.Auth;
 using ERPCore.Infra.Auth.AuthHex;
+using ERPCore.Infra.Gl;
 using ERPCore.Infra.Persistence;
 using ERPCore.Infra.Storage;
 using ERPCore.Infra.UoW;
 using ERPCore.Repositories;
 using ERPCore.Repositories.Interfaces;
 using ERPCore.Services;
+using ERPCore.Services.Interfaces;
 using ERPCore.Services.Auth;
 using ERPCore.Services.Hrm;
 using ERPCore.Services.Interfaces;
+using ERPCore.Services.Production;
 using ERPCore.Services.Stock;
 using ERPCore.System.Errors;
 using Microsoft.AspNetCore.Authentication;
@@ -50,6 +53,15 @@ builder.Services.AddScoped<IAuthUserService, AuthUserService>();
 builder.Services.AddScoped<IAuthRecoveryService, AuthRecoveryService>();
 builder.Services.AddScoped<IAuthAltService, AuthAltService>();
 
+// General Ledger service proxy → external GL microservice (docs/12-GENERAL-LEDGER-INTEGRATION.md)
+builder.Services.AddHttpClient<IGeneralLedgerClient, GeneralLedgerClient>(c =>
+{
+    var baseUrl = builder.Configuration["GeneralLedgerService:BaseUrl"]
+        ?? throw new InvalidOperationException("GeneralLedgerService:BaseUrl is not configured.");
+    c.BaseAddress = new Uri(baseUrl);
+});
+builder.Services.AddScoped<IGeneralLedgerService, GeneralLedgerService>();
+
 // Current-user (audit actor). AuthHex has no sub/nameid → a claims transformation
 // JIT-provisions a local shadow user and injects the local `int` id as `nameid`.
 builder.Services.AddHttpContextAccessor();
@@ -61,6 +73,7 @@ builder.Services.AddScoped<IUnitOfWork, UnitOfWork>();
 builder.Services.AddScoped(typeof(IRepository<>), typeof(Repository<>));
 
 // Master-data services (docs/11 §2)
+builder.Services.AddScoped<ICustomerService, CustomerService>();
 builder.Services.AddScoped<IItemService, ItemService>();
 builder.Services.AddScoped<IUomService, UomService>();
 builder.Services.AddScoped<ICategoryService, CategoryService>();
@@ -81,10 +94,17 @@ builder.Services.AddScoped<IRfqService, RfqService>();
 builder.Services.AddScoped<IPurchaseOrderService, PurchaseOrderService>();
 
 // Stock core + goods receipt (docs/11 §4–5)
+builder.Services.AddScoped<IUomConverter, UomConverter>();
 builder.Services.AddScoped<IFifoCostingService, FifoCostingService>();
 builder.Services.AddScoped<IStockService, StockService>();
 builder.Services.AddScoped<IGrnService, GrnService>();
 
+// Sales (Phase 1)
+builder.Services.AddScoped<ISalesPricingService, SalesPricingService>();
+builder.Services.AddScoped<ISalesInvoiceService, SalesInvoiceService>();
+builder.Services.AddScoped<ISalesSlipService, SalesSlipService>();
+builder.Services.AddScoped<ISalesReportService, SalesReportService>();
+
 // Stock transactions + reference data (docs/11 §5–6)
 builder.Services.AddScoped<IStockMutator, StockMutator>();
 builder.Services.AddScoped<IReasonCodeService, ReasonCodeService>();
@@ -97,6 +117,9 @@ builder.Services.AddScoped<IPurchaseReturnService, PurchaseReturnService>();
 // Cross-cutting: audit trail + GL-ready journal read access (docs/11 §6 / FR-X-02, FR-STK-13)
 builder.Services.AddScoped<IAuditService, AuditService>();
 
+// Dashboard aggregate stats (cross-domain read: stock, GRN, procurement)
+builder.Services.AddScoped<IDashboardService, DashboardService>();
+
 // HRM (docs/13-BACKEND-HRM-API.md): org masters, employee core, staff documents
 builder.Services.AddSingleton<IFileStorageService, LocalFileStorageService>();
 builder.Services.AddScoped<IBranchService, BranchService>();
@@ -133,12 +156,22 @@ builder.Services.AddScoped<IPayslipService, PayslipService>();
 // HRM: Reports (docs/13-BACKEND-HRM-API.md §6) — read-only, no new entities
 builder.Services.AddScoped<IHrReportService, HrReportService>();
 
+// Manufacturing / Production Lines (docs/30-BACKEND-PHASE2.md Part A). Templates stand
+// alone; runs consume FifoCostingService for all stock movement. ProductionGraphValidator
+// is deliberately unregistered — it is a pure static algorithm, not an injected service.
+builder.Services.AddScoped<IProductionTemplateService, ProductionTemplateService>();
+builder.Services.AddScoped<IProductionRunService, ProductionRunService>();
+
 // Health checks (EF Core DB)
 builder.Services.AddHealthChecks().AddDbContextCheck<ErpDbContext>();
 
 // Swagger / OpenAPI (Swashbuckle v10 → OpenAPI 3.1)
 builder.Services.AddEndpointsApiExplorer();
-builder.Services.AddSwaggerGen(o => o.SwaggerDoc("v1", new OpenApiInfo { Title = "ERPCore API", Version = "v1" }));
+builder.Services.AddSwaggerGen(o =>
+{
+    o.SwaggerDoc("v1", new OpenApiInfo { Title = "ERPCore API", Version = "v1" });
+    o.CustomSchemaIds(t => t.FullName!.Replace("+", "."));
+});
 
 var app = builder.Build();
 

Backend/ERPCore/Services/CustomerService.cs

@@ -0,0 +1,168 @@
+using ERPCore.Common.Http;
+using ERPCore.Domain.Entities;
+using ERPCore.Domain.Enums;
+using ERPCore.Dtos.Common;
+using ERPCore.Dtos.Customers;
+using ERPCore.Infra.UoW;
+using ERPCore.Repositories.Interfaces;
+using ERPCore.Services.Interfaces;
+using ERPCore.System.Errors;
+using Microsoft.EntityFrameworkCore;
+
+namespace ERPCore.Services;
+
+public sealed class CustomerService : ICustomerService
+{
+    private readonly IRepository<Customer> _customers;
+    private readonly IRepository<Warehouse> _warehouses;
+    private readonly IUnitOfWork _uow;
+
+    public CustomerService(IRepository<Customer> customers, IRepository<Warehouse> warehouses, IUnitOfWork uow)
+    {
+        _customers = customers;
+        _warehouses = warehouses;
+        _uow = uow;
+    }
+
+    public async Task<PagedResponse<CustomerDto>> ListAsync(PageQuery query, EntityStatus? status, CustomerType? customerType, CancellationToken ct = default)
+    {
+        var q = _customers.Query().AsNoTracking();
+        if (!string.IsNullOrWhiteSpace(query.Q))
+        {
+            var term = query.Q.Trim();
+            q = q.Where(c => EF.Functions.ILike(c.Name, $"%{term}%")
+                             || EF.Functions.ILike(c.CustomerCode, $"%{term}%")
+                             || (c.DisplayName != null && EF.Functions.ILike(c.DisplayName, $"%{term}%")));
+        }
+        if (status is not null) q = q.Where(c => c.Status == status);
+        if (customerType is not null) q = q.Where(c => c.CustomerType == customerType);
+
+        var total = await q.CountAsync(ct);
+        var rows = await q.OrderBy(c => c.Name)
+            .Skip(query.Skip).Take(query.PageSize)
+            .Select(c => new CustomerDto(
+                c.CustomerId, c.CustomerCode, c.CustomerType, c.Name, c.DisplayName, c.Phone, c.Email,
+                c.AddressLine1, c.AddressLine2, c.City, c.Country, c.TaxRegistrationNo,
+                c.CreditLimit, c.CreditDays, c.DefaultWarehouseId, c.Status, c.CreatedAt, c.UpdatedAt))
+            .ToListAsync(ct);
+
+        return PagedResponse<CustomerDto>.Create(rows, query.Page, query.PageSize, total);
+    }
+
+    public async Task<ETagged<CustomerDto>?> GetAsync(int customerId, CancellationToken ct = default)
+    {
+        var customer = await _customers.Query().AsNoTracking()
+            .FirstOrDefaultAsync(c => c.CustomerId == customerId, ct);
+        return customer is null ? null : new ETagged<CustomerDto>(Map(customer), customer.RowVersion);
+    }
+
+    public async Task<ETagged<CustomerDto>> CreateAsync(CreateCustomerRequest request, CancellationToken ct = default)
+    {
+        var code = request.CustomerCode.Trim();
+        var name = request.Name.Trim();
+
+        if (await _customers.Query().AnyAsync(c => c.CustomerCode.ToLower() == code.ToLower(), ct))
+            throw new ConflictException($"A customer code '{code}' already exists.");
+
+        if (!string.IsNullOrWhiteSpace(request.Email))
+        {
+            var email = request.Email.Trim();
+            if (await _customers.Query().AnyAsync(c => c.Email != null && c.Email.ToLower() == email.ToLower(), ct))
+                throw new ConflictException($"A customer with email '{email}' already exists.");
+        }
+
+        if (request.DefaultWarehouseId is not null)
+        {
+            var exists = await _warehouses.Query().AnyAsync(w => w.WarehouseId == request.DefaultWarehouseId, ct);
+            if (!exists) throw new NotFoundException($"Warehouse {request.DefaultWarehouseId} was not found.");
+        }
+
+        var customer = new Customer
+        {
+            CustomerCode = code,
+            CustomerType = request.CustomerType,
+            Name = name,
+            DisplayName = Normalize(request.DisplayName),
+            Phone = Normalize(request.Phone),
+            Email = Normalize(request.Email),
+            AddressLine1 = Normalize(request.AddressLine1),
+            AddressLine2 = Normalize(request.AddressLine2),
+            City = Normalize(request.City),
+            Country = Normalize(request.Country),
+            TaxRegistrationNo = Normalize(request.TaxRegistrationNo),
+            CreditLimit = request.CreditLimit,
+            CreditDays = request.CreditDays,
+            DefaultWarehouseId = request.DefaultWarehouseId,
+            Status = EntityStatus.Active,
+            CreatedAt = DateTime.UtcNow
+        };
+
+        await _customers.AddAsync(customer, ct);
+        await _uow.SaveChangesAsync(ct);
+
+        return new ETagged<CustomerDto>(Map(customer), customer.RowVersion);
+    }
+
+    public async Task<ETagged<CustomerDto>> UpdateAsync(int customerId, UpdateCustomerRequest request, uint expectedRowVersion, CancellationToken ct = default)
+    {
+        var customer = await _customers.GetByIdAsync(customerId, ct)
+            ?? throw new NotFoundException($"Customer {customerId} was not found.");
+
+        if (customer.RowVersion != expectedRowVersion)
+            throw new DomainException(ErrorCodes.ConcurrencyConflict, "The customer was modified by another request.", 412);
+
+        var code = request.CustomerCode.Trim();
+        var name = request.Name.Trim();
+
+        if (!string.Equals(customer.CustomerCode, code, StringComparison.Ordinal)
+            && await _customers.Query().AnyAsync(c => c.CustomerCode.ToLower() == code.ToLower() && c.CustomerId != customerId, ct))
+            throw new ConflictException($"A customer code '{code}' already exists.");
+
+        if (!string.Equals(customer.Email, request.Email?.Trim(), StringComparison.OrdinalIgnoreCase)
+            && !string.IsNullOrWhiteSpace(request.Email)
+            && await _customers.Query().AnyAsync(c => c.Email != null && c.Email.ToLower() == request.Email!.Trim().ToLower() && c.CustomerId != customerId, ct))
+            throw new ConflictException($"A customer with email '{request.Email.Trim()}' already exists.");
+
+        if (request.DefaultWarehouseId is not null)
+        {
+            var exists = await _warehouses.Query().AnyAsync(w => w.WarehouseId == request.DefaultWarehouseId, ct);
+            if (!exists) throw new NotFoundException($"Warehouse {request.DefaultWarehouseId} was not found.");
+        }
+
+        customer.CustomerCode = code;
+        customer.CustomerType = request.CustomerType;
+        customer.Name = name;
+        customer.DisplayName = Normalize(request.DisplayName);
+        customer.Phone = Normalize(request.Phone);
+        customer.Email = Normalize(request.Email);
+        customer.AddressLine1 = Normalize(request.AddressLine1);
+        customer.AddressLine2 = Normalize(request.AddressLine2);
+        customer.City = Normalize(request.City);
+        customer.Country = Normalize(request.Country);
+        customer.TaxRegistrationNo = Normalize(request.TaxRegistrationNo);
+        customer.CreditLimit = request.CreditLimit;
+        customer.CreditDays = request.CreditDays;
+        customer.DefaultWarehouseId = request.DefaultWarehouseId;
+        customer.UpdatedAt = DateTime.UtcNow;
+
+        await _uow.SaveChangesAsync(ct);
+        return new ETagged<CustomerDto>(Map(customer), customer.RowVersion);
+    }
+
+    public async Task SetStatusAsync(int customerId, EntityStatus status, CancellationToken ct = default)
+    {
+        var customer = await _customers.GetByIdAsync(customerId, ct)
+            ?? throw new NotFoundException($"Customer {customerId} was not found.");
+
+        customer.Status = status;
+        customer.UpdatedAt = DateTime.UtcNow;
+        await _uow.SaveChangesAsync(ct);
+    }
+
+    private static CustomerDto Map(Customer c) => new(
+        c.CustomerId, c.CustomerCode, c.CustomerType, c.Name, c.DisplayName, c.Phone, c.Email,
+        c.AddressLine1, c.AddressLine2, c.City, c.Country, c.TaxRegistrationNo,
+        c.CreditLimit, c.CreditDays, c.DefaultWarehouseId, c.Status, c.CreatedAt, c.UpdatedAt);
+
+    private static string? Normalize(string? value) => string.IsNullOrWhiteSpace(value) ? null : value.Trim();
+}

Backend/ERPCore/Services/DashboardService.cs

@@ -0,0 +1,79 @@
+using ERPCore.Domain.Entities;
+using ERPCore.Domain.Enums;
+using ERPCore.Dtos.Common;
+using ERPCore.Dtos.Dashboard;
+using ERPCore.Repositories.Interfaces;
+using ERPCore.Services.Interfaces;
+using Microsoft.EntityFrameworkCore;
+
+namespace ERPCore.Services;
+
+/// <summary>
+/// Aggregate counts pulled straight from each domain's repository — no PagedResponse
+/// overhead, since the dashboard only needs totals. Low-stock reuses <see cref="IReorderService"/>
+/// rather than re-deriving the FIFO-available-vs-reorder-point comparison (docs/11 §5.7).
+/// On-hand summary and stock valuation sum <see cref="StockLayer.QtyRemaining"/> (and
+/// QtyRemaining × UnitCost for valuation) directly in SQL — cheap, unlike reorder alerts,
+/// because they need no per-item live lookup.
+/// </summary>
+public sealed class DashboardService : IDashboardService
+{
+    private readonly IRepository<StockLayer> _layers;
+    private readonly IRepository<Grn> _grns;
+    private readonly IRepository<PurchaseOrder> _pos;
+    private readonly IRepository<Requisition> _requisitions;
+    private readonly IRepository<StockCount> _counts;
+    private readonly IRepository<Rfq> _rfqs;
+    private readonly IReorderService _reorder;
+
+    public DashboardService(
+        IRepository<StockLayer> layers, IRepository<Grn> grns, IRepository<PurchaseOrder> pos,
+        IRepository<Requisition> requisitions, IRepository<StockCount> counts, IRepository<Rfq> rfqs,
+        IReorderService reorder)
+    {
+        _layers = layers;
+        _grns = grns;
+        _pos = pos;
+        _requisitions = requisitions;
+        _counts = counts;
+        _rfqs = rfqs;
+        _reorder = reorder;
+    }
+
+    public async Task<DashboardStatsDto> GetStatsAsync(CancellationToken ct = default)
+    {
+        // Sequential, not Task.WhenAll: these repositories share one scoped DbContext,
+        // which cannot run concurrent operations.
+        var onHandTotal = await _layers.Query().AsNoTracking().SumAsync(l => (decimal?)l.QtyRemaining, ct) ?? 0m;
+        var onHandWarehouses = await _layers.Query().AsNoTracking()
+            .Select(l => l.WarehouseId).Distinct().CountAsync(ct);
+        var stockValuationTotal = await _layers.Query().AsNoTracking()
+            .SumAsync(l => (decimal?)(l.QtyRemaining * l.UnitCost), ct) ?? 0m;
+        // EF can't translate constructing WarehouseValuationDto directly inside the GroupBy
+        // Select — project to an anonymous type first, then materialize into the record.
+        var stockValuationByWarehouseRaw = await _layers.Query().AsNoTracking()
+            .GroupBy(l => l.WarehouseId)
+            .Select(g => new { WarehouseId = g.Key, Total = g.Sum(x => x.QtyRemaining * x.UnitCost) })
+            .OrderByDescending(w => w.Total)
+            .ToListAsync(ct);
+        var stockValuationByWarehouse = stockValuationByWarehouseRaw
+            .Select(w => new WarehouseValuationDto(w.WarehouseId, w.Total))
+            .ToList();
+        var pendingGrns = await _grns.Query().AsNoTracking().CountAsync(g => g.Status == GrnStatus.Draft, ct);
+        var pendingApprovalPOs = await _pos.Query().AsNoTracking()
+            .CountAsync(p => p.Status == PurchaseOrderStatus.PendingApproval, ct);
+        var openRequisitions = await _requisitions.Query().AsNoTracking()
+            .CountAsync(r => r.Status == RequisitionStatus.Submitted, ct);
+        var pendingCounts = await _counts.Query().AsNoTracking()
+            .CountAsync(c => c.Status == CountStatus.Counted, ct);
+        var openRfqs = await _rfqs.Query().AsNoTracking().CountAsync(r => r.Status == RfqStatus.Open, ct);
+
+        // PageSize:1 is enough — GetAlertsAsync computes the full alert count before paging.
+        var lowStockAlerts = (await _reorder.GetAlertsAsync(null, new PageQuery { Page = 1, PageSize = 1 }, ct))
+            .Pagination.TotalItems;
+
+        return new DashboardStatsDto(
+            lowStockAlerts, onHandTotal, onHandWarehouses, stockValuationTotal, stockValuationByWarehouse,
+            pendingApprovalPOs, pendingGrns, openRequisitions, pendingCounts, openRfqs);
+    }
+}

Backend/ERPCore/Services/GeneralLedgerService.cs

@@ -0,0 +1,16 @@
+using ERPCore.Infra.Gl;
+using ERPCore.Services.Interfaces;
+
+namespace ERPCore.Services;
+
+/// <inheritdoc cref="IGeneralLedgerService"/>
+public sealed class GeneralLedgerService : IGeneralLedgerService
+{
+    private readonly IGeneralLedgerClient _client;
+
+    public GeneralLedgerService(IGeneralLedgerClient client) => _client = client;
+
+    public Task<GeneralLedgerResponse> ForwardAsync(
+        HttpMethod method, string path, string? queryString, string? contentType, Stream? body, CancellationToken ct)
+        => _client.SendAsync(method, path, queryString, contentType, body, ct);
+}

Backend/ERPCore/Services/GrnService.cs

@@ -33,9 +33,9 @@ public sealed class GrnService : IGrnService
     private readonly IRepository<Bin> _bins;
     private readonly IRepository<Vendor> _vendors;
     private readonly IRepository<Batch> _batches;
-    private readonly IRepository<UomConversion> _conversions;
     private readonly IRepository<StockLayer> _layers;
     private readonly IRepository<StockLedger> _ledger;
+    private readonly IUomConverter _uomConverter;
     private readonly IFifoCostingService _fifo;
     private readonly INumberSequenceService _numbers;
     private readonly ICurrentUser _currentUser;
@@ -45,7 +45,7 @@ public sealed class GrnService : IGrnService
         IRepository<Grn> grns, IRepository<PurchaseOrder> pos, IRepository<PoLine> poLines,
         IRepository<Item> items, IRepository<Uom> uoms, IRepository<Warehouse> warehouses,
         IRepository<Bin> bins, IRepository<Vendor> vendors, IRepository<Batch> batches,
-        IRepository<UomConversion> conversions, IRepository<StockLayer> layers, IRepository<StockLedger> ledger,
+        IRepository<StockLayer> layers, IRepository<StockLedger> ledger, IUomConverter uomConverter,
         IFifoCostingService fifo, INumberSequenceService numbers, ICurrentUser currentUser, IUnitOfWork uow)
     {
         _grns = grns;
@@ -57,9 +57,9 @@ public sealed class GrnService : IGrnService
         _bins = bins;
         _vendors = vendors;
         _batches = batches;
-        _conversions = conversions;
         _layers = layers;
         _ledger = ledger;
+        _uomConverter = uomConverter;
         _fifo = fifo;
         _numbers = numbers;
         _currentUser = currentUser;
@@ -345,19 +345,14 @@ public sealed class GrnService : IGrnService
         return created; // linked via GrnLine.Batch navigation; FK fixed up on SaveChanges
     }
 
-    private async Task<(decimal QtyBase, decimal UnitCostBase)> ToBaseAsync(
+    /// <summary>
+    /// Delegates to the shared <see cref="IUomConverter"/>. This was a private method here
+    /// until manufacturing needed the same conversion for stage stock inputs; behaviour is
+    /// identical, so receive costing is unchanged.
+    /// </summary>
+    private Task<(decimal QtyBase, decimal UnitCostBase)> ToBaseAsync(
         Item item, int uomId, decimal qty, decimal unitCostPerUom, CancellationToken ct)
-    {
-        if (uomId == item.BaseUomId)
-            return (qty, unitCostPerUom);
-
-        var conv = await _conversions.Query().AsNoTracking()
-            .FirstOrDefaultAsync(c => c.ItemId == item.ItemId && c.FromUomId == uomId && c.ToUomId == item.BaseUomId, ct)
-            ?? throw new DomainException(ErrorCodes.Validation,
-                $"No UOM conversion from {uomId} to base UOM {item.BaseUomId} for item {item.ItemId}.", 422);
-
-        return (qty * conv.Factor, unitCostPerUom / conv.Factor);
-    }
+        => _uomConverter.ToBaseAsync(item, uomId, qty, unitCostPerUom, ct);
 
     private async Task UpdatePoStatusAsync(int? poId, CancellationToken ct)
     {

Backend/ERPCore/Services/Interfaces/ICustomerService.cs

@@ -0,0 +1,15 @@
+using ERPCore.Common.Http;
+using ERPCore.Dtos.Common;
+using ERPCore.Dtos.Customers;
+using ERPCore.Domain.Enums;
+
+namespace ERPCore.Services.Interfaces;
+
+public interface ICustomerService
+{
+    Task<PagedResponse<CustomerDto>> ListAsync(PageQuery query, EntityStatus? status, CustomerType? customerType, CancellationToken ct = default);
+    Task<ETagged<CustomerDto>?> GetAsync(int customerId, CancellationToken ct = default);
+    Task<ETagged<CustomerDto>> CreateAsync(CreateCustomerRequest request, CancellationToken ct = default);
+    Task<ETagged<CustomerDto>> UpdateAsync(int customerId, UpdateCustomerRequest request, uint expectedRowVersion, CancellationToken ct = default);
+    Task SetStatusAsync(int customerId, EntityStatus status, CancellationToken ct = default);
+}

Backend/ERPCore/Services/Interfaces/IDashboardService.cs

@@ -0,0 +1,9 @@
+using ERPCore.Dtos.Dashboard;
+
+namespace ERPCore.Services.Interfaces;
+
+/// <summary>Cross-domain aggregate stats for the dashboard overview.</summary>
+public interface IDashboardService
+{
+    Task<DashboardStatsDto> GetStatsAsync(CancellationToken ct = default);
+}

Backend/ERPCore/Services/Interfaces/IFifoCostingService.cs

@@ -29,11 +29,22 @@ public interface IFifoCostingService
     Task<IReadOnlyList<ConsumedSegment>> ConsumeAsync(
         int itemId, int warehouseId, int? batchId, decimal qtyBase, CancellationToken ct = default);
 
-    /// <summary>Append an immutable ledger entry (value = qtyBase × unitCost).</summary>
+    /// <summary>
+    /// Append an immutable ledger entry. Value defaults to <c>round(qtyBase × unitCost, 4)</c>.
+    /// </summary>
+    /// <param name="valueOverride">
+    /// Posts this exact value instead of deriving it from qty × unit cost. Needed when the
+    /// authoritative figure is a total rather than a rate: a production receipt must carry the
+    /// run's cost pool exactly, but <c>unitCost = pool / goodQty</c> rounds to 6 dp, and at
+    /// 100+ units that rounding error exceeds the ledger's 4 dp tick — so the derived value
+    /// would drift from the pool (FR-MFG-13). Also used by leftover and cancel returns, whose
+    /// value is the exact consumed residual. Omit for every rate-driven movement.
+    /// </param>
     Task<StockLedger> PostLedgerAsync(
         int itemId, int warehouseId, int? binId, int? batchId, int? serialId, int userId,
         Direction direction, decimal qtyBase, decimal unitCost, decimal runningBalance,
-        string sourceDocType, int sourceDocId, DateTime createdAt, CancellationToken ct = default);
+        string sourceDocType, int sourceDocId, DateTime createdAt, CancellationToken ct = default,
+        decimal? valueOverride = null);
 
     /// <summary>Current on-hand (Σ open-layer qtyRemaining) for an item at a warehouse.</summary>
     Task<decimal> GetOnHandAsync(int itemId, int warehouseId, CancellationToken ct = default);

Backend/ERPCore/Services/Interfaces/IGeneralLedgerService.cs

@@ -0,0 +1,16 @@
+using ERPCore.Infra.Gl;
+
+namespace ERPCore.Services.Interfaces;
+
+/// <summary>
+/// Single entry point into the external General Ledger service — the one function
+/// used both by <see cref="ERPCore.Controllers.GeneralLedgerController"/> (frontend
+/// requests, forwarded verbatim) and, once wired, other ERPCore services that need to
+/// post directly to GL (e.g. GRN confirm, adjustments — docs/12-GENERAL-LEDGER-INTEGRATION.md).
+/// No business logic lives here yet; this pass only connects the transport.
+/// </summary>
+public interface IGeneralLedgerService
+{
+    Task<GeneralLedgerResponse> ForwardAsync(
+        HttpMethod method, string path, string? queryString, string? contentType, Stream? body, CancellationToken ct);
+}

Backend/ERPCore/Services/Interfaces/IProductionRunService.cs

@@ -0,0 +1,99 @@
+using ERPCore.Common.Http;
+using ERPCore.Domain.Enums;
+using ERPCore.Dtos.Common;
+using ERPCore.Dtos.Production;
+
+namespace ERPCore.Services.Interfaces;
+
+/// <summary>
+/// Production run lifecycle (docs/30 §D.2–D.3, FR-MFG-08..19). Every stock-affecting
+/// action runs inside a single <c>ExecuteInTransactionAsync</c> scope and consumes stock
+/// only through <c>IFifoCostingService</c> (NFR-02/NFR-05).
+/// </summary>
+public interface IProductionRunService
+{
+    Task<PagedResponse<RunSummaryDto>> ListAsync(
+        PageQuery query, ProductionRunStatus? status, int? templateId, int? warehouseId,
+        CancellationToken ct = default);
+
+    Task<ETagged<RunGraphDto>?> GetAsync(int runId, CancellationToken ct = default);
+
+    /// <summary>
+    /// Instantiates a template (FR-MFG-08): copies every stage, input, output and edge,
+    /// scales all quantities by <c>targetQty / terminalOutputQtyPerBatch</c>, issues a
+    /// <c>PRD-…</c> document number, and leaves entry stages Ready with the rest Waiting.
+    /// </summary>
+    Task<ETagged<RunGraphDto>> CreateAsync(CreateRunRequest request, CancellationToken ct = default);
+
+    /// <summary>
+    /// Per-run quantity override on a stage that has not started
+    /// (<c>409 STAGE_NOT_EDITABLE</c> once it has). Re-evaluates the stage's readiness,
+    /// since raising an upstream input's planned quantity can un-ready it.
+    /// </summary>
+    Task<RunStageDto> UpdateStageQuantitiesAsync(
+        int runId, int runStageId, UpdateStageQuantitiesRequest request, CancellationToken ct = default);
+
+    /// <summary>
+    /// <c>Ready → InProgress</c> (FR-MFG-10). FIFO-consumes every Stock input from the run
+    /// warehouse in one transaction and stamps <c>actualStartAt</c>.
+    /// <para>Consumes <c>max(0, plannedBase − consumedQty)</c> per input, so a rework
+    /// restart with an unchanged planned quantity consumes nothing and one with a raised
+    /// planned quantity consumes only the delta (FR-MFG-16).</para>
+    /// </summary>
+    Task<StartStageResultDto> StartStageAsync(int runId, int runStageId, CancellationToken ct = default);
+
+    /// <summary>
+    /// <c>InProgress → Done</c> (FR-MFG-11). Records produced and scrapped quantities per
+    /// output plus the custom field values. A re-complete after a rework <b>overwrites</b>
+    /// the previous figures rather than adding to them.
+    /// </summary>
+    Task<RunStageDto> CompleteStageAsync(
+        int runId, int runStageId, CompleteStageRequest request, CancellationToken ct = default);
+
+    /// <summary>
+    /// <c>Done → Approved</c> (FR-MFG-12/13). Non-terminal: hands WIP to the children,
+    /// defaulting to the full available quantity. Terminal: posts the production receipt —
+    /// a finished-goods layer costed at <c>costPool / goodQty</c> — and completes the run.
+    /// </summary>
+    Task<ApproveStageResultDto> ApproveStageAsync(
+        int runId, int runStageId, ApproveStageRequest request, CancellationToken ct = default);
+
+    /// <summary>
+    /// Later partial transfer of a remainder held on an already-Approved stage (FR-MFG-12),
+    /// never exceeding produced − scrapped − already transferred.
+    /// </summary>
+    Task<TransferResultDto> TransferAsync(
+        int runId, int runStageId, TransferRemainderRequest request, CancellationToken ct = default);
+
+    /// <summary>
+    /// Returns unconsumed material to stock before the receipt closes the pool (FR-MFG-14).
+    /// The inbound layer is created at the <b>weighted cost actually consumed</b> for that
+    /// input, so the move is cost-preserving and the pool reduces by exactly what leaves it.
+    /// <c>409 RUN_COST_CLOSED</c> once the run has completed.
+    /// </summary>
+    Task<ReturnLeftoverResultDto> ReturnLeftoverAsync(
+        int runId, int runInputId, ReturnLeftoverRequest request, CancellationToken ct = default);
+
+    /// <summary>
+    /// Downstream reject (FR-MFG-15): this stage rejects the work it received, its delivering
+    /// parents revert <c>Approved → InProgress</c> with their transferred quantities pulled
+    /// back, and this stage returns to Waiting. Consumed stock stays consumed.
+    /// </summary>
+    Task<RejectIntakeResultDto> RejectIntakeAsync(
+        int runId, int runStageId, RejectRequest request, CancellationToken ct = default);
+
+    /// <summary>
+    /// Terminal reject (FR-MFG-16): resets the whole run to its starting stages, increments
+    /// <c>reworkCount</c> and snapshots the discarded figures into the event history.
+    /// Already-consumed material remains in the cost pool.
+    /// </summary>
+    Task<TerminalRejectResultDto> RejectTerminalAsync(
+        int runId, int runStageId, RejectRequest request, CancellationToken ct = default);
+
+    /// <summary>
+    /// Cancels an in-progress run (FR-MFG-17). Net consumed-and-not-returned stock goes back
+    /// at its consumed weighted cost; scrapped output quantities are written off on the event.
+    /// <c>409 RUN_NOT_CANCELLABLE</c> for a completed run.
+    /// </summary>
+    Task<CancelRunResultDto> CancelAsync(int runId, CancelRunRequest request, CancellationToken ct = default);
+}

Backend/ERPCore/Services/Interfaces/IProductionTemplateService.cs

@@ -0,0 +1,33 @@
+using ERPCore.Common.Http;
+using ERPCore.Domain.Enums;
+using ERPCore.Dtos.Common;
+using ERPCore.Dtos.Production;
+
+namespace ERPCore.Services.Interfaces;
+
+/// <summary>
+/// Production template CRUD and graph validation (docs/30 §D.1, FR-MFG-01..07).
+/// </summary>
+public interface IProductionTemplateService
+{
+    Task<PagedResponse<TemplateSummaryDto>> ListAsync(PageQuery query, EntityStatus? status, CancellationToken ct = default);
+
+    Task<ETagged<TemplateGraphDto>?> GetAsync(int templateId, CancellationToken ct = default);
+
+    Task<ETagged<TemplateGraphDto>> CreateAsync(SaveTemplateRequest request, CancellationToken ct = default);
+
+    /// <summary>
+    /// Replaces the whole graph. Requires the current row version (<c>If-Match</c>) and is
+    /// refused with <c>409 TEMPLATE_IN_USE</c> while any run of this template is
+    /// InProgress — edit-lock stands in for versioning (FR-MFG-06).
+    /// </summary>
+    Task<ETagged<TemplateGraphDto>> UpdateAsync(
+        int templateId, SaveTemplateRequest request, uint expectedRowVersion, CancellationToken ct = default);
+
+    /// <summary>
+    /// Activate/deactivate (FR-MFG-01). Deliberately <b>not</b> edit-locked: deactivating is
+    /// the "never delete a referenced master" path (FR-MD-08) and only stops <i>new</i> runs
+    /// being started, so it must stay available while runs are in flight.
+    /// </summary>
+    Task SetStatusAsync(int templateId, EntityStatus status, CancellationToken ct = default);
+}

Backend/ERPCore/Services/Interfaces/ISalesInvoiceService.cs

@@ -0,0 +1,16 @@
+using ERPCore.Common.Http;
+using ERPCore.Dtos.Common;
+using ERPCore.Dtos.Sales;
+using ERPCore.Domain.Enums;
+
+namespace ERPCore.Services.Interfaces;
+
+public interface ISalesInvoiceService
+{
+    Task<PagedResponse<SalesInvoiceSummaryDto>> ListAsync(PageQuery query, SalesInvoiceStatus? status, int? customerId, int? warehouseId, CancellationToken ct = default);
+    Task<ETagged<SalesInvoiceDto>?> GetAsync(int salesInvoiceId, CancellationToken ct = default);
+    Task<ETagged<SalesInvoiceDto>> CreateAsync(CreateSalesInvoiceRequest request, CancellationToken ct = default);
+    Task<ETagged<SalesInvoiceDto>> UpdateAsync(int salesInvoiceId, UpdateSalesInvoiceRequest request, uint expectedRowVersion, CancellationToken ct = default);
+    Task<SalesInvoiceDto> PostAsync(int salesInvoiceId, CancellationToken ct = default);
+    Task<SalesInvoiceDto> CancelAsync(int salesInvoiceId, CancellationToken ct = default);
+}

Backend/ERPCore/Services/Interfaces/ISalesPricingService.cs

@@ -0,0 +1,16 @@
+namespace ERPCore.Services.Interfaces;
+
+public interface ISalesPricingService
+{
+    Task<SalesPriceResolution> ResolveAsync(
+        int itemId,
+        int warehouseId,
+        decimal? requestedUnitPrice,
+        bool allowManualOverride,
+        CancellationToken ct = default);
+}
+
+public sealed record SalesPriceResolution(
+    decimal UnitPrice,
+    string PriceSource,
+    decimal BaseCost);

Backend/ERPCore/Services/Interfaces/ISalesReportService.cs

@@ -0,0 +1,13 @@
+using ERPCore.Dtos.Sales;
+
+namespace ERPCore.Services.Interfaces;
+
+public interface ISalesReportService
+{
+    Task<IReadOnlyList<SalesDailySummaryRowDto>> DailySummaryAsync(DateOnly from, DateOnly to, CancellationToken ct = default);
+    Task<IReadOnlyList<SalesItemSummaryRowDto>> ItemSummaryAsync(DateOnly from, DateOnly to, int? itemId, int? warehouseId, CancellationToken ct = default);
+    Task<IReadOnlyList<SalesCustomerSummaryRowDto>> CustomerSummaryAsync(DateOnly from, DateOnly to, int? customerId, CancellationToken ct = default);
+    Task<IReadOnlyList<SalesWarehouseSummaryRowDto>> WarehouseSummaryAsync(DateOnly from, DateOnly to, int? warehouseId, CancellationToken ct = default);
+    Task<IReadOnlyList<SalesDiscountSummaryRowDto>> DiscountSummaryAsync(DateOnly from, DateOnly to, CancellationToken ct = default);
+    Task<IReadOnlyList<SalesFreeIssueSummaryRowDto>> FreeIssueSummaryAsync(DateOnly from, DateOnly to, CancellationToken ct = default);
+}

Backend/ERPCore/Services/Interfaces/ISalesSlipService.cs

@@ -0,0 +1,16 @@
+using ERPCore.Common.Http;
+using ERPCore.Dtos.Common;
+using ERPCore.Dtos.Sales;
+using ERPCore.Domain.Enums;
+
+namespace ERPCore.Services.Interfaces;
+
+public interface ISalesSlipService
+{
+    Task<PagedResponse<SalesSlipSummaryDto>> ListAsync(PageQuery query, SalesSlipStatus? status, int? customerId, int? warehouseId, CancellationToken ct = default);
+    Task<ETagged<SalesSlipDto>?> GetAsync(int salesSlipId, CancellationToken ct = default);
+    Task<ETagged<SalesSlipDto>> CreateAsync(CreateSalesSlipRequest request, CancellationToken ct = default);
+    Task<ETagged<SalesSlipDto>> UpdateAsync(int salesSlipId, UpdateSalesSlipRequest request, uint expectedRowVersion, CancellationToken ct = default);
+    Task<SalesSlipDto> PostAsync(int salesSlipId, CancellationToken ct = default);
+    Task<SalesSlipDto> CancelAsync(int salesSlipId, CancellationToken ct = default);
+}

Backend/ERPCore/Services/Interfaces/IUomConverter.cs

@@ -0,0 +1,35 @@
+using ERPCore.Domain.Entities;
+
+namespace ERPCore.Services.Interfaces;
+
+/// <summary>
+/// Converts a quantity and its per-UOM cost into the item's <b>base</b> UOM.
+/// </summary>
+/// <remarks>
+/// <para>Everything in the FIFO engine — <c>StockLayer</c>, <c>StockLedger</c>,
+/// <c>IFifoCostingService.ConsumeAsync</c> — works exclusively in base UOM, while
+/// documents let a user enter a line in any UOM the item has a conversion for. This is the
+/// one place that bridges the two.</para>
+/// <para>Extracted from <c>GrnService</c>'s private <c>ToBaseAsync</c> when manufacturing
+/// needed the same conversion for stage stock inputs (docs/30 never mentions UOM
+/// conversion, but <c>STAGE_INPUT.uom_id</c> is a free FK — without this, an input
+/// specified in "Box of 12" would consume 1 base unit instead of 12 and silently
+/// mis-cost the run).</para>
+/// </remarks>
+public interface IUomConverter
+{
+    /// <summary>
+    /// Returns the quantity and unit cost restated in <paramref name="item"/>'s base UOM.
+    /// A no-op when <paramref name="uomId"/> already is the base UOM. Throws 422 when no
+    /// conversion is defined for the item from that UOM to its base.
+    /// </summary>
+    Task<(decimal QtyBase, decimal UnitCostBase)> ToBaseAsync(
+        Item item, int uomId, decimal qty, decimal unitCostPerUom, CancellationToken ct = default);
+
+    /// <summary>
+    /// Quantity-only conversion, for callers that have no per-UOM cost to restate (a
+    /// production stage input declares a quantity; its cost comes from the FIFO layers it
+    /// consumes, not from the document).
+    /// </summary>
+    Task<decimal> ToBaseQtyAsync(Item item, int uomId, decimal qty, CancellationToken ct = default);
+}

Backend/ERPCore/Services/Production/ProductionGraphValidator.cs

@@ -0,0 +1,211 @@
+using ERPCore.Domain.Enums;
+using ERPCore.System.Errors;
+
+namespace ERPCore.Services.Production;
+
+/// <summary>
+/// Validates a template stage graph (FR-MFG-02, FR-MFG-04, FR-MFG-05) and throws the
+/// matching <c>422 GRAPH_*</c> domain error on the first violation.
+/// </summary>
+/// <remarks>
+/// <para>This is an <b>algorithm, not a service</b> — pure, synchronous, no database and
+/// no DI, in the spirit of <c>FifoCostingService</c> being the one place FIFO lives. It
+/// deliberately has no interface: <c>Services/Interfaces/</c> exists for things that get
+/// injected, and registering this would buy nothing.</para>
+/// <para>It works entirely in <b>keys</b>, never database ids, so the identical code path
+/// runs for a POST (where nothing has an id yet) and a PUT (where most things do). All
+/// database-dependent checks — does this item exist, is it Active, does this UOM exist —
+/// stay in <c>ProductionTemplateService</c> so this stays free of I/O.</para>
+/// <para>Checks run cheapest-first and fail fast, and every message names the offending
+/// stage or edge so the canvas can focus it (docs/21 §2).</para>
+/// </remarks>
+public static class ProductionGraphValidator
+{
+    public sealed record InputDraft(int Index, StageInputSource Source, int? ItemId, string? FromOutputKey);
+
+    public sealed record OutputDraft(string Key, string Name, int? ItemId);
+
+    public sealed record StageDraft(
+        string Key, string Name, IReadOnlyList<InputDraft> Inputs, IReadOnlyList<OutputDraft> Outputs);
+
+    public readonly record struct EdgeDraft(string ParentKey, string ChildKey);
+
+    /// <summary>
+    /// Throws on the first rule violation; returns silently for a valid graph.
+    /// </summary>
+    public static void Validate(IReadOnlyList<StageDraft> stages, IReadOnlyList<EdgeDraft> edges)
+    {
+        // 1 — structural hygiene. These are all blocked in the canvas at draw time
+        // (docs/21 §2); this is the server backstop for a hand-rolled request.
+        if (stages.Count == 0)
+            throw Invalid("A template must have at least one stage.");
+
+        var stageByKey = new Dictionary<string, StageDraft>(StringComparer.Ordinal);
+        foreach (var s in stages)
+        {
+            if (string.IsNullOrWhiteSpace(s.Key))
+                throw Invalid("Every stage requires a key.");
+            if (!stageByKey.TryAdd(s.Key, s))
+                throw Invalid($"Duplicate stage key '{s.Key}'.");
+        }
+
+        // Output keys are unique across the whole template, not just within a stage —
+        // an Upstream input names one by key alone, so a collision would be ambiguous.
+        var outputOwner = new Dictionary<string, string>(StringComparer.Ordinal);
+        foreach (var s in stages)
+            foreach (var o in s.Outputs)
+            {
+                if (string.IsNullOrWhiteSpace(o.Key))
+                    throw Invalid($"Every output of stage '{s.Name}' requires a key.");
+                if (!outputOwner.TryAdd(o.Key, s.Key))
+                    throw Invalid($"Duplicate output key '{o.Key}' (stage '{s.Name}').");
+            }
+
+        var edgeSet = new HashSet<(string, string)>();
+        foreach (var e in edges)
+        {
+            if (!stageByKey.ContainsKey(e.ParentKey) || !stageByKey.ContainsKey(e.ChildKey))
+                throw Invalid($"Edge '{e.ParentKey}' → '{e.ChildKey}' references a stage that is not in the payload.");
+            if (string.Equals(e.ParentKey, e.ChildKey, StringComparison.Ordinal))
+                throw Invalid($"Stage '{stageByKey[e.ParentKey].Name}' cannot connect to itself.");
+            if (!edgeSet.Add((e.ParentKey, e.ChildKey)))
+                throw Invalid($"Duplicate edge '{stageByKey[e.ParentKey].Name}' → '{stageByKey[e.ChildKey].Name}'.");
+        }
+
+        var children = stages.ToDictionary(s => s.Key, _ => new List<string>(), StringComparer.Ordinal);
+        var parents = stages.ToDictionary(s => s.Key, _ => new List<string>(), StringComparer.Ordinal);
+        foreach (var (parent, child) in edgeSet)
+        {
+            children[parent].Add(child);
+            parents[child].Add(parent);
+        }
+
+        // 2 — cycle detection by Kahn's algorithm. If the toposort can't reach every
+        // stage, the unreached set is exactly the stages trapped in (or downstream of)
+        // a cycle, which is what the client highlights.
+        var indegree = stages.ToDictionary(s => s.Key, s => parents[s.Key].Count, StringComparer.Ordinal);
+        var queue = new Queue<string>(indegree.Where(kv => kv.Value == 0).Select(kv => kv.Key));
+        var sorted = 0;
+        while (queue.Count > 0)
+        {
+            var key = queue.Dequeue();
+            sorted++;
+            foreach (var child in children[key])
+                if (--indegree[child] == 0)
+                    queue.Enqueue(child);
+        }
+
+        if (sorted != stages.Count)
+        {
+            var trapped = indegree.Where(kv => kv.Value > 0).Select(kv => stageByKey[kv.Key].Name);
+            throw new DomainException(ErrorCodes.GraphCycle,
+                $"The stage graph contains a cycle involving: {string.Join(", ", trapped)}.", 422);
+        }
+
+        // 3 — exactly one terminal stage (multiple starts may converge, but the line must
+        // end in one place, because that single stage is what receives the finished good).
+        var terminals = stages.Where(s => children[s.Key].Count == 0).ToList();
+        if (terminals.Count != 1)
+            throw new DomainException(ErrorCodes.GraphTerminalCount,
+                terminals.Count == 0
+                    ? "The stage graph has no final stage."
+                    : $"The stage graph must converge to exactly one final stage, but {terminals.Count} have no outgoing connection: {string.Join(", ", terminals.Select(t => t.Name))}.",
+                422);
+
+        var terminal = terminals[0];
+        var entries = stages.Where(s => parents[s.Key].Count == 0).ToList();
+
+        // 4 — connectivity. One traversal each way subsumes all three of "no disconnected
+        // stages", "every stage reachable from an entry" and "every stage reaches the
+        // terminal": an isolated stage simply appears in neither set. A lone stage is both
+        // an entry and the terminal, so it falls out correctly with no special case.
+        //
+        // Kept as defence in depth, but note it is unreachable once checks 2 and 3 pass:
+        // in an acyclic graph every stage is reachable from some source, and if exactly one
+        // stage lacks an outbound edge then every stage necessarily reaches it. An isolated
+        // stage therefore surfaces as GRAPH_TERMINAL_COUNT (it is a second terminal), which
+        // is the better message anyway because it names both offenders. Verified by the M2
+        // smoke test, which asserts that behaviour explicitly.
+        var fromEntry = Reach(entries.Select(s => s.Key), children);
+        var toTerminal = Reach([terminal.Key], parents);
+
+        var stranded = stages.Where(s => !fromEntry.Contains(s.Key) || !toTerminal.Contains(s.Key)).ToList();
+        if (stranded.Count > 0)
+            throw new DomainException(ErrorCodes.GraphDisconnected,
+                $"Every stage must sit on a path from a starting stage to '{terminal.Name}', but these do not: {string.Join(", ", stranded.Select(s => s.Name))}.",
+                422);
+
+        // 5 — input sources (FR-MFG-04). An Upstream input may only draw from an output of
+        // a DIRECT parent: allowing a grandparent's output would mean WIP skipping a stage.
+        foreach (var s in stages)
+        {
+            var allowed = parents[s.Key]
+                .SelectMany(p => stageByKey[p].Outputs.Select(o => o.Key))
+                .ToHashSet(StringComparer.Ordinal);
+
+            foreach (var input in s.Inputs)
+            {
+                if (input.Source == StageInputSource.Upstream)
+                {
+                    if (input.ItemId is not null)
+                        throw new DomainException(ErrorCodes.GraphInputSourceInvalid,
+                            $"Input {input.Index + 1} of stage '{s.Name}' is Upstream and cannot also reference an item.", 422);
+                    if (string.IsNullOrWhiteSpace(input.FromOutputKey))
+                        throw new DomainException(ErrorCodes.GraphInputSourceInvalid,
+                            $"Input {input.Index + 1} of stage '{s.Name}' is Upstream but names no source output.", 422);
+                    if (!allowed.Contains(input.FromOutputKey))
+                    {
+                        var owner = outputOwner.TryGetValue(input.FromOutputKey, out var ownerKey)
+                            ? $"'{stageByKey[ownerKey].Name}' is not a direct parent of '{s.Name}'"
+                            : $"output '{input.FromOutputKey}' does not exist";
+                        throw new DomainException(ErrorCodes.GraphInputSourceInvalid,
+                            $"Input {input.Index + 1} of stage '{s.Name}' must draw from a direct parent's output — {owner}.", 422);
+                    }
+                }
+                else
+                {
+                    if (input.ItemId is null)
+                        throw new DomainException(ErrorCodes.GraphInputSourceInvalid,
+                            $"Input {input.Index + 1} of stage '{s.Name}' is a Stock input and requires an item.", 422);
+                    if (!string.IsNullOrWhiteSpace(input.FromOutputKey))
+                        throw new DomainException(ErrorCodes.GraphInputSourceInvalid,
+                            $"Input {input.Index + 1} of stage '{s.Name}' is a Stock input and cannot reference an upstream output.", 422);
+                }
+            }
+        }
+
+        // 6 — outputs (FR-MFG-05). The terminal stage produces exactly one real Item (the
+        // finished good the receipt creates a layer for); every other output is internal
+        // WIP and must stay item-less, or it would imply stock that never exists.
+        if (terminal.Outputs.Count != 1)
+            throw new DomainException(ErrorCodes.TerminalOutputItemRequired,
+                $"The final stage '{terminal.Name}' must have exactly one output, but has {terminal.Outputs.Count}.", 422);
+
+        if (terminal.Outputs[0].ItemId is null)
+            throw new DomainException(ErrorCodes.TerminalOutputItemRequired,
+                $"The output of the final stage '{terminal.Name}' must reference the finished item.", 422);
+
+        foreach (var s in stages.Where(s => !ReferenceEquals(s, terminal)))
+            foreach (var o in s.Outputs.Where(o => o.ItemId is not null))
+                throw Invalid(
+                    $"Output '{o.Name}' of stage '{s.Name}' is intermediate work-in-progress and cannot reference an item — only the final stage produces a stocked item.");
+    }
+
+    /// <summary>Set of keys reachable from <paramref name="roots"/> following <paramref name="next"/>.</summary>
+    private static HashSet<string> Reach(IEnumerable<string> roots, Dictionary<string, List<string>> next)
+    {
+        var seen = new HashSet<string>(roots, StringComparer.Ordinal);
+        var queue = new Queue<string>(seen);
+        while (queue.Count > 0)
+            foreach (var n in next[queue.Dequeue()])
+                if (seen.Add(n))
+                    queue.Enqueue(n);
+        return seen;
+    }
+
+    /// <summary>
+    /// Structural violations the client already prevents and docs/30 §D.4 assigns no
+    /// dedicated code to — still 422, still carrying a message that names the culprit.
+    /// </summary>
+    private static DomainException Invalid(string message) => new(ErrorCodes.Validation, message, 422);
+}

Backend/ERPCore/Services/Production/ProductionJson.cs

@@ -0,0 +1,41 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace ERPCore.Services.Production;
+
+/// <summary>
+/// The one serializer for every jsonb column in the manufacturing module —
+/// <c>template_stages.field_defs</c>, <c>run_stages.field_defs</c>/<c>field_values</c>
+/// and <c>run_stage_events.payload</c>.
+/// </summary>
+/// <remarks>
+/// <para>Those columns hold a pre-serialized <c>string</c> rather than a mapped POCO,
+/// following the <c>AuditLog.ChangeSet</c> precedent. Beyond consistency this keeps
+/// <c>AuditScribe</c> honest: an owned/typed jsonb mapping would surface the nested
+/// objects as their own change-tracker entries and scatter spurious audit rows across
+/// the new tables.</para>
+/// <para>Everything is written through here so a column can only ever contain canonical
+/// JSON — the raw client string is never stored, which means a malformed
+/// <c>fieldDefs</c> can't reach the database and can't later break a run created from
+/// that template.</para>
+/// </remarks>
+public static class ProductionJson
+{
+    /// <summary>Matches the API's own wire format (docs/11 §1.3): camelCase, enums as strings.</summary>
+    public static readonly JsonSerializerOptions Options = new()
+    {
+        PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
+        DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
+        Converters = { new JsonStringEnumConverter() }
+    };
+
+    public static string Serialize<T>(T value) => JsonSerializer.Serialize(value, Options);
+
+    /// <summary>
+    /// Reads a stored column back. Returns <paramref name="fallback"/> for null/blank so a
+    /// caller never has to null-check; a parse failure is a genuine data-integrity problem
+    /// and is allowed to throw.
+    /// </summary>
+    public static T Deserialize<T>(string? json, T fallback)
+        => string.IsNullOrWhiteSpace(json) ? fallback : JsonSerializer.Deserialize<T>(json, Options) ?? fallback;
+}

Backend/ERPCore/Services/Production/ProductionTemplateService.cs

@@ -0,0 +1,496 @@
+using ERPCore.Common.Http;
+using ERPCore.Domain.Entities;
+using ERPCore.Domain.Enums;
+using ERPCore.Dtos.Common;
+using ERPCore.Dtos.Production;
+using ERPCore.Infra.Auth;
+using ERPCore.Infra.UoW;
+using ERPCore.Repositories.Interfaces;
+using ERPCore.Services.Interfaces;
+using ERPCore.System.Errors;
+using Microsoft.EntityFrameworkCore;
+
+namespace ERPCore.Services.Production;
+
+/// <summary>
+/// Production template CRUD + graph validation (docs/30 §D.1, FR-MFG-01..07).
+/// Graph rules live in <see cref="ProductionGraphValidator"/>; everything needing the
+/// database (referential checks, the edit-lock, reconciliation) lives here.
+/// </summary>
+public sealed class ProductionTemplateService : IProductionTemplateService
+{
+    private readonly IRepository<ProductionTemplate> _templates;
+    private readonly IRepository<TemplateStage> _stages;
+    private readonly IRepository<StageInput> _inputs;
+    private readonly IRepository<StageOutput> _outputs;
+    private readonly IRepository<StageEdge> _edges;
+    private readonly IRepository<Item> _items;
+    private readonly IRepository<Uom> _uoms;
+    private readonly IRepository<ProductionRun> _runs;
+    private readonly IUnitOfWork _uow;
+    private readonly ICurrentUser _currentUser;
+
+    public ProductionTemplateService(
+        IRepository<ProductionTemplate> templates, IRepository<TemplateStage> stages,
+        IRepository<StageInput> inputs, IRepository<StageOutput> outputs, IRepository<StageEdge> edges,
+        IRepository<Item> items, IRepository<Uom> uoms, IRepository<ProductionRun> runs,
+        IUnitOfWork uow, ICurrentUser currentUser)
+    {
+        _templates = templates;
+        _stages = stages;
+        _inputs = inputs;
+        _outputs = outputs;
+        _edges = edges;
+        _items = items;
+        _uoms = uoms;
+        _runs = runs;
+        _uow = uow;
+        _currentUser = currentUser;
+    }
+
+    public async Task<PagedResponse<TemplateSummaryDto>> ListAsync(
+        PageQuery query, EntityStatus? status, CancellationToken ct = default)
+    {
+        var q = _templates.Query().AsNoTracking();
+
+        if (!string.IsNullOrWhiteSpace(query.Q))
+        {
+            var term = query.Q.Trim();
+            q = q.Where(t => EF.Functions.ILike(t.Code, $"%{term}%") || EF.Functions.ILike(t.Name, $"%{term}%"));
+        }
+
+        if (status is not null) q = q.Where(t => t.Status == status);
+
+        var total = await q.CountAsync(ct);
+
+        // Projected to an anonymous type first, then mapped client-side: EF Core 10 cannot
+        // translate a record constructor sitting alongside aggregates and a collection
+        // projection (same limitation recorded for WarehouseValuationDto, 2026-07-28).
+        var rows = await q
+            .OrderBy(t => t.Code)
+            .Skip(query.Skip).Take(query.PageSize)
+            .Select(t => new
+            {
+                t.TemplateId,
+                t.Code,
+                t.Name,
+                t.Status,
+                StageCount = t.Stages.Count,
+                Stages = t.Stages.Select(s => new { s.StageId, s.Name }).ToList(),
+                Edges = t.Edges.Select(e => new { e.ParentStageId, e.ChildStageId }).ToList(),
+                // Drives the canvas edit-lock banner (docs/21 §2) and mirrors the
+                // condition UpdateAsync enforces server-side.
+                ActiveRunCount = t.Runs.Count(r => r.Status == ProductionRunStatus.InProgress),
+                t.CreatedBy,
+                t.CreatedAt
+            })
+            .ToListAsync(ct);
+
+        var items = rows.Select(t => new TemplateSummaryDto(
+            t.TemplateId, t.Code, t.Name, t.Status, t.StageCount,
+            FlowOrderedNames(
+                t.Stages.Select(s => (s.StageId, s.Name)).ToList(),
+                t.Edges.Select(e => (e.ParentStageId, e.ChildStageId)).ToList()),
+            t.ActiveRunCount, t.CreatedBy, t.CreatedAt)).ToList();
+
+        return PagedResponse<TemplateSummaryDto>.Create(items, query.Page, query.PageSize, total);
+    }
+
+    /// <summary>
+    /// Stage names in <b>flow order</b> — upstream first — for the overview canvas, which
+    /// draws each template as a line left to right (docs/21 §1).
+    /// </summary>
+    /// <remarks>
+    /// Ordering by <c>StageId</c> would be insertion order, which routinely puts the terminal
+    /// stage first and renders the line backwards. Kahn's algorithm over the edge set gives the
+    /// real sequence, tie-broken by stage id so parallel branches come out deterministically.
+    /// Falls back to id order if the graph somehow contains a cycle, so a listing can never
+    /// fail because of bad data.
+    /// </remarks>
+    private static List<string> FlowOrderedNames(
+        List<(int StageId, string Name)> stages, List<(int ParentStageId, int ChildStageId)> edges)
+    {
+        var nameById = stages.ToDictionary(s => s.StageId, s => s.Name);
+        var children = stages.ToDictionary(s => s.StageId, _ => new List<int>());
+        var indegree = stages.ToDictionary(s => s.StageId, _ => 0);
+
+        foreach (var (parent, child) in edges)
+        {
+            if (!children.ContainsKey(parent) || !indegree.ContainsKey(child)) continue;
+            children[parent].Add(child);
+            indegree[child]++;
+        }
+
+        // SortedSet keeps the frontier in id order, so the output is stable run to run.
+        var frontier = new SortedSet<int>(indegree.Where(kv => kv.Value == 0).Select(kv => kv.Key));
+        var ordered = new List<string>(stages.Count);
+
+        while (frontier.Count > 0)
+        {
+            var next = frontier.Min;
+            frontier.Remove(next);
+            ordered.Add(nameById[next]);
+
+            foreach (var child in children[next])
+                if (--indegree[child] == 0)
+                    frontier.Add(child);
+        }
+
+        return ordered.Count == stages.Count
+            ? ordered
+            : stages.OrderBy(s => s.StageId).Select(s => s.Name).ToList();
+    }
+
+    public async Task<ETagged<TemplateGraphDto>?> GetAsync(int templateId, CancellationToken ct = default)
+    {
+        var template = await LoadGraphQuery().AsNoTracking()
+            .FirstOrDefaultAsync(t => t.TemplateId == templateId, ct);
+
+        if (template is null) return null;
+
+        // Counted separately rather than Included: the graph query already fans out over four
+        // collections, and adding Runs would multiply those rows again for a single integer.
+        var activeRuns = await _runs.Query().AsNoTracking()
+            .CountAsync(r => r.TemplateId == templateId && r.Status == ProductionRunStatus.InProgress, ct);
+
+        return new ETagged<TemplateGraphDto>(ToGraphDto(template, activeRuns), template.RowVersion);
+    }
+
+    public async Task<ETagged<TemplateGraphDto>> CreateAsync(SaveTemplateRequest request, CancellationToken ct = default)
+    {
+        var code = request.Code.Trim();
+        if (await _templates.Query().AnyAsync(t => t.Code == code, ct))
+            throw new ConflictException($"A production template with code '{code}' already exists.");
+
+        var template = new ProductionTemplate
+        {
+            Code = code,
+            Name = request.Name.Trim(),
+            Description = request.Description?.Trim(),
+            Status = EntityStatus.Active,
+            CreatedBy = _currentUser.AuditUserId,
+            CreatedAt = DateTime.UtcNow
+        };
+
+        await ValidateAsync(request, ct);
+
+        await _uow.ExecuteInTransactionAsync(async token =>
+        {
+            await _templates.AddAsync(template, token);
+            BuildGraph(template, request);
+        }, ct);
+
+        return await RequireGraphAsync(template.TemplateId, ct);
+    }
+
+    public async Task<ETagged<TemplateGraphDto>> UpdateAsync(
+        int templateId, SaveTemplateRequest request, uint expectedRowVersion, CancellationToken ct = default)
+    {
+        await ValidateAsync(request, ct);
+
+        var code = request.Code.Trim();
+        if (await _templates.Query().AnyAsync(t => t.Code == code && t.TemplateId != templateId, ct))
+            throw new ConflictException($"A production template with code '{code}' already exists.");
+
+        await _uow.ExecuteInTransactionAsync(async token =>
+        {
+            var template = await LoadGraphQuery().FirstOrDefaultAsync(t => t.TemplateId == templateId, token)
+                ?? throw new NotFoundException($"Production template {templateId} was not found.");
+
+            if (template.RowVersion != expectedRowVersion)
+                throw new DomainException(ErrorCodes.ConcurrencyConflict,
+                    "The template was modified by another request.", 412);
+
+            // FR-MFG-06: edit-lock instead of versioning. Checked inside the transaction to
+            // keep the window small; the residual race is benign because a run copies
+            // everything it needs at creation and never reads the template again.
+            var activeRuns = await _runs.Query().AsNoTracking()
+                .CountAsync(r => r.TemplateId == templateId && r.Status == ProductionRunStatus.InProgress, token);
+            if (activeRuns > 0)
+                throw new DomainException(ErrorCodes.TemplateInUse,
+                    $"This template has {activeRuns} run(s) in progress and cannot be edited until they finish.", 409);
+
+            template.Code = code;
+            template.Name = request.Name.Trim();
+            template.Description = request.Description?.Trim();
+
+            // Two passes, deliberately. Tearing the old graph down and flushing before
+            // rebuilding removes any dependence on how EF happens to order a mixed batch of
+            // inserts and deletes — which matters because stage_inputs → stage_outputs is a
+            // Restrict FK and stage_edges carries a unique (parent, child) index.
+            var keptStages = TearDownGraph(template, request);
+            await _uow.SaveChangesAsync(token);
+
+            BuildGraph(template, request, keptStages);
+        }, ct);
+
+        return await RequireGraphAsync(templateId, ct);
+    }
+
+    public async Task SetStatusAsync(int templateId, EntityStatus status, CancellationToken ct = default)
+    {
+        var template = await _templates.Query().FirstOrDefaultAsync(t => t.TemplateId == templateId, ct)
+            ?? throw new NotFoundException($"Production template {templateId} was not found.");
+
+        template.Status = status;
+        await _uow.SaveChangesAsync(ct);
+    }
+
+    // --- graph reconciliation ------------------------------------------------
+
+    private IQueryable<ProductionTemplate> LoadGraphQuery() =>
+        _templates.Query()
+            .Include(t => t.Stages).ThenInclude(s => s.Inputs)
+            .Include(t => t.Stages).ThenInclude(s => s.Outputs)
+            .Include(t => t.Edges);
+
+    /// <summary>
+    /// Runs the pure graph rules then the referential ones. Item/UOM existence needs the
+    /// database, so it can't live in the validator — but it has to run before any write.
+    /// </summary>
+    private async Task ValidateAsync(SaveTemplateRequest request, CancellationToken ct)
+    {
+        ProductionGraphValidator.Validate(
+            request.Stages.Select(s => new ProductionGraphValidator.StageDraft(
+                s.Key, s.Name,
+                s.Inputs.Select((i, idx) => new ProductionGraphValidator.InputDraft(idx, i.Source, i.ItemId, i.FromOutputKey)).ToList(),
+                s.Outputs.Select(o => new ProductionGraphValidator.OutputDraft(o.Key, o.Name, o.ItemId)).ToList())).ToList(),
+            request.Edges.Select(e => new ProductionGraphValidator.EdgeDraft(e.ParentKey, e.ChildKey)).ToList());
+
+        var itemIds = request.Stages
+            .SelectMany(s => s.Inputs.Select(i => i.ItemId).Concat(s.Outputs.Select(o => o.ItemId)))
+            .OfType<int>().Distinct().ToList();
+
+        if (itemIds.Count > 0)
+        {
+            var found = await _items.Query().AsNoTracking()
+                .Where(i => itemIds.Contains(i.ItemId))
+                .Select(i => new { i.ItemId, i.Status })
+                .ToListAsync(ct);
+
+            var missing = itemIds.Except(found.Select(f => f.ItemId)).ToList();
+            if (missing.Count > 0)
+                throw new DomainException(ErrorCodes.Validation,
+                    $"Item(s) {string.Join(", ", missing)} do not exist.", 422);
+
+            var inactive = found.Where(f => f.Status != EntityStatus.Active).Select(f => f.ItemId).ToList();
+            if (inactive.Count > 0)
+                throw new DomainException(ErrorCodes.Validation,
+                    $"Item(s) {string.Join(", ", inactive)} are inactive and cannot be used in a template.", 422);
+        }
+
+        var uomIds = request.Stages
+            .SelectMany(s => s.Inputs.Select(i => i.UomId).Concat(s.Outputs.Select(o => o.UomId)))
+            .Distinct().ToList();
+
+        var knownUoms = await _uoms.Query().AsNoTracking()
+            .Where(u => uomIds.Contains(u.UomId)).Select(u => u.UomId).ToListAsync(ct);
+
+        var missingUoms = uomIds.Except(knownUoms).ToList();
+        if (missingUoms.Count > 0)
+            throw new DomainException(ErrorCodes.Validation,
+                $"UOM(s) {string.Join(", ", missingUoms)} do not exist.", 422);
+
+        // Annotations go into jsonb unvalidated by anything else, so pin the one field the
+        // client renders off. Unknown kinds would round-trip fine but draw nothing.
+        var badKinds = request.Annotations
+            .Select(a => a.Kind)
+            .Where(k => k is not ("box" or "line"))
+            .Distinct().ToList();
+        if (badKinds.Count > 0)
+            throw new DomainException(ErrorCodes.Validation,
+                $"Unknown canvas annotation kind(s): {string.Join(", ", badKinds)}. Expected 'box' or 'line'.", 422);
+    }
+
+    /// <summary>
+    /// Removes everything the incoming payload replaces and returns the surviving stages
+    /// by key.
+    /// </summary>
+    /// <remarks>
+    /// Inputs and outputs are always replaced wholesale — nothing outside the template
+    /// references them, because a run copies into its own <c>run_stage_input</c>/
+    /// <c>run_stage_output</c> rows. Stages are <b>diffed</b>, not replaced, because
+    /// <c>run_stages.TemplateStageId</c> points at them; a stage that disappears from the
+    /// payload is deleted and that FK is set null for any historical run (see
+    /// <c>RunStageConfiguration</c>).
+    /// </remarks>
+    private Dictionary<string, TemplateStage> TearDownGraph(ProductionTemplate template, SaveTemplateRequest request)
+    {
+        var payloadKeys = request.Stages.Select(s => s.Key).ToHashSet(StringComparer.Ordinal);
+
+        foreach (var stage in template.Stages)
+        {
+            foreach (var input in stage.Inputs.ToList()) _inputs.Remove(input);
+            foreach (var output in stage.Outputs.ToList()) _outputs.Remove(output);
+        }
+
+        var kept = new Dictionary<string, TemplateStage>(StringComparer.Ordinal);
+        var doomed = new List<TemplateStage>();
+        foreach (var stage in template.Stages.ToList())
+        {
+            var key = stage.StageId.ToString();
+            if (payloadKeys.Contains(key)) kept[key] = stage;
+            else doomed.Add(stage);
+        }
+
+        // Edges are diffed rather than replaced: stage_edges has a unique (parent, child)
+        // index, and dropping then re-adding an unchanged edge in the same round trip can
+        // trip it depending on statement order.
+        var wanted = request.Edges
+            .Select(e => (Parent: ResolveKeptId(kept, e.ParentKey), Child: ResolveKeptId(kept, e.ChildKey)))
+            .Where(e => e.Parent is not null && e.Child is not null)
+            .Select(e => (e.Parent!.Value, e.Child!.Value))
+            .ToHashSet();
+
+        // Edges must go before stages. StageEdge.ParentStage/ChildStage are required
+        // relationships, so deleting a stage that a still-live edge points at makes EF throw
+        // "the association ... has been severed". Any edge touching a doomed stage is
+        // necessarily absent from `wanted` — the payload cannot reference a stage it dropped
+        // — so this ordering never orphans an edge the caller wanted to keep.
+        foreach (var edge in template.Edges.ToList())
+            if (!wanted.Contains((edge.ParentStageId, edge.ChildStageId)))
+                _edges.Remove(edge);
+
+        foreach (var stage in doomed)
+            _stages.Remove(stage);
+
+        return kept;
+    }
+
+    private static int? ResolveKeptId(Dictionary<string, TemplateStage> kept, string key)
+        => kept.TryGetValue(key, out var stage) ? stage.StageId : null;
+
+    /// <summary>
+    /// Materialises the payload onto the template.
+    /// </summary>
+    /// <remarks>
+    /// Everything is wired through <b>navigation properties</b> rather than foreign-key
+    /// ints, so EF resolves the ids itself during a single <c>SaveChanges</c>. That is what
+    /// lets a brand-new Upstream input point at a brand-new output without an intermediate
+    /// save to materialise generated keys — outputs are built in the first pass precisely
+    /// so the second pass has the entity instances to hand.
+    /// </remarks>
+    private void BuildGraph(
+        ProductionTemplate template, SaveTemplateRequest request,
+        Dictionary<string, TemplateStage>? keptStages = null)
+    {
+        // Replaced wholesale — annotations are opaque client state, not part of the graph, so
+        // there is nothing to diff and nothing else can reference them.
+        template.Annotations = request.Annotations.Count == 0
+            ? null
+            : ProductionJson.Serialize(request.Annotations);
+
+        var stagesByKey = new Dictionary<string, TemplateStage>(StringComparer.Ordinal);
+        var outputsByKey = new Dictionary<string, StageOutput>(StringComparer.Ordinal);
+
+        // Pass 1 — stages and their outputs.
+        foreach (var s in request.Stages)
+        {
+            if (keptStages is null || !keptStages.TryGetValue(s.Key, out var stage))
+            {
+                stage = new TemplateStage { Template = template };
+                template.Stages.Add(stage);
+            }
+
+            stage.Name = s.Name.Trim();
+            stage.RoleLabel = string.IsNullOrWhiteSpace(s.RoleLabel) ? null : s.RoleLabel.Trim();
+            stage.EstimatedMinutes = s.EstimatedMinutes;
+            stage.PosX = s.PosX;
+            stage.PosY = s.PosY;
+            stage.FieldDefs = ProductionJson.Serialize(s.FieldDefs);
+
+            stagesByKey[s.Key] = stage;
+
+            foreach (var o in s.Outputs)
+            {
+                var output = new StageOutput
+                {
+                    Stage = stage,
+                    ItemId = o.ItemId,
+                    Name = o.Name.Trim(),
+                    UomId = o.UomId,
+                    QtyPerBatch = o.QtyPerBatch
+                };
+                stage.Outputs.Add(output);
+                outputsByKey[o.Key] = output;
+            }
+        }
+
+        // Pass 2 — inputs, which may reference any output built above.
+        foreach (var s in request.Stages)
+        {
+            var stage = stagesByKey[s.Key];
+            foreach (var i in s.Inputs)
+            {
+                stage.Inputs.Add(new StageInput
+                {
+                    Stage = stage,
+                    Source = i.Source,
+                    ItemId = i.Source == StageInputSource.Stock ? i.ItemId : null,
+                    FromOutput = i.Source == StageInputSource.Upstream ? outputsByKey[i.FromOutputKey!] : null,
+                    UomId = i.UomId,
+                    QtyPerBatch = i.QtyPerBatch
+                });
+            }
+        }
+
+        // Pass 3 — edges not already present.
+        var existing = template.Edges
+            .Select(e => (e.ParentStageId, e.ChildStageId)).ToHashSet();
+
+        foreach (var e in request.Edges)
+        {
+            var parent = stagesByKey[e.ParentKey];
+            var child = stagesByKey[e.ChildKey];
+            if (parent.StageId != 0 && child.StageId != 0 && existing.Contains((parent.StageId, child.StageId)))
+                continue;
+
+            template.Edges.Add(new StageEdge
+            {
+                Template = template,
+                ParentStage = parent,
+                ChildStage = child
+            });
+        }
+    }
+
+    // --- mapping -------------------------------------------------------------
+
+    private async Task<ETagged<TemplateGraphDto>> RequireGraphAsync(int templateId, CancellationToken ct)
+        => await GetAsync(templateId, ct)
+           ?? throw new NotFoundException($"Production template {templateId} was not found.");
+
+    private static TemplateGraphDto ToGraphDto(ProductionTemplate t, int activeRunCount)
+    {
+        // The key a client sends back is just the id as a string; computing it here keeps
+        // that contract in exactly one place.
+        var outputKeyById = t.Stages
+            .SelectMany(s => s.Outputs)
+            .ToDictionary(o => o.OutputId, o => o.OutputId.ToString());
+
+        var stages = t.Stages
+            .OrderBy(s => s.StageId)
+            .Select(s => new TemplateStageDto(
+                s.StageId, s.StageId.ToString(), s.Name, s.RoleLabel, s.EstimatedMinutes, s.PosX, s.PosY,
+                ProductionJson.Deserialize<List<FieldDefDto>>(s.FieldDefs, []),
+                s.Inputs.OrderBy(i => i.InputId).Select(i => new StageInputDto(
+                    i.InputId, i.Source, i.ItemId, i.FromOutputId,
+                    i.FromOutputId is null ? null : outputKeyById.GetValueOrDefault(i.FromOutputId.Value),
+                    i.UomId, i.QtyPerBatch)).ToList(),
+                s.Outputs.OrderBy(o => o.OutputId).Select(o => new StageOutputDto(
+                    o.OutputId, o.OutputId.ToString(), o.ItemId, o.Name, o.UomId, o.QtyPerBatch)).ToList()))
+            .ToList();
+
+        var edges = t.Edges
+            .OrderBy(e => e.EdgeId)
+            .Select(e => new TemplateEdgeDto(
+                e.EdgeId, e.ParentStageId, e.ChildStageId,
+                e.ParentStageId.ToString(), e.ChildStageId.ToString()))
+            .ToList();
+
+        return new TemplateGraphDto(
+            t.TemplateId, t.Code, t.Name, t.Description, t.Status, stages, edges,
+            ProductionJson.Deserialize<List<CanvasAnnotationDto>>(t.Annotations, []),
+            activeRunCount, t.CreatedBy, t.CreatedAt);
+    }
+}

Backend/ERPCore/Services/SalesInvoiceService.cs

@@ -0,0 +1,251 @@
+using ERPCore.Common.Http;
+using ERPCore.Domain;
+using ERPCore.Domain.Entities;
+using ERPCore.Domain.Enums;
+using ERPCore.Dtos.Common;
+using ERPCore.Dtos.Sales;
+using ERPCore.Infra.Auth;
+using ERPCore.Infra.UoW;
+using ERPCore.Repositories.Interfaces;
+using ERPCore.Services.Interfaces;
+using ERPCore.Services.Stock;
+using ERPCore.System.Errors;
+using Microsoft.EntityFrameworkCore;
+
+namespace ERPCore.Services;
+
+public sealed class SalesInvoiceService : ISalesInvoiceService
+{
+    private readonly IRepository<SalesInvoice> _invoices;
+    private readonly IRepository<Customer> _customers;
+    private readonly IRepository<Item> _items;
+    private readonly IRepository<Uom> _uoms;
+    private readonly IRepository<Warehouse> _warehouses;
+    private readonly ISalesPricingService _pricing;
+    private readonly IFifoCostingService _fifo;
+    private readonly ICurrentUser _currentUser;
+    private readonly INumberSequenceService _numbers;
+    private readonly IUnitOfWork _uow;
+
+    public SalesInvoiceService(
+        IRepository<SalesInvoice> invoices, IRepository<Customer> customers, IRepository<Item> items,
+        IRepository<Uom> uoms, IRepository<Warehouse> warehouses, ISalesPricingService pricing, IFifoCostingService fifo,
+        ICurrentUser currentUser, INumberSequenceService numbers, IUnitOfWork uow)
+    {
+        _invoices = invoices;
+        _customers = customers;
+        _items = items;
+        _uoms = uoms;
+        _warehouses = warehouses;
+        _pricing = pricing;
+        _fifo = fifo;
+        _currentUser = currentUser;
+        _numbers = numbers;
+        _uow = uow;
+    }
+
+    public async Task<PagedResponse<SalesInvoiceSummaryDto>> ListAsync(PageQuery query, SalesInvoiceStatus? status, int? customerId, int? warehouseId, CancellationToken ct = default)
+    {
+        IQueryable<SalesInvoice> q = _invoices.Query().AsNoTracking().Include(x => x.Lines);
+        if (!string.IsNullOrWhiteSpace(query.Q))
+        {
+            var term = query.Q.Trim();
+            q = q.Where(x => EF.Functions.ILike(x.InvoiceNo, $"%{term}%") || EF.Functions.ILike(x.CustomerSnapshotName, $"%{term}%"));
+        }
+        if (status is not null) q = q.Where(x => x.Status == status);
+        if (customerId is not null) q = q.Where(x => x.CustomerId == customerId);
+        if (warehouseId is not null) q = q.Where(x => x.WarehouseId == warehouseId);
+
+        var total = await q.CountAsync(ct);
+        var rows = await q.OrderByDescending(x => x.SalesInvoiceId).Skip(query.Skip).Take(query.PageSize).ToListAsync(ct);
+
+        return PagedResponse<SalesInvoiceSummaryDto>.Create(rows.Select(MapSummary).ToList(), query.Page, query.PageSize, total);
+    }
+
+    public async Task<ETagged<SalesInvoiceDto>?> GetAsync(int salesInvoiceId, CancellationToken ct = default)
+    {
+        var invoice = await _invoices.Query().AsNoTracking().Include(x => x.Lines)
+            .FirstOrDefaultAsync(x => x.SalesInvoiceId == salesInvoiceId, ct);
+        return invoice is null ? null : new ETagged<SalesInvoiceDto>(Map(invoice), invoice.RowVersion);
+    }
+
+    public async Task<ETagged<SalesInvoiceDto>> CreateAsync(CreateSalesInvoiceRequest request, CancellationToken ct = default)
+    {
+        await ValidateReferencesAsync(request.CustomerId, request.WarehouseId, request.Lines, ct);
+        var invoice = new SalesInvoice
+        {
+            InvoiceNo = await _numbers.NextAsync(DocumentTypes.SalesInvoice, ct),
+            InvoiceDate = DateTime.UtcNow,
+            CustomerId = request.CustomerId,
+            WarehouseId = request.WarehouseId,
+            InvoiceType = request.InvoiceType,
+            Status = SalesInvoiceStatus.Draft,
+            CreatedBy = _currentUser.AuditUserId,
+            CreatedAt = DateTime.UtcNow
+        };
+        invoice.CustomerSnapshotName = await _customers.Query().Where(x => x.CustomerId == request.CustomerId).Select(x => x.DisplayName ?? x.Name).FirstAsync(ct);
+        invoice.CustomerSnapshotTaxNo = await _customers.Query().Where(x => x.CustomerId == request.CustomerId).Select(x => x.TaxRegistrationNo).FirstAsync(ct);
+        invoice.Lines = await BuildLinesAsync(request.Lines, ct);
+        Recalculate(invoice);
+
+        await _invoices.AddAsync(invoice, ct);
+        await _uow.SaveChangesAsync(ct);
+        return new ETagged<SalesInvoiceDto>(Map(invoice), invoice.RowVersion);
+    }
+
+    public async Task<ETagged<SalesInvoiceDto>> UpdateAsync(int salesInvoiceId, UpdateSalesInvoiceRequest request, uint expectedRowVersion, CancellationToken ct = default)
+    {
+        var invoice = await _invoices.Query().Include(x => x.Lines).FirstOrDefaultAsync(x => x.SalesInvoiceId == salesInvoiceId, ct)
+            ?? throw new NotFoundException($"Sales invoice {salesInvoiceId} was not found.");
+        if (invoice.RowVersion != expectedRowVersion)
+            throw new DomainException(ErrorCodes.ConcurrencyConflict, "The sales invoice was modified by another request.", 412);
+        if (invoice.Status != SalesInvoiceStatus.Draft)
+            throw new ConflictException($"Sales invoice {salesInvoiceId} is {invoice.Status} and cannot be edited.");
+
+        await ValidateReferencesAsync(request.CustomerId, request.WarehouseId, request.Lines, ct);
+        invoice.CustomerId = request.CustomerId;
+        invoice.WarehouseId = request.WarehouseId;
+        invoice.InvoiceType = request.InvoiceType;
+        invoice.CustomerSnapshotName = await _customers.Query().Where(x => x.CustomerId == request.CustomerId).Select(x => x.DisplayName ?? x.Name).FirstAsync(ct);
+        invoice.CustomerSnapshotTaxNo = await _customers.Query().Where(x => x.CustomerId == request.CustomerId).Select(x => x.TaxRegistrationNo).FirstAsync(ct);
+        invoice.Lines.Clear();
+        foreach (var line in await BuildLinesAsync(request.Lines, ct)) invoice.Lines.Add(line);
+        Recalculate(invoice);
+        invoice.UpdatedAt = DateTime.UtcNow;
+        await _uow.SaveChangesAsync(ct);
+        return new ETagged<SalesInvoiceDto>(Map(invoice), invoice.RowVersion);
+    }
+
+    public async Task<SalesInvoiceDto> PostAsync(int salesInvoiceId, CancellationToken ct = default)
+    {
+        var invoice = await _invoices.Query().Include(x => x.Lines).FirstOrDefaultAsync(x => x.SalesInvoiceId == salesInvoiceId, ct)
+            ?? throw new NotFoundException($"Sales invoice {salesInvoiceId} was not found.");
+        if (invoice.Status != SalesInvoiceStatus.Draft)
+            throw new ConflictException($"Sales invoice {salesInvoiceId} is {invoice.Status} and cannot be posted.");
+
+        var posted = await _uow.ExecuteInTransactionAsync(async token =>
+        {
+            foreach (var line in invoice.Lines)
+            {
+                if (line.Qty <= 0) continue;
+                var consumed = await _fifo.ConsumeAsync(line.ItemId, line.WarehouseId, null, line.Qty + line.FreeQty, token);
+                var cost = consumed.Count == 0 ? 0m : consumed.Sum(x => x.Qty * x.UnitCost) / consumed.Sum(x => x.Qty);
+                await _fifo.PostLedgerAsync(line.ItemId, line.WarehouseId, null, null, null, _currentUser.AuditUserId,
+                    Direction.Out, line.Qty + line.FreeQty, cost, 0m, nameof(SalesInvoice), invoice.SalesInvoiceId, DateTime.UtcNow, token);
+            }
+
+            invoice.Status = SalesInvoiceStatus.Posted;
+            invoice.UpdatedAt = DateTime.UtcNow;
+            return invoice;
+        }, ct);
+
+        return Map(posted);
+    }
+
+    public async Task<SalesInvoiceDto> CancelAsync(int salesInvoiceId, CancellationToken ct = default)
+    {
+        var invoice = await _invoices.Query().Include(x => x.Lines).FirstOrDefaultAsync(x => x.SalesInvoiceId == salesInvoiceId, ct)
+            ?? throw new NotFoundException($"Sales invoice {salesInvoiceId} was not found.");
+        if (invoice.Status != SalesInvoiceStatus.Draft)
+            throw new ConflictException($"Sales invoice {salesInvoiceId} is {invoice.Status} and cannot be cancelled.");
+        invoice.Status = SalesInvoiceStatus.Cancelled;
+        invoice.UpdatedAt = DateTime.UtcNow;
+        await _uow.SaveChangesAsync(ct);
+        return Map(invoice);
+    }
+
+    private async Task ValidateReferencesAsync(int customerId, int warehouseId, List<CreateSalesInvoiceLineRequest> lines, CancellationToken ct)
+    {
+        if (!await _customers.Query().AnyAsync(x => x.CustomerId == customerId, ct))
+            throw new NotFoundException($"Customer {customerId} was not found.");
+        if (!await _warehouses.Query().AnyAsync(x => x.WarehouseId == warehouseId, ct))
+            throw new NotFoundException($"Warehouse {warehouseId} was not found.");
+        foreach (var line in lines)
+        {
+            if (!await _items.Query().AnyAsync(x => x.ItemId == line.ItemId, ct))
+                throw new NotFoundException($"Item {line.ItemId} was not found.");
+            if (!await _uoms.Query().AnyAsync(x => x.UomId == line.UomId, ct))
+                throw new NotFoundException($"UOM {line.UomId} was not found.");
+            if (!await _warehouses.Query().AnyAsync(x => x.WarehouseId == line.WarehouseId, ct))
+                throw new NotFoundException($"Warehouse {line.WarehouseId} was not found.");
+        }
+    }
+
+    private async Task<List<SalesInvoiceLine>> BuildLinesAsync(List<CreateSalesInvoiceLineRequest> requests, CancellationToken ct)
+    {
+        var lines = new List<SalesInvoiceLine>();
+        foreach (var r in requests)
+        {
+            var item = await _items.Query().AsNoTracking().FirstAsync(x => x.ItemId == r.ItemId, ct);
+            var resolved = await _pricing.ResolveAsync(r.ItemId, r.WarehouseId, r.UnitPrice, r.AllowManualPriceOverride, ct);
+            var unitPrice = resolved.UnitPrice;
+            var priceSource = resolved.PriceSource;
+
+            var gross = r.Qty * unitPrice;
+            var discountTotal = r.IsFreeIssue
+                ? 0m
+                : CalculateDiscount(gross, r.DiscountMode, r.DiscountPct, r.DiscountValue, r.DiscountAmount);
+            var netUnit = r.Qty > 0 ? (gross - discountTotal) / r.Qty : 0m;
+            var lineTotal = gross - discountTotal;
+            var taxAmount = lineTotal * (r.TaxPct / 100m);
+
+            lines.Add(new SalesInvoiceLine
+            {
+                ItemId = r.ItemId,
+                Description = item.Name,
+                Qty = r.Qty,
+                FreeQty = r.FreeQty,
+                UomId = r.UomId,
+                WarehouseId = r.WarehouseId,
+                UnitPrice = unitPrice,
+                BaseCost = unitPrice,
+                PriceSource = priceSource,
+                DiscountPct = r.DiscountPct,
+                DiscountAmount = discountTotal,
+                DiscountMode = r.DiscountMode,
+                NetUnitPrice = netUnit,
+                LineTotal = lineTotal,
+                TaxPct = r.TaxPct,
+                TaxAmount = taxAmount,
+                IsFreeIssue = r.IsFreeIssue,
+                ParentLineId = r.ParentLineId
+            });
+        }
+        return lines;
+    }
+
+    private static void Recalculate(SalesInvoice invoice)
+    {
+        invoice.Subtotal = invoice.Lines.Sum(x => x.Qty * x.UnitPrice);
+        invoice.DiscountTotal = invoice.Lines.Sum(x => x.DiscountAmount);
+        invoice.TaxTotal = invoice.Lines.Sum(x => x.TaxAmount);
+        invoice.GrandTotal = invoice.Lines.Sum(x => x.LineTotal) + invoice.TaxTotal;
+        invoice.RoundOff = 0m;
+        invoice.NetPayable = invoice.GrandTotal + invoice.RoundOff;
+        invoice.PaidAmount = 0m;
+        invoice.BalanceAmount = invoice.NetPayable;
+    }
+
+    private static decimal CalculateDiscount(decimal gross, SalesDiscountMode mode, decimal discountPct, decimal discountValue, decimal legacyDiscountAmount)
+    {
+        var computed = mode == SalesDiscountMode.FixedAmount
+            ? discountValue
+            : gross * (discountPct / 100m);
+
+        if (computed <= 0m && legacyDiscountAmount > 0m)
+            computed = legacyDiscountAmount;
+
+        return Math.Min(gross, Math.Max(0m, computed));
+    }
+
+    private static SalesInvoiceSummaryDto MapSummary(SalesInvoice x) => new(
+        x.SalesInvoiceId, x.InvoiceNo, x.InvoiceDate, x.CustomerId, x.CustomerSnapshotName,
+        x.WarehouseId, x.InvoiceType, x.Status, new SalesInvoiceTotalsDto(
+            x.Subtotal, x.DiscountTotal, x.Lines.Sum(l => l.FreeQty), x.TaxTotal, x.GrandTotal, x.RoundOff, x.NetPayable, x.PaidAmount, x.BalanceAmount), x.CreatedAt);
+
+    private static SalesInvoiceDto Map(SalesInvoice x) => new(
+        x.SalesInvoiceId, x.InvoiceNo, x.InvoiceDate, x.CustomerId, x.CustomerSnapshotName, x.CustomerSnapshotTaxNo,
+        x.WarehouseId, x.InvoiceType, x.Status, x.CreatedBy, x.CreatedAt, x.UpdatedAt,
+        new SalesInvoiceTotalsDto(x.Subtotal, x.DiscountTotal, x.Lines.Sum(l => l.FreeQty), x.TaxTotal, x.GrandTotal, x.RoundOff, x.NetPayable, x.PaidAmount, x.BalanceAmount),
+        x.Lines.Select(l => new SalesInvoiceLineDto(l.SalesInvoiceLineId, l.ItemId, l.Description, l.Qty, l.FreeQty, l.UomId, l.WarehouseId, l.UnitPrice, l.BaseCost, l.PriceSource, l.DiscountPct, l.DiscountAmount, l.DiscountMode, l.NetUnitPrice, l.LineTotal, l.TaxPct, l.TaxAmount, l.IsFreeIssue, l.ParentLineId)).ToList());
+}

Backend/ERPCore/Services/SalesPricingService.cs

@@ -0,0 +1,79 @@
+using ERPCore.Domain;
+using ERPCore.Domain.Entities;
+using ERPCore.Domain.Enums;
+using ERPCore.Repositories.Interfaces;
+using ERPCore.Services.Interfaces;
+using ERPCore.Services.Stock;
+using Microsoft.EntityFrameworkCore;
+
+namespace ERPCore.Services;
+
+public sealed class SalesPricingService : ISalesPricingService
+{
+    private readonly IRepository<Item> _items;
+    private readonly IRepository<GrnLine> _grnLines;
+    private readonly IFifoCostingService _fifo;
+
+    public SalesPricingService(IRepository<Item> items, IRepository<GrnLine> grnLines, IFifoCostingService fifo)
+    {
+        _items = items;
+        _grnLines = grnLines;
+        _fifo = fifo;
+    }
+
+    public async Task<SalesPriceResolution> ResolveAsync(
+        int itemId, int warehouseId, decimal? requestedUnitPrice, bool allowManualOverride, CancellationToken ct = default)
+    {
+        var item = await _items.Query().AsNoTracking().FirstOrDefaultAsync(x => x.ItemId == itemId, ct)
+            ?? throw new InvalidOperationException($"Item {itemId} was not found.");
+
+        if (requestedUnitPrice is not null)
+        {
+            if (!allowManualOverride)
+            {
+                if (item.SalePrice.HasValue)
+                    return new SalesPriceResolution(item.SalePrice.Value, "SALE_PRICE", item.SalePrice.Value);
+
+                var grnPrice = await GetWeightedGrnPriceAsync(itemId, warehouseId, ct);
+                if (grnPrice is not null)
+                    return new SalesPriceResolution(grnPrice.Value, "GRN_WEIGHTED_AVG", grnPrice.Value);
+
+                return new SalesPriceResolution(await GetFifoFallbackPriceAsync(itemId, warehouseId, ct), "FIFO_AVG", 0m);
+            }
+
+            return new SalesPriceResolution(requestedUnitPrice.Value, "MANUAL", requestedUnitPrice.Value);
+        }
+
+        if (item.SalePrice.HasValue)
+            return new SalesPriceResolution(item.SalePrice.Value, "SALE_PRICE", item.SalePrice.Value);
+
+        var weighted = await GetWeightedGrnPriceAsync(itemId, warehouseId, ct);
+        if (weighted is not null)
+            return new SalesPriceResolution(weighted.Value, "GRN_WEIGHTED_AVG", weighted.Value);
+
+        return new SalesPriceResolution(await GetFifoFallbackPriceAsync(itemId, warehouseId, ct), "FIFO_AVG", 0m);
+    }
+
+    private async Task<decimal?> GetWeightedGrnPriceAsync(int itemId, int warehouseId, CancellationToken ct)
+    {
+        var rows = await _grnLines.Query().AsNoTracking()
+            .Where(l => l.ItemId == itemId
+                        && l.Grn != null
+                        && l.Grn.WarehouseId == warehouseId
+                        && l.Grn.Status == GrnStatus.Confirmed)
+            .Select(l => new { l.Qty, l.ReceivedValue })
+            .ToListAsync(ct);
+
+        var totalQty = rows.Sum(x => x.Qty);
+        if (totalQty <= 0) return null;
+
+        var totalValue = rows.Sum(x => x.ReceivedValue);
+        return totalValue / totalQty;
+    }
+
+    private async Task<decimal> GetFifoFallbackPriceAsync(int itemId, int warehouseId, CancellationToken ct)
+    {
+        var valuation = await _fifo.GetValuationAsync(itemId, warehouseId, ct);
+        return valuation.TotalQty > 0 ? valuation.TotalValue / valuation.TotalQty : 0m;
+    }
+}

Backend/ERPCore/Services/SalesReportService.cs

@@ -0,0 +1,297 @@
+using ERPCore.Domain.Entities;
+using ERPCore.Domain.Enums;
+using ERPCore.Dtos.Sales;
+using ERPCore.Repositories.Interfaces;
+using ERPCore.Services.Interfaces;
+using Microsoft.EntityFrameworkCore;
+
+namespace ERPCore.Services;
+
+public sealed class SalesReportService : ISalesReportService
+{
+    private readonly IRepository<SalesInvoice> _invoices;
+    private readonly IRepository<SalesSlip> _slips;
+
+    public SalesReportService(IRepository<SalesInvoice> invoices, IRepository<SalesSlip> slips)
+    {
+        _invoices = invoices;
+        _slips = slips;
+    }
+
+    public async Task<IReadOnlyList<SalesDailySummaryRowDto>> DailySummaryAsync(DateOnly from, DateOnly to, CancellationToken ct = default)
+    {
+        var invoiceRows = await _invoices.Query().AsNoTracking()
+            .Where(x => x.Status == SalesInvoiceStatus.Posted && x.InvoiceDate >= from.ToDateTime(TimeOnly.MinValue) && x.InvoiceDate < to.AddDays(1).ToDateTime(TimeOnly.MinValue))
+            .GroupBy(x => DateOnly.FromDateTime(x.InvoiceDate))
+            .Select(g => new
+            {
+                Date = g.Key,
+                InvoiceCount = g.Count(),
+                SlipCount = 0,
+                InvoiceSubtotal = g.Sum(x => x.Subtotal),
+                SlipSubtotal = 0m,
+                DiscountTotal = g.Sum(x => x.DiscountTotal),
+                FreeQtyTotal = g.Sum(x => x.Lines.Sum(l => l.FreeQty)),
+                TaxTotal = g.Sum(x => x.TaxTotal),
+                GrandTotal = g.Sum(x => x.GrandTotal)
+            })
+            .ToListAsync(ct);
+
+        var slipRows = await _slips.Query().AsNoTracking()
+            .Where(x => x.Status == SalesSlipStatus.Posted && x.SlipDate >= from.ToDateTime(TimeOnly.MinValue) && x.SlipDate < to.AddDays(1).ToDateTime(TimeOnly.MinValue))
+            .GroupBy(x => DateOnly.FromDateTime(x.SlipDate))
+            .Select(g => new
+            {
+                Date = g.Key,
+                InvoiceCount = 0,
+                SlipCount = g.Count(),
+                InvoiceSubtotal = 0m,
+                SlipSubtotal = g.Sum(x => x.Subtotal),
+                DiscountTotal = g.Sum(x => x.DiscountTotal),
+                FreeQtyTotal = g.Sum(x => x.Lines.Sum(l => l.FreeQty)),
+                TaxTotal = g.Sum(x => x.TaxTotal),
+                GrandTotal = g.Sum(x => x.GrandTotal)
+            })
+            .ToListAsync(ct);
+
+        return invoiceRows.Concat(slipRows)
+            .GroupBy(x => x.Date)
+            .OrderBy(x => x.Key)
+            .Select(g => new SalesDailySummaryRowDto(
+                g.Key,
+                g.Sum(x => x.InvoiceCount),
+                g.Sum(x => x.SlipCount),
+                g.Sum(x => x.InvoiceSubtotal),
+                g.Sum(x => x.SlipSubtotal),
+                g.Sum(x => x.DiscountTotal),
+                g.Sum(x => x.FreeQtyTotal),
+                g.Sum(x => x.TaxTotal),
+                g.Sum(x => x.GrandTotal)))
+            .ToList();
+    }
+
+    public async Task<IReadOnlyList<SalesItemSummaryRowDto>> ItemSummaryAsync(DateOnly from, DateOnly to, int? itemId, int? warehouseId, CancellationToken ct = default)
+    {
+        var invoiceLines = _invoices.Query().AsNoTracking()
+            .Where(x => x.Status == SalesInvoiceStatus.Posted && x.InvoiceDate >= from.ToDateTime(TimeOnly.MinValue) && x.InvoiceDate < to.AddDays(1).ToDateTime(TimeOnly.MinValue));
+        if (warehouseId is not null) invoiceLines = invoiceLines.Where(x => x.WarehouseId == warehouseId);
+        var invoiceQuery = invoiceLines.SelectMany(x => x.Lines.Select(l => new
+        {
+            l.ItemId,
+            l.Description,
+            l.Qty,
+            l.FreeQty,
+            Gross = l.Qty * l.UnitPrice,
+            l.DiscountAmount,
+            l.TaxAmount,
+            l.LineTotal,
+            l.WarehouseId
+        }));
+        if (itemId is not null) invoiceQuery = invoiceQuery.Where(x => x.ItemId == itemId);
+
+        var slipLines = _slips.Query().AsNoTracking()
+            .Where(x => x.Status == SalesSlipStatus.Posted && x.SlipDate >= from.ToDateTime(TimeOnly.MinValue) && x.SlipDate < to.AddDays(1).ToDateTime(TimeOnly.MinValue));
+        if (warehouseId is not null) slipLines = slipLines.Where(x => x.WarehouseId == warehouseId);
+        var slipQuery = slipLines.SelectMany(x => x.Lines.Select(l => new
+        {
+            l.ItemId,
+            l.Description,
+            l.Qty,
+            l.FreeQty,
+            Gross = l.Qty * l.UnitPrice,
+            l.DiscountAmount,
+            l.TaxAmount,
+            l.LineTotal,
+            l.WarehouseId
+        }));
+        if (itemId is not null) slipQuery = slipQuery.Where(x => x.ItemId == itemId);
+
+        var rows = await invoiceQuery.Concat(slipQuery)
+            .GroupBy(x => new { x.ItemId, x.Description })
+            .Select(g => new SalesItemSummaryRowDto(
+                g.Key.ItemId,
+                g.Key.Description,
+                g.Sum(x => x.Qty),
+                g.Sum(x => x.FreeQty),
+                g.Sum(x => x.Gross),
+                g.Sum(x => x.DiscountAmount),
+                g.Sum(x => x.TaxAmount),
+                g.Sum(x => x.LineTotal + x.TaxAmount)))
+            .OrderByDescending(x => x.NetAmount)
+            .ToListAsync(ct);
+
+        return rows;
+    }
+
+    public async Task<IReadOnlyList<SalesCustomerSummaryRowDto>> CustomerSummaryAsync(DateOnly from, DateOnly to, int? customerId, CancellationToken ct = default)
+    {
+        var invoiceQuery = _invoices.Query().AsNoTracking()
+            .Where(x => x.Status == SalesInvoiceStatus.Posted && x.InvoiceDate >= from.ToDateTime(TimeOnly.MinValue) && x.InvoiceDate < to.AddDays(1).ToDateTime(TimeOnly.MinValue));
+        if (customerId is not null) invoiceQuery = invoiceQuery.Where(x => x.CustomerId == customerId);
+
+        var slipQuery = _slips.Query().AsNoTracking()
+            .Where(x => x.Status == SalesSlipStatus.Posted && x.SlipDate >= from.ToDateTime(TimeOnly.MinValue) && x.SlipDate < to.AddDays(1).ToDateTime(TimeOnly.MinValue));
+        if (customerId is not null) slipQuery = slipQuery.Where(x => x.CustomerId == customerId);
+
+        var invoiceRows = await invoiceQuery
+            .GroupBy(x => new { x.CustomerId, x.CustomerSnapshotName })
+            .Select(g => new
+            {
+                g.Key.CustomerId,
+                CustomerName = g.Key.CustomerSnapshotName,
+                InvoiceCount = g.Count(),
+                SlipCount = 0,
+                SoldQty = g.Sum(x => x.Lines.Sum(l => l.Qty)),
+                FreeQty = g.Sum(x => x.Lines.Sum(l => l.FreeQty)),
+                GrossAmount = g.Sum(x => x.Subtotal),
+                DiscountTotal = g.Sum(x => x.DiscountTotal),
+                TaxTotal = g.Sum(x => x.TaxTotal),
+                NetAmount = g.Sum(x => x.GrandTotal)
+            })
+            .ToListAsync(ct);
+
+        var slipRows = await slipQuery
+            .GroupBy(x => new { x.CustomerId, x.CustomerSnapshotName })
+            .Select(g => new
+            {
+                g.Key.CustomerId,
+                CustomerName = g.Key.CustomerSnapshotName,
+                InvoiceCount = 0,
+                SlipCount = g.Count(),
+                SoldQty = g.Sum(x => x.Lines.Sum(l => l.Qty)),
+                FreeQty = g.Sum(x => x.Lines.Sum(l => l.FreeQty)),
+                GrossAmount = g.Sum(x => x.Subtotal),
+                DiscountTotal = g.Sum(x => x.DiscountTotal),
+                TaxTotal = g.Sum(x => x.TaxTotal),
+                NetAmount = g.Sum(x => x.GrandTotal)
+            })
+            .ToListAsync(ct);
+
+        return invoiceRows.Concat(slipRows)
+            .GroupBy(x => new { x.CustomerId, x.CustomerName })
+            .OrderByDescending(g => g.Sum(x => x.NetAmount))
+            .Select(g => new SalesCustomerSummaryRowDto(
+                g.Key.CustomerId,
+                g.Key.CustomerName,
+                g.Sum(x => x.InvoiceCount),
+                g.Sum(x => x.SlipCount),
+                g.Sum(x => x.SoldQty),
+                g.Sum(x => x.FreeQty),
+                g.Sum(x => x.GrossAmount),
+                g.Sum(x => x.DiscountTotal),
+                g.Sum(x => x.TaxTotal),
+                g.Sum(x => x.NetAmount)))
+            .ToList();
+    }
+
+    public async Task<IReadOnlyList<SalesWarehouseSummaryRowDto>> WarehouseSummaryAsync(DateOnly from, DateOnly to, int? warehouseId, CancellationToken ct = default)
+    {
+        var invoiceQuery = _invoices.Query().AsNoTracking()
+            .Where(x => x.Status == SalesInvoiceStatus.Posted && x.InvoiceDate >= from.ToDateTime(TimeOnly.MinValue) && x.InvoiceDate < to.AddDays(1).ToDateTime(TimeOnly.MinValue));
+        if (warehouseId is not null) invoiceQuery = invoiceQuery.Where(x => x.WarehouseId == warehouseId);
+
+        var slipQuery = _slips.Query().AsNoTracking()
+            .Where(x => x.Status == SalesSlipStatus.Posted && x.SlipDate >= from.ToDateTime(TimeOnly.MinValue) && x.SlipDate < to.AddDays(1).ToDateTime(TimeOnly.MinValue));
+        if (warehouseId is not null) slipQuery = slipQuery.Where(x => x.WarehouseId == warehouseId);
+
+        var invoiceRows = await invoiceQuery
+            .GroupBy(x => new { x.WarehouseId, x.Warehouse!.Name })
+            .Select(g => new
+            {
+                g.Key.WarehouseId,
+                WarehouseName = g.Key.Name,
+                InvoiceCount = g.Count(),
+                SlipCount = 0,
+                SoldQty = g.Sum(x => x.Lines.Sum(l => l.Qty)),
+                FreeQty = g.Sum(x => x.Lines.Sum(l => l.FreeQty)),
+                GrossAmount = g.Sum(x => x.Subtotal),
+                DiscountTotal = g.Sum(x => x.DiscountTotal),
+                TaxTotal = g.Sum(x => x.TaxTotal),
+                NetAmount = g.Sum(x => x.GrandTotal)
+            })
+            .ToListAsync(ct);
+
+        var slipRows = await slipQuery
+            .GroupBy(x => new { x.WarehouseId, x.Warehouse!.Name })
+            .Select(g => new
+            {
+                g.Key.WarehouseId,
+                WarehouseName = g.Key.Name,
+                InvoiceCount = 0,
+                SlipCount = g.Count(),
+                SoldQty = g.Sum(x => x.Lines.Sum(l => l.Qty)),
+                FreeQty = g.Sum(x => x.Lines.Sum(l => l.FreeQty)),
+                GrossAmount = g.Sum(x => x.Subtotal),
+                DiscountTotal = g.Sum(x => x.DiscountTotal),
+                TaxTotal = g.Sum(x => x.TaxTotal),
+                NetAmount = g.Sum(x => x.GrandTotal)
+            })
+            .ToListAsync(ct);
+
+        return invoiceRows.Concat(slipRows)
+            .GroupBy(x => new { x.WarehouseId, x.WarehouseName })
+            .OrderByDescending(g => g.Sum(x => x.NetAmount))
+            .Select(g => new SalesWarehouseSummaryRowDto(
+                g.Key.WarehouseId,
+                g.Key.WarehouseName,
+                g.Sum(x => x.InvoiceCount),
+                g.Sum(x => x.SlipCount),
+                g.Sum(x => x.SoldQty),
+                g.Sum(x => x.FreeQty),
+                g.Sum(x => x.GrossAmount),
+                g.Sum(x => x.DiscountTotal),
+                g.Sum(x => x.TaxTotal),
+                g.Sum(x => x.NetAmount)))
+            .ToList();
+    }
+
+    public async Task<IReadOnlyList<SalesDiscountSummaryRowDto>> DiscountSummaryAsync(DateOnly from, DateOnly to, CancellationToken ct = default)
+    {
+        var invoices = await _invoices.Query().AsNoTracking()
+            .Where(x => x.Status == SalesInvoiceStatus.Posted && x.InvoiceDate >= from.ToDateTime(TimeOnly.MinValue) && x.InvoiceDate < to.AddDays(1).ToDateTime(TimeOnly.MinValue) && x.DiscountTotal > 0m)
+            .Select(x => new SalesDiscountSummaryRowDto("Invoice", x.InvoiceNo, x.InvoiceDate, x.CustomerSnapshotName, x.Subtotal, x.DiscountTotal, x.TaxTotal, x.GrandTotal))
+            .ToListAsync(ct);
+
+        var slips = await _slips.Query().AsNoTracking()
+            .Where(x => x.Status == SalesSlipStatus.Posted && x.SlipDate >= from.ToDateTime(TimeOnly.MinValue) && x.SlipDate < to.AddDays(1).ToDateTime(TimeOnly.MinValue) && x.DiscountTotal > 0m)
+            .Select(x => new SalesDiscountSummaryRowDto("Slip", x.SlipNo, x.SlipDate, x.CustomerSnapshotName, x.Subtotal, x.DiscountTotal, x.TaxTotal, x.GrandTotal))
+            .ToListAsync(ct);
+
+        return invoices.Concat(slips).OrderByDescending(x => x.DiscountTotal).ToList();
+    }
+
+    public async Task<IReadOnlyList<SalesFreeIssueSummaryRowDto>> FreeIssueSummaryAsync(DateOnly from, DateOnly to, CancellationToken ct = default)
+    {
+        var invoiceRows = await _invoices.Query().AsNoTracking()
+            .Where(x => x.Status == SalesInvoiceStatus.Posted && x.InvoiceDate >= from.ToDateTime(TimeOnly.MinValue) && x.InvoiceDate < to.AddDays(1).ToDateTime(TimeOnly.MinValue))
+            .SelectMany(x => x.Lines.Where(l => l.FreeQty > 0m).Select(l => new SalesFreeIssueSummaryRowDto(
+                "Invoice",
+                x.InvoiceNo,
+                x.InvoiceDate,
+                x.CustomerSnapshotName,
+                l.ItemId,
+                l.Description,
+                l.FreeQty,
+                l.FreeQty * l.UnitPrice,
+                l.WarehouseId,
+                x.Warehouse!.Name)))
+            .ToListAsync(ct);
+
+        var slipRows = await _slips.Query().AsNoTracking()
+            .Where(x => x.Status == SalesSlipStatus.Posted && x.SlipDate >= from.ToDateTime(TimeOnly.MinValue) && x.SlipDate < to.AddDays(1).ToDateTime(TimeOnly.MinValue))
+            .SelectMany(x => x.Lines.Where(l => l.FreeQty > 0m).Select(l => new SalesFreeIssueSummaryRowDto(
+                "Slip",
+                x.SlipNo,
+                x.SlipDate,
+                x.CustomerSnapshotName,
+                l.ItemId,
+                l.Description,
+                l.FreeQty,
+                l.FreeQty * l.UnitPrice,
+                l.WarehouseId,
+                x.Warehouse!.Name)))
+            .ToListAsync(ct);
+
+        return invoiceRows.Concat(slipRows).OrderByDescending(x => x.FreeQty).ToList();
+    }
+}

Backend/ERPCore/Services/SalesSlipService.cs

@@ -0,0 +1,248 @@
+using ERPCore.Common.Http;
+using ERPCore.Domain;
+using ERPCore.Domain.Entities;
+using ERPCore.Domain.Enums;
+using ERPCore.Dtos.Common;
+using ERPCore.Dtos.Sales;
+using ERPCore.Infra.Auth;
+using ERPCore.Infra.UoW;
+using ERPCore.Repositories.Interfaces;
+using ERPCore.Services.Interfaces;
+using ERPCore.Services.Stock;
+using ERPCore.System.Errors;
+using Microsoft.EntityFrameworkCore;
+
+namespace ERPCore.Services;
+
+public sealed class SalesSlipService : ISalesSlipService
+{
+    private readonly IRepository<SalesSlip> _slips;
+    private readonly IRepository<Customer> _customers;
+    private readonly IRepository<Item> _items;
+    private readonly IRepository<Uom> _uoms;
+    private readonly IRepository<Warehouse> _warehouses;
+    private readonly IRepository<User> _users;
+    private readonly ISalesPricingService _pricing;
+    private readonly IFifoCostingService _fifo;
+    private readonly ICurrentUser _currentUser;
+    private readonly INumberSequenceService _numbers;
+    private readonly IUnitOfWork _uow;
+
+    public SalesSlipService(
+        IRepository<SalesSlip> slips, IRepository<Customer> customers, IRepository<Item> items,
+        IRepository<Uom> uoms, IRepository<Warehouse> warehouses, IRepository<User> users, ISalesPricingService pricing, IFifoCostingService fifo,
+        ICurrentUser currentUser, INumberSequenceService numbers, IUnitOfWork uow)
+    {
+        _slips = slips;
+        _customers = customers;
+        _items = items;
+        _uoms = uoms;
+        _warehouses = warehouses;
+        _users = users;
+        _pricing = pricing;
+        _fifo = fifo;
+        _currentUser = currentUser;
+        _numbers = numbers;
+        _uow = uow;
+    }
+
+    public async Task<PagedResponse<SalesSlipSummaryDto>> ListAsync(PageQuery query, SalesSlipStatus? status, int? customerId, int? warehouseId, CancellationToken ct = default)
+    {
+        IQueryable<SalesSlip> q = _slips.Query().AsNoTracking().Include(x => x.Lines);
+        if (!string.IsNullOrWhiteSpace(query.Q))
+        {
+            var term = query.Q.Trim();
+            q = q.Where(x => EF.Functions.ILike(x.SlipNo, $"%{term}%") || EF.Functions.ILike(x.CustomerSnapshotName, $"%{term}%"));
+        }
+        if (status is not null) q = q.Where(x => x.Status == status);
+        if (customerId is not null) q = q.Where(x => x.CustomerId == customerId);
+        if (warehouseId is not null) q = q.Where(x => x.WarehouseId == warehouseId);
+
+        var total = await q.CountAsync(ct);
+        var rows = await q.OrderByDescending(x => x.SalesSlipId).Skip(query.Skip).Take(query.PageSize).ToListAsync(ct);
+        return PagedResponse<SalesSlipSummaryDto>.Create(rows.Select(MapSummary).ToList(), query.Page, query.PageSize, total);
+    }
+
+    public async Task<ETagged<SalesSlipDto>?> GetAsync(int salesSlipId, CancellationToken ct = default)
+    {
+        var slip = await _slips.Query().AsNoTracking().Include(x => x.Lines)
+            .FirstOrDefaultAsync(x => x.SalesSlipId == salesSlipId, ct);
+        return slip is null ? null : new ETagged<SalesSlipDto>(Map(slip), slip.RowVersion);
+    }
+
+    public async Task<ETagged<SalesSlipDto>> CreateAsync(CreateSalesSlipRequest request, CancellationToken ct = default)
+    {
+        await ValidateReferencesAsync(request.CustomerId, request.WarehouseId, request.CashierUserId, request.Lines, ct);
+
+        var slip = new SalesSlip
+        {
+            SlipNo = await _numbers.NextAsync(DocumentTypes.SalesSlip, ct),
+            SlipDate = DateTime.UtcNow,
+            CustomerId = request.CustomerId,
+            WarehouseId = request.WarehouseId,
+            CashierUserId = request.CashierUserId,
+            Status = SalesSlipStatus.Draft,
+            CreatedAt = DateTime.UtcNow
+        };
+        slip.CustomerSnapshotName = await _customers.Query().Where(x => x.CustomerId == request.CustomerId).Select(x => x.DisplayName ?? x.Name).FirstAsync(ct);
+        slip.Lines = await BuildLinesAsync(request.Lines, ct);
+        Recalculate(slip);
+
+        await _slips.AddAsync(slip, ct);
+        await _uow.SaveChangesAsync(ct);
+        return new ETagged<SalesSlipDto>(Map(slip), slip.RowVersion);
+    }
+
+    public async Task<ETagged<SalesSlipDto>> UpdateAsync(int salesSlipId, UpdateSalesSlipRequest request, uint expectedRowVersion, CancellationToken ct = default)
+    {
+        var slip = await _slips.Query().Include(x => x.Lines).FirstOrDefaultAsync(x => x.SalesSlipId == salesSlipId, ct)
+            ?? throw new NotFoundException($"Sales slip {salesSlipId} was not found.");
+        if (slip.RowVersion != expectedRowVersion)
+            throw new DomainException(ErrorCodes.ConcurrencyConflict, "The sales slip was modified by another request.", 412);
+        if (slip.Status != SalesSlipStatus.Draft)
+            throw new ConflictException($"Sales slip {salesSlipId} is {slip.Status} and cannot be edited.");
+
+        await ValidateReferencesAsync(request.CustomerId, request.WarehouseId, request.CashierUserId, request.Lines, ct);
+        slip.CustomerId = request.CustomerId;
+        slip.WarehouseId = request.WarehouseId;
+        slip.CashierUserId = request.CashierUserId;
+        slip.CustomerSnapshotName = await _customers.Query().Where(x => x.CustomerId == request.CustomerId).Select(x => x.DisplayName ?? x.Name).FirstAsync(ct);
+        slip.Lines.Clear();
+        foreach (var line in await BuildLinesAsync(request.Lines, ct)) slip.Lines.Add(line);
+        Recalculate(slip);
+        slip.UpdatedAt = DateTime.UtcNow;
+        await _uow.SaveChangesAsync(ct);
+        return new ETagged<SalesSlipDto>(Map(slip), slip.RowVersion);
+    }
+
+    public async Task<SalesSlipDto> PostAsync(int salesSlipId, CancellationToken ct = default)
+    {
+        var slip = await _slips.Query().Include(x => x.Lines).FirstOrDefaultAsync(x => x.SalesSlipId == salesSlipId, ct)
+            ?? throw new NotFoundException($"Sales slip {salesSlipId} was not found.");
+        if (slip.Status != SalesSlipStatus.Draft)
+            throw new ConflictException($"Sales slip {salesSlipId} is {slip.Status} and cannot be posted.");
+
+        var posted = await _uow.ExecuteInTransactionAsync(async token =>
+        {
+            foreach (var line in slip.Lines)
+            {
+                if (line.Qty <= 0 && line.FreeQty <= 0) continue;
+                var consumed = await _fifo.ConsumeAsync(line.ItemId, line.WarehouseId, null, line.Qty + line.FreeQty, token);
+                var cost = consumed.Count == 0 ? 0m : consumed.Sum(x => x.Qty * x.UnitCost) / consumed.Sum(x => x.Qty);
+                await _fifo.PostLedgerAsync(line.ItemId, line.WarehouseId, null, null, null, _currentUser.AuditUserId,
+                    Direction.Out, line.Qty + line.FreeQty, cost, 0m, nameof(SalesSlip), slip.SalesSlipId, DateTime.UtcNow, token);
+            }
+
+            slip.Status = SalesSlipStatus.Posted;
+            slip.UpdatedAt = DateTime.UtcNow;
+            return slip;
+        }, ct);
+
+        return Map(posted);
+    }
+
+    public async Task<SalesSlipDto> CancelAsync(int salesSlipId, CancellationToken ct = default)
+    {
+        var slip = await _slips.Query().Include(x => x.Lines).FirstOrDefaultAsync(x => x.SalesSlipId == salesSlipId, ct)
+            ?? throw new NotFoundException($"Sales slip {salesSlipId} was not found.");
+        if (slip.Status != SalesSlipStatus.Draft)
+            throw new ConflictException($"Sales slip {salesSlipId} is {slip.Status} and cannot be cancelled.");
+        slip.Status = SalesSlipStatus.Cancelled;
+        slip.UpdatedAt = DateTime.UtcNow;
+        await _uow.SaveChangesAsync(ct);
+        return Map(slip);
+    }
+
+    private async Task ValidateReferencesAsync(int customerId, int warehouseId, int cashierUserId, List<CreateSalesSlipLineRequest> lines, CancellationToken ct)
+    {
+        if (!await _customers.Query().AnyAsync(x => x.CustomerId == customerId, ct))
+            throw new NotFoundException($"Customer {customerId} was not found.");
+        if (!await _warehouses.Query().AnyAsync(x => x.WarehouseId == warehouseId, ct))
+            throw new NotFoundException($"Warehouse {warehouseId} was not found.");
+        if (!await _users.Query().AnyAsync(x => x.UserId == cashierUserId, ct))
+            throw new NotFoundException($"User {cashierUserId} was not found.");
+        foreach (var line in lines)
+        {
+            if (!await _items.Query().AnyAsync(x => x.ItemId == line.ItemId, ct))
+                throw new NotFoundException($"Item {line.ItemId} was not found.");
+            if (!await _uoms.Query().AnyAsync(x => x.UomId == line.UomId, ct))
+                throw new NotFoundException($"UOM {line.UomId} was not found.");
+            if (!await _warehouses.Query().AnyAsync(x => x.WarehouseId == line.WarehouseId, ct))
+                throw new NotFoundException($"Warehouse {line.WarehouseId} was not found.");
+        }
+    }
+
+    private async Task<List<SalesSlipLine>> BuildLinesAsync(List<CreateSalesSlipLineRequest> requests, CancellationToken ct)
+    {
+        var lines = new List<SalesSlipLine>();
+        foreach (var r in requests)
+        {
+            var item = await _items.Query().AsNoTracking().FirstAsync(x => x.ItemId == r.ItemId, ct);
+            var resolved = await _pricing.ResolveAsync(r.ItemId, r.WarehouseId, r.UnitPrice, r.AllowManualPriceOverride, ct);
+            var unitPrice = resolved.UnitPrice;
+            var priceSource = resolved.PriceSource;
+
+            var gross = r.Qty * unitPrice;
+            var discountTotal = r.IsFreeIssue
+                ? 0m
+                : CalculateDiscount(gross, r.DiscountMode, r.DiscountPct, r.DiscountValue, r.DiscountAmount);
+            var netUnit = r.Qty > 0 ? (gross - discountTotal) / r.Qty : 0m;
+            var lineTotal = gross - discountTotal;
+            var taxAmount = lineTotal * (r.TaxPct / 100m);
+
+            lines.Add(new SalesSlipLine
+            {
+                ItemId = r.ItemId,
+                Description = item.Name,
+                Qty = r.Qty,
+                FreeQty = r.FreeQty,
+                UomId = r.UomId,
+                WarehouseId = r.WarehouseId,
+                UnitPrice = unitPrice,
+                BaseCost = unitPrice,
+                PriceSource = priceSource,
+                DiscountMode = r.DiscountMode,
+                DiscountPct = r.DiscountPct,
+                DiscountAmount = discountTotal,
+                NetUnitPrice = netUnit,
+                LineTotal = lineTotal,
+                TaxPct = r.TaxPct,
+                TaxAmount = taxAmount,
+                IsFreeIssue = r.IsFreeIssue,
+                ParentLineId = r.ParentLineId
+            });
+        }
+        return lines;
+    }
+
+    private static void Recalculate(SalesSlip slip)
+    {
+        slip.Subtotal = slip.Lines.Sum(x => x.Qty * x.UnitPrice);
+        slip.DiscountTotal = slip.Lines.Sum(x => x.DiscountAmount);
+        slip.TaxTotal = slip.Lines.Sum(x => x.TaxAmount);
+        slip.GrandTotal = slip.Lines.Sum(x => x.LineTotal) + slip.TaxTotal;
+        slip.PaidAmount = 0m;
+        slip.BalanceAmount = slip.GrandTotal - slip.PaidAmount;
+    }
+
+    private static decimal CalculateDiscount(decimal gross, SalesDiscountMode mode, decimal discountPct, decimal discountValue, decimal legacyDiscountAmount)
+    {
+        var computed = mode == SalesDiscountMode.FixedAmount
+            ? discountValue
+            : gross * (discountPct / 100m);
+
+        if (computed <= 0m && legacyDiscountAmount > 0m)
+            computed = legacyDiscountAmount;
+
+        return Math.Min(gross, Math.Max(0m, computed));
+    }
+
+    private static SalesSlipSummaryDto MapSummary(SalesSlip x) => new(
+        x.SalesSlipId, x.SlipNo, x.SlipDate, x.CustomerId, x.CustomerSnapshotName, x.WarehouseId, x.Status,
+        new SalesSlipTotalsDto(x.Subtotal, x.DiscountTotal, x.Lines.Sum(l => l.FreeQty), x.TaxTotal, x.GrandTotal, x.PaidAmount, x.BalanceAmount), x.CreatedAt);
+
+    private static SalesSlipDto Map(SalesSlip x) => new(
+        x.SalesSlipId, x.SlipNo, x.SlipDate, x.CustomerId, x.CustomerSnapshotName, x.WarehouseId, x.CashierUserId, x.Status, x.CreatedAt, x.UpdatedAt,
+        new SalesSlipTotalsDto(x.Subtotal, x.DiscountTotal, x.Lines.Sum(l => l.FreeQty), x.TaxTotal, x.GrandTotal, x.PaidAmount, x.BalanceAmount),
+        x.Lines.Select(l => new SalesSlipLineDto(l.SalesSlipLineId, l.ItemId, l.Description, l.Qty, l.FreeQty, l.UomId, l.WarehouseId, l.UnitPrice, l.BaseCost, l.PriceSource, l.DiscountPct, l.DiscountAmount, l.DiscountMode, l.NetUnitPrice, l.LineTotal, l.TaxPct, l.TaxAmount, l.IsFreeIssue, l.ParentLineId)).ToList());
+}

Backend/ERPCore/Services/Stock/FifoCostingService.cs

@@ -121,7 +121,8 @@ public sealed class FifoCostingService : IFifoCostingService
     public async Task<StockLedger> PostLedgerAsync(
         int itemId, int warehouseId, int? binId, int? batchId, int? serialId, int userId,
         Direction direction, decimal qtyBase, decimal unitCost, decimal runningBalance,
-        string sourceDocType, int sourceDocId, DateTime createdAt, CancellationToken ct = default)
+        string sourceDocType, int sourceDocId, DateTime createdAt, CancellationToken ct = default,
+        decimal? valueOverride = null)
     {
         var entry = new StockLedger
         {
@@ -134,7 +135,9 @@ public sealed class FifoCostingService : IFifoCostingService
             Direction = direction,
             QtyBase = qtyBase,
             UnitCost = unitCost,
-            Value = Math.Round(qtyBase * unitCost, 4, MidpointRounding.AwayFromZero),
+            Value = valueOverride is not null
+                ? Math.Round(valueOverride.Value, 4, MidpointRounding.AwayFromZero)
+                : Math.Round(qtyBase * unitCost, 4, MidpointRounding.AwayFromZero),
             RunningBalance = runningBalance,
             SourceDocType = sourceDocType,
             SourceDocId = sourceDocId,

Backend/ERPCore/Services/Stock/UomConverter.cs

@@ -0,0 +1,38 @@
+using ERPCore.Domain.Entities;
+using ERPCore.Repositories.Interfaces;
+using ERPCore.Services.Interfaces;
+using ERPCore.System.Errors;
+using Microsoft.EntityFrameworkCore;
+
+namespace ERPCore.Services.Stock;
+
+/// <summary>
+/// Shared UOM → base-UOM conversion (see <see cref="IUomConverter"/>). Behaviour is
+/// unchanged from the <c>GrnService.ToBaseAsync</c> it was extracted from, so the GRN
+/// receive path keeps costing exactly as before.
+/// </summary>
+public sealed class UomConverter : IUomConverter
+{
+    private readonly IRepository<UomConversion> _conversions;
+
+    public UomConverter(IRepository<UomConversion> conversions) => _conversions = conversions;
+
+    public async Task<(decimal QtyBase, decimal UnitCostBase)> ToBaseAsync(
+        Item item, int uomId, decimal qty, decimal unitCostPerUom, CancellationToken ct = default)
+    {
+        if (uomId == item.BaseUomId)
+            return (qty, unitCostPerUom);
+
+        var conv = await _conversions.Query().AsNoTracking()
+            .FirstOrDefaultAsync(c => c.ItemId == item.ItemId && c.FromUomId == uomId && c.ToUomId == item.BaseUomId, ct)
+            ?? throw new DomainException(ErrorCodes.Validation,
+                $"No UOM conversion from {uomId} to base UOM {item.BaseUomId} for item {item.ItemId}.", 422);
+
+        // Quantity scales up by the factor, so the per-unit cost scales down by it —
+        // total value is preserved.
+        return (qty * conv.Factor, unitCostPerUom / conv.Factor);
+    }
+
+    public async Task<decimal> ToBaseQtyAsync(Item item, int uomId, decimal qty, CancellationToken ct = default)
+        => (await ToBaseAsync(item, uomId, qty, 0m, ct)).QtyBase;
+}

Backend/ERPCore/System/Errors/ErrorCodes.cs

@@ -47,4 +47,26 @@ public static class ErrorCodes
     public const string SalaryStructureOverlap = "SALARY_STRUCTURE_OVERLAP";
     public const string TaxSlabGapInvalid = "TAX_SLAB_GAP_INVALID";
     public const string PayrollPeriodLocked = "PAYROLL_PERIOD_LOCKED";
+
+    // Manufacturing / Production Lines (docs/30-BACKEND-PHASE2.md §D.4)
+    public const string TemplateInUse = "TEMPLATE_IN_USE";
+    public const string TemplateInactive = "TEMPLATE_INACTIVE";
+    public const string GraphCycle = "GRAPH_CYCLE";
+    public const string GraphTerminalCount = "GRAPH_TERMINAL_COUNT";
+    public const string GraphDisconnected = "GRAPH_DISCONNECTED";
+    public const string GraphInputSourceInvalid = "GRAPH_INPUT_SOURCE_INVALID";
+    public const string TerminalOutputItemRequired = "TERMINAL_OUTPUT_ITEM_REQUIRED";
+    public const string StageNotReady = "STAGE_NOT_READY";
+    public const string StageNotInProgress = "STAGE_NOT_IN_PROGRESS";
+    public const string StageNotDone = "STAGE_NOT_DONE";
+    public const string StageNotEditable = "STAGE_NOT_EDITABLE";
+    public const string StageRejectInvalid = "STAGE_REJECT_INVALID";
+    public const string RequiredFieldMissing = "REQUIRED_FIELD_MISSING";
+    public const string TransferExceedsAvailable = "TRANSFER_EXCEEDS_AVAILABLE";
+    public const string LeftoverExceedsConsumed = "LEFTOVER_EXCEEDS_CONSUMED";
+    public const string RunCostClosed = "RUN_COST_CLOSED";
+    public const string RunNotCancellable = "RUN_NOT_CANCELLABLE";
+
+    // General Ledger service proxy (GeneralLedgerController → external GL service, docs/12)
+    public const string GlServiceUnavailable = "GL_SERVICE_UNAVAILABLE";
 }

Backend/ERPCore/appsettings.Development.json

@@ -6,7 +6,7 @@
     }
   },
   "ConnectionStrings": {
-    "DefaultConnection": "Host=localhost;Port=5432;Database=ERPCore;Username=postgres;Password=root"
+    "DefaultConnection": "Host=localhost;Port=5432;Database=ERPCoreDev;Username=postgres;Password=root"
   },
   "AuthHex": {
     "BaseUrl": "http://localhost:5011"

Backend/ERPCore/appsettings.json

@@ -16,11 +16,15 @@
     "RequiredRoleCode": ""
   },
   "AuthHex": {
-    "BaseUrl": "http://localhost:5011"
+    "BaseUrl": "http://localhost:5602"
   },
   "FileStorage": {
     "RootPath": "App_Data/hr-documents",
     "MaxSizeBytes": 10485760
   },
+  "GeneralLedgerService": {
+    "BaseUrl": "https://localhost:7024/api/v1/",
+    "ApiKey": "1A5FE0E389C029B1FBCD2A94650CEBF0656083BF06FF48E5E11987040ABA262D"
+  },
   "AllowedHosts": "*"
 }

Backend/PROGRESS.md

@@ -105,6 +105,44 @@ Convention: `docs/01-DOC-GUIDE.md §6`. Update this file in the **same commit**
 - [~] FEFO picking for perishables; block expired / on-hold issue — **issue-block done + verified** (`ONHOLD_NOT_ISSUABLE`, `EXPIRED_BATCH_BLOCKED`; on-hold/expired layers excluded from consume). FEFO *pick ordering* (oldest-expiry first) not yet built.
 - [x] Reason codes (FR-X-04) — `ReasonCode` entity + `GET/POST /reason-codes`; standard set (docs/10 §B.8.3) seeded idempotently at startup (`DataSeeder`). Verified.
 
+## 7. External Integrations
+> **General Ledger service** (separate microservice, own repo/DB) — connected 2026-07-20 as a generic reverse-proxy only; no ERPCore business logic posts to it yet. Full contract + progress detail: `docs/12-GENERAL-LEDGER-INTEGRATION.md`.
+- [~] Generic proxy `GET|POST|PUT /api/v1/gl/{**path}` (`GeneralLedgerController` → `IGeneralLedgerService` → `IGeneralLedgerClient`) — forwards method/path/query/body/content-type verbatim to the GL service with a server-attached `X-Api-Key`; GL's response (status + body) returned unchanged. ErpAccess-door-policy-gated like every other v1 endpoint. Config: `GeneralLedgerService:BaseUrl`/`ApiKey` in `appsettings.json`. Build verified clean; **not yet live-smoke-tested** (no running GL instance this pass).
+- [ ] Internal wiring — ERPCore services (GRN confirm, adjustments, etc.) calling `IGeneralLedgerService` directly to post real journal entries. Deliberately deferred.
+
+> ### 2026-07-20 — RBAC nav seed for the frontend's new "Ledgers" section
+> The `Frontend/PROGRESS.md` §8 "Ledgers" sidebar section (docs/21-GENERAL-LEDGER-FRONTEND.md) needs a matching `NavItem`/`SubNavItem`/`Permission` row for every entry, or the sidebar filters it out for every role regardless of the frontend change (docs/10 C.8, `GET /auth/me`'s `navCodes`). Added via `NavItemConfiguration.cs`/`SubNavItemConfiguration.cs`/`PermissionConfiguration.cs` `HasData`: `NavItem` `ledgers` (id 11), 7 `SubNavItem` rows (ids 9–15, `ledgers.trial-balance` … `ledgers.bank-accounts`), 8 `Permission` rows (ids 19–26) — same one-`Permission`-per-nav-entry convention as every existing nav row. Migration `AddLedgersNavSeed`.
+> **Build note:** a locally running `ERPCore.exe` (PID 29692) held the default `bin/Debug` output locked for the whole session, so `dotnet ef migrations add` twice produced an empty no-op migration off a stale assembly (`--no-build` silently reused pre-edit code) before the real cause was found. Fixed by building to a scratch output directory (unaffected by the lock), copying the fresh `ERPCore.dll` over the locked `bin/Debug` copy (the running process only locks the `.exe`, not the `.dll`), then re-scaffolding — the resulting migration's `Up`/`Down` were verified by inspection against the identical, already-applied `AddRolesNavPermissions` migration's `InsertData`/`DeleteData` shape. The stray process was left running rather than killed, since it wasn't started by this work and may be in active use elsewhere.
+> **Not yet applied to a live database** — no Postgres instance was available in this pass to run `dotnet ef database update` against. `dotnet build` is clean (0 warnings/0 errors).
+> **Operational step still needed post-deploy (not code):** a new `NavItem`/`SubNavItem` carries no `RolePermission` grants by default — an administrator must check the new Ledgers permissions for the relevant role(s) via **Settings → Roles** before anyone sees the sidebar entry, same as every previous nav addition.
+
+> ### 2026-07-30 — RBAC nav seed: 8th sub-item for the new "Tax Report" screen
+> The frontend's GL-revision pass (`docs/21-GENERAL-LEDGER-FRONTEND.md`, Frontend/PROGRESS.md §8) added a Tax Report screen to the Ledgers sidebar section — needs the same nav-seed treatment as every other entry (docs/10 C.8). Added `SubNavItem` id 16 (`ledgers.tax-report`, `/dashboard/ledgers/tax-report`, sort order 7) and `Permission` id 27 (`NAV:ledgers.tax-report`); re-sequenced the existing `ledgers.bank-accounts` row's `SortOrder` from 7→8 so Tax Report sits before it, matching the sidebar array's actual order. Migration `AddTaxReportNavSeed` — no locked-process issue this time (confirmed no stray `ERPCore.exe` running before scaffolding), generated cleanly on the first attempt with real `InsertData`/`UpdateData`/`DeleteData` (`Down()` correctly restores `bank-accounts`' `SortOrder` to 7). `dotnet build` clean (0 warnings/0 errors). **Not yet applied to a live database** — same open item as the original `AddLedgersNavSeed` migration; both are still pending `dotnet ef database update` against a real Postgres instance.
+
+> ### 2026-07-30 (2) — Fixed a real `SubNavItemId`/`PermissionId` collision between Procurement and Ledgers seed data
+> **Root cause:** when the 2026-07-20 `AddLedgersNavSeed` migration was authored, its `SubNavItem`/`Permission` IDs were picked by looking at the *actual DB row count*, not the config source — but `SubNavItemConfiguration.cs`/`PermissionConfiguration.cs` already had `HasData` entries for Procurement's 4 sub-items (`procurement.requisitions`/`.rfqs`/`.purchase-orders`/`.purchase-returns`, ids 9–12/19–22) that **had never actually been migrated into any database** (no migration `Up()` anywhere ever inserts them — confirmed by grep across every migration file). Ledgers then claimed the same ids (9–12 sub-nav, 19–22 permission) for its own rows, so the config ended up with two `HasData` entries sharing the same primary key per table. `ErpDbContextModelSnapshot.cs` had silently absorbed both (`dotnet ef migrations add` doesn't hard-fail on this at scaffold time), but **EF's runtime model validator does** — `dotnet ef migrations add` for anything touching these tables, and by extension normal app startup/first `DbContext` use, throws `InvalidOperationException: A seed entity ... has the same key value as another seed entity mapped to the same table`. This is very likely the crash the user was hitting.
+> **Fix:** moved Procurement's 4 sub-nav rows off the colliding ids onto **17–20** (`SubNavItemId`) and **28–31** (`PermissionId`), past every id already claimed by Ledgers/Tax-Report (max 16/27). Removed the phantom duplicate Procurement entries from `ErpDbContextModelSnapshot.cs` (they never reflected real DB state) so the differ could compute a clean diff, then generated migration **`FixProcurementNavIdCollision`** — pure `InsertData` for the 4 sub-nav rows + 4 permission rows at their new ids (this is also the *first* migration that actually creates Procurement's sub-nav-item/permission rows in the database at all). `Down()` is a clean `DeleteData` reversal.
+> **Verified:** running `dotnet ef migrations add` against the pre-fix config reproduced the exact `InvalidOperationException` above (scaffold failed outright, no migration file produced), confirming this was a real, reproducible crash and not a false alarm; after the fix, the same command succeeded and `dotnet ef migrations list` builds the full model with no error, listing all 7 migrations (the last 2 — `AddTaxReportNavSeed`, `FixProcurementNavIdCollision` — still `(Pending)`, no Postgres instance available this session); `dotnet build` clean (0 warnings/0 errors). **Not yet applied to a live database** — same standing blocker as the two prior nav-seed migrations.
+> Also fixed, same pass: `Frontend/erp-system/components/Layouts/AppSidebar.tsx`'s auto-expand-active-parent logic tripped `react-hooks/set-state-in-effect` (`setExpanded` called synchronously inside a `useEffect`) — converted to the same "adjust state during render" pattern used for the Ledgers report pages, keyed on a `pathname + item-codes` composite key (tracked via a `lastAutoExpandKey` state var) so it still re-fires once `items` populates after the RBAC `navCodes` fetch resolves. `npx eslint components/Layouts/AppSidebar.tsx` clean.
+
+> ### 2026-07-31 — RBAC nav seed: new "Accounts" nav item (Cheque Management screens + Cash/Bank Accounts moved off Ledgers)
+> The frontend added a new "Accounts" sidebar section (`Frontend/PROGRESS.md` §8) for the new Cheque Management screens and to hold Cash/Bank Accounts, which moved out of Ledgers into it (user-requested — Cheque Books/Received Cheques/Cash-Bank Accounts are all the same kind of operational account bookkeeping, not a statutory report). Migration **`AddAccountsNavSeed`**: `InsertData` for `NavItem` `accounts` (id 12) and two new `SubNavItem`/`Permission` pairs (`accounts.cheque-books` id 21/33, `accounts.received-cheques` id 22/34); **`UpdateData`, not delete-and-recreate**, for the existing Cash/Bank Accounts `SubNavItem`/`Permission` (ids 15/26) — same ids, just new `Code`/`Href`/`NavItemId` — so a role that had already been granted this permission under its old `ledgers.bank-accounts` code doesn't silently lose it just because the section changed. `Down()` correctly reverses both the inserts and the renamed-row update back to its Ledgers-era values.
+> **No locked-process issue avoided this time** — `ERPCore.exe` was found running twice during this pass (the user had restarted it between turns to test the Tax Report fix); confirmed with the user before killing it each time, per this session's standing caution around stopping their dev server. `dotnet build` clean (0 warnings/0 errors); `dotnet ef migrations list` shows all 8 migrations with none pending. **Applied to the live database this session** (`dotnet ef database update`) — unlike every prior nav-seed migration this session, this one did not have to wait for a live Postgres instance to become available.
+> **Operational step still needed post-deploy (not code):** same as every previous nav addition — an administrator must grant the new `NAV:accounts`/`NAV:accounts.cheque-books`/`NAV:accounts.received-cheques` permissions to the relevant role(s) via **Settings → Roles** before anyone sees the new sidebar entries (the re-homed `NAV:accounts.bank-accounts` keeps whatever grants it already had).
+
+> ### 2026-07-31 (2) — Root-caused and fixed a repo-wide bug: 36 tables (all of HRM + all of Manufacturing) existed in the EF model but not in the actual database, and no `dotnet ef migrations add` could ever surface it
+> **User-reported:** after rebasing `feat/general-ledger-service` onto `origin/Dev`, some tables from the other branch weren't being created by `migrations add` + `database update`. Ground-truthed against the live Postgres instance (queried `pg_tables`/`__EFMigrationsHistory` directly, since EF's own diff tooling only ever compares the compiled model against `ErpDbContextModelSnapshot.cs` — never the real database — so it's structurally blind to this class of bug): the database had 45 tables; the current model/snapshot expects 80. All 25 `hr_*` tables and all 11 `production_runs`/`production_templates`/`run_*`/`stage_*`/`template_stages` tables were completely absent, despite `ErpDbContext`/`Infra/Persistence/Configurations` fully describing them and `ErpDbContextModelSnapshot.cs` already listing them.
+> **Root cause: a `.gitignore` rule (`**/Migrations/`, added early on to stop *new* EF migrations from being committed) combined disastrously with `ErpDbContextModelSnapshot.cs` staying tracked** (`.gitignore` doesn't retroactively untrack already-tracked files, and the snapshot was one of the original 4 tracked migrations). Every `dotnet ef migrations add` after that point updated the snapshot (which **did** get committed normally, since it was already tracked) but wrote its actual migration `.cs`/`.Designer.cs` pair as new, gitignored, never-committed files. Confirmed via `git show --stat` on every historical commit touching the snapshot: several — including the commit that added the entire HRM module and the one that added Manufacturing (`7d6e597`) — show large snapshot insertions with **zero** migration files in the same commit. Net effect: the snapshot has been silently lying about the applied-migration history for a long time; `dotnet ef migrations add` never detects a "missing" table because, as far as the (already-tracked, already-correct-looking) snapshot is concerned, nothing has changed — the actual `CreateTable` migration simply never existed anywhere in git, on any machine that didn't happen to still have it sitting locally, ungitignored-but-untracked.
+> **Fix, in order:**
+> 1. Confirmed the exact 36-table gap by comparing `pg_tables` against every `b.ToTable(...)` call in the snapshot (script, not archaeology — this is the only way to get ground truth once the snapshot itself is suspect).
+> 2. Temporarily removed just those 36 entities' blocks from `ErpDbContextModelSnapshot.cs` (verified 2–3 balanced-brace occurrences per entity removed cleanly, nothing else touched), so `dotnet ef migrations add` would have something real to diff against.
+> 3. Generated **`AddMissingHrmAndManufacturingTables`** — verified its `Up()` contains exactly 36 `CreateTable` calls (matching the missing-table list precisely, no more/fewer) and its `Down()` exactly 36 matching `DropTable` calls; no `AlterColumn`/`DropColumn`/`RenameColumn` against any pre-existing table, confirming this was a pure addition with zero collateral schema drift.
+> 4. Applied it (`dotnet ef database update`); re-queried `pg_tables` live — all 81 tables (80 + `__EFMigrationsHistory`) now present. Confirmed fully settled by scaffolding one more throwaway migration afterward and checking it came back empty (no remaining model/snapshot drift), then removing it.
+> 5. **Fixed the actual root cause, not just this one symptom:** reverted the `.gitignore` rule — EF Core migrations are now tracked like any other source file, so this can't recur the same way. Every migration created since the rule was added (`AddLedgersNavSeed`, `AddTaxReportNavSeed`, `FixProcurementNavIdCollision`, `AddAccountsNavSeed`, the empty `production` migration, and this pass's `AddMissingHrmAndManufacturingTables`) was sitting on disk ungitignored-but-uncommitted the whole time — now staged to actually join the repo.
+> **Verified:** `dotnet build` clean (0 errors, pre-existing `CS8981` naming warning on the already-present `production` migration class only); `dotnet ef migrations list` shows all 10 migrations, none pending. **A locally running `ERPCore.exe` had to be stopped mid-session (user's explicit approval obtained first) to free the build lock**, same recurring issue as every previous migration pass this week.
+> **Left as-is, deliberately:** the empty `production` migration (`20260731123720_production.cs`) — it's a harmless no-op (it was the user's own prior attempt to fix this exact bug, which came back empty for the reason explained above) and renaming/removing it now would just be churn; the real fix landed in the next migration.
+> **Action needed from the user:** the `.gitignore` fix means these migration files are no longer excluded, but nothing has been `git add`ed or committed yet — per standing instruction, commits only happen when explicitly asked.
+
 ## Deferred (Phase 2+ — do NOT build now, hooks only)
 - [ ] Vendor invoice + three-way match
 - [ ] Reservation/allocation fulfilment
@@ -178,9 +216,108 @@ Spec: `docs/12-BACKEND-HRM.md` (model + rules) · `docs/13-BACKEND-HRM-API.md` (
 - [x] Employee salary history (`.../salary-history?employeeId=`) — full `EmployeeSalaryStructure` revision history, ordered newest first
 - [x] Leave balance report (`.../leave-balances?year=`), document expiry report (`.../document-expiry?withinDays=`)
 
+---
+
+# Manufacturing — Production Lines (Phase 2)
+
+Spec: `docs/30-BACKEND-PHASE2.md` (model + rules **and** API — one doc, unlike Phase 1). Frontend consumption: `docs/21-FRONTEND-PHASE2.md`. Security: `docs/02-SECURITY.md §B.6` (narrow DTOs — statuses are never client-settable) + `§B.7` (FIFO row-locking inside the UoW txn).
+
+> **§11–§16 code complete, migration applied, and live smoke-tested (2026-07-30).** `dotnet build` clean (0 errors; the only warnings are the two pre-existing `CS8981` from the badly-named `chages` migration). Migration `AddManufacturingPhase2` — 11 `CreateTable`, zero `AlterColumn`, applied and verified against `information_schema`. **312 smoke assertions, all green**, via re-runnable scripts in `Backend/smoke/` against local Postgres + a real AuthHex session.
+
+## 11. Sub-phase 2.1 — Schema + enums
+- [x] 11 entities (`ProductionTemplate`, `TemplateStage`, `StageEdge`, `StageInput`, `StageOutput`, `ProductionRun`, `RunStage`, `RunEdge`, `RunStageInput`, `RunStageOutput`, `RunStageEvent`) + `ProductionConfiguration.cs` (all 11 configs in one file, per the `StockConfiguration.cs` precedent). snake_case tables, PascalCase columns, enums as `varchar(20)`, qty/value `(18,4)`, unit cost + scale factor `(18,6)`, `xmin` RowVersion on template/run/run-stage
+- [x] Enums `ProductionRunStatus`, `ProductionStageStatus`, `StageInputSource`, `RunStageEventType`, `CustomFieldType`; `ReasonContext` += `Production`; `DocumentTypes.Production = "PRD"`; new `Domain/LedgerSourceTypes.cs`
+- [x] 4 Production reason codes seeded idempotently (`PRD-SCRAP`, `PRD-LEFTOVER`, `PRD-CANCEL`, `PRD-REWORK-LOSS`) — verified live via `GET /reason-codes?context=Production`
+- [x] jsonb (`field_defs`, `field_values`, `payload`) as CLR `string` + `HasColumnType("jsonb")`, always written through `ProductionJson` so a column can only hold canonical JSON. Follows the `AuditLog.ChangeSet` precedent; a typed/owned mapping would make `AuditScribe` emit spurious audit rows for the nested entries
+
+## 12. Sub-phase 2.2 — Templates + graph validation (FR-MFG-01..07)
+> **Smoke: 38/38** (`Backend/smoke/m2_templates.py`). Zero stock touched.
+- [x] `ProductionGraphValidator` — a `public static class`, deliberately not an injected service (pure, synchronous, no DI). Kahn toposort → `GRAPH_CYCLE`; terminal count → `GRAPH_TERMINAL_COUNT`; one combined bidirectional-reachability check → `GRAPH_DISCONNECTED`; direct-parent check → `GRAPH_INPUT_SOURCE_INVALID`; terminal output → `TERMINAL_OUTPUT_ITEM_REQUIRED`. Works in **keys**, not ids, so identical code serves POST and PUT
+- [x] `/production-templates` list/get/create/update/status, ETag + `If-Match` (428 missing, 412 stale), `409 TEMPLATE_IN_USE` on PUT while a run is InProgress
+- [x] Full-graph PUT reconciliation: stages **diffed** (a run references them), inputs/outputs **replaced**, edges **diffed** (unique `(parent, child)` index). Rebuilt through navigation properties so EF resolves generated keys in one `SaveChanges`
+
+## 13. Sub-phase 2.3 — Run creation, board, detail, quantities (FR-MFG-08/09/18)
+> **Smoke: 54/54** (`m3_runs.py`). Zero stock touched.
+- [x] `POST /production-runs` — copies stages/inputs/outputs/edges in three passes, scales from the **unrounded** ratio (rounding each quantity once, so a repeating scale factor doesn't compound), `PRD-2026-0000N` from `NumberSequenceService` inside the transaction, entry stages `Ready`
+- [x] `GET /production-runs` with `stageSummary` computed server-side; projected to an anonymous type first then mapped client-side (EF Core 10 cannot translate a record ctor alongside aggregates — same failure as `WarehouseValuationDto`, 2026-07-28)
+- [x] `GET /production-runs/{id}` full graph incl. events, derived `isTerminal`/`isEntry`/`availableToTransfer`/`actualMinutes`/`costPool`
+- [x] `PUT .../stages/{sid}/quantities` — `409 STAGE_NOT_EDITABLE` once started, and re-evaluates readiness (raising an upstream planned qty demotes a Ready stage back to Waiting)
+
+## 14. Sub-phase 2.4 — Stage execution (FR-MFG-10/11/12) · first stock-touching
+> **Smoke: 66/66** (`m4_stage_actions.py`) **+ 14/14** (`m4b_uom_conversion.py`). Isolated `SMOKE-PRD` warehouse.
+- [x] `…/start` — FIFO-consumes Stock inputs via `IFifoCostingService.ConsumeAsync`, `PRDI` ledger, `actualStartAt`. Consumes `max(0, plannedBase − consumedQty)` so a rework restart draws only the delta
+- [x] `…/complete` — produced/scrapped per output + custom field values; `400 REQUIRED_FIELD_MISSING`, `400 REASON_CODE_REQUIRED`, Production-context reason enforced. **Overwrites** on a re-complete
+- [x] `…/approve` (non-terminal) + `…/transfer` — default full transfer, optional partial, `422 TRANSFER_EXCEEDS_AVAILABLE`, child readiness recomputed. Routes by `fromRunOutputId`, not by edge
+- [x] **`IUomConverter` extracted** from `GrnService.ToBaseAsync` into `Services/Stock/UomConverter.cs`; `GrnService` delegates to it, behaviour unchanged. Verified: a stage input declared in a 12× UOM consumes **360** base units, not 30; the ledger records base; an undefined conversion is `422`, never assumed 1:1
+
+## 15. Sub-phase 2.5 — Terminal receipt + cost pool (FR-MFG-13)
+> **Smoke: 36/36** (`m5_receipt.py`).
+- [x] Terminal approve creates the finished layer at `costPool / goodQty`, posts `PRDR`, completes the run and closes the pool (`409 RUN_COST_CLOSED`)
+- [x] **`decimal? valueOverride` added to `IFifoCostingService.PostLedgerAsync`** (default keeps `round(qty × unitCost, 4)`; every existing call site unaffected). Empirically necessary, not theoretical: at 300 units the 6 dp unit cost gives a naive value of `3405.5553` against a pool of `3405.5552` — a real 0.0001 drift. The smoke test asserts the naive product *would* have drifted, so the fixture cannot silently go blind
+- [x] Batch/serial-tracked finished goods refused with `422` (this phase defines no batch creation on receipt). **Untested** — no tracked item exists in the dev DB; noted in the script
+
+## 16. Sub-phase 2.6 — Leftover return, rework, cancel (FR-MFG-14..17)
+> **Smoke: 104/104** (`m6_m7_leftover_rework_cancel.py`).
+- [x] `…/return-leftover` — inbound at the input's consumed weighted cost, `PRDL`, bin null (raw material, not the finished-goods bin). Value computed from the **unrounded** weighted cost and rounded once; a *full* return takes the exact residual so `returnedValue == consumedValue` precisely. `422 LEFTOVER_EXCEEDS_CONSUMED`, `409 RUN_COST_CLOSED`
+- [x] `…/reject-intake` — parent `transferredQty` **decremented** (not zeroed, so a parent that also fed another child stays consistent), parent `Approved → InProgress` with `ActualStartAt` preserved, rejecting stage → `Waiting`. Allowed from `Ready` **or** `Waiting` with delivered intake
+- [x] `…/reject` (terminal) — whole-run reset with one snapshot event per pass; `plannedQty` and `consumed*`/`returned*` **preserved**, stock untouched. Verified across two consecutive rework passes
+- [x] `POST .../cancel` — returns `consumed − returned` per input at the consumed weighted cost (`PRDC`), `balances` dictionary accumulated per item (layers created in-transaction are invisible to `GetOnHandAsync` until `SaveChanges`), scrapped output qty recorded as `scrappedWrittenOff`. `409 RUN_NOT_CANCELLABLE`
+- [x] Event history + estimated-vs-actual (FR-MFG-19) — every action writes one `RUN_STAGE_EVENT`; failed actions write none (the write rolls back with the change)
+
+**Bugs found and fixed during this phase (not silently patched):**
+- **Template PUT 500** — deleting a `TemplateStage` while a `StageEdge` still referenced it severed a required EF relationship. Edges are now removed before stages; any edge touching a deleted stage is by construction absent from the payload, so nothing the caller wanted is orphaned.
+- **`receipt.layerId` returned 0** — the `ReceiptDto` was built inside the transaction, before `SaveChanges` generated the id. Now mapped after the commit (same fix as the `ledgerRefs:[0]` issue recorded 2026-07-13).
+- **Runtime messages carried U+2212** (typographic minus) and broke console/log encoding on Windows cp1252. Exception strings now use ASCII hyphens; comments keep the typographic form, matching the rest of the codebase.
+
+**Deviations / decisions (recorded, not silently assumed) — all mirrored into `docs/30`:**
+- **§A.1 was a no-op.** `StockLayer.GrnLineId` was already nullable in entity, config, snapshot **and** database. Phase-1 schema was not altered at all; NFR-08 holds without exception.
+- **Ledger codes are `PRDI`/`PRDR`/`PRDL`/`PRDC`**, not the doc's 15–22-char names — `SourceDocType` is `varchar(10)` on both `stock_ledger` and `journal_entry_stubs`, and widening it would have been a second Phase-1 schema change.
+- **Three additions to Part C:** `RUN_EDGE` (a run must own its edges or a later template edit rewrites completed-run history), `RUN_STAGE.pos_x/pos_y` (the run canvas renders from them), `RUN_STAGE_EVENT.run_id` + nullable `run_stage_id` (run-level events, single-query timeline). `RUN_STAGE.template_stage_id` made nullable + `SET NULL` so a template stays editable after runs complete.
+- **UOM conversion is unspecified in docs/30** but essential. Contract consequence: `plannedQty` is in the input's declared UOM while `consumed*`/`returned*` are in the item's **base** UOM.
+- **`Idempotency-Key` accepted and ignored**, matching `GrnService.ConfirmAsync`. Status guards are the replay story; `RunStage.RowVersion` (xmin) prevents two concurrent terminal approves double-posting a receipt.
+- **FR-MFG-17's "− scrapped" is not computable** at the input level (scrap lives on outputs, in output UOM). Scrap never entered stock, so nothing is deducted; scrapped quantities are recorded on the cancel event instead.
+- **`GRAPH_DISCONNECTED` is unreachable** once cycle + terminal-count pass; kept as defence in depth. An isolated stage surfaces as `GRAPH_TERMINAL_COUNT`.
+- **Edit-lock TOCTOU accepted** — checked inside the transaction, but under READ COMMITTED a run could still be created against a template mid-edit. Benign: runs copy everything at creation and never re-read the template.
+
+**Not done this pass (tracked, not silently skipped):**
+- [x] **Frontend wiring** (`docs/21-FRONTEND-PHASE2.md` §8) — done in the same session; see `Frontend/PROGRESS.md` §§11–13. Not browser-verified (same AuthHex blocker).
+- **Batch/serial-tracked finished goods** — guarded with a 422, and that guard is unexercised (no tracked item in the dev DB).
+- **`NAV:production` permission** is not seeded; the sidebar still relies on the `bypassCodes` stopgap (same as `procurement`/`hrm`).
+- **No automated test project** — verification is the `Backend/smoke/` scripts, per house practice.
+
+> ### 2026-07-30 — Dev-database repair + a drift audit worth repeating
+> **`users."Email"` was missing from the database** while present in the entity and the model snapshot, so `ShadowUserClaimsTransformation`'s JIT insert failed with `42703` on **every authenticated request** — surfacing to callers as a confusing `InvalidOperationException: Sequence contains no elements`. `GET /items` and everything else 500'd. Fixed by the hand-written migration `RepairUserEmailColumn` (idempotent `ADD COLUMN IF NOT EXISTS` + the unique index, matching `UserConfiguration`'s `HasMaxLength(320)`).
+>
+> **Root cause — four migrations recorded as applied with zero operations:** `ini2`, `initial2`, `chages`, `chages1` each advanced the model snapshot without emitting any DDL. Anything added to the model in those windows exists in the snapshot but never reached the database.
+>
+> **Method note (this is the reusable part):** a scaffolded probe migration coming back **empty proves only `model == snapshot`, never `snapshot == database`** — which is exactly how this hid. The real audit was `dotnet ef dbcontext script` (which renders the *current model*) diffed against `information_schema.columns`.
+>
+> **Still outstanding — not fixed here, deliberately:** the same four empty migrations mean **all 25 HRM tables (`hr_*`) exist in the model and snapshot but not in this database**, so every HRM endpoint fails. Creating 25 tables of another module as a side effect of manufacturing work would be worse than reporting it; it needs its own repair migration and its own verification.
+>
+> **Also worth knowing:** `.gitignore:38` is `**/Migrations/`, so **no migration in this repo is version-controlled** — `AddManufacturingPhase2` and `RepairUserEmailColumn` exist only on the machine that created them. Anyone else must regenerate them.
+
+> ### 2026-07-30 (later) — Three server-side additions the frontend wiring needed
+> All three are amended into `docs/30` as built. None changes an existing endpoint's behaviour.
+>
+> - **`TemplateGraphDto.activeRunCount`** — the builder derives its edit-locked state from it. Counted with its own scalar query rather than an `Include`, because the graph query already fans out over four collections and adding `Runs` would multiply those rows again for one integer.
+> - **`production_templates."Annotations"` (jsonb)** + `SaveTemplateRequest.Annotations`, migration **`AddTemplateCanvasAnnotations`** (exactly one `AddColumn`, applied and verified). The builder canvas already drew grouping boxes and divider lines and the contract had nowhere to keep them, so **every save would have silently discarded the user's layout**. Stored through `ProductionJson` like every other jsonb column, so the column can only ever hold canonical JSON; `List<CanvasAnnotationDto>` capped at 200 by `[MaxLength]`, and `Kind` validated to `box`/`line` in `ValidateAsync` because nothing else constrains free-form client state going into jsonb. Deliberately invisible to `ProductionGraphValidator` — annotations carry no graph semantics.
+> - **Wholesale replacement is the flip side and is now pinned by an assertion:** a PUT that omits `annotations` clears them. `m2_templates.py` asserts preserve → clear → restore explicitly, because silent data loss is worse than an error.
+>
+> **Smoke suite: extended but NOT re-run.** `m2_templates.py` gained 10 assertions (annotation round-trip incl. geometry/label/rotation, `activeRunCount` on the graph, unknown-kind rejection, and the clear/restore pair). **These are unverified.** AuthHex cannot issue a token — its configured MySQL host `187.127.102.190:3306` is unreachable from this machine (`MySqlConnector … Connect Timeout expired` on `POST /api/user`), and the localhost alternative in its `appsettings.json` is commented out. `dotnet build` is clean and the migration applied cleanly, but the last full green run of the suite (312/312) predates these additions.
+>
+> **HRM schema gap CLOSED** (by the repo owner, not this work): migrations `production` (another empty one — the fifth) and **`AddHrmTables`** now exist, the latter creating all 25 `hr_*` tables. The "still outstanding" note in the entry above is resolved; the underlying lesson about empty migrations is not.
+
+
 ## Done
 <!-- move [x] items here with date + note if the active list grows long -->
 
+### 2026-07-28 — Dashboard overview endpoint (`GET /dashboard/stats`)
+- **New cross-domain aggregate for the frontend dashboard** — `Dtos/Dashboard/DashboardDtos.cs`, `IDashboardService`/`DashboardService`, `DashboardController` (`GET /api/v1/dashboard/stats`). Mirrors `docs/dashboard-implementation.pdf`'s widget list: low-stock alerts (reuses `IReorderService.GetAlertsAsync`, `PageSize:1` since it computes the full count before paging), on-hand total/warehouse-count and stock-valuation total/by-warehouse (all SQL-side `SUM`/`GROUP BY` over `StockLayer`, cheap unlike reorder alerts since they need no per-item live lookup), pending-approval POs, pending (Draft) GRNs, open (Submitted) requisitions, pending (Counted) stock counts, open RFQs. Registered in `Program.cs`. docs/11-BACKEND-PHASE1.md §5.8.
+- **Not covered:** GRN inspection-hold counts (`HoldStatus` lives on GRN lines, no list/count endpoint exposes it) and recent stock movements (frontend calls `GET /stock/ledger` directly — no aggregation needed for a small `pageSize`).
+- **Bug found + fixed during this work — `WarehouseValuationDto` construction inside `GroupBy().Select()` doesn't translate.** EF Core 10 can't turn a record's constructor call into SQL inside a grouped projection (`InvalidOperationException`, confirmed live via `logs/erpcore-20260728.log`). Fixed by projecting to an anonymous type first (`Select(g => new { g.Key, Total = ... })`), materializing with `ToListAsync`, then mapping to the DTO record client-side.
+- **Unrelated bug found while testing this — `GET /items` 500s on every call: `column i.SalePrice does not exist`.** `ItemConfiguration.cs` maps `Item.SalePrice`, but the `AddItemSalePrice` migration (2026-07-22 entry above) was never actually applied to this dev database — despite that entry claiming "Applied to the local DB". Confirmed via `logs/erpcore-20260727.log`; `dotnet ef migrations add` against the current model produces an **empty** migration (no `Up`/`Down` ops), meaning the model snapshot already believes `SalePrice` exists even though the column doesn't — the snapshot and the real schema have drifted. **Not yet fixed** — needs a hand-written `AddColumn` migration (the auto-diff can't see the gap) run against this specific database; blocks the dashboard's on-hand/valuation widgets from ever showing item names, and blocks the entire Products page and every item picker (GRN/PO/ledger/valuation).
+- **Verified:** `dotnet build` clean (isolated output directory, to avoid the Visual-Studio-debugger file lock that repeatedly blocked rebuilding the live dev instance this session). Runtime-verified against the live log after a VS restart — confirmed reaching real code (not 404), the `GroupBy` bug above was caught this way. Full 200-response verification still pending the next VS restart.
+
 ### 2026-07-22 — Item fixed sale price + GRN off-PO items (migration `AddItemSalePrice`)
 - **Item sale price (FR-MD-01).** New nullable `Item.SalePrice` (`numeric(18,4)`, `ItemConfiguration.HasPrecision(18,4)`), threaded through `ItemListItemDto`/`ItemDetailDto`/`CreateItemRequest`/`UpdateItemRequest` (`[Range(0, …)]`) and mapped in `ItemService` (create/update/`ToDetail`/list projection). **Sales-only** — it never touches `GrnService`, FIFO, `StockLayer`, or the ledger, so receipt/costing behaviour is byte-for-byte unchanged. `null` ⇒ "use stock value"; the fixed-vs-stock choice is a frontend toggle, not a server field (no `price_mode` enum). docs/10 C.1/C.9 + decision #14, docs/11 §2.1, 02-SECURITY C.1.
 - **GRN off-PO items (FR-GRN-01).** A PO-based GRN may now carry lines with `poLineId: null` (item not on the PO). **No backend change** — `GrnService.CreateAsync` already routed such lines through the direct-receipt path (entered cost, no over-receipt check, no PO-balance update). Documented as intended behaviour; the frontend now exposes it. docs/10 FR-GRN-01/C.3 (`po_line_id` nullable) + decision #15, docs/11 §4.1, 02-SECURITY C.3.