initial refactori trasnfer to laying, and depretitation to 25 week

2026-06-09 15:07:49 +00:00 · 2026-05-27 15:00:13 +07:00
47 changed files with 1232 additions and 2047 deletions
@@ -1,304 +0,0 @@
 // Command cleanup-released-stock-allocations menghapus baris stock_allocations
 // dengan status='RELEASED' yang sudah lewat masa retensi.
 //
 // Baris RELEASED muncul dari operasi Rollback / Reflow FIFO v2. Closing reports
 // dan flow bisnis hanya membaca status='ACTIVE', sehingga RELEASED rows aman
 // dihapus setelah masa retensi tertentu (default 90 hari).
 //
 // Cara pakai:
 //
 //	go run ./cmd/cleanup-released-stock-allocations/                          # dry-run
 //	go run ./cmd/cleanup-released-stock-allocations/ -apply                   # apply (90 hari)
 //	go run ./cmd/cleanup-released-stock-allocations/ -apply -retention-days=30
 //	go run ./cmd/cleanup-released-stock-allocations/ -apply -batch-size=5000
 //	go run ./cmd/cleanup-released-stock-allocations/ -apply -skip-vacuum
 package main
 import (
 	"context"
 	"encoding/json"
 	"flag"
 	"fmt"
 	"log"
 	"os"
 	"strings"
 	"time"
 	"gitlab.com/mbugroup/lti-api.git/internal/config"
 	"gitlab.com/mbugroup/lti-api.git/internal/database"
 	"gitlab.com/mbugroup/lti-api.git/internal/entities"
 	"gorm.io/gorm"
 )
 const (
 	outputTable = "table"
 	outputJSON  = "json"
 )
 type options struct {
 	Apply          bool
 	Output         string
 	DBSSLMode      string
 	RetentionDays  int
 	BatchSize      int
 	SkipVacuum     bool
 }
 type sizeStat struct {
 	TableSize string `json:"table_size" gorm:"column:table_size"`
 	TotalSize string `json:"total_size" gorm:"column:total_size"`
 	RowCount  int64  `json:"row_count"  gorm:"column:row_count"`
 }
 type runSummary struct {
 	Mode             string   `json:"mode"`
 	RetentionDays    int      `json:"retention_days"`
 	CutoffTime       string   `json:"cutoff_time"`
 	BatchSize        int      `json:"batch_size"`
 	CandidateRows    int64    `json:"candidate_rows"`
 	DeletedRows      int64    `json:"deleted_rows,omitempty"`
 	BatchesExecuted  int      `json:"batches_executed,omitempty"`
 	BeforeSize       sizeStat `json:"before_size"`
 	AfterSize        sizeStat `json:"after_size,omitempty"`
 	DurationSeconds  float64  `json:"duration_seconds"`
 	VacuumExecuted   bool     `json:"vacuum_executed"`
 	OverallStatus    string   `json:"overall_status"`
 }
 func main() {
 	opts, err := parseFlags()
 	if err != nil {
 		log.Fatalf("invalid flags: %v", err)
 	}
 	if opts.DBSSLMode != "" {
 		config.DBSSLMode = opts.DBSSLMode
 	}
 	ctx := context.Background()
 	db := database.Connect(config.DBHost, config.DBName)
 	start := time.Now()
 	cutoff := time.Now().Add(-time.Duration(opts.RetentionDays) * 24 * time.Hour)
 	summary := runSummary{
 		RetentionDays: opts.RetentionDays,
 		CutoffTime:    cutoff.UTC().Format(time.RFC3339),
 		BatchSize:     opts.BatchSize,
 		OverallStatus: "PASS",
 	}
 	// Ambil ukuran tabel sebelum cleanup
 	before, err := fetchSizeStat(ctx, db)
 	if err != nil {
 		log.Fatalf("failed to fetch initial size: %v", err)
 	}
 	summary.BeforeSize = before
 	// Hitung kandidat row
 	candidate, err := countCandidates(ctx, db, cutoff)
 	if err != nil {
 		log.Fatalf("failed to count candidates: %v", err)
 	}
 	summary.CandidateRows = candidate
 	if candidate == 0 {
 		summary.Mode = modeLabel(opts.Apply)
 		summary.DurationSeconds = time.Since(start).Seconds()
 		fmt.Printf("No RELEASED rows older than %d days found. Nothing to do.\n", opts.RetentionDays)
 		render(opts.Output, summary)
 		return
 	}
 	if !opts.Apply {
 		summary.Mode = "DRY_RUN"
 		summary.DurationSeconds = time.Since(start).Seconds()
 		render(opts.Output, summary)
 		fmt.Println()
 		fmt.Println("Re-run with -apply to actually delete the rows above.")
 		return
 	}
 	summary.Mode = "APPLY"
 	deleted, batches, err := applyCleanup(ctx, db, cutoff, opts.BatchSize)
 	summary.DeletedRows = deleted
 	summary.BatchesExecuted = batches
 	if err != nil {
 		summary.OverallStatus = "FAIL"
 		render(opts.Output, summary)
 		log.Fatalf("apply failed after %d batches (%d rows deleted): %v", batches, deleted, err)
 	}
 	// VACUUM ANALYZE supaya space benar-benar dibebaskan ke OS
 	if !opts.SkipVacuum {
 		if err := runVacuum(ctx, db); err != nil {
 			// VACUUM gagal jangan-mengaborkan, log saja
 			log.Printf("WARN: VACUUM ANALYZE gagal: %v", err)
 		} else {
 			summary.VacuumExecuted = true
 		}
 	}
 	after, err := fetchSizeStat(ctx, db)
 	if err != nil {
 		log.Printf("WARN: gagal ambil ukuran tabel setelah cleanup: %v", err)
 	} else {
 		summary.AfterSize = after
 	}
 	summary.DurationSeconds = time.Since(start).Seconds()
 	render(opts.Output, summary)
 }
 func parseFlags() (*options, error) {
 	var opts options
 	flag.BoolVar(&opts.Apply, "apply", false, "Apply deletion (omit for dry-run)")
 	flag.StringVar(&opts.Output, "output", outputTable, "Output format: table or json")
 	flag.StringVar(&opts.DBSSLMode, "db-sslmode", "", "Database sslmode override")
 	flag.IntVar(&opts.RetentionDays, "retention-days", 90, "Keep RELEASED rows newer than N days")
 	flag.IntVar(&opts.BatchSize, "batch-size", 10000, "Rows deleted per transaction")
 	flag.BoolVar(&opts.SkipVacuum, "skip-vacuum", false, "Skip VACUUM ANALYZE after cleanup")
 	flag.Parse()
 	opts.Output = strings.ToLower(strings.TrimSpace(opts.Output))
 	opts.DBSSLMode = strings.TrimSpace(opts.DBSSLMode)
 	if opts.Output == "" {
 		opts.Output = outputTable
 	}
 	if opts.Output != outputTable && opts.Output != outputJSON {
 		return nil, fmt.Errorf("unsupported --output=%s", opts.Output)
 	}
 	if opts.RetentionDays < 0 {
 		return nil, fmt.Errorf("retention-days must be >= 0, got %d", opts.RetentionDays)
 	}
 	if opts.BatchSize <= 0 {
 		return nil, fmt.Errorf("batch-size must be > 0, got %d", opts.BatchSize)
 	}
 	return &opts, nil
 }
 func countCandidates(ctx context.Context, db *gorm.DB, cutoff time.Time) (int64, error) {
 	var count int64
 	err := db.WithContext(ctx).
 		Table("stock_allocations").
 		Where("status = ?", entities.StockAllocationStatusReleased).
 		Where("released_at IS NOT NULL AND released_at < ?", cutoff).
 		Count(&count).Error
 	return count, err
 }
 func applyCleanup(ctx context.Context, db *gorm.DB, cutoff time.Time, batchSize int) (int64, int, error) {
 	var totalDeleted int64
 	batches := 0
 	for {
 		var affected int64
 		err := db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
 			// Pakai CTE supaya LIMIT bisa dipakai bersama DELETE di PostgreSQL.
 			// `released_at IS NOT NULL` defensif — rows lama dari migrasi mungkin
 			// NULL meski status=RELEASED.
 			res := tx.Exec(`
 DELETE FROM stock_allocations
 WHERE id IN (
    SELECT id FROM stock_allocations
    WHERE status = ?
      AND released_at IS NOT NULL
      AND released_at < ?
    ORDER BY id ASC
    LIMIT ?
 )
 `, entities.StockAllocationStatusReleased, cutoff, batchSize)
 			if res.Error != nil {
 				return res.Error
 			}
 			affected = res.RowsAffected
 			return nil
 		})
 		if err != nil {
 			return totalDeleted, batches, err
 		}
 		if affected == 0 {
 			break
 		}
 		totalDeleted += affected
 		batches++
 		log.Printf("batch %d: deleted %d rows (running total: %d)", batches, affected, totalDeleted)
 		if affected < int64(batchSize) {
 			break
 		}
 	}
 	return totalDeleted, batches, nil
 }
 func runVacuum(ctx context.Context, db *gorm.DB) error {
 	// VACUUM tidak bisa di-jalankan dalam transaksi.
 	// gorm SkipDefaultTransaction sudah true, tapi tetap aman menggunakan raw DB.
 	sqlDB, err := db.DB()
 	if err != nil {
 		return err
 	}
 	_, err = sqlDB.ExecContext(ctx, "VACUUM ANALYZE stock_allocations")
 	return err
 }
 func fetchSizeStat(ctx context.Context, db *gorm.DB) (sizeStat, error) {
 	var stat sizeStat
 	err := db.WithContext(ctx).Raw(`
 SELECT
    pg_size_pretty(pg_relation_size('stock_allocations')) AS table_size,
    pg_size_pretty(pg_total_relation_size('stock_allocations')) AS total_size,
    (SELECT COUNT(*) FROM stock_allocations)::bigint AS row_count
 `).Scan(&stat).Error
 	return stat, err
 }
 func modeLabel(apply bool) string {
 	if apply {
 		return "APPLY"
 	}
 	return "DRY_RUN"
 }
 func render(mode string, summary runSummary) {
 	if mode == outputJSON {
 		enc := json.NewEncoder(os.Stdout)
 		enc.SetIndent("", "  ")
 		_ = enc.Encode(summary)
 		return
 	}
 	fmt.Printf("=== Cleanup RELEASED stock_allocations ===\n")
 	fmt.Printf("Mode               : %s\n", summary.Mode)
 	fmt.Printf("Retention days     : %d (cutoff < %s)\n", summary.RetentionDays, summary.CutoffTime)
 	fmt.Printf("Batch size         : %d\n", summary.BatchSize)
 	fmt.Printf("Candidate rows     : %d\n", summary.CandidateRows)
 	fmt.Printf("\n--- Before ---\n")
 	fmt.Printf("Total rows         : %d\n", summary.BeforeSize.RowCount)
 	fmt.Printf("Table size         : %s\n", summary.BeforeSize.TableSize)
 	fmt.Printf("Total size (idx)   : %s\n", summary.BeforeSize.TotalSize)
 	if summary.Mode == "APPLY" {
 		fmt.Printf("\n--- Apply ---\n")
 		fmt.Printf("Deleted rows       : %d\n", summary.DeletedRows)
 		fmt.Printf("Batches executed   : %d\n", summary.BatchesExecuted)
 		fmt.Printf("VACUUM executed    : %v\n", summary.VacuumExecuted)
 		if summary.AfterSize.RowCount > 0 || summary.AfterSize.TableSize != "" {
 			fmt.Printf("\n--- After ---\n")
 			fmt.Printf("Total rows         : %d\n", summary.AfterSize.RowCount)
 			fmt.Printf("Table size         : %s\n", summary.AfterSize.TableSize)
 			fmt.Printf("Total size (idx)   : %s\n", summary.AfterSize.TotalSize)
 		}
 	}
 	fmt.Printf("\nDuration           : %.2fs\n", summary.DurationSeconds)
 	fmt.Printf("Overall status     : %s\n", summary.OverallStatus)
 }
@@ -102,11 +102,17 @@ type HppV2CostRepository interface {
 	GetProjectFlockKandangContext(ctx context.Context, projectFlockKandangId uint) (*HppV2ProjectFlockKandangContext, error)
 	GetProjectFlockKandangIDs(ctx context.Context, projectFlockId uint) ([]uint, error)
 	GetLatestTransferInputByProjectFlockKandangID(ctx context.Context, projectFlockKandangId uint, period time.Time) (*HppV2LatestTransferInputRow, error)
 	// GetAllTransferInputsByProjectFlockKandangID return SEMUA approved transfer ke target kandang
 	// itu, untuk skenario multi-source di mana 1 target menerima dari multiple transfer terpisah.
 	// Setiap row = 1 transfer dengan cost basis & chick_in_date sendiri (per source). Order:
 	// effective_date ASC, id ASC (kronologis).
 	GetAllTransferInputsByProjectFlockKandangID(ctx context.Context, projectFlockKandangId uint, period time.Time) ([]HppV2LatestTransferInputRow, error)
 	GetManualDepreciationInputByProjectFlockID(ctx context.Context, projectFlockID uint) (*HppV2ManualDepreciationInputRow, error)
 	GetRecordingStockRoutingAdjustmentCostByProjectFlockID(ctx context.Context, projectFlockID uint, periodDate time.Time) (float64, error)
 	GetFarmDepreciationSnapshotByProjectFlockIDAndPeriod(ctx context.Context, projectFlockID uint, periodDate time.Time) (*HppV2FarmDepreciationSnapshotRow, error)
 	GetEarliestChickInDateByProjectFlockID(ctx context.Context, projectFlockID uint) (*time.Time, error)
-	GetDepreciationPercents(ctx context.Context, houseTypes []string, maxDay int) (map[string]map[int]float64, error)
+	GetChickinPopulationByPFKForFarm(ctx context.Context, projectFlockID uint) (map[uint]float64, error)
 	GetMultiplicationPercentages(ctx context.Context, houseTypes []string, maxDay int) (map[string]map[int]float64, error)
 	ListUsageCostRowsByProductFlags(ctx context.Context, projectFlockKandangIDs []uint, flagNames []string, date *time.Time) ([]HppV2UsageCostRow, error)
 	ListAdjustmentCostRowsByProductFlags(ctx context.Context, projectFlockKandangIDs []uint, flagNames []string, date *time.Time) ([]HppV2AdjustmentCostRow, error)
 	ListExpenseRealizationRowsByProjectFlockKandangIDs(ctx context.Context, projectFlockKandangIDs []uint, date *time.Time, ekspedisi bool) ([]HppV2ExpenseCostRow, error)
@@ -230,6 +236,62 @@ LIMIT 1
 	return &row, nil
 }
 func (r *HppV2RepositoryImpl) GetAllTransferInputsByProjectFlockKandangID(
 	ctx context.Context,
 	projectFlockKandangId uint,
 	period time.Time,
 ) ([]HppV2LatestTransferInputRow, error) {
 	var rows []HppV2LatestTransferInputRow
 	query := `
 WITH latest_transfer_approval AS (
 	SELECT a.approvable_id, a.action
 	FROM approvals a
 	JOIN (
 		SELECT approvable_id, MAX(action_at) AS latest_action_at
 		FROM approvals
 		WHERE approvable_type = @approval_type
 		GROUP BY approvable_id
 	) la
 		ON la.approvable_id = a.approvable_id
 		AND la.latest_action_at = a.action_at
 	WHERE a.approvable_type = @approval_type
 ),
 approved_transfers AS (
 	SELECT
 		lt.id,
 		lt.from_project_flock_id,
 		COALESCE(DATE(lt.effective_move_date), DATE(lt.economic_cutoff_date), DATE(lt.transfer_date)) AS effective_date
 	FROM laying_transfers lt
 	JOIN latest_transfer_approval lta ON lta.approvable_id = lt.id
 	WHERE lt.deleted_at IS NULL
 	  AND lt.executed_at IS NOT NULL
 	  AND lta.action = 'APPROVED'
 )
 SELECT
 	ltt.target_project_flock_kandang_id AS project_flock_kandang_id,
 	at.from_project_flock_id AS source_project_flock_id,
 	at.effective_date AS transfer_date,
 	ltt.total_qty AS transfer_qty,
 	at.id AS transfer_id
 FROM laying_transfer_targets ltt
 JOIN approved_transfers at ON at.id = ltt.laying_transfer_id
 WHERE ltt.deleted_at IS NULL
  AND ltt.target_project_flock_kandang_id = @project_flock_kandang_id
  AND at.effective_date <= DATE(@period_date)
 ORDER BY at.effective_date ASC, at.id ASC
 `
 	err := r.db.WithContext(ctx).Raw(query, map[string]any{
 		"approval_type":            utils.ApprovalWorkflowTransferToLaying.String(),
 		"project_flock_kandang_id": projectFlockKandangId,
 		"period_date":              period,
 	}).Scan(&rows).Error
 	if err != nil {
 		return nil, err
 	}
 	return rows, nil
 }
 func (r *HppV2RepositoryImpl) GetManualDepreciationInputByProjectFlockID(
 	ctx context.Context,
 	projectFlockID uint,
@@ -373,7 +435,34 @@ func (r *HppV2RepositoryImpl) GetEarliestChickInDateByProjectFlockID(ctx context
 	return selected.ChickInDate, nil
 }
-func (r *HppV2RepositoryImpl) GetDepreciationPercents(
+func (r *HppV2RepositoryImpl) GetChickinPopulationByPFKForFarm(
 	ctx context.Context,
 	projectFlockID uint,
 ) (map[uint]float64, error) {
 	type row struct {
 		ProjectFlockKandangID uint    `gorm:"column:project_flock_kandang_id"`
 		TotalQty              float64 `gorm:"column:total_qty"`
 	}
 	var rows []row
 	err := r.db.WithContext(ctx).
 		Table("project_chickins AS pc").
 		Select("pc.project_flock_kandang_id, SUM(pc.usage_qty) AS total_qty").
 		Joins("JOIN project_flock_kandangs AS pfk ON pfk.id = pc.project_flock_kandang_id").
 		Where("pc.deleted_at IS NULL").
 		Where("pfk.project_flock_id = ?", projectFlockID).
 		Group("pc.project_flock_kandang_id").
 		Scan(&rows).Error
 	if err != nil {
 		return nil, err
 	}
 	result := make(map[uint]float64, len(rows))
 	for _, x := range rows {
 		result[x.ProjectFlockKandangID] = x.TotalQty
 	}
 	return result, nil
 }
 func (r *HppV2RepositoryImpl) GetMultiplicationPercentages(
 	ctx context.Context,
 	houseTypes []string,
 	maxDay int,
@@ -384,19 +473,19 @@ func (r *HppV2RepositoryImpl) GetDepreciationPercents(
 	}
 	type row struct {
-		HouseType           string
+		HouseType                string
-		Day                 int
+		Day                      int
-		DepreciationPercent float64
+		MultiplicationPercentage float64
 	}
 	rows := make([]row, 0)
-	err := r.db.WithContext(ctx).
+	err := r.db.WithContext(ctx).Raw(`
-		Table("house_depreciation_standards").
+		SELECT DISTINCT ON (house_type::text, day)
-		Select("house_type::text AS house_type, day, depreciation_percent").
+			house_type::text AS house_type, day, multiplication_percentage
-		Where("house_type::text IN ?", houseTypes).
+		FROM house_depreciation_standards
-		Where("day <= ?", maxDay).
+		WHERE house_type::text IN ? AND day <= ?
-		Order("house_type ASC, day ASC").
+		ORDER BY house_type, day, effective_date DESC NULLS LAST
-		Scan(&rows).Error
+	`, houseTypes, maxDay).Scan(&rows).Error
 	if err != nil {
 		return nil, err
 	}
@@ -405,7 +494,7 @@ func (r *HppV2RepositoryImpl) GetDepreciationPercents(
 		if _, exists := result[item.HouseType]; !exists {
 			result[item.HouseType] = make(map[int]float64)
 		}
-		result[item.HouseType][item.Day] = item.DepreciationPercent
+		result[item.HouseType][item.Day] = item.MultiplicationPercentage
 	}
 	return result, nil
@@ -6,8 +6,8 @@ import (
 )
 const (
-	depreciationStartAgeDayCloseHouse = 155
+	depreciationStartAgeDayCloseHouse = 175
-	depreciationStartAgeDayOpenHouse  = 176
+	depreciationStartAgeDayOpenHouse  = 175
 )
 func NormalizeDepreciationHouseType(raw string) string {
@@ -26,8 +26,8 @@ func DepreciationStartAgeDay(houseType string) int {
 }
 func FlockAgeDay(originDate time.Time, periodDate time.Time) int {
-	origin := time.Date(originDate.Year(), originDate.Month(), originDate.Day(), 0, 0, 0, 0, originDate.Location())
+	origin := time.Date(originDate.Year(), originDate.Month(), originDate.Day(), 0, 0, 0, 0, time.UTC)
-	period := time.Date(periodDate.Year(), periodDate.Month(), periodDate.Day(), 0, 0, 0, 0, periodDate.Location())
+	period := time.Date(periodDate.Year(), periodDate.Month(), periodDate.Day(), 0, 0, 0, 0, time.UTC)
 	if period.Before(origin) {
 		return 0
 	}
@@ -47,9 +47,9 @@ func CalculateDepreciationAtDayN(
 	initialPulletCost float64,
 	dayN int,
 	houseType string,
-	percentByHouseType map[string]map[int]float64,
+	multiplicationByHouseType map[string]map[int]float64,
 ) (float64, float64, float64) {
-	return CalculateDepreciationFromDayRange(initialPulletCost, 1, dayN, houseType, percentByHouseType)
+	return CalculateDepreciationFromDayRange(initialPulletCost, 1, dayN, houseType, multiplicationByHouseType)
 }
 func CalculateDepreciationFromDayRange(
@@ -57,8 +57,8 @@ func CalculateDepreciationFromDayRange(
 	startDay int,
 	endDay int,
 	houseType string,
-	percentByHouseType map[string]map[int]float64,
+	multiplicationByHouseType map[string]map[int]float64,
-) (float64, float64, float64) {
+) (pulletCostDayN, depreciationValue, multiplicationPercentage float64) {
 	if initialPulletCost <= 0 || endDay <= 0 {
 		return 0, 0, 0
 	}
@@ -70,30 +70,30 @@ func CalculateDepreciationFromDayRange(
 	}
 	normalizedHouseType := NormalizeDepreciationHouseType(houseType)
-	housePercent, exists := percentByHouseType[normalizedHouseType]
+	houseMult, exists := multiplicationByHouseType[normalizedHouseType]
 	if !exists {
 		return 0, 0, 0
 	}
 	current := initialPulletCost
 	pulletCostDayN := 0.0
 	depreciationValue := 0.0
 	depreciationPercent := 0.0
 	for day := startDay; day <= endDay; day++ {
-		pct := housePercent[day]
+		mult, ok := houseMult[day]
-		dep := current * (pct / 100)
+		if !ok {
 			// No standard for this day → assume no depreciation (mult=1).
 			mult = 1.0
 		}
 		if day == endDay {
 			pulletCostDayN = current
-			depreciationValue = dep
+			multiplicationPercentage = mult
-			depreciationPercent = pct
+			depreciationValue = current * (1.0 - mult)
 		}
-		current -= dep
+		current = current * mult
 		if current < 0 {
 			current = 0
 		}
 	}
-	return pulletCostDayN, depreciationValue, depreciationPercent
+	return pulletCostDayN, depreciationValue, multiplicationPercentage
 }
 func CalculateEffectiveDepreciationPercent(totalDepreciationValue, totalPulletCostDayN float64) float64 {
@@ -1,393 +0,0 @@
 package service
 import (
 	"context"
 	"fmt"
 	"math"
 	"strings"
 	"time"
 	"github.com/sirupsen/logrus"
 	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
 	"gitlab.com/mbugroup/lti-api.git/internal/utils"
 	"gorm.io/gorm"
 )
 // ParentKind enumerasi parent yang punya grand_total dari SUM children.
 type ParentKind string
 const (
 	ParentKindPurchase  ParentKind = "PURCHASE"
 	ParentKindMarketing ParentKind = "MARKETING"
 	ParentKindExpense   ParentKind = "EXPENSE"
 )
 // AllocationKind enumerasi sub-row anak target FIFO allocation.
 type AllocationKind string
 const (
 	AllocKindPurchaseItem             AllocationKind = "PURCHASE_ITEM"
 	AllocKindMarketingDeliveryProduct AllocationKind = "MDP"
 	AllocKindExpenseRealization       AllocationKind = "EXPENSE_REALIZATION"
 )
 // fifoEpsilon untuk float comparison saat FIFO matching.
 const fifoEpsilon = 0.001
 // FifoPaymentService meng-orchestrate FIFO allocation antara payments dan
 // sub-row anak (purchase_items / marketing_delivery_products / expense_realizations).
 type FifoPaymentService interface {
 	// ReallocateForParty wipe allocations untuk semua payment party tsb,
 	// lalu re-FIFO dari history (sort children by date ASC, payments by payment_date ASC).
 	// Caller WAJIB pass tx untuk konsistensi dengan mutasi upstream.
 	ReallocateForParty(ctx context.Context, tx *gorm.DB, partyType string, partyID uint) error
 	// RecomputeGrandTotal refresh parent.grand_total = SUM children eligible amount.
 	RecomputeGrandTotal(ctx context.Context, tx *gorm.DB, kind ParentKind, parentID uint) error
 }
 type fifoPaymentService struct {
 	db     *gorm.DB
 	logger *logrus.Logger
 }
 func NewFifoPaymentService(db *gorm.DB, logger *logrus.Logger) FifoPaymentService {
 	if logger == nil {
 		logger = logrus.StandardLogger()
 	}
 	return &fifoPaymentService{db: db, logger: logger}
 }
 func (s *fifoPaymentService) txOrDB(tx *gorm.DB) *gorm.DB {
 	if tx != nil {
 		return tx
 	}
 	return s.db
 }
 type childRow struct {
 	Kind      AllocationKind
 	ChildID   uint64
 	Amount    float64
 	Remaining float64
 }
 type paymentRow struct {
 	ID      uint
 	Nominal float64
 	Date    time.Time
 }
 // ReallocateForParty acquire advisory lock then perform full re-FIFO.
 // Jika tx nil, function buka transaction sendiri (advisory lock harus dalam TX).
 func (s *fifoPaymentService) ReallocateForParty(ctx context.Context, tx *gorm.DB, partyType string, partyID uint) error {
 	if partyID == 0 {
 		return nil
 	}
 	party := strings.ToUpper(strings.TrimSpace(partyType))
 	if party != string(utils.PaymentPartyCustomer) && party != string(utils.PaymentPartySupplier) {
 		return fmt.Errorf("fifoPayment: invalid party_type %q", partyType)
 	}
 	if tx == nil {
 		return s.db.WithContext(ctx).Transaction(func(innerTx *gorm.DB) error {
 			return s.reallocateInTx(ctx, innerTx, party, partyID)
 		})
 	}
 	return s.reallocateInTx(ctx, tx, party, partyID)
 }
 func (s *fifoPaymentService) reallocateInTx(ctx context.Context, tx *gorm.DB, party string, partyID uint) error {
 	db := tx.WithContext(ctx)
 	// Advisory lock per (party_type, party_id) — 1-arg form (bigint).
 	// Postgres 2-arg form butuh kedua param int4, sedangkan party_id bisa lebih besar.
 	lockKey := fmt.Sprintf("payment_alloc:%s:%d", party, partyID)
 	if err := db.Exec("SELECT pg_advisory_xact_lock(hashtext(?)::bigint)", lockKey).Error; err != nil {
 		return fmt.Errorf("fifoPayment: advisory lock: %w", err)
 	}
 	// Wipe existing allocations untuk semua payment party tsb
 	if err := db.Exec(`
 		DELETE FROM payment_allocations
 		WHERE payment_id IN (
 			SELECT id FROM payments
 			WHERE party_type = ? AND party_id = ? AND deleted_at IS NULL
 		)
 	`, party, partyID).Error; err != nil {
 		return fmt.Errorf("fifoPayment: wipe allocations: %w", err)
 	}
 	children, err := s.fetchChildren(ctx, db, party, partyID)
 	if err != nil {
 		return err
 	}
 	if len(children) == 0 {
 		return nil
 	}
 	// Fetch SEMUA payments termasuk SALDO_AWAL agar allocation tercatat di DB
 	// (SaldoAwal opening credit harus consume oldest debts; tanpa allocation row,
 	// debt yang ter-cover SaldoAwal akan tampak "Belum Lunas" di report).
 	payments, err := s.fetchAllPayments(ctx, db, party, partyID)
 	if err != nil {
 		return err
 	}
 	// Greedy: per payment, alokasi ke children tertua dengan remaining > 0
 	allocs := make([]entity.PaymentAllocation, 0, len(payments))
 	now := time.Now()
 	for _, pay := range payments {
 		remaining := pay.Nominal
 		if remaining <= fifoEpsilon {
 			continue
 		}
 		for i := range children {
 			if remaining <= fifoEpsilon {
 				break
 			}
 			if children[i].Remaining <= fifoEpsilon {
 				continue
 			}
 			used := math.Min(remaining, children[i].Remaining)
 			children[i].Remaining -= used
 			remaining -= used
 			alloc := entity.PaymentAllocation{
 				PaymentId:   pay.ID,
 				Amount:      used,
 				AllocatedAt: now,
 			}
 			switch children[i].Kind {
 			case AllocKindPurchaseItem:
 				id := uint(children[i].ChildID)
 				alloc.PurchaseItemId = &id
 			case AllocKindMarketingDeliveryProduct:
 				id := uint(children[i].ChildID)
 				alloc.MarketingDeliveryProductId = &id
 			case AllocKindExpenseRealization:
 				id := children[i].ChildID
 				alloc.ExpenseRealizationId = &id
 			}
 			allocs = append(allocs, alloc)
 		}
 	}
 	if len(allocs) == 0 {
 		return nil
 	}
 	// Batch insert allocations
 	if err := db.CreateInBatches(&allocs, 500).Error; err != nil {
 		return fmt.Errorf("fifoPayment: insert allocations: %w", err)
 	}
 	return nil
 }
 // fetchChildren return eligible sub-rows sorted by date ASC, id ASC.
 func (s *fifoPaymentService) fetchChildren(ctx context.Context, db *gorm.DB, party string, partyID uint) ([]childRow, error) {
 	if party == string(utils.PaymentPartySupplier) {
 		return s.fetchSupplierChildren(ctx, db, partyID)
 	}
 	return s.fetchCustomerChildren(ctx, db, partyID)
 }
 func (s *fifoPaymentService) fetchSupplierChildren(ctx context.Context, db *gorm.DB, supplierID uint) ([]childRow, error) {
 	// purchase_items eligible: purchases approval latest step >= Receiving (4), action != REJECTED, received_date IS NOT NULL
 	var purchaseRows []chronoRow
 	purchaseSQL := `
 		SELECT 'PURCHASE_ITEM' AS kind,
 		       pi.id::BIGINT AS child_id,
 		       pi.total_price AS amount,
 		       pi.received_date AS sort_date,
 		       pi.id::BIGINT AS sort_id
 		FROM purchase_items pi
 		JOIN purchases p ON p.id = pi.purchase_id
 		JOIN LATERAL (
 			SELECT a.step_number, a.action
 			FROM approvals a
 			WHERE a.approvable_type = ? AND a.approvable_id = p.id
 			ORDER BY a.action_at DESC, a.id DESC
 			LIMIT 1
 		) la ON TRUE
 		WHERE p.supplier_id = ?
 		  AND p.deleted_at IS NULL
 		  AND pi.received_date IS NOT NULL
 		  AND la.step_number >= ?
 		  AND (la.action IS NULL OR la.action <> ?)
 		  AND pi.total_price > 0
 		ORDER BY pi.received_date ASC, pi.id ASC
 	`
 	if err := db.WithContext(ctx).Raw(purchaseSQL,
 		string(utils.ApprovalWorkflowPurchase),
 		supplierID,
 		uint16(utils.PurchaseStepReceiving),
 		string(entity.ApprovalActionRejected),
 	).Scan(&purchaseRows).Error; err != nil {
 		return nil, fmt.Errorf("fifoPayment: fetch purchase items: %w", err)
 	}
 	// expense_realizations via expense_nonstocks → expenses, approval latest step >= Realisasi (5)
 	// Sort pakai e.transaction_date (bukan realization_date) supaya FIFO match dengan tanggal yang
 	// dipakai report sebagai "tanggal dokumen" — user assume FIFO = lunasi yang transaction_date paling tua dulu.
 	var expenseRows []chronoRow
 	expenseSQL := `
 		SELECT 'EXPENSE_REALIZATION' AS kind,
 		       er.id::BIGINT AS child_id,
 		       (er.qty * er.price) AS amount,
 		       e.transaction_date AS sort_date,
 		       er.id::BIGINT AS sort_id
 		FROM expense_realizations er
 		JOIN expense_nonstocks en ON en.id = er.expense_nonstock_id
 		JOIN expenses e ON e.id = en.expense_id
 		JOIN LATERAL (
 			SELECT a.step_number, a.action
 			FROM approvals a
 			WHERE a.approvable_type = ? AND a.approvable_id = e.id
 			ORDER BY a.action_at DESC, a.id DESC
 			LIMIT 1
 		) la ON TRUE
 		WHERE e.supplier_id = ?
 		  AND e.deleted_at IS NULL
 		  AND la.step_number >= ?
 		  AND (la.action IS NULL OR la.action <> ?)
 		  AND (er.qty * er.price) > 0
 		ORDER BY e.transaction_date ASC, e.id ASC, er.id ASC
 	`
 	if err := db.WithContext(ctx).Raw(expenseSQL,
 		string(utils.ApprovalWorkflowExpense),
 		supplierID,
 		uint16(utils.ExpenseStepRealisasi),
 		string(entity.ApprovalActionRejected),
 	).Scan(&expenseRows).Error; err != nil {
 		return nil, fmt.Errorf("fifoPayment: fetch expense realizations: %w", err)
 	}
 	// Merge in chronological order (kedua list sudah sorted; merge stable)
 	merged := mergeSortedByDate(purchaseRows, expenseRows)
 	out := make([]childRow, 0, len(merged))
 	for _, r := range merged {
 		out = append(out, childRow{
 			Kind:      AllocationKind(r.Kind),
 			ChildID:   r.ChildID,
 			Amount:    r.Amount,
 			Remaining: r.Amount,
 		})
 	}
 	return out, nil
 }
 func (s *fifoPaymentService) fetchCustomerChildren(ctx context.Context, db *gorm.DB, customerID uint) ([]childRow, error) {
 	var mdpRows []chronoRow
 	sql := `
 		SELECT 'MDP' AS kind,
 		       mdp.id::BIGINT AS child_id,
 		       mdp.total_price AS amount,
 		       mdp.delivery_date AS sort_date,
 		       mdp.id::BIGINT AS sort_id
 		FROM marketing_delivery_products mdp
 		JOIN marketing_products mp ON mp.id = mdp.marketing_product_id
 		JOIN marketings m ON m.id = mp.marketing_id
 		WHERE m.customer_id = ?
 		  AND m.deleted_at IS NULL
 		  AND mdp.delivery_date IS NOT NULL
 		  AND mdp.total_price > 0
 		ORDER BY mdp.delivery_date ASC, mdp.id ASC
 	`
 	if err := db.WithContext(ctx).Raw(sql, customerID).Scan(&mdpRows).Error; err != nil {
 		return nil, fmt.Errorf("fifoPayment: fetch marketing delivery products: %w", err)
 	}
 	out := make([]childRow, 0, len(mdpRows))
 	for _, r := range mdpRows {
 		out = append(out, childRow{
 			Kind:      AllocationKind(r.Kind),
 			ChildID:   r.ChildID,
 			Amount:    r.Amount,
 			Remaining: r.Amount,
 		})
 	}
 	return out, nil
 }
 // fetchAllPayments return SEMUA payments (termasuk SALDO_AWAL) sort by payment_date ASC, id ASC.
 // SALDO_AWAL diperlakukan sebagai payment tertua agar opening credit otomatis consume oldest debts via FIFO.
 func (s *fifoPaymentService) fetchAllPayments(ctx context.Context, db *gorm.DB, party string, partyID uint) ([]paymentRow, error) {
 	var rows []paymentRow
 	sql := `
 		SELECT id, nominal, payment_date AS date
 		FROM payments
 		WHERE party_type = ? AND party_id = ?
 		  AND deleted_at IS NULL
 		  AND nominal > 0
 		ORDER BY payment_date ASC, id ASC
 	`
 	if err := db.WithContext(ctx).Raw(sql, party, partyID).Scan(&rows).Error; err != nil {
 		return nil, fmt.Errorf("fifoPayment: fetch payments: %w", err)
 	}
 	return rows, nil
 }
 // RecomputeGrandTotal refresh parent.grand_total dari SUM children eligible amount.
 func (s *fifoPaymentService) RecomputeGrandTotal(ctx context.Context, tx *gorm.DB, kind ParentKind, parentID uint) error {
 	db := s.txOrDB(tx).WithContext(ctx)
 	if parentID == 0 {
 		return nil
 	}
 	switch kind {
 	case ParentKindPurchase:
 		return db.Exec(`
 			UPDATE purchases p
 			SET grand_total = COALESCE((SELECT SUM(total_price) FROM purchase_items WHERE purchase_id = p.id), 0)
 			WHERE p.id = ?
 		`, parentID).Error
 	case ParentKindMarketing:
 		return db.Exec(`
 			UPDATE marketings m
 			SET grand_total = COALESCE((
 				SELECT SUM(mdp.total_price)
 				FROM marketing_delivery_products mdp
 				JOIN marketing_products mp ON mp.id = mdp.marketing_product_id
 				WHERE mp.marketing_id = m.id AND mdp.delivery_date IS NOT NULL
 			), 0)
 			WHERE m.id = ?
 		`, parentID).Error
 	case ParentKindExpense:
 		return db.Exec(`
 			UPDATE expenses e
 			SET grand_total = COALESCE((
 				SELECT SUM(er.qty * er.price)
 				FROM expense_realizations er
 				JOIN expense_nonstocks en ON en.id = er.expense_nonstock_id
 				WHERE en.expense_id = e.id
 			), 0)
 			WHERE e.id = ?
 		`, parentID).Error
 	default:
 		return fmt.Errorf("fifoPayment: unknown parent kind %q", kind)
 	}
 }
 // chronoRow row antara untuk merge sort children.
 type chronoRow struct {
 	Kind     string
 	ChildID  uint64
 	Amount   float64
 	SortDate time.Time
 	SortID   uint64
 }
 func mergeSortedByDate(a, b []chronoRow) []chronoRow {
 	out := make([]chronoRow, 0, len(a)+len(b))
 	i, j := 0, 0
 	for i < len(a) && j < len(b) {
 		if a[i].SortDate.Before(b[j].SortDate) ||
 			(a[i].SortDate.Equal(b[j].SortDate) && a[i].SortID < b[j].SortID) {
 			out = append(out, a[i])
 			i++
 		} else {
 			out = append(out, b[j])
 			j++
 		}
 	}
 	out = append(out, a[i:]...)
 	out = append(out, b[j:]...)
 	return out
 }
@@ -1191,26 +1191,72 @@ func (s *hppV2Service) getDepreciationComponent(
 		}, nil
 	}
-	if totalPulletCost <= 0 {
+	// Multi-source support: 1 target kandang bisa menerima dari MULTIPLE transfer terpisah
-		return nil, nil
+	// (tiap transfer = 1 source kandang). Depresiasi per target = SUM dari per-transfer depresiasi.
-	}
+	// Setiap transfer dihitung dengan chick_in_date source-nya sendiri dan cost basis pro-rated
-
+	// berdasarkan qty share (transfer.qty / totalTransferQty).
-	transferInput, err := s.hppRepo.GetLatestTransferInputByProjectFlockKandangID(context.Background(), projectFlockKandangId, periodDate)
+	transferInputs, err := s.hppRepo.GetAllTransferInputsByProjectFlockKandangID(context.Background(), projectFlockKandangId, periodDate)
 	if err != nil {
 		return nil, err
 	}
-	var part *HppV2ComponentPart
+	// Filter valid transfers (punya source flock id)
-	if transferInput != nil && transferInput.SourceProjectFlockID > 0 {
+	validTransfers := make([]commonRepo.HppV2LatestTransferInputRow, 0, len(transferInputs))
-		part, err = s.buildNormalTransferDepreciationPart(contextRow, transferInput, periodDate, totalPulletCost)
+	totalTransferQty := 0.0
-		if err != nil {
+	for _, t := range transferInputs {
-			return nil, err
+		if t.SourceProjectFlockID == 0 {
 			continue
 		}
-	} else {
+		validTransfers = append(validTransfers, t)
-		part, err = s.buildManualCutoverDepreciationPart(projectFlockKandangId, contextRow, periodDate, totalPulletCost)
+		totalTransferQty += t.TransferQty
-		if err != nil {
+	}
-			return nil, err
+
 	if len(validTransfers) > 0 {
 		if totalPulletCost <= 0 {
 			return nil, nil
 		}
 		totalDepreciation := 0.0
 		parts := make([]HppV2ComponentPart, 0, len(validTransfers))
 		for i := range validTransfers {
 			t := validTransfers[i]
 			// Pro-rate cost basis per transfer berdasarkan qty share.
 			// CATATAN: pendekatan ini AKURAT kalau cost per ekor sama antar source flock.
 			// Kalau cost per ekor berbeda signifikan antar source, follow-up: refactor
 			// `buildGrowingUsagePart` untuk multi-source-flock cost computation.
 			transferCostBasis := totalPulletCost
 			if totalTransferQty > 0 && len(validTransfers) > 1 {
 				transferCostBasis = totalPulletCost * (t.TransferQty / totalTransferQty)
 			}
 			part, partErr := s.buildNormalTransferDepreciationPart(contextRow, &t, periodDate, transferCostBasis)
 			if partErr != nil {
 				return nil, partErr
 			}
 			if part == nil {
 				continue
 			}
 			totalDepreciation += part.Total
 			parts = append(parts, *part)
 		}
 		if len(parts) == 0 {
 			return nil, nil
 		}
 		return &HppV2Component{
 			Code:   hppV2ComponentDepreciation,
 			Title:  "Depreciation",
 			Scopes: []string{hppV2ScopeProductionCost},
 			Total:  totalDepreciation,
 			Parts:  parts,
 		}, nil
 	}
 	// Fallback: manual cut-over (kandang tanpa transfer record)
 	part, err := s.buildManualCutoverDepreciationPart(projectFlockKandangId, contextRow, periodDate, totalPulletCost)
 	if err != nil {
 		return nil, err
 	}
 	if part == nil {
 		return nil, nil
@@ -1344,20 +1390,22 @@ func (s *hppV2Service) buildNormalTransferDepreciationPart(
 	}
 	houseType := NormalizeDepreciationHouseType(contextRow.HouseType)
-	percentByHouseType, err := s.hppRepo.GetDepreciationPercents(context.Background(), []string{houseType}, scheduleDay)
+	multiplicationByHouseType, err := s.hppRepo.GetMultiplicationPercentages(context.Background(), []string{houseType}, scheduleDay)
 	if err != nil {
 		return nil, err
 	}
-	pulletCostDayN, depreciationValue, depreciationPercent := CalculateDepreciationAtDayN(
+	pulletCostDayN, depreciationValue, multiplicationPercentage := CalculateDepreciationAtDayN(
 		totalPulletCost,
 		scheduleDay,
 		contextRow.HouseType,
-		percentByHouseType,
+		multiplicationByHouseType,
 	)
-	if depreciationValue <= 0 {
+	if depreciationValue <= 0 && pulletCostDayN <= 0 {
 		return nil, nil
 	}
 	totalValueAfter := pulletCostDayN * multiplicationPercentage
 	depreciationPercent := (1.0 - multiplicationPercentage) * 100.0
 	return &HppV2ComponentPart{
 		Code:   hppV2PartDepreciationNormal,
@@ -1365,13 +1413,15 @@ func (s *hppV2Service) buildNormalTransferDepreciationPart(
 		Scopes: []string{hppV2ScopeProductionCost},
 		Total:  depreciationValue,
 		Details: map[string]any{
-			"basis_total":             totalPulletCost,
+			"basis_total":                           totalPulletCost,
-			"pullet_cost_day_n":       pulletCostDayN,
+			"pullet_cost_day_n":                     pulletCostDayN,
-			"depreciation_percent":    depreciationPercent,
+			"multiplication_percentage":             multiplicationPercentage,
-			"schedule_day":            scheduleDay,
+			"total_value_pullet_after_depreciation": totalValueAfter,
-			"origin_date":             formatDateOnly(*originDate),
+			"depreciation_percent":                  depreciationPercent,
-			"transfer_date":           formatDateOnly(transferInput.TransferDate),
+			"schedule_day":                          scheduleDay,
-			"source_project_flock_id": transferInput.SourceProjectFlockID,
+			"origin_date":                           formatDateOnly(*originDate),
 			"transfer_date":                         formatDateOnly(transferInput.TransferDate),
 			"source_project_flock_id":               transferInput.SourceProjectFlockID,
 		},
 		References: []HppV2Reference{
 			{
@@ -1392,7 +1442,7 @@ func (s *hppV2Service) buildManualCutoverDepreciationPart(
 	periodDate time.Time,
 	totalPulletCost float64,
 ) (*HppV2ComponentPart, error) {
-	if contextRow == nil || totalPulletCost <= 0 {
+	if contextRow == nil {
 		return nil, nil
 	}
@@ -1407,6 +1457,21 @@ func (s *hppV2Service) buildManualCutoverDepreciationPart(
 		return nil, nil
 	}
 	populations, err := s.hppRepo.GetChickinPopulationByPFKForFarm(context.Background(), contextRow.ProjectFlockID)
 	if err != nil {
 		return nil, err
 	}
 	var totalPopulation float64
 	for _, qty := range populations {
 		totalPopulation += qty
 	}
 	kandangPopulation := populations[projectFlockKandangId]
 	if totalPopulation <= 0 || kandangPopulation <= 0 {
 		return nil, nil
 	}
 	populationShare := kandangPopulation / totalPopulation
 	basis := manualInput.TotalCost * populationShare
 	originDate, err := s.hppRepo.GetEarliestChickInDateByProjectFlockID(context.Background(), contextRow.ProjectFlockID)
 	if err != nil {
 		return nil, err
@@ -1427,21 +1492,24 @@ func (s *hppV2Service) buildManualCutoverDepreciationPart(
 	}
 	houseType := NormalizeDepreciationHouseType(contextRow.HouseType)
-	percentByHouseType, err := s.hppRepo.GetDepreciationPercents(context.Background(), []string{houseType}, reportScheduleDay)
+	multiplicationByHouseType, err := s.hppRepo.GetMultiplicationPercentages(context.Background(), []string{houseType}, reportScheduleDay)
 	if err != nil {
 		return nil, err
 	}
-	pulletCostDayN, depreciationValue, depreciationPercent := CalculateDepreciationFromDayRange(
+	pulletCostDayN, depreciationValue, multiplicationPercentage := CalculateDepreciationFromDayRange(
-		totalPulletCost,
+		basis,
 		startDay,
 		reportScheduleDay,
 		contextRow.HouseType,
-		percentByHouseType,
+		multiplicationByHouseType,
 	)
-	if depreciationValue <= 0 {
+	if depreciationValue <= 0 && pulletCostDayN <= 0 {
 		return nil, nil
 	}
 	totalValueAfter := pulletCostDayN * multiplicationPercentage
 	depreciationPercent := (1.0 - multiplicationPercentage) * 100.0
 	_ = totalPulletCost
 	return &HppV2ComponentPart{
 		Code:   hppV2PartDepreciationCutover,
@@ -1449,15 +1517,19 @@ func (s *hppV2Service) buildManualCutoverDepreciationPart(
 		Scopes: []string{hppV2ScopeProductionCost},
 		Total:  depreciationValue,
 		Details: map[string]any{
-			"basis_total":           totalPulletCost,
+			"basis_total":                           basis,
-			"pullet_cost_day_n":     pulletCostDayN,
+			"manual_input_total":                    manualInput.TotalCost,
-			"depreciation_percent":  depreciationPercent,
+			"population_share":                      populationShare,
-			"schedule_day":          reportScheduleDay,
+			"pullet_cost_day_n":                     pulletCostDayN,
-			"start_schedule_day":    startDay,
+			"multiplication_percentage":             multiplicationPercentage,
-			"origin_date":           formatDateOnly(*originDate),
+			"total_value_pullet_after_depreciation": totalValueAfter,
-			"cutover_date":          formatDateOnly(manualInput.CutoverDate),
+			"depreciation_percent":                  depreciationPercent,
-			"manual_input_id":       manualInput.ID,
+			"schedule_day":                          reportScheduleDay,
-			"project_flock_kandang": projectFlockKandangId,
+			"start_schedule_day":                    startDay,
 			"origin_date":                           formatDateOnly(*originDate),
 			"cutover_date":                          formatDateOnly(manualInput.CutoverDate),
 			"manual_input_id":                       manualInput.ID,
 			"project_flock_kandang":                 projectFlockKandangId,
 		},
 		References: []HppV2Reference{
 			{
@@ -1465,7 +1537,7 @@ func (s *hppV2Service) buildManualCutoverDepreciationPart(
 				ID:           manualInput.ID,
 				Date:         formatDateOnly(manualInput.CutoverDate),
 				Qty:          1,
-				Total:        totalPulletCost,
+				Total:        manualInput.TotalCost,
 				AppliedTotal: depreciationValue,
 			},
 		},
@@ -1724,7 +1796,7 @@ func partHasScope(part *HppV2ComponentPart, scope string) bool {
 }
 func dateOnly(value time.Time) time.Time {
-	return time.Date(value.Year(), value.Month(), value.Day(), 0, 0, 0, 0, value.Location())
+	return time.Date(value.Year(), value.Month(), value.Day(), 0, 0, 0, 0, time.UTC)
 }
 func formatDateOnly(value time.Time) string {
@@ -57,6 +57,14 @@ func (s *hppV2RepoStub) GetLatestTransferInputByProjectFlockKandangID(_ context.
 	return s.latestTransferByPFK[projectFlockKandangId], nil
 }
 func (s *hppV2RepoStub) GetAllTransferInputsByProjectFlockKandangID(_ context.Context, projectFlockKandangId uint, _ time.Time) ([]commonRepo.HppV2LatestTransferInputRow, error) {
 	row := s.latestTransferByPFK[projectFlockKandangId]
 	if row == nil {
 		return []commonRepo.HppV2LatestTransferInputRow{}, nil
 	}
 	return []commonRepo.HppV2LatestTransferInputRow{*row}, nil
 }
 func (s *hppV2RepoStub) GetManualDepreciationInputByProjectFlockID(_ context.Context, projectFlockID uint) (*commonRepo.HppV2ManualDepreciationInputRow, error) {
 	return s.manualInputByProject[projectFlockID], nil
 }
@@ -93,6 +101,18 @@ func (s *hppV2RepoStub) GetDepreciationPercents(_ context.Context, houseTypes []
 	return result, nil
 }
 // GetMultiplicationPercentages — alias yang sama dengan GetDepreciationPercents untuk match
 // interface HppV2CostRepository (interface dipakai method name baru ini).
 func (s *hppV2RepoStub) GetMultiplicationPercentages(ctx context.Context, houseTypes []string, maxDay int) (map[string]map[int]float64, error) {
 	return s.GetDepreciationPercents(ctx, houseTypes, maxDay)
 }
 // GetChickinPopulationByPFKForFarm — return populasi per PFK dari satu project flock.
 // Stub minimal: return empty map (depreciation manual cutover tidak di-test di sini).
 func (s *hppV2RepoStub) GetChickinPopulationByPFKForFarm(_ context.Context, _ uint) (map[uint]float64, error) {
 	return map[uint]float64{}, nil
 }
 func (s *hppV2RepoStub) ListUsageCostRowsByProductFlags(_ context.Context, projectFlockKandangIDs []uint, flagNames []string, _ *time.Time) ([]commonRepo.HppV2UsageCostRow, error) {
 	return append([]commonRepo.HppV2UsageCostRow{}, s.usageRowsByKey[stubKey(projectFlockKandangIDs, flagNames)]...), nil
 }
@@ -121,9 +121,12 @@ func init() {
 	// Redis
 	RedisURL = viper.GetString("REDIS_URL")
 	// TransferToLayingGrowingMaxWeek: batas umur (minggu dari chick_in) yang masih boleh ditransfer ke laying.
 	// Disatukan dengan depreciation_start_age_day = 175 hari = 25 minggu, agar konsisten antara batas transfer
 	// dan kapan depresiasi mulai berjalan.
 	TransferToLayingGrowingMaxWeek = viper.GetInt("TRANSFER_TO_LAYING_GROWING_MAX_WEEK")
 	if TransferToLayingGrowingMaxWeek <= 0 {
-		TransferToLayingGrowingMaxWeek = 19
+		TransferToLayingGrowingMaxWeek = 25
 	}
 	// Object storage
@@ -0,0 +1,17 @@
 -- Hapus open_house dan close_house rows dengan effective_date baru
 DELETE FROM house_depreciation_standards
 WHERE house_type IN ('open_house', 'close_house') AND effective_date = '2026-05-20';
 -- Hapus kolom multiplication_percentage
 ALTER TABLE house_depreciation_standards DROP COLUMN multiplication_percentage;
 -- Invalidate snapshot cache
 DELETE FROM farm_depreciation_snapshots;
 -- Kembalikan unique constraint lama
 ALTER TABLE house_depreciation_standards
    DROP CONSTRAINT house_depreciation_standards_house_type_day_eff_unique;
 ALTER TABLE house_depreciation_standards
    ADD CONSTRAINT house_depreciation_standards_house_type_day_unique
    UNIQUE (house_type, day);
@@ -0,0 +1,279 @@
 -- Drop unique constraint lama (house_type, day) agar bisa support multi effective_date
 ALTER TABLE house_depreciation_standards
    DROP CONSTRAINT house_depreciation_standards_house_type_day_unique;
 -- Unique baru: (house_type, day, effective_date)
 -- NULL dianggap distinct di PostgreSQL → row lama (effective_date NULL) tidak konflik dengan row baru
 ALTER TABLE house_depreciation_standards
    ADD CONSTRAINT house_depreciation_standards_house_type_day_eff_unique
    UNIQUE (house_type, day, effective_date);
 -- Tambah kolom multiplication_percentage (nilai dari baris ke-3 Excel "Depresiasi 25 week.xlsx")
 ALTER TABLE house_depreciation_standards
    ADD COLUMN multiplication_percentage numeric(20,15) NOT NULL DEFAULT 0;
 -- Isi multiplication_percentage untuk semua row existing (effective_date IS NULL)
 -- Value diambil dari row 3 Excel: kolom A=day1 s/d TL=day532
 UPDATE house_depreciation_standards AS hds
 SET multiplication_percentage = v.val
 FROM (VALUES
    (1,0.997742664),(2,0.997737557),(3,0.997732426),(4,0.997727273),(5,0.997722096),
    (6,0.997716895),(7,0.99771167),(8,0.997706422),(9,0.997701149),(10,0.997695853),
    (11,0.997690531),(12,0.9977),(13,0.997679814),(14,0.997674419),(15,0.998),
    (16,0.997997998),(17,0.997993982),(18,0.99798995),(19,0.997985901),(20,0.997981837),
    (21,0.997977755),(22,0.997635934),(23,0.997630332),(24,0.997624703),(25,0.997619048),
    (26,0.997613365),(27,0.997607656),(28,0.997601918),(29,0.997596154),(30,0.997590361),
    (31,0.997584541),(32,0.997578692),(33,0.997572816),(34,0.99756691),(35,0.997560976),
    (36,0.997555012),(37,0.99754902),(38,0.997542998),(39,0.997536946),(40,0.997530864),
    (41,0.997524752),(42,0.99751861),(43,0.997867804),(44,0.997863248),(45,0.997858672),
    (46,0.997854077),(47,0.997849462),(48,0.997844828),(49,0.997840173),(50,0.997474747),
    (51,0.997468354),(52,0.997461929),(53,0.997455471),(54,0.99744898),(55,0.997442455),
    (56,0.997435897),(57,0.997429306),(58,0.99742268),(59,0.997416021),(60,0.997409326),
    (61,0.997402597),(62,0.997395833),(63,0.997389034),(64,0.997756171),(65,0.997751124),
    (66,0.997746056),(67,0.997740964),(68,0.997735849),(69,0.997730711),(70,0.99772555),
    (71,0.997340426),(72,0.997333333),(73,0.997326203),(74,0.997319035),(75,0.997311828),
    (76,0.997304582),(77,0.9972973),(78,0.99767712),(79,0.99767171),(80,0.99766628),
    (81,0.99766082),(82,0.99765533),(83,0.99764982),(84,0.997644287),(85,0.997245179),
    (86,0.997237569),(87,0.997229917),(88,0.997222222),(89,0.997214485),(90,0.997206704),
    (91,0.99719888),(92,0.997191011),(93,0.997183099),(94,0.997175141),(95,0.997167139),
    (96,0.997159091),(97,0.997150997),(98,0.997142857),(99,0.997544003),(100,0.997537957),
    (101,0.99753188),(102,0.997525773),(103,0.997519636),(104,0.997513469),(105,0.99750727),
    (106,0.997084548),(107,0.997076023),(108,0.997067449),(109,0.997058824),(110,0.997050147),
    (111,0.99704142),(112,0.997032641),(113,0.99744898),(114,0.997442455),(115,0.997435897),
    (116,0.997429306),(117,0.99742268),(118,0.997416021),(119,0.997409326),(120,0.996969697),
    (121,0.996960486),(122,0.99695122),(123,0.996941896),(124,0.996932515),(125,0.996923077),
    (126,0.99691358),(127,0.997346307),(128,0.997339246),(129,0.997332148),(130,0.997325011),
    (131,0.997317836),(132,0.997310623),(133,0.997303371),(134,0.996845426),(135,0.996835443),
    (136,0.996825397),(137,0.996815287),(138,0.996805112),(139,0.996794872),(140,0.996784566),
    (141,0.997235023),(142,0.997227357),(143,0.997219648),(144,0.997211896),(145,0.997204101),
    (146,0.997196262),(147,0.997188379),(148,0.996710526),(149,0.99669967),(150,0.996688742),
    (151,0.996677741),(152,0.996666667),(153,0.996655518),(154,0.996644295),(155,0.997113997),
    (156,0.997105644),(157,0.997097242),(158,0.997088792),(159,0.997080292),(160,0.997071742),
    (161,0.997063142),(162,0.997054492),(163,0.99704579),(164,0.997037037),(165,0.997028232),
    (166,0.997019374),(167,0.997010463),(168,0.997001499),(169,0.996491228),(170,0.996478873),
    (171,0.996466431),(172,0.996453901),(173,0.996441281),(174,0.996428571),(175,0.996415771),
    (176,0.996916752),(177,0.996907216),(178,0.996897622),(179,0.996887967),(180,0.996878252),
    (181,0.996868476),(182,0.996858639),(183,0.996848739),(184,0.996838778),(185,0.996828753),
    (186,0.996818664),(187,0.996808511),(188,0.996798292),(189,0.996788009),(190,0.996240602),
    (191,0.996226415),(192,0.996212121),(193,0.996197719),(194,0.996183206),(195,0.996168582),
    (196,0.996153846),(197,0.996690568),(198,0.996679579),(199,0.996668517),(200,0.996657382),
    (201,0.996646171),(202,0.996634885),(203,0.996623523),(204,0.996612084),(205,0.996600567),
    (206,0.996588971),(207,0.996577296),(208,0.996565541),(209,0.996553705),(210,0.996541787),
    (211,0.996529786),(212,0.996517702),(213,0.996505533),(214,0.996493279),(215,0.996480938),
    (216,0.996468511),(217,0.996455995),(218,0.996443391),(219,0.996430696),(220,0.99641791),
    (221,0.996405033),(222,0.996392063),(223,0.996378998),(224,0.996365839),(225,0.995744681),
    (226,0.995726496),(227,0.995708155),(228,0.995689655),(229,0.995670996),(230,0.995652174),
    (231,0.995633188),(232,0.996240602),(233,0.996226415),(234,0.996212121),(235,0.996197719),
    (236,0.996183206),(237,0.996168582),(238,0.996153846),(239,0.9961389960),(240,0.996124031),
    (241,0.996108949),(242,0.99609375),(243,0.996078431),(244,0.996062992),(245,0.996047431),
    (246,0.996031746),(247,0.996015936),(248,0.996),(249,0.995983936),(250,0.995967742),
    (251,0.995951417),(252,0.995934959),(253,0.995918367),(254,0.995901639),(255,0.995884774),
    (256,0.995867769),(257,0.995850622),(258,0.995833333),(259,0.9958158999),(260,0.995798319),
    (261,0.995780591),(262,0.995762712),(263,0.995744681),(264,0.995726496),(265,0.995708155),
    (266,0.995689655),(267,0.995670996),(268,0.995652174),(269,0.995633188),(270,0.995614035),
    (271,0.995594714),(272,0.995575221),(273,0.995555556),(274,0.995535714),(275,0.995515695),
    (276,0.995495495),(277,0.995475113),(278,0.995454545),(279,0.99543379),(280,0.995412844),
    (281,0.995391705),(282,0.99537037),(283,0.995348837),(284,0.995327103),(285,0.995305164),
    (286,0.995282919),(287,0.995260664),(288,0.996031746),(289,0.996015936),(290,0.996),
    (291,0.995983936),(292,0.995967742),(293,0.995951417),(294,0.995934959),(295,0.995102041),
    (296,0.995077933),(297,0.995053586),(298,0.995028998),(299,0.995004163),(300,0.994979079),
    (301,0.994953743),(302,0.994928149),(303,0.994902294),(304,0.994876174),(305,0.994849785),
    (306,0.994823123),(307,0.994796184),(308,0.994768963),(309,0.994741455),(310,0.994713656),
    (311,0.994685562),(312,0.994657168),(313,0.994628469),(314,0.99459946),(315,0.994570136),
    (316,0.994540491),(317,0.994510522),(318,0.994480221),(319,0.994449584),(320,0.994418605),
    (321,0.994387278),(322,0.994355597),(323,0.995269631),(324,0.995247148),(325,0.995224451),
    (326,0.995201536),(327,0.995178399),(328,0.995155039),(329,0.995131451),(330,0.994129159),
    (331,0.994094488),(332,0.994059406),(333,0.994023904),(334,0.993987976),(335,0.993951613),
    (336,0.993914807),(337,0.994897959),(338,0.994871795),(339,0.994845361),(340,0.994818653),
    (341,0.994791667),(342,0.994764398),(343,0.994736842),(344,0.993650794),(345,0.993610224),
    (346,0.993569132),(347,0.993527508),(348,0.993484342),(349,0.993442623),(350,0.99339934),
    (351,0.993355482),(352,0.993311037),(353,0.993265993),(354,0.993220339),(355,0.993174061),
    (356,0.993127148),(357,0.993079585),(358,0.994192799),(359,0.994158879),(360,0.994124559),
    (361,0.994089835),(362,0.994054697),(363,0.994019139),(364,0.993983153),(365,0.992736077),
    (366,0.992682927),(367,0.992628993),(368,0.992574257),(369,0.992518703),(370,0.992462312),
    (371,0.992405063),(372,0.993622449),(373,0.993581515),(374,0.993540052),(375,0.993498049),
    (376,0.993455497),(377,0.993412385),(378,0.9933687),(379,0.993324433),(380,0.99327957),
    (381,0.9932341),(382,0.993188011),(383,0.993141289),(384,0.993093923),(385,0.993045897),
    (386,0.991596639),(387,0.991525424),(388,0.991452991),(389,0.99137931),(390,0.991304348),
    (391,0.99122807),(392,0.991150442),(393,0.992559524),(394,0.992503748),(395,0.99244713),
    (396,0.99238965),(397,0.992331288),(398,0.992272025),(399,0.992211838),(400,0.992150706),
    (401,0.992088608),(402,0.992025518),(403,0.991961415),(404,0.991896272),(405,0.991830065),
    (406,0.991762768),(407,0.991694352),(408,0.991624791),(409,0.991554054),(410,0.991482112),
    (411,0.991408935),(412,0.991334489),(413,0.991258741),(414,0.989417989),(415,0.989304813),
    (416,0.989189189),(417,0.989071038),(418,0.988950276),(419,0.988826816),(420,0.988700565),
    (421,0.99047619),(422,0.990384615),(423,0.990291262),(424,0.990196078),(425,0.99009901),
    (426,0.99),(427,0.98989899),(428,0.989795918),(429,0.989690722),(430,0.989583333),
    (431,0.989473684),(432,0.989361702),(433,0.989247312),(434,0.989130435),(435,0.989010989),
    (436,0.988888889),(437,0.988764045),(438,0.988636364),(439,0.988505747),(440,0.988372093),
    (441,0.988235294),(442,0.988095238),(443,0.987951807),(444,0.987804878),(445,0.987654321),
    (446,0.9875),(447,0.987341772),(448,0.987179487),(449,0.987012987),(450,0.986842105),
    (451,0.986666667),(452,0.986486486),(453,0.98630137),(454,0.986111111),(455,0.985915493),
    (456,0.985714286),(457,0.985507246),(458,0.985294118),(459,0.985074627),(460,0.984848485),
    (461,0.984615385),(462,0.984375),(463,0.987301587),(464,0.987138264),(465,0.986970684),
    (466,0.98679868),(467,0.986622074),(468,0.986440678),(469,0.986254296),(470,0.982578397),
    (471,0.982269504),(472,0.981949458),(473,0.981617647),(474,0.981273408),(475,0.980916031),
    (476,0.980544747),(477,0.98015873),(478,0.979757085),(479,0.979338843),(480,0.978902954),
    (481,0.978448276),(482,0.977973568),(483,0.977477477),(484,0.976958525),(485,0.976415094),
    (486,0.975845411),(487,0.975247525),(488,0.974619289),(489,0.973958333),(490,0.973262032),
    (491,0.978021978),(492,0.97752809),(493,0.977011494),(494,0.976470588),(495,0.975903614),
    (496,0.975308642),(497,0.974683544),(498,0.967532468),(499,0.966442953),(500,0.965277778),
    (501,0.964028777),(502,0.962686567),(503,0.96124031),(504,0.959677419),(505,0.966386555),
    (506,0.965217391),(507,0.963963964),(508,0.962616822),(509,0.961165049),(510,0.95959596),
    (511,0.957894737),(512,0.945054945),(513,0.941860465),(514,0.938271605),(515,0.934210526),
    (516,0.929577465),(517,0.924242424),(518,0.918032787),(519,0.928571429),(520,0.923076923),
    (521,0.916666667),(522,0.909090909),(523,0.9),(524,0.888888889),(525,0.875),
    (526,0.857142857),(527,0.833333333),(528,0.8),(529,0.75),(530,0.666666667),
    (531,0.5),(532,9.11e-12)
 ) AS v(day_num, val)
 WHERE hds.day = v.day_num;
 -- Insert open_house baru dengan effective_date 2026-05-20
 -- multiplication_percentage diambil dari row existing (sudah di-UPDATE di step sebelumnya)
 INSERT INTO house_depreciation_standards
    (house_type, day, effective_date, depreciation_percent, standard_week, name, multiplication_percentage)
 SELECT
    'open_house'::house_type_enum,
    day,
    '2026-05-20'::date,
    depreciation_percent,
    25,
    'Standard Open House Week 25',
    multiplication_percentage
 FROM (
    SELECT DISTINCT ON (day)
        day, depreciation_percent, multiplication_percentage
    FROM house_depreciation_standards
    WHERE house_type = 'open_house'
    ORDER BY day, effective_date DESC NULLS LAST
 ) effective_open_house;
 -- Insert close_house baru: depreciation_percent dari open_house, multiplication_percentage dari Excel row 8 (close_house)
 INSERT INTO house_depreciation_standards
    (house_type, day, effective_date, depreciation_percent, standard_week, name, multiplication_percentage)
 SELECT
    'close_house'::house_type_enum,
    oh.day,
    '2026-05-20'::date,
    oh.depreciation_percent,
    25,
    'Standard Close House Week 25',
    ch.val
 FROM (
    SELECT DISTINCT ON (day)
        day, depreciation_percent
    FROM house_depreciation_standards
    WHERE house_type = 'open_house'
    ORDER BY day, effective_date DESC NULLS LAST
 ) oh
 JOIN (VALUES
    (1,0.9981),(2,0.9981),(3,0.9981),(4,0.9981),(5,0.9981),
    (6,0.9981),(7,0.9981),(8,0.9978),(9,0.9978),(10,0.9978),
    (11,0.9978),(12,0.9978),(13,0.9978),(14,0.9978),(15,0.9978),
    (16,0.9978),(17,0.9978),(18,0.9978),(19,0.9978),(20,0.9978),
    (21,0.9978),(22,0.9981),(23,0.9981),(24,0.9981),(25,0.9981),
    (26,0.9981),(27,0.9981),(28,0.9981),(29,0.9978),(30,0.9978),
    (31,0.9978),(32,0.9978),(33,0.9978),(34,0.9978),(35,0.9978),
    (36,0.9978),(37,0.9978),(38,0.9978),(39,0.9978),(40,0.9978),
    (41,0.9978),(42,0.9978),(43,0.9978),(44,0.9978),(45,0.9978),
    (46,0.9978),(47,0.9978),(48,0.9978),(49,0.9978),(50,0.9981),
    (51,0.9981),(52,0.9981),(53,0.9981),(54,0.9981),(55,0.9981),
    (56,0.9981),(57,0.9978),(58,0.9978),(59,0.9978),(60,0.9978),
    (61,0.9978),(62,0.9978),(63,0.9978),(64,0.9978),(65,0.9978),
    (66,0.9977),(67,0.9977),(68,0.9977),(69,0.9977),(70,0.9977),
    (71,0.9973),(72,0.9973),(73,0.9973),(74,0.9973),(75,0.9973),
    (76,0.9973),(77,0.9973),(78,0.9977),(79,0.9977),(80,0.9977),
    (81,0.9977),(82,0.9977),(83,0.9976),(84,0.9976),(85,0.9972),
    (86,0.9972),(87,0.9972),(88,0.9972),(89,0.9972),(90,0.9972),
    (91,0.9972),(92,0.9972),(93,0.9972),(94,0.9972),(95,0.9972),
    (96,0.9972),(97,0.9972),(98,0.9971),(99,0.9975),(100,0.9975),
    (101,0.9975),(102,0.9975),(103,0.9975),(104,0.9975),(105,0.9975),
    (106,0.9971),(107,0.9971),(108,0.9971),(109,0.9971),(110,0.9971),
    (111,0.997),(112,0.997),(113,0.9974),(114,0.9974),(115,0.9974),
    (116,0.9974),(117,0.9974),(118,0.9974),(119,0.9974),(120,0.997),
    (121,0.997),(122,0.997),(123,0.9969),(124,0.9969),(125,0.9969),
    (126,0.9969),(127,0.9973),(128,0.9973),(129,0.9973),(130,0.9973),
    (131,0.9973),(132,0.9973),(133,0.9973),(134,0.9968),(135,0.9968),
    (136,0.9968),(137,0.9968),(138,0.9968),(139,0.9968),(140,0.9968),
    (141,0.9972),(142,0.9972),(143,0.9972),(144,0.9972),(145,0.9972),
    (146,0.9972),(147,0.9972),(148,0.9967),(149,0.9967),(150,0.9967),
    (151,0.9967),(152,0.9967),(153,0.9967),(154,0.9966),(155,0.9971),
    (156,0.9971),(157,0.9971),(158,0.9971),(159,0.9971),(160,0.9971),
    (161,0.9971),(162,0.9971),(163,0.997),(164,0.997),(165,0.997),
    (166,0.997),(167,0.997),(168,0.997),(169,0.9965),(170,0.9965),
    (171,0.9965),(172,0.9965),(173,0.9964),(174,0.9964),(175,0.9964),
    (176,0.9969),(177,0.9969),(178,0.9969),(179,0.9969),(180,0.9969),
    (181,0.9969),(182,0.9969),(183,0.9968),(184,0.9968),(185,0.9968),
    (186,0.9968),(187,0.9968),(188,0.9968),(189,0.9968),(190,0.9962),
    (191,0.9962),(192,0.9962),(193,0.9962),(194,0.9962),(195,0.9962),
    (196,0.9962),(197,0.9967),(198,0.9967),(199,0.9967),(200,0.9967),
    (201,0.9966),(202,0.9966),(203,0.9966),(204,0.9966),(205,0.9966),
    (206,0.9966),(207,0.9966),(208,0.9966),(209,0.9966),(210,0.9965),
    (211,0.9965),(212,0.9965),(213,0.9965),(214,0.9965),(215,0.9965),
    (216,0.9965),(217,0.9965),(218,0.9964),(219,0.9964),(220,0.9964),
    (221,0.9964),(222,0.9964),(223,0.9964),(224,0.9964),(225,0.9957),
    (226,0.9957),(227,0.9957),(228,0.9957),(229,0.9957),(230,0.9957),
    (231,0.9956),(232,0.9962),(233,0.9962),(234,0.9962),(235,0.9962),
    (236,0.9962),(237,0.9962),(238,0.9962),(239,0.9961),(240,0.9961),
    (241,0.9961),(242,0.9961),(243,0.9961),(244,0.9961),(245,0.996),
    (246,0.996),(247,0.996),(248,0.996),(249,0.996),(250,0.996),
    (251,0.996),(252,0.9959),(253,0.9959),(254,0.9959),(255,0.9959),
    (256,0.9959),(257,0.9959),(258,0.9958),(259,0.9958),(260,0.9958),
    (261,0.9958),(262,0.9958),(263,0.9957),(264,0.9957),(265,0.9957),
    (266,0.9957),(267,0.9957),(268,0.9957),(269,0.9956),(270,0.9956),
    (271,0.9956),(272,0.9956),(273,0.9956),(274,0.9955),(275,0.9955),
    (276,0.9955),(277,0.9955),(278,0.9955),(279,0.9954),(280,0.9954),
    (281,0.9954),(282,0.9954),(283,0.9953),(284,0.9953),(285,0.9953),
    (286,0.9953),(287,0.9953),(288,0.996),(289,0.996),(290,0.996),
    (291,0.996),(292,0.996),(293,0.996),(294,0.9959),(295,0.9951),
    (296,0.9951),(297,0.9951),(298,0.995),(299,0.995),(300,0.995),
    (301,0.995),(302,0.9949),(303,0.9949),(304,0.9949),(305,0.9948),
    (306,0.9948),(307,0.9948),(308,0.9948),(309,0.9947),(310,0.9947),
    (311,0.9947),(312,0.9947),(313,0.9946),(314,0.9946),(315,0.9946),
    (316,0.9945),(317,0.9945),(318,0.9945),(319,0.9944),(320,0.9944),
    (321,0.9944),(322,0.9944),(323,0.9953),(324,0.9952),(325,0.9952),
    (326,0.9952),(327,0.9952),(328,0.9952),(329,0.9951),(330,0.9941),
    (331,0.9941),(332,0.9941),(333,0.994),(334,0.994),(335,0.994),
    (336,0.9939),(337,0.9949),(338,0.9949),(339,0.9948),(340,0.9948),
    (341,0.9948),(342,0.9948),(343,0.9947),(344,0.9937),(345,0.9936),
    (346,0.9936),(347,0.9935),(348,0.9935),(349,0.9934),(350,0.9934),
    (351,0.9934),(352,0.9933),(353,0.9933),(354,0.9932),(355,0.9932),
    (356,0.9931),(357,0.9931),(358,0.9942),(359,0.9942),(360,0.9941),
    (361,0.9941),(362,0.9941),(363,0.994),(364,0.994),(365,0.9927),
    (366,0.9927),(367,0.9926),(368,0.9926),(369,0.9925),(370,0.9925),
    (371,0.9924),(372,0.9936),(373,0.9936),(374,0.9935),(375,0.9935),
    (376,0.9935),(377,0.9934),(378,0.9934),(379,0.9933),(380,0.9933),
    (381,0.9932),(382,0.9932),(383,0.9931),(384,0.9931),(385,0.993),
    (386,0.9916),(387,0.9915),(388,0.9915),(389,0.9914),(390,0.9913),
    (391,0.9912),(392,0.9912),(393,0.9926),(394,0.9925),(395,0.9924),
    (396,0.9924),(397,0.9923),(398,0.9923),(399,0.9922),(400,0.9922),
    (401,0.9921),(402,0.992),(403,0.992),(404,0.9919),(405,0.9918),
    (406,0.9918),(407,0.9917),(408,0.9916),(409,0.9916),(410,0.9915),
    (411,0.9914),(412,0.9913),(413,0.9913),(414,0.9894),(415,0.9893),
    (416,0.9892),(417,0.9891),(418,0.989),(419,0.9888),(420,0.9887),
    (421,0.9905),(422,0.9904),(423,0.9903),(424,0.9902),(425,0.9901),
    (426,0.99),(427,0.9899),(428,0.9898),(429,0.9897),(430,0.9896),
    (431,0.9895),(432,0.9894),(433,0.9892),(434,0.9891),(435,0.989),
    (436,0.9889),(437,0.9888),(438,0.9886),(439,0.9885),(440,0.9884),
    (441,0.9882),(442,0.9881),(443,0.988),(444,0.9878),(445,0.9877),
    (446,0.9875),(447,0.9873),(448,0.9872),(449,0.987),(450,0.9868),
    (451,0.9867),(452,0.9865),(453,0.9863),(454,0.9861),(455,0.9859),
    (456,0.9857),(457,0.9855),(458,0.9853),(459,0.9851),(460,0.9848),
    (461,0.9846),(462,0.9844),(463,0.9873),(464,0.9871),(465,0.987),
    (466,0.9868),(467,0.9866),(468,0.9864),(469,0.9863),(470,0.9826),
    (471,0.9823),(472,0.9819),(473,0.9816),(474,0.9813),(475,0.9809),
    (476,0.9805),(477,0.9802),(478,0.9798),(479,0.9793),(480,0.9789),
    (481,0.9784),(482,0.978),(483,0.9775),(484,0.977),(485,0.9764),
    (486,0.9758),(487,0.9752),(488,0.9746),(489,0.974),(490,0.9733),
    (491,0.978),(492,0.9775),(493,0.977),(494,0.9765),(495,0.9759),
    (496,0.9753),(497,0.9747),(498,0.9675),(499,0.9664),(500,0.9653),
    (501,0.964),(502,0.9627),(503,0.9612),(504,0.9597),(505,0.9664),
    (506,0.9652),(507,0.964),(508,0.9626),(509,0.9612),(510,0.9596),
    (511,0.9579),(512,0.9451),(513,0.9419),(514,0.9383),(515,0.9342),
    (516,0.9296),(517,0.9242),(518,0.918),(519,0.9286),(520,0.9231),
    (521,0.9167),(522,0.9091),(523,0.9),(524,0.8889),(525,0.875),
    (526,0.8571),(527,0.8333),(528,0.8),(529,0.75),(530,0.6667),
    (531,0.5),(532,0)
 ) AS ch(day, val) ON oh.day = ch.day;
 -- Invalidate snapshot cache depreciation agar recompute dengan standard baru
 DELETE FROM farm_depreciation_snapshots;
@@ -0,0 +1,22 @@
 -- Rollback: balik ke rule lama (19 minggu = 133 hari)
 BEGIN;
 UPDATE laying_transfers lt
 SET economic_cutoff_date = sub.cutoff_date,
    updated_at = NOW()
 FROM (
    SELECT
        lt2.id AS transfer_id,
        (MIN(pc.chick_in_date)::date + INTERVAL '133 days')::date AS cutoff_date
    FROM laying_transfers lt2
    JOIN project_chickins pc ON pc.project_flock_kandang_id = lt2.source_project_flock_kandang_id
    WHERE lt2.deleted_at IS NULL
      AND lt2.source_project_flock_kandang_id IS NOT NULL
      AND pc.deleted_at IS NULL
    GROUP BY lt2.id
 ) sub
 WHERE lt.id = sub.transfer_id
  AND lt.deleted_at IS NULL;
 COMMIT;
@@ -0,0 +1,24 @@
 -- Recalculate laying_transfers.economic_cutoff_date dari rule 19 minggu (lama) ke 25 minggu (baru,
 -- sejalan dengan depreciation_start_age_day = 175). Semua transfer historis yang punya
 -- source_project_flock_kandang_id akan di-update agar economic_cutoff_date = source.chick_in_date + 175 hari.
 BEGIN;
 UPDATE laying_transfers lt
 SET economic_cutoff_date = sub.cutoff_date,
    updated_at = NOW()
 FROM (
    SELECT
        lt2.id AS transfer_id,
        (MIN(pc.chick_in_date)::date + INTERVAL '175 days')::date AS cutoff_date
    FROM laying_transfers lt2
    JOIN project_chickins pc ON pc.project_flock_kandang_id = lt2.source_project_flock_kandang_id
    WHERE lt2.deleted_at IS NULL
      AND lt2.source_project_flock_kandang_id IS NOT NULL
      AND pc.deleted_at IS NULL
    GROUP BY lt2.id
 ) sub
 WHERE lt.id = sub.transfer_id
  AND lt.deleted_at IS NULL;
 COMMIT;
@@ -0,0 +1,3 @@
 -- Down migration: tidak ada cara restore TRUNCATE. Snapshot akan auto-regenerate on demand.
 -- File kosong sengaja: rollback safe karena snapshot dianggap cache yang bisa di-regenerate.
 SELECT 1;
@@ -0,0 +1,10 @@
 -- Truncate semua farm_depreciation_snapshots agar di-recompute dengan logic baru:
 -- 1. Multi-transfer per target kandang sekarang menghasilkan multiple parts (1 per transfer)
 -- 2. Economic cutoff date sudah diupdate dari 19 minggu ke 25 minggu
 -- 3. Format `components` JSON tetap kompatibel — yang berubah adalah jumlah entries (lebih banyak
 --    untuk kandang multi-transfer)
 --
 -- Snapshot akan otomatis di-regenerate saat user request `/api/reports/expense/depreciation`
 -- untuk period yang relevan.
 TRUNCATE TABLE farm_depreciation_snapshots;
@@ -1,99 +0,0 @@
 BEGIN;
 -- ============================================================
 -- Rollback dynamic via audit snapshots di schema `migration_audit.jamali_w10_*`.
 -- Semua reverse dibaca dari snapshot yang dibuat oleh UP migration —
 -- tidak ada IDs/qty yang hardcode. Robust terhadap data drift antara
 -- dump time dan UP apply time (misalnya row baru warehouse_id=10
 -- yang muncul setelah dump diambil).
 --
 -- LIMITASI: FK relinks di stock_logs / stock_allocations / recording_eggs /
 -- marketing_products / dll. TIDAK direverse di sini (skip audit per-row
 -- untuk hemat storage ~40MB). Setelah down, 9 PW W10 yang di-restore
 -- akan kosong dari child rows (semua child masih pointing ke W25 PW
 -- yang sebelumnya menerima merge). Untuk rollback penuh, restore DB
 -- dari backup pre-migration.
 -- ============================================================
 -- Guard: pastikan audit tables ada (kalau tidak, fail-loud)
 DO $$
 BEGIN
  IF NOT EXISTS (
    SELECT 1 FROM information_schema.tables
    WHERE table_schema = 'migration_audit'
      AND table_name = 'jamali_w10_pw_deleted_snapshot'
  ) THEN
    RAISE EXCEPTION 'Audit table migration_audit.jamali_w10_* tidak ditemukan. UP migration belum dijalankan atau audit sudah di-drop. Restore dari DB backup jika perlu.';
  END IF;
 END $$;
 -- 1. Un-soft-delete warehouse 10 (kalau memang di-softdelete oleh UP)
 UPDATE warehouses w
 SET deleted_at = NULL, updated_at = NOW()
 FROM migration_audit.jamali_w10_warehouse_softdeleted a
 WHERE w.id = a.id;
 -- 2. Un-soft-delete stock_transfers self-loop yang disoft-delete UP step 7.1
 UPDATE stock_transfers st
 SET deleted_at = NULL, updated_at = NOW()
 FROM migration_audit.jamali_w10_st_softdeleted a
 WHERE st.id = a.id;
 -- 3. Reverse stock_transfers redirect (CASE-based dari snapshot was_from_w10/was_to_w10)
 UPDATE stock_transfers st
 SET from_warehouse_id = CASE WHEN a.was_from_w10 THEN 10 ELSE st.from_warehouse_id END,
    to_warehouse_id   = CASE WHEN a.was_to_w10   THEN 10 ELSE st.to_warehouse_id   END,
    updated_at = NOW()
 FROM migration_audit.jamali_w10_st_redirected a
 WHERE st.id = a.id;
 -- 3b. Self-loop transfers (W10<->W25 awal) juga punya from_warehouse_id=25 atau
 -- to_warehouse_id=25 setelah UP step 7.2. Karena snapshot jamali_w10_st_softdeleted
 -- punya kolom from_warehouse_id & to_warehouse_id asli, pakai itu untuk reverse.
 UPDATE stock_transfers st
 SET from_warehouse_id = 10, updated_at = NOW()
 FROM migration_audit.jamali_w10_st_softdeleted a
 WHERE st.id = a.id AND a.from_warehouse_id = 10;
 UPDATE stock_transfers st
 SET to_warehouse_id = 10, updated_at = NOW()
 FROM migration_audit.jamali_w10_st_softdeleted a
 WHERE st.id = a.id AND a.to_warehouse_id = 10;
 -- 4. Reverse purchase_items.warehouse_id 25 -> 10
 UPDATE purchase_items
 SET warehouse_id = 10
 WHERE id IN (SELECT id FROM migration_audit.jamali_w10_purchase_items);
 -- 5. Reverse W10-only PW (warehouse_id 25 -> 10, restore pfk asli dari snapshot)
 UPDATE product_warehouses pw
 SET warehouse_id = 10, project_flock_kandang_id = a.original_pfk
 FROM migration_audit.jamali_w10_pw_w10only_snapshot a
 WHERE pw.id = a.id;
 -- 6. Subtract qty dari W25 PW (reverse merge)
 -- WARNING: kalau W25 qty sudah dikonsumsi pasca-UP (sales/recording/dll),
 -- hasil bisa negatif. Tidak ada CHECK constraint di product_warehouses.qty,
 -- jadi silent. Operator harus verifikasi manual post-down:
 --   SELECT id, qty FROM product_warehouses WHERE qty < 0;
 UPDATE product_warehouses pw
 SET qty = pw.qty - a.merged_qty
 FROM migration_audit.jamali_w10_qty_merge a
 WHERE pw.id = a.target_pw_id;
 -- 7. Re-INSERT 9 W10 PW rows yang di-DELETE oleh UP (PK asli + qty asli)
 INSERT INTO product_warehouses (id, product_id, warehouse_id, qty, project_flock_kandang_id)
 SELECT id, product_id, 10, qty, project_flock_kandang_id
 FROM migration_audit.jamali_w10_pw_deleted_snapshot;
 -- 8. Cleanup audit tables (drop satu per satu, tidak wildcard untuk safety)
 DROP TABLE migration_audit.jamali_w10_pw_deleted_snapshot;
 DROP TABLE migration_audit.jamali_w10_qty_merge;
 DROP TABLE migration_audit.jamali_w10_pw_w10only_snapshot;
 DROP TABLE migration_audit.jamali_w10_st_softdeleted;
 DROP TABLE migration_audit.jamali_w10_st_redirected;
 DROP TABLE migration_audit.jamali_w10_purchase_items;
 DROP TABLE migration_audit.jamali_w10_warehouse_softdeleted;
 -- Schema migration_audit dipertahankan (bisa dipakai migration lain di masa depan)
 COMMIT;
@@ -1,241 +0,0 @@
 BEGIN;
 -- ============================================================
 -- Normalisasi warehouse 10 (Jamali NON_AKTIF) -> 25 (Gudang Farm Jamali)
 -- Background: Dua warehouse LOKASI di area & lokasi sama (area_id=6,
 -- location_id=16). W10 sudah ditandai NON_AKTIF tapi masih punya 13
 -- product_warehouses, 3,590 stock_logs, ~790K stock_allocations,
 -- 332 marketing_products, 17 purchase_items, dan 14 stock_transfers.
 -- Migration ini konsolidasikan semua relasi ke W25 lalu soft-delete W10.
 --
 -- Klasifikasi data:
 -- A. 9 product_warehouses W10 overlap dengan W25 (sama product_id, pfk=NULL)
 --    -> merge qty ke W25, relink semua FK ke product_warehouses.id,
 --       lalu DELETE W10 PW rows.
 -- B. 4 product_warehouses W10-only -> UPDATE warehouse_id=25.
 --    Rows 1188/1189/1190 punya pfk=98 (anomali LOKASI, seharusnya NULL
 --    per aturan di CLAUDE.md [2026-05-06]) -> normalisasi sekalian.
 -- C. 17 purchase_items.warehouse_id=10 -> UPDATE 25 (no unique conflict).
 -- D. 3 stock_transfers W10<->W25 (PND-LTI-00107/00109/00119) akan jadi
 --    self-loop W25<->W25 setelah merge -> soft-delete.
 -- E. 12 stock_transfers EGG_FARM_CUTOVER to_warehouse_id=10 -> UPDATE 25.
 -- F. warehouse_id=10 sendiri -> soft-delete.
 --
 -- UP membuat 7 snapshot table di schema `migration_audit.jamali_w10_*`
 -- sebelum mutasi. DOWN baca snapshot itu untuk reverse dynamic (tidak
 -- hardcode IDs/qty), sehingga apapun yang ada di production saat UP
 -- dijalankan akan ter-audit dan ter-reverse. FK relinks
 -- (stock_logs/stock_allocations/dll) TIDAK di-audit (storage ~40MB)
 -- — limitation: tidak bisa di-reverse DOWN, full rollback = DB backup.
 -- ============================================================
 -- STEP -1: Buat schema audit + snapshot tables (idempotent rerun via DROP IF EXISTS)
 CREATE SCHEMA IF NOT EXISTS migration_audit;
 DROP TABLE IF EXISTS migration_audit.jamali_w10_pw_deleted_snapshot;
 DROP TABLE IF EXISTS migration_audit.jamali_w10_qty_merge;
 DROP TABLE IF EXISTS migration_audit.jamali_w10_pw_w10only_snapshot;
 DROP TABLE IF EXISTS migration_audit.jamali_w10_st_softdeleted;
 DROP TABLE IF EXISTS migration_audit.jamali_w10_st_redirected;
 DROP TABLE IF EXISTS migration_audit.jamali_w10_purchase_items;
 DROP TABLE IF EXISTS migration_audit.jamali_w10_warehouse_softdeleted;
 -- Snapshot 9 W10 PW yang akan di-DELETE (overlap dgn W25, pfk=NULL)
 CREATE TABLE migration_audit.jamali_w10_pw_deleted_snapshot AS
 SELECT pw10.id, pw10.product_id, pw10.qty, pw10.project_flock_kandang_id
 FROM product_warehouses pw10
 JOIN product_warehouses pw25
  ON pw25.product_id = pw10.product_id
 AND pw25.warehouse_id = 25
 AND pw25.project_flock_kandang_id IS NULL
 WHERE pw10.warehouse_id = 10 AND pw10.project_flock_kandang_id IS NULL;
 -- Snapshot qty delta per W25 target (untuk reverse subtract)
 CREATE TABLE migration_audit.jamali_w10_qty_merge AS
 SELECT pw25.id AS target_pw_id, pw10.id AS source_pw_id, pw10.qty AS merged_qty
 FROM product_warehouses pw10
 JOIN product_warehouses pw25
  ON pw25.product_id = pw10.product_id
 AND pw25.warehouse_id = 25
 AND pw25.project_flock_kandang_id IS NULL
 WHERE pw10.warehouse_id = 10 AND pw10.project_flock_kandang_id IS NULL;
 -- Snapshot W10-only PW (yang akan di-UPDATE warehouse_id 10->25)
 CREATE TABLE migration_audit.jamali_w10_pw_w10only_snapshot AS
 SELECT pw10.id, pw10.project_flock_kandang_id AS original_pfk
 FROM product_warehouses pw10
 WHERE pw10.warehouse_id = 10
  AND pw10.id NOT IN (SELECT id FROM migration_audit.jamali_w10_pw_deleted_snapshot);
 -- Snapshot stock_transfers yang akan di-soft-delete (self-loop W10<->W25)
 -- Simpan from/to_warehouse_id asli supaya DOWN bisa reverse direction tepat
 CREATE TABLE migration_audit.jamali_w10_st_softdeleted AS
 SELECT id, movement_number, from_warehouse_id, to_warehouse_id
 FROM stock_transfers
 WHERE deleted_at IS NULL
  AND ((from_warehouse_id = 10 AND to_warehouse_id = 25)
    OR (from_warehouse_id = 25 AND to_warehouse_id = 10));
 -- Snapshot stock_transfers yang akan di-UPDATE (W10<->other, bukan self-loop)
 CREATE TABLE migration_audit.jamali_w10_st_redirected AS
 SELECT id,
       (from_warehouse_id = 10) AS was_from_w10,
       (to_warehouse_id = 10)   AS was_to_w10
 FROM stock_transfers
 WHERE deleted_at IS NULL
  AND (from_warehouse_id = 10 OR to_warehouse_id = 10)
  AND id NOT IN (SELECT id FROM migration_audit.jamali_w10_st_softdeleted);
 -- Snapshot purchase_items IDs (cheap, ~17 rows)
 CREATE TABLE migration_audit.jamali_w10_purchase_items AS
 SELECT id FROM purchase_items WHERE warehouse_id = 10;
 -- Snapshot warehouses soft-delete flag (1 row, kalau memang masih aktif)
 CREATE TABLE migration_audit.jamali_w10_warehouse_softdeleted AS
 SELECT id FROM warehouses WHERE id = 10 AND deleted_at IS NULL;
 -- STEP 0: Pre-check sanity (idempotent guards)
 DO $$
 DECLARE v_count INT;
 BEGIN
  SELECT COUNT(*) INTO v_count FROM warehouses
  WHERE id IN (10, 25) AND type = 'LOKASI' AND area_id = 6 AND location_id = 16;
  IF v_count <> 2 THEN
    RAISE EXCEPTION 'Pre-check: warehouse 10/25 schema mismatch (got % rows)', v_count;
  END IF;
  SELECT COUNT(*) INTO v_count FROM purchase_items a
  JOIN purchase_items b ON a.purchase_id = b.purchase_id
    AND a.product_id = b.product_id
    AND a.id <> b.id
  WHERE a.warehouse_id = 10 AND b.warehouse_id = 25;
  IF v_count > 0 THEN
    RAISE EXCEPTION 'Pre-check: % purchase_items unique conflict (purchase_id,product_id)', v_count;
  END IF;
 END $$;
 -- STEP 1: Merge qty W10 -> W25 untuk overlap (pfk=NULL)
 UPDATE product_warehouses pw25
 SET qty = pw25.qty + pw10.qty
 FROM product_warehouses pw10
 WHERE pw10.warehouse_id = 10 AND pw10.project_flock_kandang_id IS NULL
  AND pw25.warehouse_id = 25 AND pw25.project_flock_kandang_id IS NULL
  AND pw25.product_id = pw10.product_id;
 -- STEP 2: Build temp mapping (W10 PW id -> W25 PW id) untuk overlap saja
 CREATE TEMP TABLE _pw_map ON COMMIT DROP AS
 SELECT pw10.id AS old_id, pw25.id AS new_id
 FROM product_warehouses pw10
 JOIN product_warehouses pw25
  ON pw25.product_id = pw10.product_id
 AND pw25.warehouse_id = 25
 AND pw25.project_flock_kandang_id IS NULL
 WHERE pw10.warehouse_id = 10 AND pw10.project_flock_kandang_id IS NULL;
 CREATE INDEX ON _pw_map(old_id);
 -- STEP 3: Relink semua FK ke product_warehouses.id (hanya rows di _pw_map)
 UPDATE stock_logs SET product_warehouse_id = m.new_id
  FROM _pw_map m WHERE stock_logs.product_warehouse_id = m.old_id;
 UPDATE stock_allocations SET product_warehouse_id = m.new_id
  FROM _pw_map m WHERE stock_allocations.product_warehouse_id = m.old_id;
 UPDATE recording_eggs SET product_warehouse_id = m.new_id
  FROM _pw_map m WHERE recording_eggs.product_warehouse_id = m.old_id;
 UPDATE recording_stocks SET product_warehouse_id = m.new_id
  FROM _pw_map m WHERE recording_stocks.product_warehouse_id = m.old_id;
 UPDATE recording_depletions SET product_warehouse_id = m.new_id
  FROM _pw_map m WHERE recording_depletions.product_warehouse_id = m.old_id;
 UPDATE recording_depletions SET source_product_warehouse_id = m.new_id
  FROM _pw_map m WHERE recording_depletions.source_product_warehouse_id = m.old_id;
 UPDATE adjustment_stocks SET product_warehouse_id = m.new_id
  FROM _pw_map m WHERE adjustment_stocks.product_warehouse_id = m.old_id;
 UPDATE marketing_products SET product_warehouse_id = m.new_id
  FROM _pw_map m WHERE marketing_products.product_warehouse_id = m.old_id;
 UPDATE marketing_delivery_products SET product_warehouse_id = m.new_id
  FROM _pw_map m WHERE marketing_delivery_products.product_warehouse_id = m.old_id;
 UPDATE project_chickins SET product_warehouse_id = m.new_id
  FROM _pw_map m WHERE project_chickins.product_warehouse_id = m.old_id;
 UPDATE project_chickin_details SET product_warehouse_id = m.new_id
  FROM _pw_map m WHERE project_chickin_details.product_warehouse_id = m.old_id;
 UPDATE project_flock_populations SET product_warehouse_id = m.new_id
  FROM _pw_map m WHERE project_flock_populations.product_warehouse_id = m.old_id;
 UPDATE laying_transfers SET source_product_warehouse_id = m.new_id
  FROM _pw_map m WHERE laying_transfers.source_product_warehouse_id = m.old_id;
 UPDATE laying_transfer_sources SET product_warehouse_id = m.new_id
  FROM _pw_map m WHERE laying_transfer_sources.product_warehouse_id = m.old_id;
 UPDATE laying_transfer_targets SET product_warehouse_id = m.new_id
  FROM _pw_map m WHERE laying_transfer_targets.product_warehouse_id = m.old_id;
 UPDATE stock_transfer_details SET source_product_warehouse_id = m.new_id
  FROM _pw_map m WHERE stock_transfer_details.source_product_warehouse_id = m.old_id;
 UPDATE stock_transfer_details SET dest_product_warehouse_id = m.new_id
  FROM _pw_map m WHERE stock_transfer_details.dest_product_warehouse_id = m.old_id;
 UPDATE purchase_items SET product_warehouse_id = m.new_id
  FROM _pw_map m WHERE purchase_items.product_warehouse_id = m.old_id;
 -- FIFO v2 tables (kosong di dump 2026-05-25, defensive)
 UPDATE fifo_stock_v2_operation_log SET product_warehouse_id = m.new_id
  FROM _pw_map m WHERE fifo_stock_v2_operation_log.product_warehouse_id = m.old_id;
 UPDATE fifo_stock_v2_reflow_checkpoints SET product_warehouse_id = m.new_id
  FROM _pw_map m WHERE fifo_stock_v2_reflow_checkpoints.product_warehouse_id = m.old_id;
 UPDATE fifo_stock_v2_shadow_allocations SET product_warehouse_id = m.new_id
  FROM _pw_map m WHERE fifo_stock_v2_shadow_allocations.product_warehouse_id = m.old_id;
 -- STEP 4: Hard-delete W10 PW yang sudah merged (9 rows expected)
 DELETE FROM product_warehouses WHERE id IN (SELECT old_id FROM _pw_map);
 -- STEP 5: Sisa W10 PW (4 rows: 1188/1189/1190/1196) -> warehouse_id=25,
 -- pfk dinormalisasi ke NULL sekalian (LOKASI rule)
 UPDATE product_warehouses
 SET warehouse_id = 25, project_flock_kandang_id = NULL
 WHERE warehouse_id = 10;
 -- STEP 6: purchase_items.warehouse_id (17 rows)
 UPDATE purchase_items SET warehouse_id = 25 WHERE warehouse_id = 10;
 -- STEP 7: stock_transfers
 -- 7.1 Soft-delete self-loop (W10<->W25 akan jadi W25<->W25)
 UPDATE stock_transfers
 SET deleted_at = NOW(), updated_at = NOW()
 WHERE deleted_at IS NULL
  AND ((from_warehouse_id = 10 AND to_warehouse_id = 25)
    OR (from_warehouse_id = 25 AND to_warehouse_id = 10));
 -- 7.2 Sisa W10<->other -> 25 (12 EGG_FARM_CUTOVER ke W10)
 UPDATE stock_transfers SET from_warehouse_id = 25, updated_at = NOW() WHERE from_warehouse_id = 10;
 UPDATE stock_transfers SET to_warehouse_id = 25, updated_at = NOW() WHERE to_warehouse_id = 10;
 -- STEP 8: Soft-delete warehouse 10 sendiri
 UPDATE warehouses SET deleted_at = NOW(), updated_at = NOW()
 WHERE id = 10 AND deleted_at IS NULL;
 -- STEP 9: Post-check (fail-fast jika ada residu)
 DO $$
 DECLARE v_count INT;
 BEGIN
  SELECT COUNT(*) INTO v_count FROM product_warehouses WHERE warehouse_id = 10;
  IF v_count <> 0 THEN RAISE EXCEPTION 'product_warehouses W10 residual %', v_count; END IF;
  SELECT COUNT(*) INTO v_count FROM purchase_items WHERE warehouse_id = 10;
  IF v_count <> 0 THEN RAISE EXCEPTION 'purchase_items W10 residual %', v_count; END IF;
  SELECT COUNT(*) INTO v_count FROM stock_transfers
  WHERE deleted_at IS NULL AND (from_warehouse_id = 10 OR to_warehouse_id = 10);
  IF v_count <> 0 THEN RAISE EXCEPTION 'stock_transfers W10 residual %', v_count; END IF;
 END $$;
 COMMIT;
@@ -1,29 +0,0 @@
 BEGIN;
 -- ============================================================
 -- Rollback stock_log drift fix: DELETE corrective rows yang di-insert UP.
 -- IDs ditarik dari audit table `migration_audit.jamali_w10_stocklog_corrections`.
 -- Setelah delete, `last_stock_log.stock` kembali ke nilai pre-fix (drift muncul lagi).
 -- ============================================================
 -- Guard: audit table harus ada
 DO $$
 BEGIN
  IF NOT EXISTS (
    SELECT 1 FROM information_schema.tables
    WHERE table_schema = 'migration_audit'
      AND table_name = 'jamali_w10_stocklog_corrections'
  ) THEN
    RAISE EXCEPTION
      'Audit table migration_audit.jamali_w10_stocklog_corrections tidak ditemukan. UP belum dijalankan atau audit sudah di-drop.';
  END IF;
 END $$;
 -- DELETE corrective stock_logs yang di-insert oleh UP
 DELETE FROM stock_logs
 WHERE id IN (SELECT stock_log_id FROM migration_audit.jamali_w10_stocklog_corrections);
 -- Cleanup audit table
 DROP TABLE migration_audit.jamali_w10_stocklog_corrections;
 COMMIT;
@@ -1,111 +0,0 @@
 BEGIN;
 -- ============================================================
 -- Fix stock_log drift pasca-merge warehouse Jamali (NON_AKTIF) -> Gudang Farm Jamali.
 -- Follow-up migration setelah 20260528121631_normalize_warehouse_jamali_10_to_25.
 --
 -- Setelah merge, `stock_logs.stock` (running ledger) drift dari
 -- `product_warehouses.qty` karena: pre-existing drift di W10 + W25 sources,
 -- plus FIFO reflow yang trigger pasca-merge (Recording-Edit) recompute
 -- pw.qty tapi stock_logs tidak ikut update.
 --
 -- Migration ini insert 1 ADJUSTMENT stock_log corrective per PW yang drift
 -- supaya `last_stock_log.stock = pw.qty`. Logic ekivalen dengan
 -- `cmd/fix-stock-log-drift`.
 --
 -- Karakteristik dynamic:
 --   - Tidak hardcode PW IDs atau drift values
 --   - Iterate via merge target + W10-only kept PWs (data-driven dari snapshot)
 --   - Per PW: hitung drift runtime, skip kalau negligible (< 0.001) atau no logs
 --   - Track stock_log IDs yang di-insert untuk DOWN reverse
 -- ============================================================
 -- Guard: previous migration (normalisasi) audit harus ada
 DO $$
 BEGIN
  IF NOT EXISTS (
    SELECT 1 FROM information_schema.tables
    WHERE table_schema = 'migration_audit'
      AND table_name = 'jamali_w10_qty_merge'
  ) THEN
    RAISE EXCEPTION
      'Migration 20260528121631 (normalize_warehouse_jamali) belum dijalankan atau audit-nya sudah di-drop. Apply UP-nya dulu sebelum migration ini.';
  END IF;
 END $$;
 -- Audit table untuk track stock_log IDs yang di-insert (untuk DOWN reverse)
 DROP TABLE IF EXISTS migration_audit.jamali_w10_stocklog_corrections;
 CREATE TABLE migration_audit.jamali_w10_stocklog_corrections (
  stock_log_id BIGINT NOT NULL PRIMARY KEY,
  product_warehouse_id BIGINT NOT NULL,
  drift NUMERIC(15,3) NOT NULL,
  inserted_at TIMESTAMPTZ DEFAULT NOW()
 );
 -- Insert corrective ADJUSTMENT stock_log untuk tiap PW yang drift
 DO $$
 DECLARE
  rec RECORD;
  v_last_log_stock NUMERIC(15,3);
  v_drift NUMERIC(15,3);
  v_new_log_id BIGINT;
  v_inserts INT := 0;
 BEGIN
  FOR rec IN (
    SELECT pw.id AS pw_id, pw.qty AS qty
    FROM product_warehouses pw
    WHERE pw.id IN (
      -- Merge target W25 PWs (9 rows)
      SELECT target_pw_id FROM migration_audit.jamali_w10_qty_merge
      UNION
      -- W10-only PWs yang di-update warehouse_id 10->25 (4 rows)
      SELECT id FROM migration_audit.jamali_w10_pw_w10only_snapshot
    )
  ) LOOP
    -- Ambil stock akhir di stock_logs ledger
    SELECT stock INTO v_last_log_stock
    FROM stock_logs
    WHERE product_warehouse_id = rec.pw_id
    ORDER BY id DESC
    LIMIT 1;
    -- PW tanpa stock_logs entry (mis. 1188/1189/1190 ayam) -> skip
    IF v_last_log_stock IS NULL THEN
      CONTINUE;
    END IF;
    v_drift := rec.qty - v_last_log_stock;
    -- Drift negligible -> skip
    IF ABS(v_drift) < 0.001 THEN
      CONTINUE;
    END IF;
    -- Insert corrective ADJUSTMENT stock_log
    INSERT INTO stock_logs (
      product_warehouse_id, loggable_type, loggable_id,
      notes, increase, decrease, stock, created_by, created_at
    ) VALUES (
      rec.pw_id,
      'ADJUSTMENT',
      0,
      'Koreksi stock_log drift pasca-merge warehouse Jamali (migration 20260528123243)',
      CASE WHEN v_drift > 0 THEN v_drift ELSE 0 END,
      CASE WHEN v_drift < 0 THEN -v_drift ELSE 0 END,
      rec.qty,
      1,
      NOW()
    ) RETURNING id INTO v_new_log_id;
    -- Track ke audit table untuk DOWN
    INSERT INTO migration_audit.jamali_w10_stocklog_corrections (
      stock_log_id, product_warehouse_id, drift
    ) VALUES (v_new_log_id, rec.pw_id, v_drift);
    v_inserts := v_inserts + 1;
  END LOOP;
  RAISE NOTICE 'Inserted % corrective stock_logs to align ledger with pw.qty', v_inserts;
 END $$;
 COMMIT;
@@ -1,3 +0,0 @@
 ALTER TABLE marketings DROP COLUMN IF EXISTS grand_total;
 ALTER TABLE expenses DROP COLUMN IF EXISTS grand_total;
 ALTER TABLE purchases DROP COLUMN IF EXISTS grand_total;
@@ -1,42 +0,0 @@
 -- Marketing belum punya grand_total. Tambahkan dengan DEFAULT 0.
 ALTER TABLE marketings ADD COLUMN grand_total NUMERIC(15, 3) NOT NULL DEFAULT 0;
 -- Expense grand_total sebelumnya di-drop di migration 20251125055613. Re-add.
 ALTER TABLE expenses ADD COLUMN grand_total NUMERIC(15, 3) NOT NULL DEFAULT 0;
 ALTER TABLE purchases ADD COLUMN grand_total NUMERIC(15, 3) NOT NULL DEFAULT 0;
 -- Backfill nilai grand_total dari children:
 -- marketings.grand_total = SUM marketing_delivery_products.total_price (WHERE delivery_date IS NOT NULL)
 UPDATE marketings m
 SET grand_total = COALESCE(s.t, 0)
 FROM (
    SELECT mp.marketing_id AS marketing_id, SUM(mdp.total_price) AS t
    FROM marketing_delivery_products mdp
    JOIN marketing_products mp ON mp.id = mdp.marketing_product_id
    WHERE mdp.delivery_date IS NOT NULL
    GROUP BY mp.marketing_id
 ) s
 WHERE s.marketing_id = m.id;
 -- expenses.grand_total = SUM(expense_realizations.qty * expense_realizations.price) via expense_nonstocks
 UPDATE expenses e
 SET grand_total = COALESCE(s.t, 0)
 FROM (
    SELECT en.expense_id AS expense_id, SUM(er.qty * er.price) AS t
    FROM expense_realizations er
    JOIN expense_nonstocks en ON en.id = er.expense_nonstock_id
    GROUP BY en.expense_id
 ) s
 WHERE s.expense_id = e.id;
 -- purchases.grand_total sudah ada sejak migration 20251104084555.
 -- Recompute juga untuk safety supaya konsisten dengan SUM purchase_items.total_price.
 UPDATE purchases p
 SET grand_total = COALESCE(s.t, 0)
 FROM (
    SELECT purchase_id, SUM(total_price) AS t
    FROM purchase_items
    GROUP BY purchase_id
 ) s
 WHERE s.purchase_id = p.id;
@@ -1,5 +0,0 @@
 DROP INDEX IF EXISTS idx_payments_party_active;
 DROP INDEX IF EXISTS idx_mdp_delivery_date_partial;
 DROP INDEX IF EXISTS idx_purchase_items_received_date_partial;
 DROP TABLE IF EXISTS payment_allocations;
@@ -1,27 +0,0 @@
 -- Tabel payment_allocations menyimpan hasil FIFO matching antara payment dengan
 -- sub-row anak (purchase_item / marketing_delivery_product / expense_realization).
 -- Setiap allocation row HARUS terhubung ke tepat 1 child via 3 nullable FK
 -- (polymorphic-via-multiple-nullable-FK; lebih aman dari single polymorphic kolom).
 CREATE TABLE IF NOT EXISTS payment_allocations (
    id BIGSERIAL PRIMARY KEY,
    payment_id BIGINT NOT NULL REFERENCES payments(id) ON DELETE CASCADE,
    purchase_item_id BIGINT NULL REFERENCES purchase_items(id) ON DELETE CASCADE,
    marketing_delivery_product_id BIGINT NULL REFERENCES marketing_delivery_products(id) ON DELETE CASCADE,
    expense_realization_id BIGINT NULL REFERENCES expense_realizations(id) ON DELETE CASCADE,
    amount NUMERIC(15, 3) NOT NULL CHECK (amount > 0),
    allocated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
    CONSTRAINT chk_payment_alloc_exactly_one CHECK (
        num_nonnulls(purchase_item_id, marketing_delivery_product_id, expense_realization_id) = 1
    )
 );
 CREATE INDEX IF NOT EXISTS idx_payment_alloc_payment ON payment_allocations (payment_id);
 CREATE INDEX IF NOT EXISTS idx_payment_alloc_purchase_item ON payment_allocations (purchase_item_id) WHERE purchase_item_id IS NOT NULL;
 CREATE INDEX IF NOT EXISTS idx_payment_alloc_mdp ON payment_allocations (marketing_delivery_product_id) WHERE marketing_delivery_product_id IS NOT NULL;
 CREATE INDEX IF NOT EXISTS idx_payment_alloc_realization ON payment_allocations (expense_realization_id) WHERE expense_realization_id IS NOT NULL;
 CREATE INDEX IF NOT EXISTS idx_payment_alloc_allocated_at ON payment_allocations (allocated_at);
 -- Helper partial indexes untuk FIFO loop performance
 CREATE INDEX IF NOT EXISTS idx_purchase_items_received_date_partial ON purchase_items (received_date) WHERE received_date IS NOT NULL;
 CREATE INDEX IF NOT EXISTS idx_mdp_delivery_date_partial ON marketing_delivery_products (delivery_date) WHERE delivery_date IS NOT NULL;
 CREATE INDEX IF NOT EXISTS idx_payments_party_active ON payments (party_type, party_id, payment_date) WHERE deleted_at IS NULL;
@@ -1,4 +0,0 @@
 -- Rollback backfill: hapus semua allocations dan drop function.
 TRUNCATE payment_allocations;
 DROP FUNCTION IF EXISTS fn_fifo_backfill_party(TEXT, BIGINT);
@@ -1,170 +0,0 @@
 -- Backfill payment_allocations untuk data historis via FIFO simulation.
 -- Seluruh migration ini berjalan dalam 1 transaction (golang-migrate default).
 -- Jika ada party yang gagal di tengah loop, seluruh backfill ROLLBACK otomatis.
 -- Fungsi inti: FIFO greedy untuk 1 party (supplier/customer).
 -- Algoritma:
 --   1. Hapus payment_allocations existing untuk party tsb (idempotent).
 --   2. Kumpulkan eligible children sort by date ASC ke array (kind, id, amount, remaining).
 --   3. Konsumsi creditCarry (SUM payment SALDO_AWAL) ke children tertua — TIDAK insert allocation row.
 --   4. Loop payments (selain SALDO_AWAL) ORDER BY payment_date ASC: greedy alokasi ke child tertua dengan remaining > 0.
 --   5. Sisa nominal payment tidak insert row (otomatis credit balance untuk dokumen baru).
 CREATE OR REPLACE FUNCTION fn_fifo_backfill_party(
    p_party_type TEXT,
    p_party_id BIGINT
 ) RETURNS VOID AS $func$
 DECLARE
    v_party_type TEXT := UPPER(p_party_type);
    v_payment RECORD;
    v_child RECORD;
    v_remaining NUMERIC(15, 3);
    v_used NUMERIC(15, 3);
    v_eps CONSTANT NUMERIC(15, 3) := 0.001;
 BEGIN
    -- Acquire advisory lock untuk anti-race (1-arg form: hashtext returns int4, cast ke bigint)
    PERFORM pg_advisory_xact_lock(hashtext('payment_alloc:' || v_party_type || ':' || p_party_id::text)::bigint);
    -- Hapus allocations existing untuk party tsb (idempotent ulang-jalan)
    DELETE FROM payment_allocations pa
    USING payments p
    WHERE pa.payment_id = p.id
      AND p.party_type = v_party_type
      AND p.party_id = p_party_id;
    -- TEMP table untuk antrian children (sort sudah ada di INSERT...SELECT ORDER BY)
    CREATE TEMP TABLE IF NOT EXISTS _children_queue (
        seq BIGSERIAL PRIMARY KEY,
        kind TEXT NOT NULL,           -- 'PURCHASE_ITEM' / 'MDP' / 'EXPENSE_REALIZATION'
        child_id BIGINT NOT NULL,
        amount NUMERIC(15, 3) NOT NULL,
        remaining NUMERIC(15, 3) NOT NULL
    ) ON COMMIT DROP;
    TRUNCATE _children_queue;
    IF v_party_type = 'SUPPLIER' THEN
        -- purchase_items eligible: received_date IS NOT NULL, approval latest step >= 4 (Receiving), action != REJECTED
        INSERT INTO _children_queue (kind, child_id, amount, remaining)
        SELECT 'PURCHASE_ITEM', pi.id, pi.total_price, pi.total_price
        FROM purchase_items pi
        JOIN purchases p ON p.id = pi.purchase_id
        JOIN LATERAL (
            SELECT a.step_number, a.action
            FROM approvals a
            WHERE a.approvable_type = 'PURCHASES' AND a.approvable_id = p.id
            ORDER BY a.action_at DESC, a.id DESC
            LIMIT 1
        ) la ON true
        WHERE p.supplier_id = p_party_id
          AND p.deleted_at IS NULL
          AND pi.received_date IS NOT NULL
          AND la.step_number >= 4
          AND (la.action IS NULL OR la.action <> 'REJECTED')
          AND pi.total_price > 0
        ORDER BY pi.received_date ASC, pi.id ASC;
        -- expense_realizations eligible: parent expense approval latest step >= 5 (Realisasi), action != REJECTED.
        -- Sort pakai e.transaction_date supaya FIFO konsisten dengan tanggal yang di-display di report.
        INSERT INTO _children_queue (kind, child_id, amount, remaining)
        SELECT 'EXPENSE_REALIZATION', er.id, (er.qty * er.price), (er.qty * er.price)
        FROM expense_realizations er
        JOIN expense_nonstocks en ON en.id = er.expense_nonstock_id
        JOIN expenses e ON e.id = en.expense_id
        JOIN LATERAL (
            SELECT a.step_number, a.action
            FROM approvals a
            WHERE a.approvable_type = 'EXPENSES' AND a.approvable_id = e.id
            ORDER BY a.action_at DESC, a.id DESC
            LIMIT 1
        ) la ON true
        WHERE e.supplier_id = p_party_id
          AND e.deleted_at IS NULL
          AND la.step_number >= 5
          AND (la.action IS NULL OR la.action <> 'REJECTED')
          AND (er.qty * er.price) > 0
        ORDER BY e.transaction_date ASC, e.id ASC, er.id ASC;
    ELSIF v_party_type = 'CUSTOMER' THEN
        -- marketing_delivery_products eligible: delivery_date IS NOT NULL (match current report behavior, tidak filter approval)
        INSERT INTO _children_queue (kind, child_id, amount, remaining)
        SELECT 'MDP', mdp.id, mdp.total_price, mdp.total_price
        FROM marketing_delivery_products mdp
        JOIN marketing_products mp ON mp.id = mdp.marketing_product_id
        JOIN marketings m ON m.id = mp.marketing_id
        WHERE m.customer_id = p_party_id
          AND m.deleted_at IS NULL
          AND mdp.delivery_date IS NOT NULL
          AND mdp.total_price > 0
        ORDER BY mdp.delivery_date ASC, mdp.id ASC;
    ELSE
        RETURN;
    END IF;
    -- Skip jika tidak ada children eligible
    IF NOT EXISTS (SELECT 1 FROM _children_queue) THEN
        RETURN;
    END IF;
    -- Loop SEMUA payments termasuk SALDO_AWAL ORDER BY payment_date ASC, id ASC.
    -- SALDO_AWAL diperlakukan sebagai payment tertua sehingga opening credit otomatis
    -- consume oldest debts via FIFO. Tanpa allocation row, debt yang ter-cover SaldoAwal
    -- akan tampak "Belum Lunas" di report.
    FOR v_payment IN
        SELECT id, nominal
        FROM payments
        WHERE party_type = v_party_type
          AND party_id = p_party_id
          AND deleted_at IS NULL
          AND nominal > v_eps
        ORDER BY payment_date ASC, id ASC
    LOOP
        v_remaining := v_payment.nominal;
        -- Greedy alokasi ke children tertua dengan remaining > 0
        FOR v_child IN
            SELECT seq, kind, child_id, remaining
            FROM _children_queue
            WHERE remaining > v_eps
            ORDER BY seq ASC
        LOOP
            EXIT WHEN v_remaining <= v_eps;
            -- v_child.remaining is snapshot at cursor open; re-fetch latest to avoid drift in same payment iter
            SELECT remaining INTO v_used FROM _children_queue WHERE seq = v_child.seq;
            IF v_used <= v_eps THEN
                CONTINUE;
            END IF;
            v_used := LEAST(v_remaining, v_used);
            UPDATE _children_queue SET remaining = remaining - v_used WHERE seq = v_child.seq;
            v_remaining := v_remaining - v_used;
            IF v_child.kind = 'PURCHASE_ITEM' THEN
                INSERT INTO payment_allocations (payment_id, purchase_item_id, amount, allocated_at)
                VALUES (v_payment.id, v_child.child_id, v_used, NOW());
            ELSIF v_child.kind = 'MDP' THEN
                INSERT INTO payment_allocations (payment_id, marketing_delivery_product_id, amount, allocated_at)
                VALUES (v_payment.id, v_child.child_id, v_used, NOW());
            ELSIF v_child.kind = 'EXPENSE_REALIZATION' THEN
                INSERT INTO payment_allocations (payment_id, expense_realization_id, amount, allocated_at)
                VALUES (v_payment.id, v_child.child_id, v_used, NOW());
            END IF;
        END LOOP;
    END LOOP;
 END;
 $func$ LANGUAGE plpgsql;
 -- Invoke per-party. Gagal di satu party → entire transaction ROLLBACK.
 DO $do$
 DECLARE
    r RECORD;
 BEGIN
    FOR r IN
        SELECT DISTINCT party_type, party_id
        FROM payments
        WHERE deleted_at IS NULL
          AND party_id IS NOT NULL
    LOOP
        PERFORM fn_fifo_backfill_party(r.party_type, r.party_id);
    END LOOP;
 END;
 $do$;
@@ -18,7 +18,6 @@ type Expense struct {
 	TransactionDate         time.Time      `gorm:"type:date;not null"`
 	Notes                   string         `gorm:"type:text;column:notes"`
 	IsPaid                  bool           `gorm:"column:is_paid;not null;default:false"`
 	GrandTotal              float64        `gorm:"column:grand_total;type:numeric(15,3);not null;default:0"`
 	CreatedBy               uint64         `gorm:""`
 	CreatedAt               time.Time      `gorm:"autoCreateTime"`
 	UpdatedAt               time.Time      `gorm:"autoUpdateTime"`
@@ -15,7 +15,6 @@ type Marketing struct {
 	SalesPersonId uint           `gorm:"not null"`
 	Notes         string         `gorm:"type:text"`
 	MarketingType string         `gorm:"type:varchar(50)"`
 	GrandTotal    float64        `gorm:"column:grand_total;type:numeric(15,3);not null;default:0"`
 	CreatedBy     uint           `gorm:"not null"`
 	CreatedAt     time.Time      `gorm:"autoCreateTime"`
 	UpdatedAt     time.Time      `gorm:"autoUpdateTime"`
@@ -1,23 +0,0 @@
 package entities
 import (
 	"time"
 )
 // PaymentAllocation merepresentasikan hasil FIFO matching dari 1 payment ke
 // tepat 1 sub-row anak (purchase_item / marketing_delivery_product /
 // expense_realization). DB constraint memastikan hanya satu FK yang non-null.
 type PaymentAllocation struct {
 	Id                         uint64    `gorm:"primaryKey;autoIncrement"`
 	PaymentId                  uint      `gorm:"not null;index"`
 	PurchaseItemId             *uint     `gorm:"column:purchase_item_id"`
 	MarketingDeliveryProductId *uint     `gorm:"column:marketing_delivery_product_id"`
 	ExpenseRealizationId       *uint64   `gorm:"column:expense_realization_id"`
 	Amount                     float64   `gorm:"type:numeric(15,3);not null"`
 	AllocatedAt                time.Time `gorm:"type:timestamptz;not null;default:NOW()"`
 	Payment                  *Payment                  `gorm:"foreignKey:PaymentId;references:Id"`
 	PurchaseItem             *PurchaseItem             `gorm:"foreignKey:PurchaseItemId;references:Id"`
 	MarketingDeliveryProduct *MarketingDeliveryProduct `gorm:"foreignKey:MarketingDeliveryProductId;references:Id"`
 	ExpenseRealization       *ExpenseRealization       `gorm:"foreignKey:ExpenseRealizationId;references:Id"`
 }
@@ -12,7 +12,6 @@ type Purchase struct {
 	SupplierId uint `gorm:"not null"`
 	CreditTerm int  `gorm:"column:credit_term;not null;default:0"`
 	DueDate    *time.Time
 	GrandTotal float64 `gorm:"column:grand_total;type:numeric(15,3);not null;default:0"`
 	Notes      *string
 	CreatedAt  time.Time  `gorm:"autoCreateTime"`
 	UpdatedAt  time.Time  `gorm:"autoUpdateTime"`
@@ -45,8 +45,7 @@ func (ExpenseModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validate *
 		panic(fmt.Sprintf("failed to register expense approval workflow: %v", err))
 	}
-	fifoPaymentSvc := commonSvc.NewFifoPaymentService(db, utils.Log)
+	expenseService := sExpense.NewExpenseService(expenseRepo, supplierRepo, nonstockRepo, approvalSvc, realizationRepo, projectFlockKandangRepo, documentSvc, validate)
 	expenseService := sExpense.NewExpenseService(expenseRepo, supplierRepo, nonstockRepo, approvalSvc, realizationRepo, projectFlockKandangRepo, documentSvc, fifoPaymentSvc, validate)
 	userService := sUser.NewUserService(userRepo, validate)
 	ExpenseRoutes(router, userService, expenseService)
@@ -54,10 +54,9 @@ type expenseService struct {
 	RealizationRepository   repository.ExpenseRealizationRepository
 	ProjectFlockKandangRepo projectFlockKandangRepo.ProjectFlockKandangRepository
 	DocumentSvc             commonSvc.DocumentService
 	FifoPaymentSvc          commonSvc.FifoPaymentService
 }
-func NewExpenseService(repo repository.ExpenseRepository, supplierRepo supplierRepo.SupplierRepository, nonstockRepo nonstockRepo.NonstockRepository, approvalSvc commonSvc.ApprovalService, realizationRepo repository.ExpenseRealizationRepository, projectFlockKandangRepo projectFlockKandangRepo.ProjectFlockKandangRepository, documentSvc commonSvc.DocumentService, fifoPaymentSvc commonSvc.FifoPaymentService, validate *validator.Validate) ExpenseService {
+func NewExpenseService(repo repository.ExpenseRepository, supplierRepo supplierRepo.SupplierRepository, nonstockRepo nonstockRepo.NonstockRepository, approvalSvc commonSvc.ApprovalService, realizationRepo repository.ExpenseRealizationRepository, projectFlockKandangRepo projectFlockKandangRepo.ProjectFlockKandangRepository, documentSvc commonSvc.DocumentService, validate *validator.Validate) ExpenseService {
 	return &expenseService{
 		Log:                     utils.Log,
 		Validate:                validate,
@@ -68,23 +67,6 @@ func NewExpenseService(repo repository.ExpenseRepository, supplierRepo supplierR
 		RealizationRepository:   realizationRepo,
 		ProjectFlockKandangRepo: projectFlockKandangRepo,
 		DocumentSvc:             documentSvc,
 		FifoPaymentSvc:          fifoPaymentSvc,
 	}
 }
 // reallocateAfterRealization called after expense realization changes that may
 // affect supplier debt: recompute grand_total + reallocate FIFO.
 func (s *expenseService) reallocateAfterRealization(ctx context.Context, expenseID uint, supplierID uint64) {
 	if s.FifoPaymentSvc == nil {
 		return
 	}
 	if err := s.FifoPaymentSvc.RecomputeGrandTotal(ctx, nil, commonSvc.ParentKindExpense, expenseID); err != nil {
 		s.Log.Warnf("Failed to recompute grand_total for expense %d: %+v", expenseID, err)
 	}
 	if supplierID > 0 {
 		if err := s.FifoPaymentSvc.ReallocateForParty(ctx, nil, string(utils.PaymentPartySupplier), uint(supplierID)); err != nil {
 			s.Log.Warnf("Failed to reallocate payments for supplier %d: %+v", supplierID, err)
 		}
 	}
 }
@@ -1096,9 +1078,6 @@ func (s *expenseService) CreateRealization(c *fiber.Ctx, expenseID uint, req *va
 	}
 	invalidateFromDate := commonSvc.MinNonZeroDateOnlyUTC(expense.TransactionDate, realizationDate, expense.RealizationDate)
 	s.invalidateDepreciationSnapshotsByExpense(c.Context(), nil, expenseID, invalidateFromDate, nil)
 	s.reallocateAfterRealization(c.Context(), expenseID, expense.SupplierId)
 	return responseDTO, nil
 }
@@ -1543,9 +1522,6 @@ func (s *expenseService) UpdateRealization(c *fiber.Ctx, expenseID uint, req *va
 		return nil, err
 	}
 	s.invalidateDepreciationSnapshotsByExpense(c.Context(), nil, expenseID, invalidateFromDate, nil)
 	s.reallocateAfterRealization(c.Context(), expenseID, expense.SupplierId)
 	return responseDTO, nil
 }
@@ -29,9 +29,7 @@ func (PaymentModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validate *
 		panic(fmt.Sprintf("failed to register payment approval workflow: %v", err))
 	}
-	fifoPaymentService := commonSvc.NewFifoPaymentService(db, nil)
+	paymentService := sPayment.NewPaymentService(paymentRepo, approvalService, validate)
 	paymentService := sPayment.NewPaymentService(paymentRepo, approvalService, fifoPaymentService, validate)
 	userService := sUser.NewUserService(userRepo, validate)
 	PaymentRoutes(router, userService, paymentService)
@@ -32,14 +32,12 @@ type paymentService struct {
 	Validate         *validator.Validate
 	Repository       repository.PaymentRepository
 	ApprovalSvc      commonSvc.ApprovalService
 	FifoPaymentSvc   commonSvc.FifoPaymentService
 	approvalWorkflow approvalutils.ApprovalWorkflowKey
 }
 func NewPaymentService(
 	repo repository.PaymentRepository,
 	approvalSvc commonSvc.ApprovalService,
 	fifoPaymentSvc commonSvc.FifoPaymentService,
 	validate *validator.Validate,
 ) PaymentService {
 	return &paymentService{
@@ -47,7 +45,6 @@ func NewPaymentService(
 		Validate:         validate,
 		Repository:       repo,
 		ApprovalSvc:      approvalSvc,
 		FifoPaymentSvc:   fifoPaymentSvc,
 		approvalWorkflow: utils.ApprovalWorkflowPayment,
 	}
 }
@@ -162,12 +159,6 @@ func (s *paymentService) CreateOne(c *fiber.Ctx, req *validation.Create) (*entit
 			}
 		}
 		if s.FifoPaymentSvc != nil {
 			if err := s.FifoPaymentSvc.ReallocateForParty(c.Context(), dbTransaction, createBody.PartyType, createBody.PartyId); err != nil {
 				return err
 			}
 		}
 		return nil
 	})
 	if err != nil {
@@ -260,46 +251,7 @@ func (s paymentService) UpdateOne(c *fiber.Ctx, req *validation.Update, id uint)
 		return s.GetOne(c, id)
 	}
-	// Snapshot party lama untuk reallocate kalau party baru berbeda.
+	if err := s.Repository.PatchOne(c.Context(), id, updateBody, nil); err != nil {
 	existing, err := s.Repository.GetByID(c.Context(), id, nil)
 	if errors.Is(err, gorm.ErrRecordNotFound) {
 		return nil, fiber.NewError(fiber.StatusNotFound, "Payment not found")
 	}
 	if err != nil {
 		s.Log.Errorf("Failed get payment for update: %+v", err)
 		return nil, err
 	}
 	oldPartyType := existing.PartyType
 	oldPartyID := existing.PartyId
 	newPartyType := oldPartyType
 	newPartyID := oldPartyID
 	if v, ok := updateBody["party_type"].(string); ok {
 		newPartyType = v
 	}
 	if v, ok := updateBody["party_id"].(uint); ok {
 		newPartyID = v
 	}
 	err = s.Repository.DB().WithContext(c.Context()).Transaction(func(tx *gorm.DB) error {
 		paymentRepoTx := repository.NewPaymentRepository(tx)
 		if err := paymentRepoTx.PatchOne(c.Context(), id, updateBody, nil); err != nil {
 			return err
 		}
 		if s.FifoPaymentSvc != nil {
 			if err := s.FifoPaymentSvc.ReallocateForParty(c.Context(), tx, newPartyType, newPartyID); err != nil {
 				return err
 			}
 			if oldPartyType != newPartyType || oldPartyID != newPartyID {
 				if err := s.FifoPaymentSvc.ReallocateForParty(c.Context(), tx, oldPartyType, oldPartyID); err != nil {
 					return err
 				}
 			}
 		}
 		return nil
 	})
 	if err != nil {
 		if errors.Is(err, gorm.ErrRecordNotFound) {
 			return nil, fiber.NewError(fiber.StatusNotFound, "Payment not found")
 		}
@@ -35,8 +35,7 @@ func (TransactionModule) RegisterRoutes(router fiber.Router, db *gorm.DB, valida
 		panic(fmt.Sprintf("failed to register injection approval workflow: %v", err))
 	}
-	fifoPaymentService := commonSvc.NewFifoPaymentService(db, utils.Log)
+	transactionService := sTransaction.NewTransactionService(transactionRepo, approvalService, validate)
 	transactionService := sTransaction.NewTransactionService(transactionRepo, approvalService, fifoPaymentService, validate)
 	userService := sUser.NewUserService(userRepo, validate)
 	TransactionRoutes(router, userService, transactionService)
@@ -30,22 +30,19 @@ type transactionService struct {
 	Validate          *validator.Validate
 	Repository        repository.TransactionRepository
 	ApprovalSvc       commonSvc.ApprovalService
 	FifoPaymentSvc    commonSvc.FifoPaymentService
 	approvalWorkflows map[string]approvalutils.ApprovalWorkflowKey
 }
 func NewTransactionService(
 	repo repository.TransactionRepository,
 	approvalSvc commonSvc.ApprovalService,
 	fifoPaymentSvc commonSvc.FifoPaymentService,
 	validate *validator.Validate,
 ) TransactionService {
 	return &transactionService{
-		Log:            utils.Log,
+		Log:         utils.Log,
-		Validate:       validate,
+		Validate:    validate,
-		Repository:     repo,
+		Repository:  repo,
-		ApprovalSvc:    approvalSvc,
+		ApprovalSvc: approvalSvc,
 		FifoPaymentSvc: fifoPaymentSvc,
 		approvalWorkflows: map[string]approvalutils.ApprovalWorkflowKey{
 			string(utils.TransactionTypeSaldoAwal): utils.ApprovalWorkflowInitial,
 			string(utils.TransactionTypeInjection): utils.ApprovalWorkflowInjection,
@@ -185,19 +182,6 @@ func (s transactionService) GetOne(c *fiber.Ctx, id uint) (*entity.Payment, erro
 }
 func (s transactionService) DeleteOne(c *fiber.Ctx, id uint) error {
 	// Snapshot party SEBELUM delete supaya bisa re-FIFO setelah trigger DB
 	// (`trg_soft_delete_fk_payments`) CASCADE hard-DELETE allocations.
 	existing, err := s.Repository.GetByID(c.Context(), id, nil)
 	if err != nil {
 		if errors.Is(err, gorm.ErrRecordNotFound) {
 			return fiber.NewError(fiber.StatusNotFound, "Transaction not found")
 		}
 		s.Log.Errorf("Failed to load transaction before delete: %+v", err)
 		return err
 	}
 	partyType := existing.PartyType
 	partyID := existing.PartyId
 	if err := s.Repository.DeleteOne(c.Context(), id); err != nil {
 		if errors.Is(err, gorm.ErrRecordNotFound) {
 			return fiber.NewError(fiber.StatusNotFound, "Transaction not found")
@@ -205,14 +189,6 @@ func (s transactionService) DeleteOne(c *fiber.Ctx, id uint) error {
 		s.Log.Errorf("Failed to delete transaction: %+v", err)
 		return err
 	}
 	// Re-FIFO setelah delete agar payment lain yang masih punya unallocated nominal
 	// otomatis reflow ke MDP/purchase_item/expense_realization yang kekurangan paid.
 	if s.FifoPaymentSvc != nil && partyID > 0 {
 		if err := s.FifoPaymentSvc.ReallocateForParty(c.Context(), nil, partyType, partyID); err != nil {
 			s.Log.Warnf("Failed to reallocate payments after delete (party=%s id=%d): %+v", partyType, partyID, err)
 		}
 	}
 	return nil
 }
@@ -65,7 +65,6 @@ func (TransferModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validate
 		expenseRealizationRepo,
 		projectFlockKandangRepo,
 		documentSvc,
 		commonSvc.NewFifoPaymentService(db, utils.Log),
 		validate,
 	)
@@ -35,7 +35,6 @@ func (MarketingModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validate
 	stockLogRepo := rShared.NewStockLogRepository(db)
 	fifoStockV2Service := commonSvc.NewFifoStockV2Service(db, utils.Log)
 	fifoPaymentService := commonSvc.NewFifoPaymentService(db, utils.Log)
 	approvalRepo := commonRepo.NewApprovalRepository(db)
 	approvalSvc := commonSvc.NewApprovalService(approvalRepo)
@@ -48,7 +47,7 @@ func (MarketingModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validate
 	projectFlockKandangRepo := rProjectFlockKandang.NewProjectFlockKandangRepository(db)
 	salesOrdersService := service.NewSalesOrdersService(marketingRepo, customerRepo, productWarehouseRepo, userRepo, approvalSvc, fifoStockV2Service, warehouseRepo, projectFlockKandangRepo, validate)
-	deliveryOrdersService := service.NewDeliveryOrdersService(marketingRepo, marketingProductRepo, marketingDeliveryProductRepo, stockLogRepo, productWarehouseRepo, projectFlockPopulationRepo, approvalSvc, fifoStockV2Service, fifoPaymentService, validate)
+	deliveryOrdersService := service.NewDeliveryOrdersService(marketingRepo, marketingProductRepo, marketingDeliveryProductRepo, stockLogRepo, productWarehouseRepo, projectFlockPopulationRepo, approvalSvc, fifoStockV2Service, validate)
 	userService := sUser.NewUserService(userRepo, validate)
 	RegisterRoutes(router, userService, salesOrdersService, deliveryOrdersService)
@@ -48,7 +48,6 @@ type deliveryOrdersService struct {
 	ProjectFlockPopulationRepo   rProjectFlock.ProjectFlockPopulationRepository
 	ApprovalSvc                  commonSvc.ApprovalService
 	FifoStockV2Svc               commonSvc.FifoStockV2Service
 	FifoPaymentSvc               commonSvc.FifoPaymentService
 }
 func NewDeliveryOrdersService(
@@ -60,7 +59,6 @@ func NewDeliveryOrdersService(
 	projectFlockPopulationRepo rProjectFlock.ProjectFlockPopulationRepository,
 	approvalSvc commonSvc.ApprovalService,
 	fifoStockV2Svc commonSvc.FifoStockV2Service,
 	fifoPaymentSvc commonSvc.FifoPaymentService,
 	validate *validator.Validate,
 ) DeliveryOrdersService {
 	return &deliveryOrdersService{
@@ -73,22 +71,6 @@ func NewDeliveryOrdersService(
 		ProjectFlockPopulationRepo:   projectFlockPopulationRepo,
 		ApprovalSvc:                  approvalSvc,
 		FifoStockV2Svc:               fifoStockV2Svc,
 		FifoPaymentSvc:               fifoPaymentSvc,
 	}
 }
 // reallocateAfterDelivery refresh marketing.grand_total + reallocate FIFO untuk customer.
 func (s *deliveryOrdersService) reallocateAfterDelivery(ctx context.Context, marketingID uint, customerID uint) {
 	if s.FifoPaymentSvc == nil {
 		return
 	}
 	if err := s.FifoPaymentSvc.RecomputeGrandTotal(ctx, nil, commonSvc.ParentKindMarketing, marketingID); err != nil {
 		utils.Log.Warnf("Failed to recompute grand_total for marketing %d: %+v", marketingID, err)
 	}
 	if customerID > 0 {
 		if err := s.FifoPaymentSvc.ReallocateForParty(ctx, nil, string(utils.PaymentPartyCustomer), customerID); err != nil {
 			utils.Log.Warnf("Failed to reallocate payments for customer %d: %+v", customerID, err)
 		}
 	}
 }
@@ -436,7 +418,6 @@ func (s *deliveryOrdersService) CreateOne(c *fiber.Ctx, req *validation.Delivery
 		return nil, fiber.NewError(fiber.StatusBadRequest, "Delivery order already exists for this marketing")
 	}
 	var capturedCustomerID uint
 	err = s.MarketingRepo.DB().WithContext(c.Context()).Transaction(func(dbTransaction *gorm.DB) error {
 		marketingProductRepositoryTx := marketingRepo.NewMarketingProductRepository(dbTransaction)
 		marketingDeliveryProductRepositoryTx := marketingRepo.NewMarketingDeliveryProductRepository(dbTransaction)
@@ -447,7 +428,6 @@ func (s *deliveryOrdersService) CreateOne(c *fiber.Ctx, req *validation.Delivery
 		if err != nil {
 			return fiber.NewError(fiber.StatusInternalServerError, "Failed to fetch marketing")
 		}
 		capturedCustomerID = marketing.CustomerId
 		allMarketingProducts, err := marketingProductRepositoryTx.GetByMarketingID(c.Context(), req.MarketingId)
 		if err != nil {
@@ -539,8 +519,6 @@ func (s *deliveryOrdersService) CreateOne(c *fiber.Ctx, req *validation.Delivery
 		return nil, fiber.NewError(fiber.StatusInternalServerError, "Failed to create delivery order")
 	}
 	s.reallocateAfterDelivery(c.Context(), req.MarketingId, capturedCustomerID)
 	return s.getMarketingWithDeliveries(c, req.MarketingId)
 }
@@ -569,7 +547,6 @@ func (s deliveryOrdersService) UpdateOne(c *fiber.Ctx, req *validation.DeliveryO
 		return nil, fiber.NewError(fiber.StatusInternalServerError, "Failed to check approval status")
 	}
 	var capturedCustomerID uint
 	err = s.MarketingRepo.DB().WithContext(c.Context()).Transaction(func(dbTransaction *gorm.DB) error {
 		marketingProductRepositoryTx := marketingRepo.NewMarketingProductRepository(dbTransaction)
 		marketingDeliveryProductRepositoryTx := marketingRepo.NewMarketingDeliveryProductRepository(dbTransaction)
@@ -580,7 +557,6 @@ func (s deliveryOrdersService) UpdateOne(c *fiber.Ctx, req *validation.DeliveryO
 		if err != nil {
 			return fiber.NewError(fiber.StatusInternalServerError, "Failed to fetch marketing")
 		}
 		capturedCustomerID = marketing.CustomerId
 		allMarketingProducts, err := marketingProductRepositoryTx.GetByMarketingID(c.Context(), id)
 		if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
@@ -686,8 +662,6 @@ func (s deliveryOrdersService) UpdateOne(c *fiber.Ctx, req *validation.DeliveryO
 		return nil, fiber.NewError(fiber.StatusInternalServerError, "Failed to update delivery order")
 	}
 	s.reallocateAfterDelivery(c.Context(), id, capturedCustomerID)
 	return s.getMarketingWithDeliveries(c, id)
 }
@@ -312,10 +312,10 @@ func (u *ProjectflockController) LookupProjectFlockKandang(c *fiber.Ctx) error {
 		mapped := warehouseDTO.ToWarehouseRelationDTO(*warehouse)
 		dtoResult.Warehouse = &mapped
 	}
-	if _, isLaying, serr := u.ProjectflockService.GetProjectFlockKandangTransferStateAtDate(c, result.Id, recordDate); serr != nil {
+	if isTransition, isLaying, serr := u.ProjectflockService.GetProjectFlockKandangTransferStateAtDate(c, result.Id, recordDate); serr != nil {
 		return serr
 	} else {
-		dtoResult.IsTransition = false
+		dtoResult.IsTransition = isTransition
 		dtoResult.IsLaying = isLaying
 	}
 	applyCutOverLayingLookupOverride(&dtoResult)
@@ -346,7 +346,7 @@ func (u *ProjectflockController) LookupProjectFlockKandang(c *fiber.Ctx) error {
 }
 func applyCutOverLayingLookupOverride(result *dto.ProjectFlockKandangDTO) {
-	if result == nil || result.ProjectFlock == nil || result.IsLaying || result.ChickInDate == nil {
+	if result == nil || result.ProjectFlock == nil || result.IsLaying || result.IsTransition || result.ChickInDate == nil {
 		return
 	}
@@ -588,17 +588,29 @@ func (s projectflockService) GetProjectFlockKandangTransferStateAtDate(ctx *fibe
 	switch category {
 	case strings.ToUpper(string(utils.ProjectFlockCategoryGrowing)):
 		transfer, err = s.TransferLayingRepo.GetLatestApprovedBySourceKandang(ctx.Context(), projectFlockKandangID)
 		if err != nil {
 			if errors.Is(err, gorm.ErrRecordNotFound) {
 				return false, false, nil
 			}
 			s.Log.Errorf("Failed to resolve transfer state for project flock kandang %d: %+v", projectFlockKandangID, err)
 			return false, false, fiber.NewError(fiber.StatusInternalServerError, "Failed to resolve transfer state")
 		}
 	case strings.ToUpper(string(utils.ProjectFlockCategoryLaying)):
-		transfer, err = s.TransferLayingRepo.GetLatestApprovedByTargetKandang(ctx.Context(), projectFlockKandangID)
+		// Multi-source: target kandang bisa menerima dari multiple transfer terpisah. Pakai
-	default:
+		// EARLIEST transfer (transfer_date ASC) sebagai anchor — kandang masuk transition/laying
-		return false, false, nil
+		// mengikuti batch pertama yang sampai.
-	}
+		allTransfers, allErr := s.TransferLayingRepo.GetAllApprovedByTargetKandang(ctx.Context(), projectFlockKandangID)
-	if err != nil {
+		if allErr != nil {
-		if errors.Is(err, gorm.ErrRecordNotFound) {
+			s.Log.Errorf("Failed to resolve transfers for project flock kandang %d: %+v", projectFlockKandangID, allErr)
 			return false, false, fiber.NewError(fiber.StatusInternalServerError, "Failed to resolve transfer state")
 		}
 		if len(allTransfers) == 0 {
 			return false, false, nil
 		}
-		s.Log.Errorf("Failed to resolve transfer state for project flock kandang %d: %+v", projectFlockKandangID, err)
+		// Repository ORDER BY transfer_date ASC, id ASC → [0] = earliest
-		return false, false, fiber.NewError(fiber.StatusInternalServerError, "Failed to resolve transfer state")
+		transfer = &allTransfers[0]
 	default:
 		return false, false, nil
 	}
 	if transfer == nil {
 		return false, false, nil
@@ -198,10 +198,22 @@ func (s recordingService) GetAll(c *fiber.Ctx, params *validation.Query) ([]enti
 	if err != nil {
 		return nil, 0, err
 	}
-	targetTransferByPFK, err := s.TransferLayingRepo.GetLatestApprovedByTargetKandangs(c.Context(), layingPFKIDs)
+	// Multi-source support: 1 target kandang bisa menerima dari multiple transfer terpisah.
 	// Untuk state evaluation (IsTransition/IsLaying), kita pakai EARLIEST transfer sebagai anchor
 	// (sesuai dengan rule "kandang masuk fase laying mengikuti batch pertama yang sampai").
 	allTransfersByTarget, err := s.TransferLayingRepo.GetAllApprovedByTargetKandangs(c.Context(), layingPFKIDs)
 	if err != nil {
 		return nil, 0, err
 	}
 	targetTransferByPFK := make(map[uint]*entity.LayingTransfer, len(allTransfersByTarget))
 	for pfkID, list := range allTransfersByTarget {
 		if len(list) == 0 {
 			continue
 		}
 		// list sudah ORDER BY transfer_date ASC, id ASC → element [0] adalah earliest
 		earliest := list[0]
 		targetTransferByPFK[pfkID] = &earliest
 	}
 	hasTargetRecordingCache := make(map[uint]bool)
 	cutOverChickinAvailability := make(map[uint]bool)
@@ -1292,17 +1304,29 @@ func (s *recordingService) evaluatePopulationMutationState(ctx context.Context,
 	switch category {
 	case strings.ToUpper(string(utils.ProjectFlockCategoryGrowing)):
 		transfer, err = s.TransferLayingRepo.GetLatestApprovedBySourceKandang(ctx, recording.ProjectFlockKandangId)
 		if err != nil {
 			if errors.Is(err, gorm.ErrRecordNotFound) {
 				return true, false, false, false, nil, time.Time{}, nil
 			}
 			s.Log.Errorf("Failed to resolve approved transfer for recording %d: %+v", recording.Id, err)
 			return true, false, false, false, nil, time.Time{}, fiber.NewError(fiber.StatusInternalServerError, "Gagal memvalidasi perubahan populasi recording")
 		}
 	case strings.ToUpper(string(utils.ProjectFlockCategoryLaying)):
-		transfer, err = s.TransferLayingRepo.GetLatestApprovedByTargetKandang(ctx, recording.ProjectFlockKandangId)
+		// Multi-source: target kandang bisa menerima dari multiple transfer terpisah.
-	default:
+		// Pakai EARLIEST transfer (transfer_date ASC) sebagai anchor untuk state evaluation —
-		return true, false, false, false, nil, time.Time{}, nil
+		// kandang dianggap masuk transition/laying berdasarkan batch pertama yang masuk.
-	}
+		allTransfers, allErr := s.TransferLayingRepo.GetAllApprovedByTargetKandang(ctx, recording.ProjectFlockKandangId)
-	if err != nil {
+		if allErr != nil {
-		if errors.Is(err, gorm.ErrRecordNotFound) {
+			s.Log.Errorf("Failed to resolve approved transfers for recording %d: %+v", recording.Id, allErr)
 			return true, false, false, false, nil, time.Time{}, fiber.NewError(fiber.StatusInternalServerError, "Gagal memvalidasi perubahan populasi recording")
 		}
 		if len(allTransfers) == 0 {
 			return true, false, false, false, nil, time.Time{}, nil
 		}
-		s.Log.Errorf("Failed to resolve approved transfer for recording %d: %+v", recording.Id, err)
+		// Repository sudah ORDER BY transfer_date ASC, id ASC → element [0] adalah earliest.
-		return true, false, false, false, nil, time.Time{}, fiber.NewError(fiber.StatusInternalServerError, "Gagal memvalidasi perubahan populasi recording")
+		transfer = &allTransfers[0]
 	default:
 		return true, false, false, false, nil, time.Time{}, nil
 	}
 	if transfer == nil {
 		return true, false, false, false, nil, time.Time{}, nil
@@ -19,6 +19,11 @@ type TransferLayingRepository interface {
 	GetLatestApprovedByTargetKandang(ctx context.Context, targetProjectFlockKandangID uint) (*entity.LayingTransfer, error)
 	GetLatestApprovedBySourceKandangs(ctx context.Context, pfkIDs []uint) (map[uint]*entity.LayingTransfer, error)
 	GetLatestApprovedByTargetKandangs(ctx context.Context, pfkIDs []uint) (map[uint]*entity.LayingTransfer, error)
 	// GetAllApprovedByTargetKandang return semua approved transfer yang menuju ke target kandang itu.
 	// Dipakai untuk multi-source case di mana 1 target kandang bisa menerima dari multiple transfer
 	// terpisah (tiap transfer = 1 source). Order: transfer_date ASC, id ASC (kronologis).
 	GetAllApprovedByTargetKandang(ctx context.Context, targetProjectFlockKandangID uint) ([]entity.LayingTransfer, error)
 	GetAllApprovedByTargetKandangs(ctx context.Context, pfkIDs []uint) (map[uint][]entity.LayingTransfer, error)
 	// Tambah method baru untuk query dengan filter lengkap
 	GetAllWithFilters(ctx context.Context, offset int, limit int, params *GetAllFilterParams) ([]entity.LayingTransfer, int64, error)
@@ -362,3 +367,89 @@ func (r *TransferLayingRepositoryImpl) GetLatestApprovedByTargetKandangs(ctx con
 	}
 	return result, nil
 }
 // GetAllApprovedByTargetKandang return SEMUA approved transfer ke target kandang itu (bukan hanya yang
 // terbaru). Dipakai untuk skenario multi-source di mana 1 target kandang menerima dari multiple transfer
 // terpisah, sehingga depresiasi/HPP/recording state perlu aggregate dari semua transfer.
 func (r *TransferLayingRepositoryImpl) GetAllApprovedByTargetKandang(ctx context.Context, targetProjectFlockKandangID uint) ([]entity.LayingTransfer, error) {
 	if targetProjectFlockKandangID == 0 {
 		return nil, nil
 	}
 	var transfers []entity.LayingTransfer
 	err := r.db.WithContext(ctx).
 		Model(&entity.LayingTransfer{}).
 		Joins("JOIN laying_transfer_targets ltt ON ltt.laying_transfer_id = laying_transfers.id AND ltt.deleted_at IS NULL").
 		Where("ltt.target_project_flock_kandang_id = ?", targetProjectFlockKandangID).
 		Where("laying_transfers.deleted_at IS NULL").
 		Where(`(
 			SELECT a.action
 			FROM approvals a
 			WHERE a.approvable_type = ?
 			  AND a.approvable_id = laying_transfers.id
 			ORDER BY a.id DESC
 			LIMIT 1
 		) = ?`, string(utils.ApprovalWorkflowTransferToLaying), entity.ApprovalActionApproved).
 		Order("laying_transfers.transfer_date ASC, laying_transfers.id ASC").
 		Distinct("laying_transfers.*").
 		Find(&transfers).Error
 	if err != nil {
 		return nil, err
 	}
 	return transfers, nil
 }
 // GetAllApprovedByTargetKandangs batch version: return map dari target_pfk_id ke list of approved transfers.
 // Order per target: transfer_date ASC, id ASC.
 func (r *TransferLayingRepositoryImpl) GetAllApprovedByTargetKandangs(ctx context.Context, pfkIDs []uint) (map[uint][]entity.LayingTransfer, error) {
 	result := make(map[uint][]entity.LayingTransfer)
 	if len(pfkIDs) == 0 {
 		return result, nil
 	}
 	type targetTransferRow struct {
 		TargetPFKID uint `gorm:"column:target_pfk_id"`
 		TransferID  uint `gorm:"column:transfer_id"`
 	}
 	var rows []targetTransferRow
 	err := r.db.WithContext(ctx).Raw(`
 		SELECT ltt.target_project_flock_kandang_id AS target_pfk_id, ltt.laying_transfer_id AS transfer_id
 		FROM laying_transfer_targets ltt
 		JOIN laying_transfers t ON t.id = ltt.laying_transfer_id AND t.deleted_at IS NULL
 		WHERE ltt.target_project_flock_kandang_id IN ?
 		  AND ltt.deleted_at IS NULL
 		  AND (
 		      SELECT a.action FROM approvals a
 		      WHERE a.approvable_type = ? AND a.approvable_id = t.id
 		      ORDER BY a.id DESC LIMIT 1
 		  ) = ?
 		ORDER BY t.transfer_date ASC, t.id ASC
 	`,
 		pfkIDs, string(utils.ApprovalWorkflowTransferToLaying), string(entity.ApprovalActionApproved),
 	).Scan(&rows).Error
 	if err != nil {
 		return nil, err
 	}
 	if len(rows) == 0 {
 		return result, nil
 	}
 	transferIDs := make([]uint, 0, len(rows))
 	targetsByTransfer := make(map[uint][]uint, len(rows))
 	for _, row := range rows {
 		transferIDs = append(transferIDs, row.TransferID)
 		targetsByTransfer[row.TransferID] = append(targetsByTransfer[row.TransferID], row.TargetPFKID)
 	}
 	var transfers []entity.LayingTransfer
 	if err := r.db.WithContext(ctx).Where("id IN ? AND deleted_at IS NULL", transferIDs).Order("transfer_date ASC, id ASC").Find(&transfers).Error; err != nil {
 		return nil, err
 	}
 	for i := range transfers {
 		for _, targetID := range targetsByTransfer[transfers[i].Id] {
 			result[targetID] = append(result[targetID], transfers[i])
 		}
 	}
 	return result, nil
 }
@@ -1617,6 +1617,13 @@ func (s *transferLayingService) validateKandangOwnership(
 	return nil
 }
 // validateTargetSourceLineage memvalidasi bahwa source kandang yang sama TIDAK boleh ditransfer 2x ke
 // target kandang yang sama (anti-duplicate pair). Aturan lama "satu target hanya boleh punya satu
 // source" sudah dihapus — sekarang 1 target boleh menerima dari multiple source kandang via transfer
 // terpisah (multi-source via N-call approach).
 //
 // Yang ditolak: kalau ada approved transfer lain (id != excludeTransferID) yang punya pair
 // (source = sourceProjectFlockKandangID, target ∈ targetKandangIDs) yang sama.
 func (s *transferLayingService) validateTargetSourceLineage(
 	ctx context.Context,
 	sourceProjectFlockKandangID uint,
@@ -1637,7 +1644,7 @@ func (s *transferLayingService) validateTargetSourceLineage(
 		}
 		seen[targetKandangID] = struct{}{}
-		existingTransfer, err := s.Repository.GetLatestApprovedByTargetKandang(ctx, targetKandangID)
+		existingTransfers, err := s.Repository.GetAllApprovedByTargetKandang(ctx, targetKandangID)
 		if err != nil {
 			if errors.Is(err, gorm.ErrRecordNotFound) {
 				continue
@@ -1645,47 +1652,49 @@ func (s *transferLayingService) validateTargetSourceLineage(
 			s.Log.Errorf("Failed to validate transfer lineage for target kandang %d: %+v", targetKandangID, err)
 			return fiber.NewError(fiber.StatusInternalServerError, "Gagal memvalidasi relasi sumber transfer ke laying")
 		}
 		if existingTransfer == nil {
 			continue
 		}
 		if excludeTransferID != 0 && existingTransfer.Id == excludeTransferID {
 			continue
 		}
-		existingSourceID := uint(0)
+		for i := range existingTransfers {
-		if existingTransfer.SourceProjectFlockKandangId != nil && *existingTransfer.SourceProjectFlockKandangId != 0 {
+			existingTransfer := &existingTransfers[i]
-			existingSourceID = *existingTransfer.SourceProjectFlockKandangId
+			if excludeTransferID != 0 && existingTransfer.Id == excludeTransferID {
-		}
+				continue
 		if existingSourceID == 0 && s.LayingTransferSourceRepo != nil {
 			sources, sourceErr := s.LayingTransferSourceRepo.GetByLayingTransferId(ctx, existingTransfer.Id)
 			if sourceErr != nil {
 				s.Log.Errorf("Failed to resolve transfer sources for lineage validation transfer=%d: %+v", existingTransfer.Id, sourceErr)
 				return fiber.NewError(fiber.StatusInternalServerError, "Gagal memvalidasi relasi sumber transfer ke laying")
 			}
-			for _, source := range sources {
+
-				if source.SourceProjectFlockKandangId != 0 {
+			// Source di header (single source of truth per migration 20260307130342).
-					existingSourceID = source.SourceProjectFlockKandangId
+			existingSourceID := uint(0)
-					break
+			if existingTransfer.SourceProjectFlockKandangId != nil && *existingTransfer.SourceProjectFlockKandangId != 0 {
 				existingSourceID = *existingTransfer.SourceProjectFlockKandangId
 			}
 			// Fallback ke laying_transfer_sources untuk transfer yang belum punya source di header
 			// (historis pre-migration 20260307130342).
 			if existingSourceID == 0 && s.LayingTransferSourceRepo != nil {
 				sources, sourceErr := s.LayingTransferSourceRepo.GetByLayingTransferId(ctx, existingTransfer.Id)
 				if sourceErr != nil {
 					s.Log.Errorf("Failed to resolve transfer sources for lineage validation transfer=%d: %+v", existingTransfer.Id, sourceErr)
 					return fiber.NewError(fiber.StatusInternalServerError, "Gagal memvalidasi relasi sumber transfer ke laying")
 				}
 				for _, source := range sources {
 					if source.SourceProjectFlockKandangId == sourceProjectFlockKandangID {
 						existingSourceID = source.SourceProjectFlockKandangId
 						break
 					}
 				}
 			}
 		}
 		if existingSourceID == 0 {
 			continue
 		}
 		if existingSourceID == sourceProjectFlockKandangID {
 			continue
 		}
-		return fiber.NewError(
+			if existingSourceID != sourceProjectFlockKandangID {
-			fiber.StatusBadRequest,
+				continue
-			fmt.Sprintf(
+			}
-				"Kandang tujuan %d sudah memiliki lineage sumber kandang %d dari transfer %s. Tidak boleh ganti ke sumber kandang %d.",
+
-				targetKandangID,
+			return fiber.NewError(
-				existingSourceID,
+				fiber.StatusBadRequest,
-				existingTransfer.TransferNumber,
+				fmt.Sprintf(
-				sourceProjectFlockKandangID,
+					"Source kandang %d sudah pernah ditransfer ke target kandang %d via transfer %s. Tidak boleh duplikat (source, target) pair yang sama.",
-			),
+					sourceProjectFlockKandangID,
-		)
+					targetKandangID,
 					existingTransfer.TransferNumber,
 				),
 			)
 		}
 	}
 	return nil
@@ -61,7 +61,6 @@ func (PurchaseModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validate
 		expenseRealizationRepo,
 		projectFlockKandangRepository,
 		documentSvc,
 		commonSvc.NewFifoPaymentService(db, utils.Log),
 		validate,
 	)
 	expenseBridge := service.NewExpenseBridge(
@@ -73,7 +72,6 @@ func (PurchaseModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validate
 	)
 	fifoStockV2Service := commonSvc.NewFifoStockV2Service(db, utils.Log)
 	fifoPaymentService := commonSvc.NewFifoPaymentService(db, utils.Log)
 	purchaseService := service.NewPurchaseService(
 		validate,
@@ -86,7 +84,6 @@ func (PurchaseModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validate
 		approvalService,
 		expenseBridge,
 		fifoStockV2Service,
 		fifoPaymentService,
 		documentSvc,
 	)
@@ -64,7 +64,6 @@ type purchaseService struct {
 	ApprovalSvc             commonSvc.ApprovalService
 	ExpenseBridge           PurchaseExpenseBridge
 	FifoStockV2Svc          commonSvc.FifoStockV2Service
 	FifoPaymentSvc          commonSvc.FifoPaymentService
 	DocumentSvc             commonSvc.DocumentService
 	approvalWorkflow        approvalutils.ApprovalWorkflowKey
 }
@@ -92,7 +91,6 @@ func NewPurchaseService(
 	approvalSvc commonSvc.ApprovalService,
 	expenseBridge PurchaseExpenseBridge,
 	fifoStockV2Svc commonSvc.FifoStockV2Service,
 	fifoPaymentSvc commonSvc.FifoPaymentService,
 	documentSvc commonSvc.DocumentService,
 ) PurchaseService {
 	return &purchaseService{
@@ -107,7 +105,6 @@ func NewPurchaseService(
 		ApprovalSvc:             approvalSvc,
 		ExpenseBridge:           expenseBridge,
 		FifoStockV2Svc:          fifoStockV2Svc,
 		FifoPaymentSvc:          fifoPaymentSvc,
 		DocumentSvc:             documentSvc,
 		approvalWorkflow:        utils.ApprovalWorkflowPurchase,
 	}
@@ -1409,16 +1406,6 @@ func (s *purchaseService) ReceiveProducts(c *fiber.Ctx, id uint, req *validation
 		return nil, err
 	}
 	// Refresh purchase.grand_total + reallocate payment FIFO untuk supplier (new debt baru emerges).
 	if s.FifoPaymentSvc != nil && receivingAction == entity.ApprovalActionApproved {
 		if err := s.FifoPaymentSvc.RecomputeGrandTotal(c.Context(), nil, commonSvc.ParentKindPurchase, purchase.Id); err != nil {
 			s.Log.Warnf("Failed to recompute grand_total for purchase %d: %+v", purchase.Id, err)
 		}
 		if err := s.FifoPaymentSvc.ReallocateForParty(c.Context(), nil, string(utils.PaymentPartySupplier), uint(purchase.SupplierId)); err != nil {
 			s.Log.Warnf("Failed to reallocate payments for supplier %d: %+v", purchase.SupplierId, err)
 		}
 	}
 	return updated, nil
 }
@@ -16,13 +16,17 @@ type ExpenseDepreciationMetaDTO struct {
 }
 type ExpenseDepreciationRowDTO struct {
-	ProjectFlockID               int64   `json:"project_flock_id"`
+	ProjectFlockID                    int64   `json:"project_flock_id"`
-	FarmName                     string  `json:"farm_name"`
+	FarmName                          string  `json:"farm_name"`
-	Period                       string  `json:"period"`
+	Period                            string  `json:"period"`
-	DepreciationPercentEffective float64 `json:"depreciation_percent_effective"`
+	DepreciationPercentEffective      float64 `json:"depreciation_percent_effective"`
-	DepreciationValue            float64 `json:"depreciation_value"`
+	DepreciationValue                 float64 `json:"depreciation_value"`
-	PulletCostDayNTotal          float64 `json:"pullet_cost_day_n_total"`
+	PulletCostDayNTotal               float64 `json:"pullet_cost_day_n_total"`
-	Components                   any     `json:"components"`
+	MultiplicationPercentage          float64 `json:"multiplication_percentage"`
 	DayN                              int     `json:"day_n"`
 	ChickinDate                       string  `json:"chickin_date"`
 	TotalValuePulletAfterDepreciation float64 `json:"total_value_pullet_after_depreciation"`
 	Components                        any     `json:"components"`
 }
 type ExpenseDepreciationManualInputRowDTO struct {
@@ -37,10 +37,10 @@ type FarmDepreciationManualInputRow struct {
 	Note           *string
 }
-type houseDepreciationPercentRow struct {
+type houseMultiplicationPercentageRow struct {
-	HouseType           string
+	HouseType                string
-	Day                 int
+	Day                      int
-	DepreciationPercent float64
+	MultiplicationPercentage float64
 }
 type ExpenseDepreciationRepository interface {
@@ -48,8 +48,9 @@ type ExpenseDepreciationRepository interface {
 	GetSnapshotsByPeriodAndFarmIDs(ctx context.Context, period time.Time, farmIDs []uint) ([]entity.FarmDepreciationSnapshot, error)
 	UpsertSnapshots(ctx context.Context, rows []entity.FarmDepreciationSnapshot) error
 	DeleteSnapshotsFromDate(ctx context.Context, fromDate time.Time, farmIDs []uint) error
 	DeleteSnapshotsByFarmIDs(ctx context.Context, farmIDs []uint) error
 	GetLatestTransferInputsByFarms(ctx context.Context, period time.Time, farmIDs []uint) ([]FarmDepreciationLatestTransferRow, error)
-	GetDepreciationPercents(ctx context.Context, houseTypes []string, maxDay int) (map[string]map[int]float64, error)
+	GetMultiplicationPercentages(ctx context.Context, houseTypes []string, maxDay int) (map[string]map[int]float64, error)
 	GetLatestManualInputsByFarms(ctx context.Context, areaIDs, locationIDs, projectFlockIDs []int64) ([]FarmDepreciationManualInputRow, error)
 	UpsertManualInput(ctx context.Context, row *entity.FarmDepreciationManualInput) error
 	DB() *gorm.DB
@@ -159,6 +160,17 @@ func (r *expenseDepreciationRepository) DeleteSnapshotsFromDate(
 	return query.Delete(nil).Error
 }
 func (r *expenseDepreciationRepository) DeleteSnapshotsByFarmIDs(ctx context.Context, farmIDs []uint) error {
 	if len(farmIDs) == 0 {
 		return nil
 	}
 	return r.db.WithContext(ctx).
 		Table("farm_depreciation_snapshots").
 		Where("project_flock_id IN ?", farmIDs).
 		Delete(nil).Error
 }
 func (r *expenseDepreciationRepository) GetLatestTransferInputsByFarms(
 	ctx context.Context,
 	period time.Time,
@@ -228,7 +240,7 @@ ORDER BY ltt.target_project_flock_kandang_id, at.effective_date DESC, at.id DESC
 	return rows, nil
 }
-func (r *expenseDepreciationRepository) GetDepreciationPercents(
+func (r *expenseDepreciationRepository) GetMultiplicationPercentages(
 	ctx context.Context,
 	houseTypes []string,
 	maxDay int,
@@ -238,14 +250,14 @@ func (r *expenseDepreciationRepository) GetDepreciationPercents(
 		return result, nil
 	}
-	rows := make([]houseDepreciationPercentRow, 0)
+	rows := make([]houseMultiplicationPercentageRow, 0)
-	if err := r.db.WithContext(ctx).
+	if err := r.db.WithContext(ctx).Raw(`
-		Table("house_depreciation_standards").
+		SELECT DISTINCT ON (house_type::text, day)
-		Select("house_type::text AS house_type, day, depreciation_percent").
+			house_type::text AS house_type, day, multiplication_percentage
-		Where("house_type::text IN ?", houseTypes).
+		FROM house_depreciation_standards
-		Where("day <= ?", maxDay).
+		WHERE house_type::text IN ? AND day <= ?
-		Order("house_type ASC, day ASC").
+		ORDER BY house_type, day, effective_date DESC NULLS LAST
-		Scan(&rows).Error; err != nil {
+	`, houseTypes, maxDay).Scan(&rows).Error; err != nil {
 		return nil, err
 	}
@@ -253,7 +265,7 @@ func (r *expenseDepreciationRepository) GetDepreciationPercents(
 		if _, exists := result[row.HouseType]; !exists {
 			result[row.HouseType] = make(map[int]float64)
 		}
-		result[row.HouseType][row.Day] = row.DepreciationPercent
+		result[row.HouseType][row.Day] = row.MultiplicationPercentage
 	}
 	return result, nil
@@ -237,6 +237,9 @@ func (s *repportService) GetExpenseDepreciation(ctx *fiber.Ctx) ([]dto.ExpenseDe
 	snapshotByFarmID := make(map[uint]entity.FarmDepreciationSnapshot)
 	if params.ForceRecompute {
 		if err := s.ExpenseDepreciationRepo.DeleteSnapshotsByFarmIDs(ctx.Context(), farmIDs); err != nil {
 			return nil, nil, err
 		}
 		computedSnapshots, computeErr := s.computeExpenseDepreciationSnapshots(ctx.Context(), periodDate, farmIDs, farmNameByID)
 		if computeErr != nil {
 			return nil, nil, computeErr
@@ -289,24 +292,31 @@ func (s *repportService) GetExpenseDepreciation(ctx *fiber.Ctx) ([]dto.ExpenseDe
 		snapshot, exists := snapshotByFarmID[candidate.ProjectFlockID]
 		if !exists {
 			rows = append(rows, dto.ExpenseDepreciationRowDTO{
-				ProjectFlockID:               int64(candidate.ProjectFlockID),
+				ProjectFlockID:                    int64(candidate.ProjectFlockID),
-				FarmName:                     candidate.FarmName,
+				FarmName:                          candidate.FarmName,
-				Period:                       params.Period,
+				Period:                            params.Period,
-				DepreciationPercentEffective: 0,
+				DepreciationPercentEffective:      0,
-				DepreciationValue:            0,
+				DepreciationValue:                 0,
-				PulletCostDayNTotal:          0,
+				PulletCostDayNTotal:               0,
-				Components:                   map[string]any{},
+				TotalValuePulletAfterDepreciation: 0,
 				Components:                        map[string]any{},
 			})
 			continue
 		}
 		components := parseSnapshotComponents(snapshot.Components)
 		multiplicationPercentage, dayN, chickinDate := depreciationSnapshotInfo(components)
 		rows = append(rows, dto.ExpenseDepreciationRowDTO{
-			ProjectFlockID:               int64(snapshot.ProjectFlockId),
+			ProjectFlockID:                    int64(snapshot.ProjectFlockId),
-			FarmName:                     candidate.FarmName,
+			FarmName:                          candidate.FarmName,
-			Period:                       params.Period,
+			Period:                            params.Period,
-			DepreciationPercentEffective: snapshot.DepreciationPercentEffective,
+			DepreciationPercentEffective:      snapshot.DepreciationPercentEffective,
-			DepreciationValue:            snapshot.DepreciationValue,
+			DepreciationValue:                 snapshot.DepreciationValue,
-			PulletCostDayNTotal:          snapshot.PulletCostDayNTotal,
+			PulletCostDayNTotal:               snapshot.PulletCostDayNTotal,
-			Components:                   parseSnapshotComponents(snapshot.Components),
+			MultiplicationPercentage:          multiplicationPercentage,
 			DayN:                              dayN,
 			ChickinDate:                       chickinDate,
 			TotalValuePulletAfterDepreciation: snapshot.PulletCostDayNTotal - snapshot.DepreciationValue,
 			Components:                        components,
 		})
 	}
@@ -472,23 +482,26 @@ func (s *repportService) UpsertExpenseDepreciationManualInput(ctx *fiber.Ctx, re
 }
 type depreciationKandangComponent struct {
-	ProjectFlockKandangID uint    `json:"project_flock_kandang_id"`
+	ProjectFlockKandangID             uint    `json:"project_flock_kandang_id"`
-	KandangID             uint    `json:"kandang_id"`
+	KandangID                         uint    `json:"kandang_id"`
-	KandangName           string  `json:"kandang_name"`
+	KandangName                       string  `json:"kandang_name"`
-	TransferID            uint    `json:"transfer_id"`
+	TransferID                        uint    `json:"transfer_id"`
-	TransferDate          string  `json:"transfer_date"`
+	TransferDate                      string  `json:"transfer_date"`
-	SourceProjectFlockID  uint    `json:"source_project_flock_id"`
+	SourceProjectFlockID              uint    `json:"source_project_flock_id"`
-	HouseType             string  `json:"house_type"`
+	HouseType                         string  `json:"house_type"`
-	DayN                  int     `json:"day_n"`
+	DayN                              int     `json:"day_n"`
-	DepreciationPercent   float64 `json:"depreciation_percent"`
+	DepreciationPercent               float64 `json:"depreciation_percent"`
-	TransferQty           float64 `json:"transfer_qty"`
+	MultiplicationPercentage          float64 `json:"multiplication_percentage"`
-	PulletCostDayN        float64 `json:"pullet_cost_day_n"`
+	TransferQty                       float64 `json:"transfer_qty"`
-	DepreciationValue     float64 `json:"depreciation_value"`
+	PulletCostDayN                    float64 `json:"pullet_cost_day_n"`
-	DepreciationSource    string  `json:"depreciation_source,omitempty"`
+	DepreciationValue                 float64 `json:"depreciation_value"`
-	ManualInputID         *uint   `json:"manual_input_id,omitempty"`
+	TotalValuePulletAfterDepreciation float64 `json:"total_value_pullet_after_depreciation"`
-	CutoverDate           string  `json:"cutover_date,omitempty"`
+	DepreciationSource                string  `json:"depreciation_source,omitempty"`
-	OriginDate            string  `json:"origin_date,omitempty"`
+	ManualInputID                     *uint   `json:"manual_input_id,omitempty"`
-	StartScheduleDay      *int    `json:"start_schedule_day,omitempty"`
+	CutoverDate                       string  `json:"cutover_date,omitempty"`
 	OriginDate                        string  `json:"origin_date,omitempty"`
 	ChickinDate                       string  `json:"chickin_date,omitempty"`
 	StartScheduleDay                  *int    `json:"start_schedule_day,omitempty"`
 }
 type depreciationFarmComponents struct {
@@ -548,17 +561,20 @@ func (s *repportService) computeExpenseDepreciationSnapshots(
 				houseType := approvalService.NormalizeDepreciationHouseType(breakdown.HouseType)
 				component := depreciationKandangComponent{
-					ProjectFlockKandangID: breakdown.ProjectFlockKandangID,
+					ProjectFlockKandangID:             breakdown.ProjectFlockKandangID,
-					KandangID:             breakdown.KandangID,
+					KandangID:                         breakdown.KandangID,
-					KandangName:           breakdown.KandangName,
+					KandangName:                       breakdown.KandangName,
-					SourceProjectFlockID:  hppV2DetailUint(part.Details, "source_project_flock_id"),
+					SourceProjectFlockID:              hppV2DetailUint(part.Details, "source_project_flock_id"),
-					HouseType:             houseType,
+					HouseType:                         houseType,
-					DayN:                  hppV2DetailInt(part.Details, "schedule_day"),
+					DayN:                              hppV2DetailInt(part.Details, "schedule_day"),
-					DepreciationPercent:   hppV2DetailFloat(part.Details, "depreciation_percent"),
+					DepreciationPercent:               hppV2DetailFloat(part.Details, "depreciation_percent"),
-					PulletCostDayN:        hppV2DetailFloat(part.Details, "pullet_cost_day_n"),
+					MultiplicationPercentage:          hppV2DetailFloat(part.Details, "multiplication_percentage"),
-					DepreciationValue:     part.Total,
+					PulletCostDayN:                    hppV2DetailFloat(part.Details, "pullet_cost_day_n"),
-					DepreciationSource:    part.Code,
+					DepreciationValue:                 part.Total,
-					OriginDate:            hppV2DetailString(part.Details, "origin_date"),
+					TotalValuePulletAfterDepreciation: hppV2DetailFloat(part.Details, "total_value_pullet_after_depreciation"),
 					DepreciationSource:                part.Code,
 					OriginDate:                        hppV2DetailString(part.Details, "origin_date"),
 					ChickinDate:                       hppV2DetailString(part.Details, "origin_date"),
 				}
 				if component.HouseType == "" {
@@ -700,8 +716,11 @@ func hppV2DetailString(details map[string]any, key string) string {
 	if details == nil || key == "" {
 		return ""
 	}
-	raw, exists := details[key]
+	return anyString(details[key])
-	if !exists || raw == nil {
+}
 func anyString(raw any) string {
 	if raw == nil {
 		return ""
 	}
 	switch value := raw.(type) {
@@ -725,6 +744,68 @@ func parseSnapshotComponents(raw []byte) any {
 	return out
 }
 func depreciationSnapshotInfo(components any) (float64, int, string) {
 	root, ok := components.(map[string]any)
 	if !ok {
 		return 0, 0, ""
 	}
 	kandang, ok := root["kandang"].([]any)
 	if !ok {
 		return 0, 0, ""
 	}
 	for _, raw := range kandang {
 		component, ok := raw.(map[string]any)
 		if !ok {
 			continue
 		}
 		dayN := int(math.Round(anyFloat(component["day_n"])))
 		multiplicationPercentage := anyFloat(component["multiplication_percentage"])
 		chickinDate := anyString(component["chickin_date"])
 		if chickinDate == "" {
 			chickinDate = anyString(component["origin_date"])
 		}
 		if dayN > 0 || multiplicationPercentage > 0 || chickinDate != "" {
 			return multiplicationPercentage, dayN, chickinDate
 		}
 	}
 	return 0, 0, ""
 }
 func anyFloat(raw any) float64 {
 	switch value := raw.(type) {
 	case float64:
 		return value
 	case float32:
 		return float64(value)
 	case int:
 		return float64(value)
 	case int8:
 		return float64(value)
 	case int16:
 		return float64(value)
 	case int32:
 		return float64(value)
 	case int64:
 		return float64(value)
 	case uint:
 		return float64(value)
 	case uint8:
 		return float64(value)
 	case uint16:
 		return float64(value)
 	case uint32:
 		return float64(value)
 	case uint64:
 		return float64(value)
 	case string:
 		parsed, err := strconv.ParseFloat(strings.TrimSpace(value), 64)
 		if err == nil {
 			return parsed
 		}
 	}
 	return 0
 }
 func valueOrEmptyString(v *string) string {
 	if v == nil {
 		return ""
@@ -750,28 +831,37 @@ func (s *repportService) GetMarketing(c *fiber.Ctx, params *validation.Marketing
 		customerGroups[customerID] = append(customerGroups[customerID], dp)
 	}
 	// Aging untuk setiap MDP berdasarkan payment_allocations: LUNAS pakai last_payment_date,
 	// else pakai today.
 	agingMap := make(map[int]int)
-	allMdpIDsForAging := make([]uint, 0)
+	for customerID := range customerGroups {
-	for _, dp := range deliveryProducts {
+		transactions, err := s.CustomerPaymentRepo.GetCustomerPaymentTransactions(c.Context(), &customerID)
-		allMdpIDsForAging = append(allMdpIDsForAging, dp.Id)
+		if err != nil {
-	}
+			continue
-	mdpAllocSummaryForMarketing, err := s.fetchMdpAllocationSummary(c.Context(), allMdpIDsForAging)
+		}
-	if err != nil {
+
-		return nil, 0, err
+		initialBalance, err := s.CustomerPaymentRepo.GetInitialBalanceByCustomer(c.Context(), customerID)
-	}
+		if err != nil {
-	for _, dp := range deliveryProducts {
+			initialBalance = 0
-		summary := mdpAllocSummaryForMarketing[dp.Id]
+		}
-		soDate := dp.MarketingProduct.Marketing.SoDate
+
-		if customerPaymentStatusFromAllocation(dp.TotalPrice, summary.PaidAmount) == "LUNAS" && !summary.LastPaymentDate.IsZero() {
+		runningBalance := initialBalance
-			days := int(summary.LastPaymentDate.Sub(soDate).Hours() / 24)
+		for i, tx := range transactions {
-			if days < 0 {
+			if tx.TransactionType == "SALES" {
-				days = 0
+				previousBalance := runningBalance
 				runningBalance -= tx.TotalPrice
 				currentBalance := runningBalance
 				_, paymentDate := s.determineSalesStatusAndPaymentDate(transactions, i, previousBalance, currentBalance)
 				if paymentDate != nil {
 					agingDays := int(paymentDate.Sub(tx.TransDate).Hours() / 24)
 					agingMap[int(tx.TransactionID)] = agingDays
 				} else {
 					agingDays := int(time.Since(tx.TransDate).Hours() / 24)
 					agingMap[int(tx.TransactionID)] = agingDays
 				}
 			} else if tx.TransactionType == "PAYMENT" {
 				runningBalance += tx.PaymentAmount
 			}
 			agingMap[int(dp.Id)] = days
 		} else {
 			agingMap[int(dp.Id)] = int(time.Since(soDate).Hours() / 24)
 		}
 	}
@@ -1160,39 +1250,28 @@ func (s *repportService) processCustomerPayment(ctx context.Context, customerID
 		return dto.CustomerPaymentReportItem{}, err
 	}
 	// Batch fetch payment allocation summaries untuk semua SALES rows (per MDP).
 	mdpIDs := make([]uint, 0)
 	for _, tx := range transactions {
 		if tx.TransactionType == "SALES" && tx.TransactionID > 0 {
 			mdpIDs = append(mdpIDs, uint(tx.TransactionID))
 		}
 	}
 	mdpAllocSummary, err := s.fetchMdpAllocationSummary(ctx, mdpIDs)
 	if err != nil {
 		return dto.CustomerPaymentReportItem{}, err
 	}
 	rows := make([]dto.CustomerPaymentReportRow, 0, len(transactions))
 	runningBalance := initialBalance
-	for _, tx := range transactions {
+	for i, tx := range transactions {
 		previousBalance := runningBalance
 		row := dto.ToCustomerPaymentReportRow(tx)
 		if tx.TransactionType == "SALES" {
 			runningBalance -= tx.TotalPrice
-			summary := mdpAllocSummary[uint(tx.TransactionID)]
+			status, paymentDate := s.determineSalesStatusAndPaymentDate(transactions, i, previousBalance, runningBalance)
-			row.Status = customerPaymentStatusFromAllocation(tx.TotalPrice, summary.PaidAmount)
+			row.Status = status
-			if row.Status == "LUNAS" && !summary.LastPaymentDate.IsZero() {
+			if status == "LUNAS" {
-				days := int(summary.LastPaymentDate.Sub(tx.TransDate).Hours() / 24)
+				if paymentDate != nil {
-				if days < 0 {
+					days := int(paymentDate.Sub(tx.TransDate).Hours() / 24)
-					days = 0
+					row.AgingDay = &days
 				} else {
 					days := 0
 					row.AgingDay = &days
 				}
 				row.AgingDay = &days
 			} else if row.Status == "LUNAS" {
 				zero := 0
 				row.AgingDay = &zero
 			} else {
 				days := int(time.Since(tx.TransDate).Hours() / 24)
 				row.AgingDay = &days
@@ -1264,19 +1343,91 @@ func (s *repportService) processCustomerPayment(ctx context.Context, customerID
 	return dto.ToCustomerPaymentReportItem(*customer, initialBalance, rows, summary), nil
 }
-// customerPaymentStatusFromAllocation menentukan status per-MDP berdasarkan
+func (s *repportService) determineSalesStatusAndPaymentDate(transactions []repportRepo.CustomerPaymentTransaction, currentIndex int, previousBalance, currentBalance float64) (string, *time.Time) {
-// SUM(payment_allocations.amount) vs MDP total_price.
+	currentSales := transactions[currentIndex]
-func customerPaymentStatusFromAllocation(totalPrice, paidAmount float64) string {
+
-	if totalPrice <= fifoAllocationEpsilon {
+	if previousBalance >= currentSales.TotalPrice {
-		return "LUNAS"
+		type paymentAllocation struct {
 			date     time.Time
 			amount   float64
 			consumed float64
 		}
 		allocations := []paymentAllocation{}
 		runningBalance := 0.0
 		for i := 0; i < currentIndex; i++ {
 			if transactions[i].TransactionType == "PAYMENT" {
 				allocations = append(allocations, paymentAllocation{
 					date:     transactions[i].TransDate,
 					amount:   transactions[i].PaymentAmount,
 					consumed: 0,
 				})
 				runningBalance += transactions[i].PaymentAmount
 			} else if transactions[i].TransactionType == "SALES" {
 				salesAmount := transactions[i].TotalPrice
 				remainingToConsume := salesAmount
 				for j := range allocations {
 					if remainingToConsume <= 0 {
 						break
 					}
 					available := allocations[j].amount - allocations[j].consumed
 					if available > 0 {
 						consume := available
 						if consume > remainingToConsume {
 							consume = remainingToConsume
 						}
 						allocations[j].consumed += consume
 						remainingToConsume -= consume
 					}
 				}
 				runningBalance -= salesAmount
 			}
 		}
 		amountNeeded := currentSales.TotalPrice
 		for _, alloc := range allocations {
 			available := alloc.amount - alloc.consumed
 			if available > 0 {
 				if amountNeeded <= available {
 					return "LUNAS", &alloc.date
 				} else {
 					amountNeeded -= available
 				}
 			}
 		}
 		if len(allocations) > 0 {
 			return "LUNAS", &allocations[0].date
 		}
 		return "LUNAS", nil
 	}
-	if paidAmount+fifoAllocationEpsilon >= totalPrice {
+
-		return "LUNAS"
+	hasPartialPaymentFromBalance := previousBalance > 0 && previousBalance < currentSales.TotalPrice
 	futureBalance := currentBalance
 	hasPayment := false
 	var paymentDateThatMadeItLunas *time.Time
 	for i := currentIndex + 1; i < len(transactions); i++ {
 		if transactions[i].TransactionType == "PAYMENT" {
 			futureBalance += transactions[i].PaymentAmount
 			hasPayment = true
 			if futureBalance >= 0 {
 				paymentDateThatMadeItLunas = &transactions[i].TransDate
 				return "LUNAS", paymentDateThatMadeItLunas
 			}
 		} else if transactions[i].TransactionType == "SALES" {
 			futureBalance -= transactions[i].TotalPrice
 		}
 	}
-	if paidAmount > fifoAllocationEpsilon {
+
-		return "DIBAYAR SEBAGIAN"
+	if hasPayment || hasPartialPaymentFromBalance {
 		return "DIBAYAR SEBAGIAN", nil
 	}
-	return "BELUM LUNAS"
+
 	return "BELUM LUNAS", nil
 }
 func mapRecordingToProductionResultDTO(record entity.Recording) dto.ProductionResultDTO {
@@ -1742,6 +1893,15 @@ func (s *repportService) GetDebtSupplier(c *fiber.Ctx, params *validation.DebtSu
 		return nil, 0, err
 	}
 	expenseIDs := make([]uint64, 0, len(expenses))
 	for _, exp := range expenses {
 		expenseIDs = append(expenseIDs, exp.Id)
 	}
 	expenseWarehousesMap, err := s.DebtSupplierRepo.GetWarehousesByExpenseIDs(c.Context(), expenseIDs)
 	if err != nil {
 		return nil, 0, err
 	}
 	purchasesBySupplier := make(map[uint][]entity.Purchase, len(supplierIDs))
 	for _, purchase := range purchases {
 		purchasesBySupplier[purchase.SupplierId] = append(purchasesBySupplier[purchase.SupplierId], purchase)
@@ -1791,34 +1951,15 @@ func (s *repportService) GetDebtSupplier(c *fiber.Ctx, params *validation.DebtSu
 		DeltaBalance float64
 		CountTotals  bool
 	}
-
+	type debtSupplierAllocation struct {
-	// Batch fetch payment allocation summaries (per purchase + per expense) untuk semua supplier.
+		RowIndex  int
-	// FIFO matching dilakukan saat payment di-create/update; report tinggal baca dari DB.
+		SortTime  time.Time
-	allPurchaseIDs := make([]uint, 0)
+		Amount    float64
-	allExpenseIDs := make([]uint64, 0)
+		CalcAging func(endDate time.Time) int
 	for _, sid := range supplierIDs {
 		for _, p := range purchasesBySupplier[sid] {
 			allPurchaseIDs = append(allPurchaseIDs, p.Id)
 		}
 		for _, e := range expensesBySupplier[sid] {
 			allExpenseIDs = append(allExpenseIDs, e.Id)
 		}
 	}
-	purchaseAllocSummary, err := s.fetchPurchaseAllocationSummary(c.Context(), allPurchaseIDs)
+	type paymentAllocation struct {
-	if err != nil {
+		Date   time.Time
-		return nil, 0, err
+		Amount float64
 	}
 	expenseAllocSummary, err := s.fetchExpenseAllocationSummary(c.Context(), allExpenseIDs)
 	if err != nil {
 		return nil, 0, err
 	}
 	// rowRef tracks which combinedRows index belongs to which purchase/expense untuk update status di-akhir.
 	type rowRef struct {
 		Index    int
 		Kind     string // "PURCHASE" / "EXPENSE"
 		Purchase entity.Purchase
 		Expense  entity.Expense
 	}
 	for _, supplierID := range supplierIDs {
@@ -1833,7 +1974,7 @@ func (s *repportService) GetDebtSupplier(c *fiber.Ctx, params *validation.DebtSu
 		total := dto.DebtSupplierTotalDTO{}
 		combinedRows := make([]debtSupplierRowItem, 0, len(items)+len(paymentItems))
-		rowRefs := make([]rowRef, 0, len(items)+len(expensesBySupplier[supplierID]))
+		purchaseAllocations := make([]debtSupplierAllocation, 0, len(items))
 		for _, purchase := range items {
 			row := buildDebtSupplierRow(purchase, now, location)
 			sortTime := resolveDebtSupplierSortTime(purchase, params.FilterBy, location)
@@ -1845,11 +1986,17 @@ func (s *repportService) GetDebtSupplier(c *fiber.Ctx, params *validation.DebtSu
 				DeltaBalance: -row.TotalPrice,
 				CountTotals:  true,
 			})
-			rowRefs = append(rowRefs, rowRef{Index: rowIndex, Kind: "PURCHASE", Purchase: purchase})
+			capturedPurchase := purchase
 			purchaseAllocations = append(purchaseAllocations, debtSupplierAllocation{
 				RowIndex:  rowIndex,
 				SortTime:  sortTime,
 				Amount:    row.TotalPrice,
 				CalcAging: func(endDate time.Time) int { return calculateDebtSupplierAging(capturedPurchase, endDate, location) },
 			})
 		}
 		for _, exp := range expensesBySupplier[supplierID] {
-			row := buildDebtSupplierExpenseRow(exp, now, location)
+			row := buildDebtSupplierExpenseRow(exp, expenseWarehousesMap[exp.Id], now, location)
 			sortTime := exp.TransactionDate.In(location)
 			rowIndex := len(combinedRows)
 			combinedRows = append(combinedRows, debtSupplierRowItem{
@@ -1859,7 +2006,25 @@ func (s *repportService) GetDebtSupplier(c *fiber.Ctx, params *validation.DebtSu
 				DeltaBalance: -row.TotalPrice,
 				CountTotals:  true,
 			})
-			rowRefs = append(rowRefs, rowRef{Index: rowIndex, Kind: "EXPENSE", Expense: exp})
+			capturedExp := exp
 			purchaseAllocations = append(purchaseAllocations, debtSupplierAllocation{
 				RowIndex:  rowIndex,
 				SortTime:  sortTime,
 				Amount:    row.TotalPrice,
 				CalcAging: func(endDate time.Time) int { return calculateExpenseAging(capturedExp, endDate, location) },
 			})
 		}
 		paymentAllocations := make([]paymentAllocation, 0, len(paymentItems)+1)
 		initialAllocation := initialBalanceTotals[supplierID] + initialPaymentTotals[supplierID] - initialPurchaseTotals[supplierID]
 		paymentCarry := 0.0
 		if initialAllocation > 0 && len(purchaseAllocations) > 0 {
 			paymentAllocations = append(paymentAllocations, paymentAllocation{
 				Date:   purchaseAllocations[0].SortTime,
 				Amount: initialAllocation,
 			})
 		} else if initialAllocation < 0 {
 			paymentCarry = -initialAllocation
 		}
 		for _, payment := range paymentItems {
@@ -1872,29 +2037,51 @@ func (s *repportService) GetDebtSupplier(c *fiber.Ctx, params *validation.DebtSu
 				DeltaBalance: payment.Nominal,
 				CountTotals:  false,
 			})
 			paymentAllocations = append(paymentAllocations, paymentAllocation{
 				Date:   sortTime,
 				Amount: payment.Nominal,
 			})
 		}
-		// Determine Status & Aging dari payment_allocations DB.
+		if len(purchaseAllocations) > 0 && len(paymentAllocations) > 0 {
-		for _, ref := range rowRefs {
+			sort.SliceStable(purchaseAllocations, func(i, j int) bool {
-			rowTotal := combinedRows[ref.Index].Row.TotalPrice
+				return purchaseAllocations[i].SortTime.Before(purchaseAllocations[j].SortTime)
-			if rowTotal <= fifoAllocationEpsilon {
+			})
-				continue
+			sort.SliceStable(paymentAllocations, func(i, j int) bool {
 				return paymentAllocations[i].Date.Before(paymentAllocations[j].Date)
 			})
 			remaining := make([]float64, len(purchaseAllocations))
 			for i := range purchaseAllocations {
 				remaining[i] = purchaseAllocations[i].Amount
 			}
-			var summary paymentAllocationSummary
+			purchaseIndex := 0
-			if ref.Kind == "PURCHASE" {
+			for _, pay := range paymentAllocations {
-				summary = purchaseAllocSummary[ref.Purchase.Id]
+				amount := pay.Amount
-			} else {
+				if amount <= 0 {
-				summary = expenseAllocSummary[ref.Expense.Id]
+					continue
-			}
+				}
-			if summary.PaidAmount+fifoAllocationEpsilon < rowTotal {
+				if paymentCarry > 0 {
-				continue
+					used := math.Min(amount, paymentCarry)
-			}
+					paymentCarry -= used
-			combinedRows[ref.Index].Row.Status = "Lunas"
+					amount -= used
-			if !summary.LastPaymentDate.IsZero() {
+				}
-				if ref.Kind == "PURCHASE" {
+				for amount > 0 && purchaseIndex < len(remaining) {
-					combinedRows[ref.Index].Row.Aging = calculateDebtSupplierAging(ref.Purchase, summary.LastPaymentDate.In(location), location)
+					if remaining[purchaseIndex] <= 0 {
-				} else {
+						purchaseIndex++
-					combinedRows[ref.Index].Row.Aging = calculateExpenseAging(ref.Expense, summary.LastPaymentDate.In(location), location)
+						continue
 					}
 					used := math.Min(amount, remaining[purchaseIndex])
 					remaining[purchaseIndex] -= used
 					amount -= used
 					if remaining[purchaseIndex] <= 0.000001 {
 						allocation := purchaseAllocations[purchaseIndex]
 						combinedRows[allocation.RowIndex].Row.Status = "Lunas"
 						combinedRows[allocation.RowIndex].Row.Aging = allocation.CalcAging(pay.Date)
 						purchaseIndex++
 					}
 				}
 				if purchaseIndex >= len(remaining) {
 					break
 				}
 			}
 		}
@@ -1971,7 +2158,8 @@ func buildDebtSupplierRow(purchase entity.Purchase, now time.Time, loc *time.Loc
 	travelNumber := "-"
 	receivedDate := ""
 	var area *areaDTO.AreaRelationDTO
-	var warehouse *warehouseDTO.WarehouseRelationDTO
+	warehouses := []warehouseDTO.WarehouseRelationDTO{}
 	seenWarehouseIDs := map[uint]bool{}
 	if len(purchase.Items) > 0 {
 		firstItem := purchase.Items[0]
@@ -1979,24 +2167,22 @@ func buildDebtSupplierRow(purchase entity.Purchase, now time.Time, loc *time.Loc
 			travelNumber = *firstItem.TravelNumber
 		}
 		if firstItem.Warehouse != nil && firstItem.Warehouse.Id != 0 {
 			mappedWarehouse := warehouseDTO.ToWarehouseRelationDTO(*firstItem.Warehouse)
 			warehouse = &mappedWarehouse
 			if firstItem.Warehouse.Area.Id != 0 {
 				mappedArea := areaDTO.ToAreaRelationDTO(firstItem.Warehouse.Area)
 				area = &mappedArea
 			}
 		}
 		earliestReceived := time.Time{}
 		for _, item := range purchase.Items {
 			totalPrice += item.TotalPrice
-			if item.ReceivedDate == nil || item.ReceivedDate.IsZero() {
+			if item.ReceivedDate != nil && !item.ReceivedDate.IsZero() {
-				continue
+				received := item.ReceivedDate.In(loc)
 				if earliestReceived.IsZero() || received.Before(earliestReceived) {
 					earliestReceived = received
 				}
 			}
-			received := item.ReceivedDate.In(loc)
+			if item.Warehouse != nil && item.Warehouse.Id != 0 && !seenWarehouseIDs[item.Warehouse.Id] {
-			if earliestReceived.IsZero() || received.Before(earliestReceived) {
+				seenWarehouseIDs[item.Warehouse.Id] = true
-				earliestReceived = received
+				warehouses = append(warehouses, warehouseDTO.ToWarehouseRelationDTO(*item.Warehouse))
 				if area == nil && item.Warehouse.Area.Id != 0 {
 					mappedArea := areaDTO.ToAreaRelationDTO(item.Warehouse.Area)
 					area = &mappedArea
 				}
 			}
 		}
 		if !earliestReceived.IsZero() {
@@ -2029,7 +2215,7 @@ func buildDebtSupplierRow(purchase entity.Purchase, now time.Time, loc *time.Loc
 		ReceivedDate: receivedDate,
 		Aging:        aging,
 		Area:         area,
-		Warehouse:    warehouse,
+		Warehouses:   warehouses,
 		DueDate:      dueDate,
 		DueStatus:    dueStatus,
 		TotalPrice:   totalPrice,
@@ -2059,7 +2245,7 @@ func buildDebtSupplierPaymentRow(payment entity.Payment, loc *time.Location) dto
 		ReceivedDate: payment.PaymentDate.In(loc).Format("2006-01-02"),
 		Aging:        0,
 		Area:         nil,
-		Warehouse:    nil,
+		Warehouses:   []warehouseDTO.WarehouseRelationDTO{},
 		DueDate:      "-",
 		DueStatus:    "-",
 		TotalPrice:   0,
@@ -2071,115 +2257,6 @@ func buildDebtSupplierPaymentRow(payment entity.Payment, loc *time.Location) dto
 	}
 }
 // fifoAllocationEpsilon untuk float comparison saat membandingkan paid vs total.
 const fifoAllocationEpsilon = 0.001
 // paymentAllocationSummary aggregates per-document paid amount + latest payment date
 // from payment_allocations table, sebagai pengganti FIFO greedy in-memory.
 type paymentAllocationSummary struct {
 	PaidAmount      float64
 	LastPaymentDate time.Time
 }
 // fetchPurchaseAllocationSummary returns map[purchase_id]{paid_amount, last_payment_date}.
 // paid_amount = SUM(payment_allocations.amount) untuk semua items dalam purchase.
 // last_payment_date = MAX(payments.payment_date) untuk allocation tersebut.
 func (s *repportService) fetchPurchaseAllocationSummary(ctx context.Context, purchaseIDs []uint) (map[uint]paymentAllocationSummary, error) {
 	out := make(map[uint]paymentAllocationSummary)
 	if len(purchaseIDs) == 0 {
 		return out, nil
 	}
 	type row struct {
 		PurchaseID  uint
 		Total       float64
 		LastPayment *time.Time
 	}
 	var rows []row
 	if err := s.db.WithContext(ctx).
 		Table("payment_allocations pa").
 		Joins("JOIN purchase_items pi ON pi.id = pa.purchase_item_id").
 		Joins("JOIN payments p ON p.id = pa.payment_id").
 		Select("pi.purchase_id AS purchase_id, SUM(pa.amount) AS total, MAX(p.payment_date) AS last_payment").
 		Where("pi.purchase_id IN ?", purchaseIDs).
 		Group("pi.purchase_id").
 		Scan(&rows).Error; err != nil {
 		return nil, err
 	}
 	for _, r := range rows {
 		summary := paymentAllocationSummary{PaidAmount: r.Total}
 		if r.LastPayment != nil {
 			summary.LastPaymentDate = *r.LastPayment
 		}
 		out[r.PurchaseID] = summary
 	}
 	return out, nil
 }
 // fetchExpenseAllocationSummary returns map[expense_id]{paid_amount, last_payment_date}.
 // Allocation di expense_realization_id → JOIN expense_nonstocks → expenses.id.
 func (s *repportService) fetchExpenseAllocationSummary(ctx context.Context, expenseIDs []uint64) (map[uint64]paymentAllocationSummary, error) {
 	out := make(map[uint64]paymentAllocationSummary)
 	if len(expenseIDs) == 0 {
 		return out, nil
 	}
 	type row struct {
 		ExpenseID   uint64
 		Total       float64
 		LastPayment *time.Time
 	}
 	var rows []row
 	if err := s.db.WithContext(ctx).
 		Table("payment_allocations pa").
 		Joins("JOIN expense_realizations er ON er.id = pa.expense_realization_id").
 		Joins("JOIN expense_nonstocks en ON en.id = er.expense_nonstock_id").
 		Joins("JOIN payments p ON p.id = pa.payment_id").
 		Select("en.expense_id AS expense_id, SUM(pa.amount) AS total, MAX(p.payment_date) AS last_payment").
 		Where("en.expense_id IN ?", expenseIDs).
 		Group("en.expense_id").
 		Scan(&rows).Error; err != nil {
 		return nil, err
 	}
 	for _, r := range rows {
 		summary := paymentAllocationSummary{PaidAmount: r.Total}
 		if r.LastPayment != nil {
 			summary.LastPaymentDate = *r.LastPayment
 		}
 		out[r.ExpenseID] = summary
 	}
 	return out, nil
 }
 // fetchMdpAllocationSummary returns map[mdp_id]{paid_amount, last_payment_date}.
 func (s *repportService) fetchMdpAllocationSummary(ctx context.Context, mdpIDs []uint) (map[uint]paymentAllocationSummary, error) {
 	out := make(map[uint]paymentAllocationSummary)
 	if len(mdpIDs) == 0 {
 		return out, nil
 	}
 	type row struct {
 		MdpID       uint
 		Total       float64
 		LastPayment *time.Time
 	}
 	var rows []row
 	if err := s.db.WithContext(ctx).
 		Table("payment_allocations pa").
 		Joins("JOIN payments p ON p.id = pa.payment_id").
 		Select("pa.marketing_delivery_product_id AS mdp_id, SUM(pa.amount) AS total, MAX(p.payment_date) AS last_payment").
 		Where("pa.marketing_delivery_product_id IN ?", mdpIDs).
 		Group("pa.marketing_delivery_product_id").
 		Scan(&rows).Error; err != nil {
 		return nil, err
 	}
 	for _, r := range rows {
 		summary := paymentAllocationSummary{PaidAmount: r.Total}
 		if r.LastPayment != nil {
 			summary.LastPaymentDate = *r.LastPayment
 		}
 		out[r.MdpID] = summary
 	}
 	return out, nil
 }
 func resolveDebtSupplierSortTime(purchase entity.Purchase, filterBy string, loc *time.Location) time.Time {
 	if strings.EqualFold(strings.TrimSpace(filterBy), "po_date") {
 		if purchase.PoDate != nil && !purchase.PoDate.IsZero() {
@@ -2272,7 +2349,7 @@ func resolveDebtSupplierReceivedDate(purchase entity.Purchase, loc *time.Locatio
 	return time.Date(earliest.Year(), earliest.Month(), earliest.Day(), 0, 0, 0, 0, loc)
 }
-func buildDebtSupplierExpenseRow(exp entity.Expense, now time.Time, loc *time.Location) dto.DebtSupplierRowDTO {
+func buildDebtSupplierExpenseRow(exp entity.Expense, warehouses []entity.Warehouse, now time.Time, loc *time.Location) dto.DebtSupplierRowDTO {
 	txDate := exp.TransactionDate.In(loc)
 	dateStr := txDate.Format("2006-01-02")
@@ -2283,10 +2360,10 @@ func buildDebtSupplierExpenseRow(exp entity.Expense, now time.Time, loc *time.Lo
 		aging = int(endDay.Sub(startDay).Hours() / 24)
 	}
-	// TotalPrice pakai expense.GrandTotal (= SUM realisasi) supaya konsisten dengan
+	totalPrice := 0.0
-	// FIFO allocation yang juga pakai realisasi. Hindari pakai SUM nonstock pengajuan
+	for _, ns := range exp.Nonstocks {
-	// karena bisa beda nilai dari realisasi → mismatch dengan paid_amount → status salah.
+		totalPrice += ns.Qty * ns.Price
-	totalPrice := exp.GrandTotal
+	}
 	var area *areaDTO.AreaRelationDTO
 	if exp.Location != nil && exp.Location.Area.Id != 0 {
@@ -2294,6 +2371,15 @@ func buildDebtSupplierExpenseRow(exp entity.Expense, now time.Time, loc *time.Lo
 		area = &mapped
 	}
 	warehouseDTOs := make([]warehouseDTO.WarehouseRelationDTO, 0, len(warehouses))
 	seenWarehouseIDs := map[uint]bool{}
 	for _, w := range warehouses {
 		if w.Id != 0 && !seenWarehouseIDs[w.Id] {
 			seenWarehouseIDs[w.Id] = true
 			warehouseDTOs = append(warehouseDTOs, warehouseDTO.ToWarehouseRelationDTO(w))
 		}
 	}
 	poNumber := ""
 	if strings.TrimSpace(exp.PoNumber) != "" {
 		poNumber = exp.PoNumber
@@ -2306,7 +2392,7 @@ func buildDebtSupplierExpenseRow(exp entity.Expense, now time.Time, loc *time.Lo
 		ReceivedDate: dateStr,
 		Aging:        aging,
 		Area:         area,
-		Warehouse:    nil,
+		Warehouses:   warehouseDTOs,
 		DueDate:      "-",
 		DueStatus:    "-",
 		TotalPrice:   totalPrice,
@@ -244,8 +244,12 @@ func AttachProductionStandards(ctx context.Context, db *gorm.DB, warnOnly bool,
 		growthDetailByStd[standardID] = growthMap
 	}
-	// Batch-load laying transfer targets → source PFK chick_in_dates
+	// Batch-load laying transfer targets → EARLIEST source PFK chick_in_date per target.
-	// untuk menentukan actual chicken week (bukan hardcode LayingWeekStart offset)
+	// Multi-source: 1 target kandang bisa menerima dari multiple transfer terpisah. Untuk
 	// production standard week, kita pakai chick_in_date PALING AWAL (umur paling tua) sebagai
 	// anchor — agar perbandingan standar produksi tidak under-estimate umur ayam.
 	// Source diambil dari header `laying_transfers.source_project_flock_kandang_id` (single source
 	// of truth per migration 20260307130342), bukan dari `laying_transfer_sources`.
 	type transferChickIn struct {
 		TargetPFKID uint
 		ChickInDate time.Time
@@ -255,14 +259,16 @@ func AttachProductionStandards(ctx context.Context, db *gorm.DB, warnOnly bool,
 	if len(layingPFKIDs) > 0 {
 		var results []transferChickIn
 		db.Raw(`
-			SELECT ltt.target_project_flock_kandang_id AS target_pfk_id, pc.chick_in_date
+			SELECT ltt.target_project_flock_kandang_id AS target_pfk_id,
 			       MIN(pc.chick_in_date) AS chick_in_date
 			FROM laying_transfer_targets ltt
-			JOIN laying_transfer_sources lts ON lts.laying_transfer_id = ltt.laying_transfer_id
+			JOIN laying_transfers lt ON lt.id = ltt.laying_transfer_id AND lt.deleted_at IS NULL
-			JOIN project_chickins pc ON pc.project_flock_kandang_id = lts.source_project_flock_kandang_id
+			JOIN project_chickins pc ON pc.project_flock_kandang_id = lt.source_project_flock_kandang_id
 			WHERE ltt.target_project_flock_kandang_id IN ?
 			  AND ltt.deleted_at IS NULL
-			  AND lts.deleted_at IS NULL
+			  AND lt.source_project_flock_kandang_id IS NOT NULL
 			  AND pc.deleted_at IS NULL
 			GROUP BY ltt.target_project_flock_kandang_id
 		`, layingPFKIDs).Scan(&results)
 		for _, r := range results {
 			sourceChickInByTarget[r.TargetPFKID] = r.ChickInDate