hr_lite 0.2.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5b975162e55e723ed0bd24a9e032eba889d18e89c106ce55fc051a8566ce41e0
-  data.tar.gz: 2a0bd3e239011f037e300f26f3e8d18e3fb9a4fe7ca17b1317e70d3318a93844
+  metadata.gz: 7d95fb8f07ae1876be368009a6d539b30938e7635d95abcbe9e1bbd404e57d0c
+  data.tar.gz: a3f31cbd6ca7936381ce13f3baf2c4ba6532431f5066867345a1c6e4c30a69b0
 SHA512:
-  metadata.gz: 2405b7818d6a8028375fb614ec0d187faf01088996e8d0754b3e7882ebc4adb2846cd4bf026de0aba86504c63264a8cdbbaaad740b610ce12661718581b45e04
-  data.tar.gz: 632fc1794614fa739375e0fe1a4c8b55195f9a51e7b4d5d74f65eadafc157f14b8e391eb7846c84a299634f1fd1e6f5abe64e5b18c253fa0ad276ce495da2c43
+  metadata.gz: 8efffc3c3f5468f3e15c7118ce0f50248e74a1e0b359a009022b9c40376c5b41c755c4cb350fbd68a6d90d734acfa23989f790c0143f2f815440983c52425488
+  data.tar.gz: b020fd0ca4df79fba65e8efdc7a99da0c6979ec050405b7b9b1fe63091d62cd421725815f46f03da450edf82635336eb7ac8814ce35807f2369252bb18631bd8

data/CHANGELOG.md

@@ -7,6 +7,102 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.4.0] - 2026-07-19
+
+### Added
+
+- **Org chart (`/org`)**: everyone-visible reporting tree (who reports to
+  whom, names + designations + departments only — never salary or private
+  data) plus each viewer's own reporting line labelled L1/L2/... Managers
+  are set per employee by leadership ("Reports to"); reporting loops are
+  rejected.
+- **Configurable leave year** (`config.leave_year_start_month`, default 1):
+  set 7 for a July–June leave year. Balances, accrual, the year-boundary
+  split rule, carry-forward rollover and comp-off credits all follow it.
+  Balance headings show "2026–27"-style labels for non-calendar years.
+- **Joining-date proration, Keka-style**: entitlement accrues only from
+  the month someone joins (joined on/before the 15th → that month counts;
+  after → from the next month). Applies to monthly accrual AND
+  yearly-upfront grants (upfront = remaining months × monthly rate).
+
+### Changed
+
+- `LeaveBalance#year` is now a LeaveYear key; `LeaveYearRolloverJob`
+  defaults to the current leave year in the configured HR time zone
+  (schedule it on the leave year's first day). The request-split
+  validation message says "leave-year boundary".
+
+### Upgrade notes
+
+- **Set `leave_year_start_month` once, at install time.** Balance rows
+  are keyed by leave year with no stored epoch — changing the start
+  month on an install with existing balances silently reinterprets
+  every row (carry, adjustments, comp-off credits) and miskeys
+  historical requests. The setter validates 1..12 and accepts "7".
+- **Joining-date proration applies to existing data.** Employees who
+  joined partway through the CURRENT year previously showed the full
+  year's accrual; from 0.4.0 they accrue only from their joining month,
+  so their entitlement can drop (and, if they already used more, go
+  negative). Where the old number was intended, add a one-off balance
+  adjustment with a note.
+
+## [0.3.0] - 2026-07-19
+
+### Added
+
+- **Comp-off requests**: employees request a credit for working a weekend
+  or holiday; admin approval credits the comp-off leave type's balance
+  (mark the type under Settings — seeds flag `CO`). New events
+  `comp_off.requested/approved/rejected/cancelled`.
+- **Regularization tickets**: forgot to punch? Employees propose the actual
+  times with a reason; admin approval writes them onto the day's attendance
+  record with the full regularization trail. New events
+  `regularization.requested/approved/rejected/cancelled`.
+- **Team board (`/team`)**: everyone-visible who's-in/who's-out for any
+  date — punch times, leave badges, hours worked that day and that month.
+- **Team leave notices**: approving a leave now bells + emails the whole
+  team ("X is on leave …", matrix row `leave.team_notice`; reasons are
+  never broadcast).
+- Approvals screens grew Leaves / Comp-off / Regularization tabs with
+  pending counts.
+
+### Fixed
+
+- Checkboxes rendered 100%-wide with misplaced labels (the bare
+  `input[type]` width rule out-ranked `.hrl-field--check`); checkbox rows
+  now size naturally and pick up the accent colour.
+- Hardening from adversarial review: comp-off credits land in the year
+  they can be spent (a December Sunday approved in January no longer
+  strands the credit on last year's balance); the balance increment locks
+  the balance row (no lost update when two admins approve concurrently);
+  a partial unique index guarantees one live comp-off request per person
+  per date; approval re-checks the calendar (StaleOffDay) after holiday
+  edits; regularization approval refuses merges that would corrupt the
+  record (checkout with no check-in, checkout before the genuine
+  check-in) with the real reason surfaced to the admin, keeps GPS flags,
+  and writes an AuditLog row like the manual fix path; tickets cannot
+  target a day covered by approved leave; only one leave type can carry
+  the comp-off flag; team notices skip exited staff; a host
+  notification-matrix override pinned on an older version no longer
+  silently drops events it doesn't know (defaults merge underneath).
+
+### Changed
+
+- `Seeds.run!` no longer re-flags CO as comp-off on every deploy (an
+  operator disabling comp-off stays disabled); pre-0.3.0 installs run
+  `Seeds.seed_comp_off_flag!` once or tick the box under Settings.
+
+## [0.2.2] - 2026-07-19
+
+### Fixed
+
+- Link-styled controls were unreadable: the global `.hrl-body a` colour
+  rule out-ranked component classes, so primary action links ("New
+  structure", "New run", "Add office", "Apply", "Download PDF", active
+  filter chips) rendered accent-on-accent with invisible text, and the
+  side-nav links lost their muted colour. The rule is now wrapped in
+  `:where()` (zero specificity) so every `.hrl-*` component wins.
+
 ## [0.2.1] - 2026-07-19
 
 ### Added

data/README.md

@@ -5,7 +5,8 @@
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](MIT-LICENSE)
 
 A lightweight, self-contained HRMS engine for Rails — attendance with
-geolocation, leave management, holiday calendar, full Indian payroll
+geolocation, leave management with comp-off requests, regularization tickets,
+an everyone-visible team board, holiday calendar, full Indian payroll
 (PF/ESI/PT/TDS) with salary-slip PDFs, kudos with @mentions, appraisals and
 promotions. Think Keka-lite, mounted inside your existing app in a few lines.
 

data/app/assets/stylesheets/hr_lite/hr_lite.css

@@ -32,7 +32,10 @@
   -webkit-font-smoothing: antialiased;
   overflow-x: hidden;
 }
-.hrl-body a { color: var(--hrl-accent); text-decoration: none; }
+/* :where() keeps this at zero specificity so any component class
+   (.hrl-btn--primary, .hrl-nav__link, ...) can set its own link colour —
+   a plain `.hrl-body a` would out-rank them and paint accent-on-accent. */
+:where(.hrl-body) a { color: var(--hrl-accent); text-decoration: none; }
 .hrl-shell { display: flex; min-height: 100vh; }
 .hrl-content { flex: 1; min-width: 0; }
 .hrl-main {
@@ -170,20 +173,30 @@
   .hrl-table--stack td { display: flex; justify-content: space-between; gap: .8rem; border-bottom: 1px dashed var(--hrl-line); }
   .hrl-table--stack td::before { content: attr(data-label); color: var(--hrl-muted); font-size: .78rem; }
   .hrl-table--stack td.hrl-num { text-align: left; }
+  .hrl-table--stack td.hrl-cell--void { display: none; }
 }
 
 /* Forms */
 .hrl-field { margin-bottom: .8rem; }
 .hrl-field label { display: block; font-size: .82rem; font-weight: 600; margin-bottom: .3rem; }
 .hrl-field .hrl-hint { color: var(--hrl-muted); font-size: .76rem; margin-top: .25rem; }
-.hrl-input, .hrl-field input[type], .hrl-field select, .hrl-field textarea {
+/* Full-width text-ish controls only — checkboxes/radios/hidden must keep
+   their natural size (a bare [type] selector out-ranked .hrl-field--check
+   and blew checkboxes up to 100% width). */
+.hrl-input,
+.hrl-field input[type]:not([type="checkbox"]):not([type="radio"]):not([type="hidden"]),
+.hrl-field select, .hrl-field textarea {
   width: 100%; min-height: 44px; padding: .55rem .7rem; font: inherit;
   border: 1px solid var(--hrl-line); border-radius: var(--hrl-radius-sm);
   background: var(--hrl-card); color: var(--hrl-ink);
 }
 .hrl-field textarea { min-height: 90px; resize: vertical; }
-.hrl-field--check { display: flex; align-items: center; gap: .5rem; }
-.hrl-field--check input { width: 1.15rem; height: 1.15rem; min-height: 0; }
+.hrl-field--check { display: flex; align-items: center; gap: .55rem; min-height: 44px; }
+.hrl-field--check input {
+  width: 1.15rem; height: 1.15rem; min-height: 0; flex: 0 0 auto;
+  accent-color: var(--hrl-accent);
+}
+.hrl-field--check label { margin-bottom: 0; font-weight: 600; }
 .hrl-errors { background: var(--hrl-bad-bg); color: var(--hrl-bad); border-radius: var(--hrl-radius-sm); padding: .7rem .9rem; margin-bottom: .85rem; font-size: .86rem; }
 .hrl-errors ul { margin: .3rem 0 0; padding-left: 1.1rem; }
 .hrl-form-actions { display: flex; gap: .6rem; margin-top: 1rem; }
@@ -228,6 +241,24 @@
 .hrl-pager { display: flex; align-items: center; justify-content: center; gap: .8rem; margin: 1rem 0; font-size: .88rem; }
 .hrl-pager__info { color: var(--hrl-muted); }
 
+/* Org chart tree + reporting-line chain */
+.hrl-tree { list-style: none; margin: 0; padding-left: 0; }
+.hrl-tree .hrl-tree { padding-left: 1.1rem; border-left: 2px solid var(--hrl-line); margin-left: .55rem; }
+.hrl-tree__node { margin: .3rem 0; }
+.hrl-tree__card {
+  display: inline-flex; flex-wrap: wrap; align-items: baseline; gap: .45rem;
+  background: var(--hrl-bg); border: 1px solid var(--hrl-line);
+  border-radius: var(--hrl-radius-sm); padding: .4rem .7rem; max-width: 100%;
+}
+.hrl-tree__card--me { border-color: var(--hrl-accent); background: var(--hrl-info-bg); }
+.hrl-tree__name, .hrl-tree__role { min-width: 0; overflow-wrap: anywhere; }
+.hrl-tree__name { font-weight: 650; font-size: .9rem; }
+.hrl-tree__role { color: var(--hrl-muted); font-size: .8rem; }
+.hrl-chainrow { display: flex; flex-wrap: wrap; align-items: center; gap: .4rem; }
+.hrl-chainrow__step { display: inline-flex; align-items: center; gap: .4rem; min-width: 0; }
+.hrl-chainrow .hrl-badge { white-space: normal; overflow-wrap: anywhere; }
+.hrl-chainrow__arrow { color: var(--hrl-muted); }
+
 /* Definition list */
 .hrl-deflist { display: grid; grid-template-columns: minmax(7rem, auto) 1fr; gap: .35rem .9rem; font-size: .9rem; }
 .hrl-deflist dt { color: var(--hrl-muted); }

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

@@ -0,0 +1,38 @@
+module HrLite
+  module Admin
+    class CompOffRequestsController < BaseController
+      def index
+        @status = params[:status].presence_in(CompOffRequest::STATUSES) || "pending"
+        @requests = paginate(CompOffRequest.includes(:user).where(status: @status).recent_first)
+      end
+
+      def show
+        @request = CompOffRequest.find(params[:id])
+      end
+
+      def approve
+        request = CompOffRequest.find(params[:id])
+        request.approve!(actor: hr_current_user, note: params[:decision_note].presence)
+        redirect_to admin_comp_off_requests_path,
+                    notice: "Approved — #{request.credit_days.to_f} day credited."
+      rescue CompOffRequest::MissingCompOffType, CompOffRequest::StaleOffDay => e
+        redirect_to admin_comp_off_request_path(request), alert: e.message
+      rescue ActiveRecord::RecordInvalid
+        redirect_to admin_comp_off_request_path(request), alert: "Only pending requests can be decided."
+      end
+
+      def reject
+        request = CompOffRequest.find(params[:id])
+        note = params[:decision_note].to_s.strip
+        if note.blank?
+          return redirect_to admin_comp_off_request_path(request), alert: "A note is required to reject."
+        end
+
+        request.reject!(actor: hr_current_user, note: note)
+        redirect_to admin_comp_off_requests_path, notice: "Request rejected."
+      rescue ActiveRecord::RecordInvalid
+        redirect_to admin_comp_off_request_path(request), alert: "Only pending requests can be decided."
+      end
+    end
+  end
+end

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

@@ -93,7 +93,7 @@ module HrLite
 
       def profile_params
         params.require(:employee_profile).permit(
-          :user_id, :employee_code, :designation, :date_of_birth, :date_of_joining,
+          :user_id, :manager_id, :employee_code, :designation, :date_of_birth, :date_of_joining,
           :date_of_exit, :department, :work_location, :pan_number, :pf_uan, :esi_number,
           :bank_account_number, :bank_ifsc, :bank_name, :tax_regime, :declared_annual_deductions
         )

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

@@ -3,7 +3,7 @@ module HrLite
     class LeaveBalancesController < BaseController
       def index
         year = params[:year].to_i
-        @year = year.between?(2000, 2100) ? year : Date.current.year
+        @year = year.between?(2000, 2100) ? year : LeaveYear.current_key
         @types = LeaveType.active.where(paid: true).where.not(annual_quota: nil)
         @employees = HrLite.employees
       end

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

@@ -46,7 +46,7 @@ module HrLite
 
       def leave_type_params
         params.require(:leave_type)
-              .permit(:name, :code, :color, :paid, :annual_quota, :accrual,
+              .permit(:name, :code, :color, :paid, :comp_off, :annual_quota, :accrual,
                       :carry_forward_cap, :active, :position)
       end
     end

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

@@ -0,0 +1,38 @@
+module HrLite
+  module Admin
+    class RegularizationRequestsController < BaseController
+      def index
+        @status = params[:status].presence_in(RegularizationRequest::STATUSES) || "pending"
+        @requests = paginate(RegularizationRequest.includes(:user).where(status: @status).recent_first)
+      end
+
+      def show
+        @request = RegularizationRequest.find(params[:id])
+      end
+
+      def approve
+        request = RegularizationRequest.find(params[:id])
+        request.approve!(actor: hr_current_user, note: params[:decision_note].presence)
+        redirect_to admin_regularization_requests_path, notice: "Ticket approved — attendance fixed."
+      rescue RegularizationRequest::InvalidMerge => e
+        redirect_to admin_regularization_request_path(request),
+                    alert: "Cannot apply — #{e.message}. Fix the day manually or reject with a note."
+      rescue ActiveRecord::RecordInvalid
+        redirect_to admin_regularization_request_path(request), alert: "Only pending tickets can be decided."
+      end
+
+      def reject
+        request = RegularizationRequest.find(params[:id])
+        note = params[:decision_note].to_s.strip
+        if note.blank?
+          return redirect_to admin_regularization_request_path(request), alert: "A note is required to reject."
+        end
+
+        request.reject!(actor: hr_current_user, note: note)
+        redirect_to admin_regularization_requests_path, notice: "Ticket rejected."
+      rescue ActiveRecord::RecordInvalid
+        redirect_to admin_regularization_request_path(request), alert: "Only pending tickets can be decided."
+      end
+    end
+  end
+end

data/app/controllers/hr_lite/comp_off_requests_controller.rb

@@ -0,0 +1,46 @@
+module HrLite
+  # Employee-side comp-off: request a credit for working a weekend/holiday.
+  # Scoping to hr_current_user IS the authorization.
+  class CompOffRequestsController < ApplicationController
+    def index
+      @requests = paginate(CompOffRequest.where(user_id: hr_current_user.id).recent_first)
+      @comp_off_type = LeaveType.comp_off_type
+    end
+
+    def new
+      @request = CompOffRequest.new(date_worked: default_date)
+    end
+
+    def create
+      @request = CompOffRequest.new(request_params.merge(user_id: hr_current_user.id))
+      if @request.save
+        redirect_to comp_off_requests_path, notice: "Comp-off request sent for approval."
+      else
+        render :new, status: :unprocessable_entity
+      end
+    rescue ActiveRecord::RecordNotUnique
+      @request.errors.add(:date_worked, "already has a comp-off request")
+      render :new, status: :unprocessable_entity
+    end
+
+    def cancel
+      request = CompOffRequest.where(user_id: hr_current_user.id).find(params[:id])
+      request.cancel!(actor: hr_current_user)
+      redirect_to comp_off_requests_path, notice: "Request cancelled."
+    rescue ActiveRecord::RecordInvalid
+      redirect_to comp_off_requests_path, alert: "Only pending requests can be cancelled."
+    end
+
+    private
+
+    def request_params
+      params.require(:comp_off_request).permit(:date_worked, :half_day, :reason)
+    end
+
+    # Most recent non-working day — the day they most likely worked extra.
+    def default_date
+      calendar = WorkingCalendar.new((Date.current - 14)..Date.current)
+      (0..14).map { |i| Date.current - i }.find { |d| !calendar.working_day?(d) } || Date.current
+    end
+  end
+end

data/app/controllers/hr_lite/leave_balances_controller.rb

@@ -2,7 +2,7 @@ module HrLite
   class LeaveBalancesController < ApplicationController
     def index
       year = params[:year].to_i
-      @year = year.between?(2000, 2100) ? year : Date.current.year
+      @year = year.between?(2000, 2100) ? year : LeaveYear.current_key
       @balances = LeaveType.active.where(paid: true).where.not(annual_quota: nil).map do |type|
         LeaveBalance.for(hr_current_user, type, @year)
       end

data/app/controllers/hr_lite/leave_requests_controller.rb

@@ -43,7 +43,7 @@ module HrLite
     end
 
     def balance_cards
-      year = Date.current.year
+      year = LeaveYear.current_key
       LeaveType.active.where(paid: true).where.not(annual_quota: nil).map do |type|
         LeaveBalance.for(hr_current_user, type, year)
       end

data/app/controllers/hr_lite/org_controller.rb

@@ -0,0 +1,51 @@
+module HrLite
+  # The everyone-visible org chart: who reports to whom, plus the viewer's
+  # own reporting line labelled L1/L2/... Only names, designations and
+  # departments — never salary, identity numbers or any other private data.
+  class OrgController < ApplicationController
+    def show
+      profiles = EmployeeProfile.includes(:user)
+                                .where("date_of_exit IS NULL OR date_of_exit >= ?", Date.current)
+                                .to_a
+      @by_user = profiles.index_by(&:user_id)
+      build_tree(profiles)
+      @own_profile = @by_user[hr_current_user.id]
+      exited = EmployeeProfile.where(date_of_exit: ...Date.current).pluck(:user_id).to_set
+      @own_chain = (@own_profile&.reporting_chain || []).reject { |boss| exited.include?(boss.id) }
+    end
+
+    private
+
+    # BFS from the natural roots, then promote anything unreached (a
+    # manager cycle that slipped past validation must degrade to extra
+    # roots, not silently vanish). @tree_children only ever contains
+    # forward edges, so the recursive partial always terminates and every
+    # active profile renders exactly once.
+    def build_tree(profiles)
+      children = profiles.group_by(&:manager_id)
+      @roots = profiles.select { |p| p.manager_id.nil? || !@by_user.key?(p.manager_id) }
+                       .sort_by { |p| HrLite.display_name(p.user).downcase }
+      @tree_children = Hash.new { |hash, key| hash[key] = [] }
+      visited = {}
+      walk = lambda do |node|
+        (children[node.user_id] || []).each do |child|
+          next if visited[child.user_id]
+
+          visited[child.user_id] = true
+          @tree_children[node.user_id] << child
+          walk.call(child)
+        end
+      end
+      @roots.each { |root| visited[root.user_id] = true }
+      @roots.each { |root| walk.call(root) }
+
+      profiles.sort_by(&:id).each do |profile|
+        next if visited[profile.user_id]
+
+        visited[profile.user_id] = true
+        @roots << profile
+        walk.call(profile)
+      end
+    end
+  end
+end

data/app/controllers/hr_lite/regularization_requests_controller.rb

@@ -0,0 +1,36 @@
+module HrLite
+  # Employee-side regularization tickets: propose punch times for a day you
+  # forgot to check in/out. Scoping to hr_current_user IS the authorization.
+  class RegularizationRequestsController < ApplicationController
+    def index
+      @requests = paginate(RegularizationRequest.where(user_id: hr_current_user.id).recent_first)
+    end
+
+    def new
+      @request = RegularizationRequest.new(date: parse_date_param(params[:date]))
+    end
+
+    def create
+      @request = RegularizationRequest.new(request_params.merge(user_id: hr_current_user.id))
+      if @request.save
+        redirect_to regularization_requests_path, notice: "Ticket raised — an admin will review it."
+      else
+        render :new, status: :unprocessable_entity
+      end
+    end
+
+    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."
+    rescue ActiveRecord::RecordInvalid
+      redirect_to regularization_requests_path, alert: "Only pending tickets can be cancelled."
+    end
+
+    private
+
+    def request_params
+      params.require(:regularization_request).permit(:date, :check_in_at, :check_out_at, :reason)
+    end
+  end
+end

data/app/controllers/hr_lite/team_controller.rb

@@ -0,0 +1,11 @@
+module HrLite
+  # The everyone-visible team board: who's in, who's out, who's on leave,
+  # hours worked — for any date. Transparency by design; shows punch times
+  # and leave types only, never reasons or personal data.
+  class TeamController < ApplicationController
+    def show
+      @date = parse_date_param(params[:date])
+      @board = TeamDay.new(date: @date)
+    end
+  end
+end

data/app/helpers/hr_lite/application_helper.rb

@@ -2,9 +2,11 @@ module HrLite
   module ApplicationHelper
     NAV_ITEMS = [
       { label: "Home",       path: :root_path,           match: [ "/" ] },
-      { label: "Attendance", path: :attendance_path,     match: [ "/attendance" ] },
-      { label: "Leaves",     path: :leave_requests_path, match: [ "/leave_requests", "/leave_balances" ] },
+      { label: "Attendance", path: :attendance_path,     match: [ "/attendance", "/regularization_requests" ] },
+      { label: "Leaves",     path: :leave_requests_path, match: [ "/leave_requests", "/leave_balances", "/comp_off_requests" ] },
+      { label: "Team",       path: :team_path,           match: [ "/team" ] },
       { label: "Calendar",   path: :calendar_path,       match: [ "/calendar", "/holidays" ] },
+      { label: "Org",        path: :org_path,            match: [ "/org" ] },
       { label: "Kudos",      path: :kudos_path,          match: [ "/kudos" ] },
       { label: "Slips",      path: :salary_slips_path,   match: [ "/salary_slips" ] },
       { label: "Career",     path: :career_path,         match: [ "/career", "/appraisals", "/profile" ] }
@@ -13,7 +15,7 @@ module HrLite
     ADMIN_NAV_ITEMS = [
       { label: "Overview",        path: :admin_overview_path,        match: [ "/admin/overview" ] },
       { label: "Team attendance", path: :admin_attendances_path,     match: [ "/admin/attendances" ] },
-      { label: "Approvals",       path: :admin_leave_requests_path,  match: [ "/admin/leave_requests", "/admin/leave_balances" ] }
+      { label: "Approvals",       path: :admin_leave_requests_path,  match: [ "/admin/leave_requests", "/admin/leave_balances", "/admin/comp_off_requests", "/admin/regularization_requests" ] }
     ].freeze
 
     LEADERSHIP_NAV_ITEMS = [
@@ -85,5 +87,62 @@ module HrLite
     def hrl_amount_in_words(amount)
       HrLite::AmountInWords.words(amount)
     end
+
+    def hrl_duration(seconds)
+      return "\u2014" if seconds.nil?
+
+      total = seconds.to_i
+      format("%dh %02dm", total / 3600, (total % 3600) / 60)
+    end
+
+    # Status badge for a TeamDay row — punch times over vague labels.
+    def hrl_team_status(row)
+      case row.kind
+      when :holiday then hrl_status_badge("Holiday", "hrl-badge--muted", worked_hint(row))
+      when :weekend then hrl_status_badge("Weekend", "hrl-badge--muted", worked_hint(row))
+      when :leave then hrl_status_badge("On leave (#{row.leave.leave_type.code})", "hrl-badge--warn")
+      when :half_day_leave then hrl_status_badge("Half-day leave (#{row.leave.leave_type.code})", "hrl-badge--warn", worked_hint(row))
+      when :upcoming then hrl_status_badge("\u2014", "hrl-badge--muted")
+      when :absent
+        label = row.date_today? ? "Not in yet" : "Absent"
+        hrl_status_badge(label, "hrl-badge--bad")
+      else # :present / :half_day punch
+        record = row.record
+        if record.check_out_at
+          hrl_status_badge("Done #{record.check_in_at.strftime('%H:%M')}\u2013#{record.check_out_at.strftime('%H:%M')}", "hrl-badge--ok")
+        elsif row.date_today?
+          hrl_status_badge("In since #{record.check_in_at.strftime('%H:%M')}", "hrl-badge--ok")
+        else
+          hrl_status_badge("In #{record.check_in_at.strftime('%H:%M')}, no check-out", "hrl-badge--warn")
+        end
+      end
+    end
+
+    # 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]
+      content_tag(:span, status.humanize, class: "hrl-badge #{css}")
+    end
+
+    private
+
+    # Always ONE root node — these land inside stacked-table flex cells,
+    # where a second sibling would be flung to the far edge.
+    def hrl_status_badge(label, css, hint = nil)
+      badge = content_tag(:span, label, class: "hrl-badge #{css}")
+      return badge unless hint
+
+      content_tag(:span, safe_join([ badge, " ", content_tag(:span, hint, class: "hrl-small hrl-muted") ]))
+    end
+
+    # A punch on a holiday/weekend/half-day-leave is worth surfacing —
+    # that's exactly what comp-off requests point at.
+    def worked_hint(row)
+      return nil unless row.record&.check_in_at
+
+      "worked #{row.record.check_in_at.strftime('%H:%M')}#{row.record.check_out_at ? "\u2013#{row.record.check_out_at.strftime('%H:%M')}" : ""}"
+    end
   end
 end

data/app/jobs/hr_lite/leave_year_rollover_job.rb

@@ -1,13 +1,25 @@
 module HrLite
-  # Jan-1 rollover: materialize carry-forward into the new year's balance
-  # rows. Idempotent — a balance whose carry has already been written is
-  # never touched again (manual adjustments stay safe).
+  # Leave-year rollover (host schedules it on the leave year's first day —
+  # Jan 1 for calendar years, Jul 1 for July–June years): materialize
+  # carry-forward into the new year's balance rows. Idempotent — a balance
+  # whose carry has already been written is never touched again (manual
+  # adjustments stay safe).
   class LeaveYearRolloverJob < ActiveJob::Base
     queue_as :default
 
-    def perform(year: Date.current.year)
-      previous_year = year - 1
+    def perform(year: nil)
+      # Resolve "today" in the HR time zone — cron often fires around the
+      # boundary midnight, and the host process may run in UTC.
+      Time.use_zone(HrLite.config.time_zone) do
+        year ||= LeaveYear.current_key
+        previous_year = year - 1
+        roll(year, previous_year)
+      end
+    end
+
+    private
 
+    def roll(year, previous_year)
       LeaveType.active.where(paid: true).where.not(annual_quota: nil).find_each do |type|
         next unless type.carry_forward_cap.positive?
 
@@ -16,7 +28,7 @@ module HrLite
           next if balance.persisted? && balance.carried_forward.positive?
 
           carry = LeaveBalance.for(user, type, previous_year)
-                              .available(as_of: Date.new(previous_year, 12, 31))
+                              .available(as_of: LeaveYear.range(previous_year).last)
           carry = [ [ carry, type.carry_forward_cap ].min, 0 ].max
           next if carry.zero? && balance.persisted?