hr_lite 0.23.1 → 0.26.0

data/app/models/hr_lite/payroll_run.rb

@@ -9,6 +9,11 @@ module HrLite
     belongs_to :created_by, class_name: HrLite.config.user_class, optional: true
     belongs_to :finalized_by, class_name: HrLite.config.user_class, optional: true
     belongs_to :published_by, class_name: HrLite.config.user_class, optional: true
+    belongs_to :first_approved_by, class_name: HrLite.config.user_class, optional: true
+
+    # A run with one of these is not paid on the 3rd without a person looking:
+    # someone missing, a state levying ₹0, or last year's / unverified rates.
+    BLOCKING_WARNING = /\ANo (salary structure|professional-tax slabs)|statutory card/
 
     validates :period_month, presence: true, uniqueness: true
     validates :status, inclusion: { in: STATUSES }
@@ -40,7 +45,8 @@ module HrLite
         update!(status: "processing")
         PayrollRunProcessor.call(self)
         transaction do
-          update!(status: "review", processed_at: Time.current)
+          # New numbers: an approval of the old ones no longer counts.
+          update!(status: "review", processed_at: Time.current, first_approved_by_id: nil, first_approved_at: nil)
           audit!("payroll.computed", actor,
                  "slips" => salary_slips.count, "warnings" => warnings.length,
                  "from_status" => previous)
@@ -60,7 +66,7 @@ module HrLite
       raise ActiveRecord::RecordInvalid.new(self), "no slips" if salary_slips.none?
 
       transaction do
-        update!(status: "finalized", finalized_at: Time.current, finalized_by_id: actor.id)
+        update!(status: "finalized", finalized_at: Time.current, finalized_by_id: actor&.id)
         # Finalizing freezes every slip in the run. Who did it, to how many
         # people, is the row an investigation starts from.
         audit!("payroll.finalized", actor, "slips" => salary_slips.count)
@@ -74,6 +80,34 @@ module HrLite
       true
     end
 
+    # Two people approve a reviewed run, at least one of them able to run
+    # payroll; the second approval finalizes and publishes it.
+    def approve!(actor:)
+      raise_unless %w[review]
+      unless HrLite.can?(actor, "payroll.approve", scope: :all)
+        raise ActiveRecord::RecordInvalid.new(self), "not an approver"
+      end
+      return stamp_first_approval!(actor) if first_approved_by_id.nil?
+      if first_approved_by_id == actor.id || [ first_approved_by, actor ].none? { |u| HrLite.can?(u, "payroll.manage", scope: :all) }
+        raise ActiveRecord::RecordInvalid.new(self), "needs a second, different approver"
+      end
+
+      finalize!(actor: actor) && publish!(actor: actor)
+    end
+
+    def blocking_warnings = warnings.grep(BLOCKING_WARNING)
+
+    # The 3rd-of-month backstop: a clean run nobody finished approving is
+    # approved by the system and says so; a run with blocking warnings waits.
+    def auto_approve!
+      raise_unless %w[review]
+      return false if blocking_warnings.any?
+
+      update!(auto_approved_at: Time.current)
+      audit!("payroll.auto_approved", nil, "slips" => salary_slips.count)
+      finalize!(actor: nil) && publish!(actor: nil)
+    end
+
     def unlock!(actor:)
       raise_unless %w[finalized]
       transaction do
@@ -92,7 +126,7 @@ module HrLite
     def publish!(actor:)
       raise_unless %w[finalized]
       transaction do
-        update!(status: "published", published_at: Time.current, published_by_id: actor.id)
+        update!(status: "published", published_at: Time.current, published_by_id: actor&.id)
         audit!("payroll.published", actor, "slips" => salary_slips.count)
       end
 
@@ -145,6 +179,16 @@ module HrLite
 
     private
 
+    def stamp_first_approval!(actor)
+      update!(first_approved_by_id: actor.id, first_approved_at: Time.current)
+      audit!("payroll.approved", actor, "slips" => salary_slips.count, "step" => 1)
+      others = HrLite.users_holding("payroll.approve", scope: :all).reject { |u| u.id == actor.id }
+      Notifications.publish("payroll.approval_needed",
+                            title: "Payroll #{label}: #{HrLite.display_name(actor)} approved — one more approval publishes it",
+                            path: "/admin/payroll_runs/#{id}", bell_to: others, email_to: others)
+      true
+    end
+
     # A repayment is booked when the run is FINALIZED, never at compute: a
     # draft is recomputed as often as the operator likes, and each pass would
     # otherwise take another instalment off the loan.

data/app/models/hr_lite/role.rb

@@ -12,6 +12,9 @@ module HrLite
     FINANCE = "Finance".freeze
     LEADERSHIP = "Leadership".freeze
     SUPER_ADMIN = "Super Admin".freeze
+    # An outside chartered accountant: reads pay and tax to verify them at
+    # year end. Not an employee — see HrLite.employees.
+    CA = "CA".freeze
 
     has_many :role_grants, dependent: :destroy
     has_many :role_assignments, dependent: :destroy

data/app/models/hr_lite/salary_structure.rb

@@ -10,9 +10,15 @@ module HrLite
     belongs_to :user, class_name: HrLite.config.user_class
     belongs_to :created_by, class_name: HrLite.config.user_class, optional: true
 
-    encrypted_money :basic, :hra, :special_allowance, :other_earnings
-    # Typed on the form to fill the lines; CTC is always derived, never stored.
-    attribute :annual_ctc, :decimal
+    encrypted_money :basic, :hra, :special_allowance, :other_earnings, :annual_ctc
+
+    # Gratuity accrues at 15/26 days of Basic a year (4.81%), inside the CTC.
+    GRATUITY_RATE = BigDecimal("0.0481")
+
+    # The CTC is the input: saving one splits it, so no line is typed by hand.
+    before_validation :fill_from_ctc, if: -> { annual_ctc.present? }
+    # The admin form saves in this context: people only ever type the CTC.
+    validates :annual_ctc, presence: true, on: :ctc_form
 
     validates :effective_from, presence: true, uniqueness: { scope: :user_id }
     validates :basic, presence: true
@@ -49,7 +55,7 @@ module HrLite
       earnings, deductions, employer = [
         { "Basic" => basic, "HRA" => hra, "Special allowance" => special_allowance, "Other" => other_earnings },
         { "PF" => pf&.employee, "ESI" => esi.employee, "Professional tax" => pts.first },
-        { "PF" => pf && (pf.employer_eps + pf.employer_epf), "ESI" => esi.employer }
+        { "PF" => pf && (pf.employer_eps + pf.employer_epf), "ESI" => esi.employer, "Gratuity" => gratuity }
       ].map { |rows| rows.select { |_, amount| Money.d(amount).positive? } }
       monthly_ctc = gross + employer.values.sum(BigDecimal(0))
       in_hand = gross - deductions.values.sum(BigDecimal(0))
@@ -76,14 +82,22 @@ module HrLite
       (earlier || self).monthly_gross
     end
 
-    # Owner's split of annual_ctc: Basic 50% of the monthly CTC, HRA 40% of
-    # Basic, employer PF and ESI paid out of the CTC; Special takes the rest.
+    # Only a CTC-split structure carries gratuity in its CTC; older hand-typed
+    # ones never did, and their CTC must not move.
+    def gratuity
+      Money.round_rupee(Money.d(basic) * GRATUITY_RATE) if annual_ctc.present? && basic
+    end
+
+    # Owner's split of annual_ctc (the labour codes' 50% wage floor): Basic 50%
+    # of the monthly CTC, HRA 50% of Basic in a metro and 40% elsewhere,
+    # employer PF, ESI and gratuity paid out of the CTC; Special takes the rest.
     def fill_from_ctc(on: effective_from || Date.current)
       monthly_ctc = Money.round_rupee(Money.d(annual_ctc) / 12)
       self.basic = Money.round_rupee(monthly_ctc / 2)
-      self.hra = Money.round_rupee(basic * BigDecimal("0.4"))
+      self.hra = Money.round_rupee(basic * BigDecimal(metro ? "0.5" : "0.4"))
+      self.other_earnings = nil
       self.special_allowance = 0
-      rest = monthly_ctc - Money.d(breakup(on: on).dig(:employer, "PF"))
+      rest = monthly_ctc - Money.d(breakup(on: on).dig(:employer, "PF")) - Money.d(gratuity)
       # Employer ESI is a share of the gross beside it: gross + ESI = rest.
       gross = (rest / (1 + StatutoryRateCard.for(on.beginning_of_month)[:esi][:employer_rate])).floor
       self.special_allowance = gross - basic - hra - Money.d(other_earnings)

data/app/models/hr_lite/statutory_rate_card_record.rb

@@ -53,14 +53,14 @@ module HrLite
       hash.to_h { |key, value| [ key, Money.d(value) ] }
     end
 
-    # A card dated mid-year would mean two sets of slabs inside one financial
-    # year, and the TDS projector works on an annual figure — there is no
-    # sensible answer to "which slabs applied to this year's income" then.
+    # Cards take effect on the 1st of a month. Most open a financial year on
+    # 1 April; a mid-year card exists for a statutory change notified inside a
+    # year (the EPF wage ceiling, 17 Sep 2026) and repeats that year's tax
+    # slabs, because TDS projects one annual figure.
     def effective_from_opens_a_financial_year
-      return if effective_from.blank?
-      return if effective_from == FinancialYear.start_for(effective_from)
+      return if effective_from.blank? || effective_from.day == 1
 
-      errors.add(:effective_from, "must be 1 April — a card covers a whole financial year")
+      errors.add(:effective_from, "must be the 1st of a month (1 April for a new financial year)")
     end
 
     REQUIRED = {

data/app/models/hr_lite/tax_declaration.rb

@@ -47,6 +47,30 @@ module HrLite
       tax_declaration_items.sum(BigDecimal(0)) { |i| i.verified_amount || BigDecimal(0) }
     end
 
+    Deduction = Struct.new(:section, :label, :claimed, :allowed, :cap, keyword_init: true)
+
+    # Old-regime lines with the law applied: each section's limit, and HRA
+    # worked out from the rent against the salary structure — never typed.
+    def deduction_rows(structure:)
+      tax_declaration_items.reject { |item| item.declared_amount.nil? || item.marked_for_destruction? }.map do |item|
+        allowed = item.section == "hra" ? self.class.hra_exemption(item.allowed(verified: verified?), structure) : item.allowed(verified: verified?)
+        Deduction.new(section: item.section, label: item.section_label, claimed: Money.d(item.declared_amount),
+                      allowed: allowed, cap: item.cap)
+      end
+    end
+
+    def old_regime_deductions(structure:) = deduction_rows(structure: structure).sum(BigDecimal(0), &:allowed)
+
+    # Annual HRA exemption: the least of the HRA received, rent less 10% of
+    # Basic, and 50% of Basic in a metro (40% elsewhere).
+    def self.hra_exemption(rent, structure)
+      return BigDecimal(0) if structure.nil? || Money.d(rent).zero?
+
+      basic = Money.d(structure.basic) * 12
+      [ Money.d(structure.hra) * 12, Money.d(rent) - basic / 10, basic * BigDecimal(structure.metro ? "0.5" : "0.4") ]
+        .min.then { |amount| Money.round_rupee([ amount, BigDecimal(0) ].max) }
+    end
+
     def submit!(actor:)
       raise ActiveRecord::RecordInvalid.new(self), "not a draft" unless draft? || rejected?
 

data/app/models/hr_lite/tax_declaration_item.rb

@@ -4,22 +4,55 @@ module HrLite
   # `verified_amount` is what the proof actually supported, which is often
   # less than what was claimed and is the number payroll uses once HR has
   # looked. Both are encrypted: what somebody invests is their business.
+  # The legal limit is applied on top, so nobody's arithmetic decides it.
   class TaxDeclarationItem < ApplicationRecord
     include EncryptedMoney
 
-    SECTIONS = %w[80c 80d 80ccd_1b 24b hra other].freeze
+    SECTIONS = %w[80c 80ccd_1b 80d 80d_parents 24b hra other].freeze
+
+    # Annual limits (old regime). 80D doubles for a senior; HRA is computed
+    # from rent; "other" has no single limit.
+    CAPS = { "80c" => 150_000, "80ccd_1b" => 50_000, "24b" => 200_000,
+             "80d" => 25_000, "80d_parents" => 25_000 }.freeze
+    SENIOR_80D_CAP = 50_000
+    RENT_NEEDS_LANDLORD_PAN = 100_000
+    PROOF_TYPES = %w[application/pdf image/jpeg image/png].freeze
+    PROOF_MAX_BYTES = 5.megabytes
 
     encrypted_money :declared_amount, :verified_amount
+    encrypts :landlord_pan
+    normalizes :landlord_pan, with: ->(pan) { pan.to_s.strip.upcase.presence }
 
     belongs_to :declaration, class_name: "HrLite::TaxDeclaration"
+    has_many_attached :proofs
 
     validates :section, inclusion: { in: SECTIONS }
     validate :amounts_are_not_negative
+    validate :landlord_pan_for_large_rent
+    validate :proofs_are_documents
 
+    # Labels name the Income-tax Act 2025 section with the 1961 one people know.
     def section_label
-      { "80c" => "80C — investments", "80d" => "80D — health insurance",
-        "80ccd_1b" => "80CCD(1B) — NPS", "24b" => "24(b) — home loan interest",
-        "hra" => "HRA exemption", "other" => "Other" }.fetch(section, section)
+      { "80c" => "Sec 123 (old 80C) — PF, PPF, ELSS, LIC, tuition fees, home-loan principal",
+        "80ccd_1b" => "Sec 124 (old 80CCD(1B)) — your own extra NPS",
+        "80d" => "Sec 126 (old 80D) — health insurance for you and family",
+        "80d_parents" => "Sec 126 (old 80D) — health insurance for parents",
+        "24b" => "Home-loan interest (old 24(b))",
+        "hra" => "Rent paid in the year (for the HRA exemption)",
+        "other" => "Other deductions" }.fetch(section, section)
+    end
+
+    def cap
+      return SENIOR_80D_CAP if senior && section.start_with?("80d")
+
+      CAPS[section]
+    end
+
+    # What payroll counts for this line: the claim until HR has checked the
+    # proof, then what the proof supported — never above the legal limit.
+    def allowed(verified:)
+      base = verified ? Money.d(verified_amount) : Money.d(declared_amount)
+      cap ? [ base, BigDecimal(cap) ].min : base
     end
 
     private
@@ -28,5 +61,24 @@ module HrLite
       errors.add(:declared_amount, "cannot be negative") if declared_amount&.negative?
       errors.add(:verified_amount, "cannot be negative") if verified_amount&.negative?
     end
+
+    def landlord_pan_for_large_rent
+      return unless section == "hra" && Money.d(declared_amount) > RENT_NEEDS_LANDLORD_PAN
+
+      if landlord_pan.blank?
+        errors.add(:landlord_pan, "is needed when rent is above ₹1,00,000 a year")
+      elsif !landlord_pan.match?(/\A[A-Z]{5}[0-9]{4}[A-Z]\z/)
+        errors.add(:landlord_pan, "is not a valid PAN (like ABCDE1234F)")
+      end
+    end
+
+    def proofs_are_documents
+      proofs.each do |proof|
+        next if PROOF_TYPES.include?(proof.blob.content_type) && proof.blob.byte_size <= PROOF_MAX_BYTES
+
+        errors.add(:proofs, "must be PDF, JPG or PNG files of up to 5 MB")
+        break
+      end
+    end
   end
 end

data/app/services/hr_lite/calculators/tds.rb

@@ -67,15 +67,16 @@ module HrLite
         )
       end
 
-      def self.slab_tax_for(taxable, slabs)
-        slabs.sum(BigDecimal(0)) do |lower, upper, rate|
-          next BigDecimal(0) if taxable <= lower
+      def self.slab_tax_for(taxable, slabs) = slab_rows(taxable, slabs).sum(BigDecimal(0)) { |row| row[:tax] }
+      private_class_method :slab_tax_for
 
-          span_top = upper && taxable > upper ? upper : taxable
-          (span_top - lower) * rate
+      # Each slab with the income that falls in it and the tax on that part.
+      def self.slab_rows(taxable, slabs)
+        slabs.map do |lower, upper, rate|
+          span = taxable <= lower ? BigDecimal(0) : (upper && taxable > upper ? upper : taxable) - lower
+          { from: lower, to: upper, rate: rate, income: span, tax: span * rate }
         end
       end
-      private_class_method :slab_tax_for
     end
   end
 end

data/app/services/hr_lite/payroll_run_processor.rb

@@ -61,6 +61,15 @@ module HrLite
                       "it genuinely levies no PT."
         end
 
+        # Only approved leave and fixes reach DayStatus; one still waiting is paid as loss of pay.
+        month = @run.period_month.all_month
+        pending = LeaveRequest.pending.overlapping_range(month.begin, month.end).count +
+                  RegularizationRequest.pending.where(date: month).count
+        if pending.positive?
+          warnings << "#{pending} leave or attendance #{pending == 1 ? 'request is' : 'requests are'} still pending for " \
+                      "#{@run.label} — they count as loss of pay until approved; approve or reject, then recompute."
+        end
+
         @run.salary_slips.where.not(id: keep_ids).destroy_all
         @run.update!(warnings: warnings)
       end

data/app/services/hr_lite/slip_builder.rb

@@ -138,7 +138,7 @@ module HrLite
       # A rejected declaration lowers nothing: its self-declared total stays editable and unchecked.
       return @profile.declared_annual_deductions if declaration.draft? || declaration.rejected?
 
-      declaration.allowable_total
+      declaration.old_regime_deductions(structure: @structure)
     end
 
     # Splits this month's one-off lines into earnings and deductions, in the

data/app/services/hr_lite/tax_computation.rb

@@ -0,0 +1,61 @@
+module HrLite
+  # Somebody's income tax for the financial year, worked out now from what
+  # is true now: the salary structure in force, the slips already paid, and
+  # their declaration with the legal limits applied. Both regimes, with every
+  # step shown, so "why is my TDS X" answers itself. Uses the same TDS
+  # calculator payroll uses, so the screen and the slip never disagree.
+  class TaxComputation
+    Sheet = Struct.new(:regime, :gross, :hra_exemption, :standard_deduction, :deductions, :taxable,
+                       :slabs, :annual_tax, :tds_paid, :remaining, :months_left, :monthly, keyword_init: true)
+
+    attr_reader :user, :month, :structure, :declaration, :paid
+
+    def initialize(user:, on: Date.current, declaration: nil)
+      @user = user
+      @month = on.beginning_of_month
+      @profile = EmployeeProfile.find_by(user_id: user.id)
+      @structure = SalaryStructure.effective_for(user, @month)
+      @declaration = declaration || TaxDeclaration.for(user, @month)
+      @paid = SalarySlip.fy_to_date(user, @month)
+    end
+
+    def regime = declaration&.regime || @profile&.tax_regime || "new"
+
+    def months_left = month.month >= 4 ? 16 - month.month : 4 - month.month
+
+    def paid_gross = paid[:gross] + Money.d(@profile&.fy_opening_gross)
+
+    def projected_gross = Money.d(structure&.monthly_gross) * months_left
+
+    def sheets = @sheets ||= TaxDeclaration::REGIMES.to_h { |name| [ name, sheet(name) ] }
+
+    def chosen = sheets[regime]
+
+    # The regime that costs less this year, and by how much.
+    def saving
+      new_tax, old_tax = sheets.values_at("new", "old").map(&:annual_tax)
+      new_tax <= old_tax ? [ "new", old_tax - new_tax ] : [ "old", new_tax - old_tax ]
+    end
+
+    private
+
+    def sheet(name)
+      rates = StatutoryRateCard.for(month)[:income_tax]
+      table = rates[name]
+      rows = name == "old" && declaration && structure ? declaration.deduction_rows(structure: structure) : []
+      hra = rows.find { |row| row.section == "hra" }&.allowed || BigDecimal(0)
+      tds_paid = paid[:tds] + Money.d(@profile&.fy_opening_tds)
+      result = Calculators::Tds.call(
+        regime: name, structure_monthly_gross: Money.d(structure&.monthly_gross),
+        gross_earned_this_month: Money.d(structure&.monthly_gross), fy_gross_paid: paid_gross,
+        fy_tds_paid: tds_paid, months_remaining: months_left,
+        declared_annual_deductions: rows.sum(BigDecimal(0), &:allowed), rates: rates
+      )
+      Sheet.new(regime: name, gross: result.projected_annual_gross, hra_exemption: hra,
+                standard_deduction: table[:standard_deduction], deductions: rows.reject { |row| row.section == "hra" },
+                taxable: result.taxable, slabs: Calculators::Tds.slab_rows(result.taxable, table[:slabs]),
+                annual_tax: result.annual_tax, tds_paid: tds_paid,
+                remaining: [ result.annual_tax - tds_paid, BigDecimal(0) ].max, months_left: months_left, monthly: result.monthly)
+    end
+  end
+end

data/app/services/hr_lite/timeline.rb

@@ -18,7 +18,7 @@ module HrLite
 
     def private_events
       newest_first(pay_items + loans + expenses + appraisals + plans + attendance_fixes + comp_offs +
-                   assets + documents + resignations + probation + hr_requests)
+                   assets + documents + resignations + probation + hr_requests + open_leave)
     end
 
     private
@@ -124,6 +124,15 @@ module HrLite
       end
     end
 
+    # Leave that never happened: still waiting, or turned down.
+    def open_leave
+      return [] unless visible?("leave.view")
+
+      LeaveRequest.where(**mine, status: %w[pending rejected]).overlapping_range(@range.begin, @range.end).includes(:leave_type).map do |leave|
+        event(leave.start_date, "Leave", "#{leave.leave_type.name} — #{leave.status}", leave.date_range_label)
+      end
+    end
+
     def attendance_fixes
       return [] unless visible?("attendance.view")
 

data/app/views/hr_lite/admin/ca_reviews/index.html.erb

@@ -0,0 +1,94 @@
+<% content_for(:page_title) { "CA review" } %>
+<% fy_label = HrLite::FinancialYear.label(@fy) %>
+<% reviewer = hr_can?("payroll.verify", scope: :all) %>
+<% resolver = hr_can?("payroll.approve", scope: :all) || hr_can?("payroll.manage", scope: :all) %>
+<% keep = ->(extra = {}) { { fy: @fy, tab: @tab, status: @status }.merge(extra).compact } %>
+<div class="hrl-page__head">
+  <h1 class="hrl-page__title">CA review — FY <%= fy_label %></h1>
+</div>
+<p class="hrl-small hrl-muted">Every published salary slip and every filed tax declaration, verified by the CA before 31 March <%= @fy.year + 1 %>. A flag goes to HR and payroll; the fix is a correcting line on a later slip or reopening the declaration — a published slip is never edited.</p>
+
+<div class="hrl-kpis">
+  <% %w[slips declarations].each do |kind| %>
+    <% total = @totals[kind] %>
+    <% done = total - @left[kind] %>
+    <div class="hrl-kpi">
+      <div class="hrl-kpi__value"><%= done %> / <%= total %></div>
+      <div class="hrl-kpi__label"><%= kind == "slips" ? "Salary slips" : "Tax declarations" %> verified</div>
+      <progress class="hrl-tax-cap" max="<%= [ total, 1 ].max %>" value="<%= done %>" aria-hidden="true"></progress>
+    </div>
+  <% end %>
+  <div class="hrl-kpi"><div class="hrl-kpi__value"><%= @left["flagged"] %></div><div class="hrl-kpi__label">Flags open</div></div>
+</div>
+
+<div class="hrl-row hrl-row--mb" role="tablist">
+  <a class="hrl-btn <%= "hrl-btn--primary" if @tab == "slips" %>" href="<%= hr_lite.admin_ca_reviews_path(keep.(tab: "slips", status: @status)) %>" aria-current="<%= @tab == "slips" ? "page" : nil %>">Salary slips</a>
+  <a class="hrl-btn <%= "hrl-btn--primary" if @tab == "declarations" %>" href="<%= hr_lite.admin_ca_reviews_path(keep.(tab: "declarations", status: @status)) %>" aria-current="<%= @tab == "declarations" ? "page" : nil %>">Tax declarations</a>
+</div>
+<div class="hrl-row hrl-row--mb">
+  <% [ [ nil, "All" ], [ "unreviewed", "To review" ], [ "flagged", "Flagged" ], [ "verified", "Verified" ], [ "resolved", "Resolved" ] ].each do |value, label| %>
+    <a class="hrl-btn <%= "hrl-btn--primary" if @status == value %>" href="<%= hr_lite.admin_ca_reviews_path(keep.(status: value)) %>"><%= label %></a>
+  <% end %>
+</div>
+
+<section class="hrl-card">
+  <% if @rows.empty? %>
+    <p class="hrl-card--empty">Nothing here.</p>
+  <% else %>
+    <% subject_type = @rows.first.class.name %>
+    <% if reviewer && @rows.any? { |row| @reviews[row.id].nil? } %>
+      <%= button_to "Verify all shown", hr_lite.verify_all_admin_ca_reviews_path, method: :post, class: "hrl-btn",
+            params: keep.(subject_type: subject_type, ids: @rows.map(&:id)),
+            form: { data: { turbo_confirm: "Verify every unreviewed item on this page?" } } %>
+    <% end %>
+    <ul class="hrl-feed">
+      <% @rows.each do |row| %>
+        <% review = @reviews[row.id] %>
+        <li class="hrl-feed__item">
+          <div class="hrl-feed__body">
+            <div class="hrl-row">
+              <% if row.is_a?(HrLite::SalarySlip) %>
+                <a class="hrl-card__link" href="<%= hr_lite.admin_salary_slip_path(row) %>"><%= hr_display_name(row.user) %> — <%= row.period_month.strftime("%B %Y") %></a>
+                <span class="hrl-small hrl-muted">net <%= hrl_money(row.net_pay) %></span>
+              <% else %>
+                <a class="hrl-card__link" href="<%= hr_lite.admin_tax_declaration_path(row) %>"><%= hr_display_name(row.user) %> — <%= row.label %></a>
+                <span class="hrl-small hrl-muted"><%= row.regime.humanize %> regime · <%= row.status.humanize %></span>
+              <% end %>
+              <span class="hrl-right">
+                <% badge = { "verified" => [ "hrl-badge--ok", "Verified" ], "flagged" => [ "hrl-badge--bad", "Flagged" ],
+                             "resolved" => [ "", "Resolved" ] }.fetch(review&.status, [ "hrl-badge--muted", "To review" ]) %>
+                <span class="hrl-badge <%= badge.first %>"><%= badge.last %></span>
+              </span>
+            </div>
+            <% if review&.note.present? %><p class="hrl-small">CA: <%= review.note %></p><% end %>
+            <% if review&.resolution_note.present? %><p class="hrl-small hrl-muted">Resolved by <%= hr_display_name(review.resolved_by) %>: <%= review.resolution_note %></p><% end %>
+            <div class="hrl-row hrl-mt">
+              <% if reviewer && review&.status != "verified" %>
+                <%= button_to "Verify", hr_lite.verify_admin_ca_reviews_path, method: :post, class: "hrl-btn",
+                      params: keep.(subject_type: subject_type, subject_id: row.id) %>
+              <% end %>
+              <% if reviewer %>
+                <details>
+                  <summary class="hrl-btn">Flag…</summary>
+                  <%= form_with url: hr_lite.flag_admin_ca_reviews_path, method: :post, local: true do %>
+                    <% keep.(subject_type: subject_type, subject_id: row.id).each do |key, value| %><%= hidden_field_tag key, value %><% end %>
+                    <div class="hrl-field"><%= label_tag "note_#{row.id}", "What is wrong" %><%= text_area_tag :note, nil, id: "note_#{row.id}", required: true, rows: 2 %></div>
+                    <%= submit_tag "Flag it", class: "hrl-btn hrl-btn--primary" %>
+                  <% end %>
+                </details>
+              <% end %>
+              <% if resolver && review&.status == "flagged" %>
+                <%= form_with url: hr_lite.resolve_admin_ca_review_path(review, keep.()), method: :post, local: true, class: "hrl-row" do %>
+                  <%= label_tag "resolution_#{review.id}", "How it was fixed", class: "hrl-sr-only" %>
+                  <%= text_field_tag :note, nil, id: "resolution_#{review.id}", placeholder: "How it was fixed" %>
+                  <%= submit_tag "Mark resolved", class: "hrl-btn" %>
+                <% end %>
+              <% end %>
+            </div>
+          </div>
+        </li>
+      <% end %>
+    </ul>
+    <%= hrl_pagination %>
+  <% end %>
+</section>

data/app/views/hr_lite/admin/employees/show.html.erb

@@ -9,6 +9,8 @@
       <a class="hrl-btn" href="<%= hr_lite.new_admin_employee_appraisal_path(@profile) %>">New appraisal</a>
       <a class="hrl-btn" href="<%= hr_lite.new_admin_employee_designation_change_path(@profile) %>">Role change</a>
       <a class="hrl-btn" href="<%= hr_lite.new_admin_performance_plan_path(user_id: @profile.user_id) %>">Start PIP</a>
+    <% end %>
+    <% if hr_can?("salary.manage", scope: :all) %>
       <a class="hrl-btn hrl-btn--primary" href="<%= hr_lite.new_admin_employee_salary_structure_path(@profile) %>">New structure</a>
     <% end %>
   </div>
@@ -84,7 +86,7 @@
     </dl>
   </section>
 
-  <% if hr_superadmin? %>
+  <% if hr_can?("salary.view", scope: :all) %>
   <section class="hrl-card">
     <h2 class="hrl-card__title">Salary structures</h2>
     <% if @structures.any? %>

data/app/views/hr_lite/admin/payroll_runs/show.html.erb

@@ -26,28 +26,38 @@
     <span class="hrl-badge"><%= @run.status.humanize %></span>
     <%# `processing` is offered too: a run stranded there by a killed process
         would otherwise have no control at all and block that month forever. %>
-    <% if @run.draft? || @run.review? || @run.processing? %>
+    <% manager = hr_can?("payroll.manage", scope: :all) %>
+    <% if manager && (@run.draft? || @run.review? || @run.processing?) %>
       <%= button_to @run.draft? ? "Compute" : "Recompute", hr_lite.compute_admin_payroll_run_path(@run),
-                    method: :post, class: "hrl-btn hrl-btn--primary" %>
+                    method: :post, class: "hrl-btn" %>
     <% end %>
-    <% if @run.review? %>
-      <%= button_to "Finalize", hr_lite.finalize_admin_payroll_run_path(@run), method: :post, class: "hrl-btn" %>
+    <% if @run.review? && hr_can?("payroll.approve", scope: :all) && @run.first_approved_by_id != hr_current_user.id %>
+      <%= button_to @run.first_approved_by_id ? "Approve and publish" : "Approve", hr_lite.approve_admin_payroll_run_path(@run),
+                    method: :post, class: "hrl-btn hrl-btn--primary",
+                    form: { data: { turbo_confirm: @run.first_approved_by_id ? "Approve #{@run.label}? This finalizes the run and publishes the slips." : "Approve #{@run.label}?" } } %>
     <% end %>
-    <% if @run.finalized? %>
+    <% if manager && @run.finalized? %>
       <%= button_to "Unlock", hr_lite.unlock_admin_payroll_run_path(@run), method: :post, class: "hrl-btn" %>
       <%= button_to "Publish to employees", hr_lite.publish_admin_payroll_run_path(@run), method: :post,
                     class: "hrl-btn hrl-btn--primary",
                     form: { data: { turbo_confirm: "Publish #{@run.label}? Employees will be notified." } } %>
     <% end %>
-    <% if @slips.any? %>
+    <% if @slips.any? && hr_can?("payroll.export", scope: :all) %>
       <a class="hrl-btn" href="<%= hr_lite.register_admin_payroll_run_path(@run, format: :csv) %>">Register CSV</a>
     <% end %>
-    <% if @run.draft? %>
+    <% if manager && @run.draft? %>
       <%= button_to "Delete draft", hr_lite.admin_payroll_run_path(@run), method: :delete,
                     class: "hrl-btn hrl-btn--danger",
                     form: { data: { turbo_confirm: "Delete this draft run?" } } %>
     <% end %>
   </div>
+  <p class="hrl-small hrl-muted hrl-mt">
+    <% if @run.review? %>
+      <%= @run.first_approved_by ? "Approved by #{hr_display_name(@run.first_approved_by)} on #{@run.first_approved_at.strftime('%-d %b')} — one more approver (HR or Super Admin) publishes it." : "Needs two approvals (HR and Super Admin). If nobody approves by the 3rd, a run with no blocking warnings is approved automatically." %>
+    <% elsif @run.auto_approved_at %>
+      Approved automatically on <%= @run.auto_approved_at.strftime("%-d %b") %> — nobody had approved it by the 3rd.
+    <% end %>
+  </p>
 </section>
 
 <section class="hrl-card">

data/app/views/hr_lite/admin/salary_structures/_form.html.erb

@@ -2,15 +2,16 @@
   <%= form_with model: structure, url: url, method: method, scope: :salary_structure, local: true do |f| %>
     <%= render "hr_lite/shared/form_errors", record: structure %>
     <% breakup = structure.breakup(on: structure.effective_from || Date.current) if structure.basic %>
-    <div class="hrl-field"><%= f.label :annual_ctc, "Annual CTC (₹ a year)" %><%= f.number_field :annual_ctc, step: 1, value: (structure.annual_ctc || breakup&.dig(:annual_ctc))&.round %></div>
+    <div class="hrl-field">
+      <%= f.label :annual_ctc, "Annual CTC (₹ a year)" %>
+      <%= f.number_field :annual_ctc, step: 1, min: 1, required: true, value: (structure.annual_ctc || breakup&.dig(:annual_ctc))&.round %>
+      <p class="hrl-hint">The only amount you type. Saving splits it: Basic 50%, HRA 50% of Basic in a metro (40% elsewhere), employer PF, ESI and gratuity (4.81% of Basic) inside the CTC, the rest as special allowance.</p>
+    </div>
     <div class="hrl-field">
       <%= f.label :effective_from, "Effective from (1st of month)" %>
       <%= f.date_field :effective_from %>
     </div>
-    <div class="hrl-field"><%= f.label :basic, "Basic (monthly)" %><%= f.number_field :basic, step: 0.01, value: structure.basic&.to_s("F") %></div>
-    <div class="hrl-field"><%= f.label :hra, "HRA" %><%= f.number_field :hra, step: 0.01, value: structure.hra&.to_s("F") %></div>
-    <div class="hrl-field"><%= f.label :special_allowance %><%= f.number_field :special_allowance, step: 0.01, value: structure.special_allowance&.to_s("F") %></div>
-    <div class="hrl-field"><%= f.label :other_earnings %><%= f.number_field :other_earnings, step: 0.01, value: structure.other_earnings&.to_s("F") %></div>
+    <div class="hrl-field hrl-field--check"><%= f.check_box :metro %><%= f.label :metro, "Works in a metro (Delhi, Mumbai, Kolkata, Chennai)" %></div>
     <div class="hrl-field hrl-field--check"><%= f.check_box :pf_applicable %><%= f.label :pf_applicable, "PF applicable" %></div>
     <div class="hrl-field hrl-field--check"><%= f.check_box :pf_on_full_basic %><%= f.label :pf_on_full_basic, "PF on full basic (no ₹15k ceiling)" %></div>
     <div class="hrl-field hrl-field--check"><%= f.check_box :esi_applicable %><%= f.label :esi_applicable, "ESI applicable (auto-exempt above gross ceiling)" %></div>
@@ -23,10 +24,17 @@
       <%= f.select :pt_state, pt_states.map { |s| [ s.humanize, s ] } %>
     </div>
     <div class="hrl-field"><%= f.label :notes %><%= f.text_area :notes %></div>
-    <% if breakup %><p class="hrl-muted hrl-small">Monthly gross <%= hrl_money(breakup[:monthly_gross]) %> · CTC <%= hrl_money(breakup[:monthly_ctc]) %> a month</p><% end %>
+    <% if breakup %>
+      <h3 class="hrl-card__title">Monthly split</h3>
+      <dl class="hrl-deflist">
+        <% breakup[:earnings].each do |label, amount| %><dt><%= label %></dt><dd><%= hrl_money(amount) %></dd><% end %>
+        <dt><strong>Gross</strong></dt><dd><strong><%= hrl_money(breakup[:monthly_gross]) %></strong></dd>
+        <% breakup[:employer].each do |label, amount| %><dt>Employer <%= label %></dt><dd><%= hrl_money(amount) %></dd><% end %>
+        <dt><strong>CTC</strong></dt><dd><strong><%= hrl_money(breakup[:monthly_ctc]) %></strong> a month</dd>
+      </dl>
+    <% end %>
     <div class="hrl-form-actions">
       <%= f.submit "Save structure", class: "hrl-btn hrl-btn--primary" %>
-      <%= f.submit "Fill from CTC", name: "fill_from_ctc", class: "hrl-btn" %>
       <a class="hrl-btn" href="<%= hr_lite.admin_employee_path(@profile) %>">Cancel</a>
     </div>
   <% end %>