hr_lite 0.53.0 → 0.55.0

data/app/controllers/hr_lite/admin/statutory_rate_cards_controller.rb

@@ -52,7 +52,8 @@ module HrLite
       def next_financial_year(newest)
         return FinancialYear.start_for(Date.current) if newest.nil?
 
-        [ newest.effective_from.next_year, FinancialYear.start_for(Date.current) ].max
+        # A mid-year card (1 Oct) must not push the next one to 1 Oct: years start on 1 April.
+        [ FinancialYear.start_for(newest.effective_from.next_year), FinancialYear.start_for(Date.current) ].max
       end
 
       # The figures arrive as flat strings from number fields and are stored

data/app/controllers/hr_lite/admin/tax_declarations_controller.rb

@@ -11,7 +11,7 @@ module HrLite
         @status = params[:status].presence_in(TaxDeclaration::STATUSES) || "submitted"
         @declarations = paginate(
           hr_scope(TaxDeclaration.includes(:user, :tax_declaration_items), "tax.view")
-            .where(status: @status).order(created_at: :desc)
+            .where(status: @status).where.not(user_id: hr_current_user.id).order(created_at: :desc)
         )
       end
 
@@ -45,7 +45,7 @@ module HrLite
 
         AuditLog.record!(action: "tax_proof.downloaded", subject: declaration, actor: hr_current_user,
                          changes: { "file" => file.filename.to_s, "owner" => HrLite.display_name(declaration.user) })
-        redirect_to Rails.application.routes.url_helpers.rails_blob_path(file, disposition: "attachment", only_path: true),
+        redirect_to Rails.application.routes.url_helpers.rails_blob_path(file, disposition: "attachment", only_path: true, expires_in: 5.minutes),
                     allow_other_host: false
       end
 
@@ -57,6 +57,8 @@ module HrLite
           declaration.tax_declaration_items.each do |item|
             item.update!(verified_amount: item.declared_amount) if item.verified_amount.nil?
           end
+          AuditLog.record!(action: "tax_declaration.accepted_all", subject: declaration, actor: hr_current_user,
+                           changes: { "owner" => HrLite.display_name(declaration.user) })
           declaration.verify!(actor: hr_current_user, note: "Proof accepted")
         end
         redirect_to admin_tax_declarations_path, notice: "Accepted and verified — payroll uses these amounts now."
@@ -66,9 +68,17 @@ module HrLite
 
       def update
         @declaration = find_manageable
+        return redirect_to admin_tax_declaration_path(@declaration), alert: "Only a submitted declaration can be checked." unless @declaration.submitted?
+
         # Recording what the proof supported is a separate act from deciding
         # — an amount can be corrected while the decision is still pending.
-        if @declaration.update(verification_params)
+        recorded = TaxDeclaration.transaction do
+          @declaration.update(verification_params) &&
+            AuditLog.record!(action: "tax_declaration.amounts_recorded", subject: @declaration, actor: hr_current_user,
+                             changes: { "owner" => HrLite.display_name(@declaration.user) })
+        end
+        if recorded
+          return verify if params[:verify] # "Record and verify": the typed amounts are saved first
           redirect_to admin_tax_declaration_path(@declaration), notice: "Amounts recorded."
         else
           @tax = TaxComputation.new(user: @declaration.user, declaration: @declaration)
@@ -81,7 +91,8 @@ module HrLite
         declaration.verify!(actor: hr_current_user, note: params[:note])
         redirect_to admin_tax_declarations_path, notice: "Verified — payroll will use the checked amounts."
       rescue ActiveRecord::RecordInvalid
-        redirect_to admin_tax_declaration_path(declaration), alert: "Only a submitted declaration can be verified."
+        redirect_to admin_tax_declaration_path(declaration),
+                    alert: declaration.errors.full_messages.first || "Only a submitted declaration can be verified."
       end
 
       def reject

data/app/controllers/hr_lite/admin/work_locations_controller.rb

@@ -5,7 +5,7 @@ module HrLite
     # Coordinates are only shown here, inside attendance.view reach.
     class WorkLocationsController < BaseController
       def index
-        @status = params[:status].presence_in(WorkLocation::STATUSES) || "approved"
+        @status = params[:status].presence_in(WorkLocation::STATUSES) || "pending"
         @locations = paginate(hr_scope(WorkLocation.where(status: @status), "attendance.view")
                                 .includes(:user).order(created_at: :desc))
       end

data/app/controllers/hr_lite/approvals_controller.rb

@@ -9,6 +9,7 @@ module HrLite
   class ApprovalsController < ApplicationController
     def index
       @approvals = paginate(Approval.pending_for(hr_current_user).includes(:step, :subject).order(:created_at))
+      @in_flow = Approval.pending_for(hr_current_user).pluck(:subject_type, :subject_id) # their queue rows would repeat them
       @delegations = ApprovalDelegation.live_on(Date.current)
                                        .where(from_user_id: hr_current_user.id)
                                        .includes(:to_user)

data/app/controllers/hr_lite/home_controller.rb

@@ -3,27 +3,18 @@ module HrLite
     def index
       @latest_kudos = Kudo.recent.includes(:giver, kudo_mentions: :user).limit(3)
       @awards = Award.current
-      @out_week = LeaveRequest.approved.overlapping_range(Date.current.beginning_of_week, Date.current.end_of_week)
+      @out_week = LeaveRequest.approved.overlapping_range(Date.current, Date.current.end_of_week)
                               .includes(:user).where(user_id: HrLite.active_employees.map(&:id))
                               .sort_by { |leave| hr_display_name(leave.user).downcase }
       @attention = attention_days
       @waiting = Approval.pending_for(hr_current_user).count
-      @queue = queue_count
-      @mine_pending = [ LeaveRequest.includes(:leave_type), RegularizationRequest, CompOffRequest ]
+      @mine_pending = [ LeaveRequest.includes(:leave_type), RegularizationRequest, CompOffRequest, WfhRequest ]
                       .flat_map { |scope| scope.pending.where(user_id: hr_current_user.id).order(created_at: :desc).limit(5) }
                       .max_by(5, &:created_at)
     end
 
     private
 
-    # Requests with no routed flow are decided straight off the HR queues, scoped as those queues decide them.
-    def queue_count
-      leave = ApprovalFlow.for(LeaveRequest.name) ? 0 : decidable(LeaveRequest, "leave.approve")
-      leave + decidable(CompOffRequest, "leave.approve") + decidable(RegularizationRequest, "attendance.manage")
-    end
-
-    def decidable(model, key) = hr_scope(model.pending, key).where.not(user_id: hr_current_user.id).count
-
     # Last week's days that still need a fix (absent, no check-out, flagged, short), minus those with a pending ticket.
     def attention_days
       range = (Date.current - 7)..(Date.current - 1)

data/app/controllers/hr_lite/loans_controller.rb

@@ -4,7 +4,7 @@ module HrLite
   class LoansController < ApplicationController
     def index
       @loans = Loan.where(user_id: hr_current_user.id).order(starts_on: :desc)
-      @outstanding = @loans.sum(BigDecimal(0), &:outstanding)
+      @outstanding = @loans.active.sum(BigDecimal(0), &:outstanding)
       @next_month = Date.current.next_month.beginning_of_month
     end
   end

data/app/controllers/hr_lite/regularization_requests_controller.rb

@@ -22,19 +22,19 @@ module HrLite
     def cancel
       request = RegularizationRequest.where(user_id: hr_current_user.id).find(params[:id])
       request.cancel!(actor: hr_current_user)
-      redirect_to regularization_requests_path, notice: "Ticket cancelled."
+      redirect_to regularization_requests_path, notice: "Day fix cancelled."
     rescue ActiveRecord::RecordInvalid
-      redirect_to regularization_requests_path, alert: "Only pending tickets can be cancelled."
+      redirect_to regularization_requests_path, alert: "Only pending day fixes can be cancelled."
     end
 
     private
 
     def create_notice
       rule = HrLite.config.self_regularization
-      return "Ticket raised — an admin will review it." unless rule
+      return "Sent for approval — your manager or HR will review it." unless rule
       return "Fixed. #{helpers.pluralize(@request.self_fixes_left, 'self-fix')} left this week." if @request.approved?
 
-      "Sent to HR as a ticket — you can fix only a missed punch or short day on a working day in the last #{rule[:within_days]} days yourself, " \
+      "Sent for approval — you can fix only a missed punch or short day on a working day in the last #{rule[:within_days]} days yourself, " \
         "#{rule[:per_week]} times a week."
     end
 

data/app/controllers/hr_lite/tax_declarations_controller.rb

@@ -28,10 +28,11 @@ module HrLite
                      TaxDeclaration.new(user_id: hr_current_user.id,
                                         financial_year: financial_year, regime: employee_regime)
       # A verified declaration is what payroll is deducting against; changing
-      # it would silently re-open a decision HR has already made.
-      if @declaration.verified?
+      # it would silently re-open a decision HR has already made. A submitted
+      # one is what HR is checking, so it cannot shift under them either.
+      if @declaration.verified? || @declaration.submitted?
         return redirect_to tax_declaration_path,
-                           alert: "This year's declaration is verified. Ask HR to reopen it."
+                           alert: "This year's declaration is #{@declaration.status}. Ask HR to reopen it."
       end
 
       if @declaration.update(declaration_params)
@@ -59,10 +60,13 @@ module HrLite
 
     private
 
+    # This year or last (late proof); any other year falls back to this one.
     def financial_year
-      FinancialYear.start_for(params[:financial_year].present? ? Date.parse(params[:financial_year]) : Date.current)
+      current = FinancialYear.start_for(Date.current)
+      asked = FinancialYear.start_for(Date.parse(params[:financial_year].to_s))
+      asked.between?(current.prev_year, current) ? asked : current
     rescue Date::Error
-      FinancialYear.start_for(Date.current)
+      current
     end
 
     def current_declaration

data/app/helpers/hr_lite/application_helper.rb

@@ -41,14 +41,16 @@ module HrLite
           queue: -> { hrl_queue(HrLite::LeaveRequest.where(status: "pending"), "leave.approve") } },
         { label: "Comp-off", path: :admin_comp_off_requests_path, match: [ "/admin/comp_off_requests" ], if: OPS,
           queue: -> { hrl_queue(HrLite::CompOffRequest.pending, "leave.approve") } },
-        { label: "Attendance fixes", path: :admin_regularization_requests_path, match: [ "/admin/regularization_requests" ], if: OPS,
+        { label: "Day fixes", path: :admin_regularization_requests_path, match: [ "/admin/regularization_requests" ], if: OPS,
           queue: -> { hrl_queue(HrLite::RegularizationRequest.pending, "attendance.manage") } },
         { label: "WFH", path: :admin_wfh_requests_path, match: [ "/admin/wfh_requests" ], if: OPS,
-          queue: -> { hrl_queue(HrLite::WfhRequest.pending, "attendance.manage") } },
+          queue: -> { hrl_queue(HrLite::WfhRequest.pending.overlapping(Date.current, Date.current + HrLite::WfhRequest::MAX_DAYS_AHEAD), "attendance.manage") } },
         { label: "Home locations", path: :admin_work_locations_path, match: [ "/admin/work_locations" ], if: OPS,
           queue: -> { hrl_queue(HrLite::WorkLocation.pending, "attendance.manage") } },
         { label: "Claims", path: :admin_expenses_path, match: [ "/admin/expenses" ], if: -> { hr_can?("expense.approve", scope: :team) },
           queue: -> { hrl_queue(HrLite::Expense.where(status: "submitted"), "expense.approve") } },
+        { label: "Resignations", path: :admin_employees_path, match: [ "/admin/resignations" ], if: LEAD,
+          queue: -> { hrl_queue(HrLite::Resignation.pending, "profile.manage") } },
         { label: "Documents to verify", path: :admin_documents_path, match: [ "/admin/documents" ], if: LEAD,
           queue: -> { hrl_queue(HrLite::Document.where(verification: "pending"), "document.view") } },
         { label: "CA review", path: :admin_ca_reviews_path, match: [ "/admin/ca_reviews" ],
@@ -69,11 +71,11 @@ module HrLite
         { label: "Team benefits", path: :admin_benefits_path, match: [ "/admin/benefits" ], if: MANAGE }
       ] },
       { label: "People", match: [ "/people" ], tabs: [
-        { label: "My team", path: :team_path, match: [ "/team" ] },
+        { label: "Team board", path: :team_path, match: [ "/team" ] },
         { label: "Org chart", path: :org_path, match: [ "/org" ] },
         { label: "Kudos", path: :kudos_path, match: [ "/kudos" ] },
         { label: "Employees", path: :admin_employees_path, match: [ "/admin/employees" ], if: LEAD },
-        { label: "Joining & exits", path: :admin_checklists_path, match: [ "/admin/checklists" ], if: MANAGE },
+        { label: "Joining & exits", path: :admin_checklists_path, match: [ "/admin/checklists" ], if: -> { hr_can?("checklist.manage", scope: :all) } },
         { label: "Awards", path: :admin_awards_path, match: [ "/admin/awards" ], if: LEAD },
         { label: "PIPs", path: :admin_performance_plans_path, match: [ "/admin/performance_plans" ], if: SUPER }
       ] },
@@ -87,15 +89,16 @@ module HrLite
       { label: "Help", tabs: [
         { label: "Policies", path: :policies_path, match: [ "/policies" ], if: -> { hr_can?("policy.view", scope: :all) } },
         { label: "Ask HR", path: :hr_requests_path, match: [ "/hr_requests" ], if: -> { hr_can?("hr_request.raise") } },
-        { label: "Help desk", path: :admin_hr_requests_path, match: [ "/admin/hr_requests" ], if: MANAGE },
+        { label: "Help desk", path: :admin_hr_requests_path, match: [ "/admin/hr_requests" ], if: -> { hr_can?("hr_request.manage", scope: :all) } },
         { label: "Manage policies", path: :admin_policies_path, match: [ "/admin/policies" ], if: -> { hr_can?("policy.manage", scope: :all) } }
       ] },
       { label: "Admin", divider: true, tabs: [
-        { label: "Settings", path: :admin_leave_types_path, match: [ "/admin/leave_types", "/admin/office_locations", "/admin/holidays", "/admin/setting", "/admin/expense_categories" ], if: LEAD },
+        { label: "Settings", path: :admin_leave_types_path, match: [ "/admin/leave_types", "/admin/office_locations", "/admin/holidays", "/admin/expense_categories" ], if: LEAD },
+        { label: "HR settings", path: :edit_admin_setting_path, match: [ "/admin/setting" ], if: LEAD },
         { label: "Roles", path: :admin_roles_path, match: [ "/admin/roles" ], if: -> { hr_can?("role.manage", scope: :all) } },
         { label: "Statutory rates", path: :admin_statutory_rate_cards_path, match: [ "/admin/statutory_rate_cards" ], if: SUPER },
         { label: "Reports", path: :admin_reports_path, match: [ "/admin/reports" ], if: -> { hr_can?("expense.approve", scope: :all) || %w[leave.view attendance.view profile.view].any? { |key| hr_can?(key, scope: :team) } } },
-        { label: "Assets", path: :admin_assets_path, match: [ "/admin/assets" ], if: MANAGE },
+        { label: "Assets", path: :admin_assets_path, match: [ "/admin/assets" ], if: -> { hr_can?("asset.manage", scope: :all) } },
         { label: "Audit trail", path: :admin_audit_logs_path, match: [ "/admin/audit_logs" ], if: LEAD }
       ] }
     ].freeze
@@ -151,6 +154,28 @@ module HrLite
     # What a queue page lets this viewer decide: their reach, never their own requests.
     def hrl_queue(relation, key) = hr_access.scope_relation(relation, key).where.not(user_id: hr_current_user.id)
 
+    # The Inbox badge's number; Home and the overview board show the same one.
+    def hrl_inbox_count
+      inbox = hrl_sections.find { |s| s[:label] == "Inbox" }
+      inbox ? hrl_waiting(inbox).to_i : 0
+    end
+
+    # One queued request in words, and where it is decided.
+    def hrl_inbox_item(tab, record)
+      case record
+      when HrLite::LeaveRequest
+        [ "#{record.leave_type.name}, #{record.date_range_label} · #{pluralize(hrl_days(record.days_count), 'day')}", hr_lite.admin_leave_request_path(record) ]
+      when HrLite::CompOffRequest then [ "Comp-off for #{record.date_worked.strftime('%a %-d %b')}", hr_lite.admin_comp_off_request_path(record) ]
+      when HrLite::RegularizationRequest then [ "Day fix, #{record.date.strftime('%a %-d %b')}", hr_lite.admin_regularization_request_path(record) ]
+      when HrLite::WfhRequest then [ "WFH, #{record.dates_label}", hr_lite.admin_wfh_request_path(record) ]
+      when HrLite::Expense then [ "Claim: #{record.category.name}, #{hrl_money(record.amount)}, #{record.spent_on.strftime('%a %-d %b')}", hr_lite.admin_expenses_path ]
+      when HrLite::Resignation
+        profile = HrLite::EmployeeProfile.find_by(user_id: record.user_id)
+        [ "Resignation, last day #{record.proposed_last_day.strftime('%-d %b %Y')}", profile ? hr_lite.admin_employee_path(profile) : hr_lite.admin_employees_path ]
+      else [ tab[:label], hr_lite.public_send(tab[:path]) ]
+      end
+    end
+
     # Everything waiting in this viewer's queues, oldest first, as [tab, record].
     def hrl_inbox_rows(limit = 50)
       inbox = hrl_sections.find { |s| s[:label] == "Inbox" } or return []
@@ -281,8 +306,8 @@ module HrLite
     # Status pill for a request lifecycle string — one colour map for every
     # list and show screen.
     def hrl_request_status_badge(status)
-      css = { "approved" => "hrl-badge--ok", "rejected" => "hrl-badge--bad",
-              "cancelled" => "hrl-badge--muted" }[status]
+      css = { "approved" => "hrl-badge--ok", "reimbursed" => "hrl-badge--ok", "verified" => "hrl-badge--ok",
+              "rejected" => "hrl-badge--bad", "cancelled" => "hrl-badge--muted", "draft" => "hrl-badge--muted" }[status]
       content_tag(:span, status.humanize, class: "hrl-badge #{css}")
     end
 

data/app/jobs/hr_lite/attendance_close_job.rb

@@ -58,7 +58,7 @@ module HrLite
         "Fix it yourself by #{(date + rule[:within_days]).strftime('%d %b')} (up to #{rule[:per_week]} a week), " \
           "or raise a ticket for HR."
       else
-        "Raise a regularization ticket to get it fixed."
+        "Use Fix a day to get it fixed."
       end
       Notifications.publish(event, title: title, body: body, path: "/regularization_requests/new?date=#{date.iso8601}",
                                    bell_to: [ user ], email_to: [ user ])

data/app/jobs/hr_lite/payroll_compute_job.rb

@@ -0,0 +1,12 @@
+module HrLite
+  # Compute off the request (PayrollRun#compute_later!). A failure restores
+  # the run's status and lands as a run warning instead of a 500.
+  class PayrollComputeJob < ApplicationJob
+    def perform(run, from, actor)
+      run.compute!(actor: actor, from: from)
+    rescue => e
+      Rails.error.report(e)
+      run.reload.update_columns(warnings: run.warnings | [ "Compute failed (#{e.message.truncate(150)}) — nothing changed; try again." ]) # rubocop:disable Rails/SkipsModelValidations
+    end
+  end
+end

data/app/models/concerns/hr_lite/audited.rb

@@ -8,6 +8,8 @@ module HrLite
 
     SKIPPED_ATTRIBUTES = %w[updated_at created_at].freeze
     REDACTED = "[changed]".freeze
+    # Personal text stored in the clear: the trail says it changed, never to what.
+    PII_COLUMNS = { "HrLite::EmployeeProfile" => %w[date_of_birth], "HrLite::HrRequest" => %w[subject body] }.freeze
 
     # *_commit, not *_create/_update/_destroy: these callbacks write an audit
     # row and email leadership a diff. Fired inside the transaction they
@@ -40,7 +42,7 @@ module HrLite
     end
 
     def hr_lite_audited_changes(action)
-      encrypted = self.class.try(:encrypted_attributes)&.map(&:to_s) || []
+      encrypted = (self.class.try(:encrypted_attributes)&.map(&:to_s) || []) + PII_COLUMNS.fetch(self.class.name, [])
 
       case action
       when "destroy"

data/app/models/concerns/hr_lite/encrypted_money.rb

@@ -8,6 +8,10 @@ module HrLite
   module EncryptedMoney
     extend ActiveSupport::Concern
 
+    included do
+      validate { @unreadable_money&.each { |attribute| errors.add(attribute, "is not a number") } }
+    end
+
     class_methods do
       def encrypted_money(*attributes)
         attributes.each do |attribute|
@@ -19,11 +23,10 @@ module HrLite
           end
 
           define_method("#{attribute}=") do |value|
-            if value.nil? || (value.respond_to?(:blank?) && value.blank?)
-              super(nil)
-            else
-              super(BigDecimal(value.to_s).round(2).to_s("F"))
-            end
+            digits = value.to_s.gsub(/[,₹\s]/, "") # "1,50,000" and "₹ 1200" are how people type money
+            super(digits.empty? ? nil : BigDecimal(digits).round(2).to_s("F"))
+          rescue ArgumentError
+            (@unreadable_money ||= []) << attribute
           end
         end
       end

data/app/models/hr_lite/attendance_record.rb

@@ -35,6 +35,7 @@ module HrLite
     validates :status, inclusion: { in: STATUSES }
     validates :half_day_part, inclusion: { in: %w[first second] }, allow_blank: true
     validate :check_out_after_check_in
+    validate :times_on_the_day, if: -> { will_save_change_to_date? || will_save_change_to_check_in_at? || will_save_change_to_check_out_at? }
 
     scope :for_date, ->(date) { where(date: date) }
     scope :for_month, ->(month) { where(date: month.beginning_of_month..month.end_of_month) }
@@ -57,9 +58,11 @@ module HrLite
       EmployeeProfile.day_minutes_for(user_id, on: date) unless HrLite.config.work_hours.nil? || date.saturday?
     end
 
-    # Hours worked, not the clock: an early start counts.
+    # Hours worked, not the clock: an early start counts. The day's penalty
+    # minutes count too, the same rule as required_check_out_at, so the card
+    # never says "day done" above "short by 20m".
     def short?
-      worked_under?(required_minutes)
+      worked_under?(required_minutes && required_minutes + penalty_minutes)
     end
 
     def below_half_day?
@@ -70,10 +73,11 @@ module HrLite
     def required_check_out_at
       return unless HrLite.config.attendance_slots && check_in_at
 
-      extra = AttendancePenalty.active.where(user_id: user_id, date: date).sum(:minutes)
-      check_in_at + (EmployeeProfile.day_minutes_for(user_id, on: date) + extra).minutes
+      check_in_at + (EmployeeProfile.day_minutes_for(user_id, on: date) + penalty_minutes).minutes
     end
 
+    def penalty_minutes = AttendancePenalty.active.where(user_id: user_id, date: date).sum(:minutes)
+
     def worked_under?(minutes) = !!(minutes && worked_duration && worked_duration < minutes.minutes)
 
     # Check in again after checking out: once a day, inside the hours HR sets in
@@ -115,5 +119,18 @@ module HrLite
 
       errors.add(:check_out_at, "must be after check-in")
     end
+
+    # No future days; check-out may run into the next morning (night shift).
+    # Only the fields being changed, in the company's zone, so re-saving an old row never fails.
+    def times_on_the_day
+      return unless date
+
+      day = ->(time) { time.in_time_zone(HrLite.config.time_zone).to_date }
+      errors.add(:date, "can't be in the future") if will_save_change_to_date? && date > day.(Time.current)
+      errors.add(:check_in_at, "must be on #{date.strftime('%d %b')}") if will_save_change_to_check_in_at? && check_in_at && day.(check_in_at) != date
+      if will_save_change_to_check_out_at? && check_out_at && !(date..date + 1).cover?(day.(check_out_at))
+        errors.add(:check_out_at, "must be on #{date.strftime('%d %b')} or the next morning")
+      end
+    end
   end
 end

data/app/models/hr_lite/comp_off_request.rb

@@ -50,6 +50,8 @@ module HrLite
         # (A duplicate live request for the same date cannot exist — the
         # partial unique index on [user_id, date_worked] guarantees it.)
         credit_balance!(type)
+        AuditLog.record!(action: "comp_off.approved", subject: self, actor: actor,
+                         changes: { "date_worked" => date_worked.to_s, "days" => credit_days.to_s("F") })
       end
 
       Notifications.publish(

data/app/models/hr_lite/document.rb

@@ -79,7 +79,7 @@ module HrLite
     def default_visibility_from_category
       return if visibility.present?
 
-      self.visibility = SENSITIVE_CATEGORIES.include?(category.to_s) ? "money" : "hr"
+      self.visibility = SENSITIVE_CATEGORIES.include?(category.to_s.downcase.strip) ? "money" : "hr"
     end
 
     def file_is_an_allowed_kind

data/app/models/hr_lite/expense.rb

@@ -39,6 +39,7 @@ module HrLite
     end
 
     def approve!(actor:, note: nil)
+      raise ActiveRecord::RecordInvalid.new(self), "not submitted" unless submitted?
       return record_routed!(actor, note, :approved) if awaiting?(actor)
 
       settle!("approved", actor, note)
@@ -46,6 +47,7 @@ module HrLite
 
     def reject!(actor:, note:)
       raise ArgumentError, "a rejection needs a reason" if note.blank?
+      raise ActiveRecord::RecordInvalid.new(self), "not submitted" unless submitted?
       return record_routed!(actor, note, :rejected) if awaiting?(actor)
 
       settle!("rejected", actor, note)
@@ -90,6 +92,7 @@ module HrLite
 
     def settle!(new_status, actor, note)
       update!(status: new_status, decision_note: note.presence)
+      approval_route.cancel_all! # decided outside the flow: nobody is left waiting to be asked
       Notifications.publish(
         new_status == "approved" ? "expense.approved" : "expense.rejected",
         title: "Your #{category.name} claim was #{new_status}",

data/app/models/hr_lite/hr_request.rb

@@ -30,6 +30,7 @@ module HrLite
     def category_label = self.class.category_label(category)
 
     def assign!(actor:, assignee:)
+      raise ActiveRecord::RecordInvalid.new(self), "already settled" unless open? || in_progress?
       update!(assigned_to_id: assignee.id, status: "in_progress")
       Notifications.publish(
         "hr_request.assigned",
@@ -41,6 +42,7 @@ module HrLite
     end
 
     def resolve!(actor:, resolution:)
+      raise ActiveRecord::RecordInvalid.new(self), "already settled" unless open? || in_progress?
       raise ArgumentError, "a resolution needs an answer" if resolution.blank?
 
       update!(status: "resolved", resolution: resolution, resolved_at: Time.current,

data/app/models/hr_lite/kudo.rb

@@ -33,10 +33,10 @@ module HrLite
       BADGES[badge]
     end
 
-    # Creates mention rows from the message markers (existing users only,
+    # Creates mention rows from the message markers (employees only,
     # giver excluded) and notifies them. Called once, right after create.
     def register_mentions!
-      ids = HrLite::MentionParser.user_ids(message) - [ giver_id ]
+      ids = (HrLite::MentionParser.user_ids(message) - [ giver_id ]) & HrLite.employees.map(&:id)
       users = HrLite.user_klass.where(id: ids)
       users.each { |u| kudo_mentions.create!(user_id: u.id) }
 

data/app/models/hr_lite/leave_request.rb

@@ -5,12 +5,15 @@ module HrLite
     STATUSES = %w[pending approved rejected cancelled].freeze
 
     belongs_to :user, class_name: HrLite.config.user_class
-    belongs_to :leave_type
+    belongs_to :leave_type, optional: true # required below, in words ("must exist" is fixed)
     belongs_to :decided_by, class_name: HrLite.config.user_class, optional: true
     # Set when HR records leave the employee forgot to apply for.
     belongs_to :created_by, class_name: HrLite.config.user_class, optional: true
 
-    validates :start_date, :end_date, presence: true
+    validates :leave_type, presence: { message: "is missing — pick one" }
+    validates :start_date, presence: { message: "is missing — pick the first day" }
+    # With no start the start error says it all (a blank end means one day).
+    validates :end_date, presence: { message: "is missing — pick the last day" }, if: :start_date
     validates :status, inclusion: { in: STATUSES }
     validates :half_day_part, inclusion: { in: %w[first second] }, allow_blank: true
 
@@ -50,7 +53,10 @@ module HrLite
       return 0 if leave_type.unlimited?
       return paid_days ? LeaveDayCounter.count(self) - paid_days : 0 if approved?
 
-      [ LeaveDayCounter.count(self) - covered_by(balance.available(as_of: start_date)), 0 ].max
+      # Pending requests of this type and leave year filed first draw on the same balance (warning only).
+      queued = self.class.pending.where(user_id: user_id, leave_type_id: leave_type_id, id: ...id,
+                                        start_date: LeaveYear.range(LeaveYear.key_for(start_date))).sum(:days_count)
+      [ LeaveDayCounter.count(self) - covered_by(balance.available(as_of: start_date) - queued), 0 ].max
     end
 
     # Unpaid share (0, 0.5 or 1) of `date`: the balance covered the leave's
@@ -113,6 +119,7 @@ module HrLite
         # And nobody should still be asked to decide a request that has been
         # called off — it would sit in their inbox for ever.
         approval_route.cancel_all!
+        flag_computed_runs! if was_approved
       end
 
       Notifications.publish(
@@ -229,6 +236,15 @@ module HrLite
         self.decision_note = note
         save!
         audit!(new_status, actor, note)
+        approval_route.cancel_all! # decided outside the flow too: nobody else is still asked
+        flag_computed_runs! if approved?
+      end
+    end
+
+    # A slip computed before this still pays the old days; a recompute clears the note.
+    def flag_computed_runs!
+      PayrollRun.where(status: "review", period_month: start_date.beginning_of_month..end_date).find_each do |run|
+        run.update!(warnings: run.warnings + [ "#{HrLite.display_name(user)}'s leave (#{date_range_label}) changed after compute — recompute" ])
       end
     end
 
@@ -270,8 +286,8 @@ module HrLite
 
     # Everyone should know a colleague will be away, the moment they apply —
     # bell + email to the whole team (matrix row "leave.team_notice"; hosts can mute either
-    # channel). Deliberately excludes the reason: dates are team-relevant,
-    # the why is not.
+    # channel). Deliberately excludes the reason and the type: dates are
+    # team-relevant, the why is not.
     def notify_team
       return if end_date < Date.current # nobody needs to hear who was out
 
@@ -280,7 +296,7 @@ module HrLite
 
       Notifications.publish(
         "leave.team_notice",
-        title: "#{HrLite.display_name(user)} is on leave — #{leave_type.name} (#{date_range_label})",
+        title: "#{HrLite.display_name(user)} is on leave (#{date_range_label})",
         path: "/team",
         bell_to: team,
         email_to: team
@@ -336,6 +352,9 @@ module HrLite
       clash = self.class.where(user_id: user_id, status: %w[pending approved])
                   .where.not(id: id)
                   .overlapping_range(start_date, end_date)
+      # A first half and a second half of the same day do not overlap.
+      opposite = { "first" => "second", "second" => "first" }[half_day_part]
+      clash = clash.where.not(half_day_part: opposite).or(clash.where(half_day_part: nil)) if opposite
       errors.add(:base, "Leave already overlaps these dates") if clash.exists?
     end
 

data/app/models/hr_lite/payroll_line_item.rb

@@ -20,6 +20,9 @@ module HrLite
     validate :period_is_not_already_paid, on: :create
     # Removing a line from a paid month rewrites a settled payslip just the same.
     before_destroy { throw :abort if paid_month? }
+    # A run already computed for the month still shows the old pay.
+    after_create { flag_stale_run("added") }
+    after_destroy { flag_stale_run("removed") }
 
     scope :for_month, ->(month) { where(period_month: month) }
 
@@ -55,5 +58,10 @@ module HrLite
     end
 
     def paid_month? = SalarySlip.settled.exists?(user_id: user_id, period_month: period_month)
+
+    def flag_stale_run(verb)
+      run = PayrollRun.find_by(period_month: period_month, status: "review")
+      run&.update!(warnings: run.warnings + [ "#{HrLite.display_name(user)}'s #{component.label} was #{verb} after compute — recompute" ])
+    end
   end
 end

data/app/models/hr_lite/payroll_run.rb

@@ -1,7 +1,7 @@
 module HrLite
   # Monthly run lifecycle: draft -> processing -> review -> finalized ->
-  # published (terminal). Compute is synchronous (pure-Ruby math over a
-  # small team; the seam for a background job is one perform_later away).
+  # published (terminal). The page computes through PayrollComputeJob
+  # (compute_later!); compute! itself is synchronous.
   class PayrollRun < ApplicationRecord
     STATUSES = %w[draft processing review finalized published].freeze
 
@@ -12,8 +12,9 @@ module HrLite
     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/
+    # someone missing, a state levying ₹0, last year's / unverified rates, or
+    # a change after compute ("… after compute — recompute") the slips lack.
+    BLOCKING_WARNING = /\ANo (salary structure|professional-tax slabs)|statutory card|after compute/
 
     validates :period_month, presence: true, uniqueness: true
     validates :status, inclusion: { in: STATUSES }
@@ -37,9 +38,9 @@ module HrLite
     # `processing` is allowed back in so a run stranded there by a killed
     # process (deploy roll, timeout) can be recomputed instead of blocking
     # that month forever.
-    def compute!(actor:)
+    def compute!(actor:, from: status)
       raise_unless %w[draft review processing]
-      previous = status
+      previous = from
 
       begin
         update!(status: "processing")
@@ -61,6 +62,14 @@ module HrLite
       end
     end
 
+    # ~1.2k queries at 54 people: the request only flips the run to processing.
+    def compute_later!(actor:)
+      raise_unless %w[draft review processing]
+      from = status
+      update!(status: "processing")
+      PayrollComputeJob.perform_later(self, from, actor)
+    end
+
     def finalize!(actor:)
       raise_unless %w[review]
       raise ActiveRecord::RecordInvalid.new(self), "no slips" if salary_slips.none?