hr_lite 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a85f50e1151c664825892bd973f34842d1330e4878e39bb4984233880258c446
-  data.tar.gz: 95012fa0d0b7332e35e1fdef90ace239a95b415cbdc9d3101cb86fac18de9f7c
+  metadata.gz: d4ea6b78faec5dd0012db2be857b1874707c5085e99c54114d611893122be1a0
+  data.tar.gz: 0572af1000548da1d1d66699939360827dd8ef6fa1cc420ed236dfb90fd69a25
 SHA512:
-  metadata.gz: 6b532c9f0fe3b5408eea1e847c40329ab28da2a4c996d7cb229d1d745187fe33b5ace2fb17b8d1ea1ec1fc2e326cfc91dfd8881d296197a9d80bb40ded90a6f2
-  data.tar.gz: 64dfd72f81d71bd48ce01a4815c95360994dfb6b06235933ba893bb8245bdf4bd79ab384d7f7ca441fcec3ab158861c73d9bf8485b2478811e7df90d67443bb9
+  metadata.gz: 79300a2187ebae2eaa26a51a4c0d8845a380cfdb6787dd2df0e3d54a18a0da32b2668586f4cd2c4f4c5d5644ff7c4a5979ab60faf69c94c8a6ee1db7bf18f91a
+  data.tar.gz: 91442183160220175e78f0951917da321b4c555f1384772dc08cbc9afc48c7ae0fdaaa7d59591181b72bb8358a75b4e20f941283860b1a755b8aa5eddc1e3729

data/CHANGELOG.md

@@ -7,6 +7,73 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [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
+
+- Email-invite onboarding: leave the starting password blank and the
+  welcome email carries a set-your-password link from the host's
+  `invite_url_for` hook; `Notifications.publish`/`EventMailer.event`
+  accept an absolute `link_url` for tokenized URLs. (Intended for 0.2.0;
+  missed the merge window.)
+
 ## [0.2.0] - 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; }

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

@@ -36,11 +36,14 @@ module HrLite
 
         if @profile.save
           if new_login
+            invite_url = HrLite.config.invite_url_for&.call(@profile.user)
             Notifications.publish(
               "employee.onboarded",
               title: "Welcome aboard — your HR account is ready",
-              body: "Sign in with your email; your manager has your starting password.",
+              body: invite_url ? "Set your password with the button below, then sign in with your email."
+                               : "Sign in with your email; your manager has your starting password.",
               path: "/",
+              link_url: invite_url,
               bell_to: [ @profile.user ],
               email_to: [ @profile.user ]
             )

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/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,8 +2,9 @@ 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: "Kudos",      path: :kudos_path,          match: [ "/kudos" ] },
       { label: "Slips",      path: :salary_slips_path,   match: [ "/salary_slips" ] },
@@ -13,7 +14,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 +86,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/mailers/hr_lite/event_mailer.rb

@@ -3,11 +3,11 @@ module HrLite
   # body, detail lines, diff table) is assembled by the Notifications bus so
   # adding an event never means adding a template.
   class EventMailer < ApplicationMailer
-    def event(to:, subject:, heading:, body: nil, lines: [], path: nil)
+    def event(to:, subject:, heading:, body: nil, lines: [], path: nil, link_url: nil)
       @heading = heading
       @body = body
       @lines = Array(lines)
-      @cta_url = HrLite::EventMailer.link_for(path)
+      @cta_url = link_url.presence || HrLite::EventMailer.link_for(path)
       mail(to: to, from: HrLite.config.mailer_from, subject: subject)
     end
 

data/app/models/hr_lite/comp_off_request.rb

@@ -0,0 +1,177 @@
+module HrLite
+  # "I worked on a weekend/holiday — credit me a day off." Approval credits
+  # the comp-off leave type's balance (an adjustment, so it shows up in the
+  # normal balance chips and can be spent through the ordinary leave flow).
+  class CompOffRequest < ApplicationRecord
+    STATUSES = %w[pending approved rejected cancelled].freeze
+
+    belongs_to :user, class_name: HrLite.config.user_class
+    belongs_to :decided_by, class_name: HrLite.config.user_class, optional: true
+
+    validates :date_worked, :reason, presence: true
+    validates :status, inclusion: { in: STATUSES }
+
+    with_options on: :create do
+      validate :date_not_in_future
+      validate :date_was_an_off_day
+      validate :no_duplicate_for_date
+    end
+
+    after_create :notify_requested
+
+    scope :pending, -> { where(status: "pending") }
+    scope :recent_first, -> { order(date_worked: :desc, id: :desc) }
+
+    STATUSES.each do |s|
+      define_method("#{s}?") { status == s }
+    end
+
+    def credit_days
+      half_day ? BigDecimal("0.5") : BigDecimal("1")
+    end
+
+    # Shown to the approver: proof the person actually punched that day.
+    def punch
+      AttendanceRecord.find_by(user_id: user_id, date: date_worked)
+    end
+
+    # --- transitions -------------------------------------------------------
+
+    # Credits the comp-off balance inside the row lock, so a double-tap
+    # cannot credit twice. Fails loudly when no comp-off type is configured
+    # or the day stopped being an off day (holiday edited away).
+    def approve!(actor:, note: nil)
+      type = LeaveType.comp_off_type
+      raise MissingCompOffType if type.nil?
+
+      transition!("approved", actor, note) do
+        raise StaleOffDay if WorkingCalendar.new(date_worked..date_worked).working_day?(date_worked)
+
+        # (A duplicate live request for the same date cannot exist — the
+        # partial unique index on [user_id, date_worked] guarantees it.)
+        credit_balance!(type)
+      end
+
+      Notifications.publish(
+        "comp_off.approved",
+        title: "Comp-off approved — #{credit_days.to_f} day#{'s' if credit_days > 1} credited for #{date_worked.strftime('%d %b')}",
+        body: decision_note.presence,
+        path: "/comp_off_requests",
+        bell_to: [ user ], email_to: [ user ]
+      )
+      true
+    end
+
+    def reject!(actor:, note:)
+      transition!("rejected", actor, note)
+      Notifications.publish(
+        "comp_off.rejected",
+        title: "Comp-off rejected — #{date_worked.strftime('%d %b')}",
+        body: decision_note.presence,
+        path: "/comp_off_requests",
+        bell_to: [ user ], email_to: [ user ]
+      )
+      true
+    end
+
+    def cancel!(actor:)
+      transition!("cancelled", actor, nil)
+      Notifications.publish(
+        "comp_off.cancelled",
+        title: "#{HrLite.display_name(user)} cancelled a comp-off request (#{date_worked.strftime('%d %b')})",
+        path: "/admin/comp_off_requests",
+        bell_to: HrLite.admin_users
+      )
+      true
+    end
+
+    class MissingCompOffType < StandardError
+      def message
+        "No active leave type is marked as comp-off — enable one under Settings → Leave types first."
+      end
+    end
+
+    class StaleOffDay < StandardError
+      def message
+        "That date is now a regular working day (the calendar changed since the request) — " \
+          "reject it and ask them to re-file if it still applies."
+      end
+    end
+
+    private
+
+    # The credit goes into the year it can actually be SPENT (the current
+    # year at approval time) — crediting date_worked.year would strand a
+    # late-December day approved in January on last year's dead balance.
+    # The balance row is locked for the increment; two admins approving two
+    # different requests for the same person cannot lose an update.
+    def credit_balance!(type)
+      year = [ date_worked.year, Date.current.year ].max
+      balance = LeaveBalance.for(user, type, year)
+      if balance.new_record?
+        begin
+          balance.save!
+        rescue ActiveRecord::RecordNotUnique
+          balance = LeaveBalance.for(user, type, year)
+        end
+      end
+      balance.with_lock do
+        balance.adjustment += credit_days
+        balance.adjustment_note = [ balance.adjustment_note.presence,
+                                    "+#{credit_days.to_f} comp-off for #{date_worked} (request ##{id})" ].compact.join("; ")
+        balance.save!
+      end
+    end
+
+    def transition!(new_status, actor, note)
+      with_lock do
+        raise ActiveRecord::RecordInvalid.new(self), "not pending" unless pending?
+
+        yield if block_given?
+        self.status = new_status
+        self.decided_by_id = actor.id
+        self.decided_at = Time.current
+        self.decision_note = note
+        save!
+      end
+    end
+
+    def date_not_in_future
+      return unless date_worked
+
+      errors.add(:date_worked, "cannot be in the future") if date_worked > Date.current
+    end
+
+    # Comp-off is for working on a day you were NOT supposed to — a weekend
+    # or a holiday (per the company calendar). Extra hours on a working day
+    # are not comp-off under the policy.
+    def date_was_an_off_day
+      return unless date_worked
+      return if date_worked > Date.current
+
+      calendar = WorkingCalendar.new(date_worked..date_worked)
+      if calendar.working_day?(date_worked)
+        errors.add(:date_worked, "was a regular working day — comp-off is for working on a weekend or holiday")
+      end
+    end
+
+    def no_duplicate_for_date
+      return unless date_worked
+
+      clash = self.class.where(user_id: user_id, date_worked: date_worked,
+                               status: %w[pending approved]).where.not(id: id)
+      errors.add(:date_worked, "already has a comp-off request") if clash.exists?
+    end
+
+    def notify_requested
+      Notifications.publish(
+        "comp_off.requested",
+        title: "#{HrLite.display_name(user)} requested comp-off for #{date_worked.strftime('%d %b')} " \
+               "(#{half_day ? 'half' : 'full'} day)",
+        body: reason.presence,
+        path: "/admin/comp_off_requests/#{id}",
+        bell_to: HrLite.admin_users
+      )
+    end
+  end
+end

data/app/models/hr_lite/leave_request.rb

@@ -52,6 +52,7 @@ module HrLite
       return false if insufficient
 
       notify_decision("Leave approved")
+      notify_team
       true
     end
 
@@ -132,6 +133,23 @@ module HrLite
       )
     end
 
+    # Everyone should know a colleague will be away — 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.
+    def notify_team
+      team = HrLite.active_employees.reject { |member| member.id == user_id }
+      return if team.empty?
+
+      Notifications.publish(
+        "leave.team_notice",
+        title: "#{HrLite.display_name(user)} is on leave — #{leave_type.name} (#{date_range_label})",
+        path: "/team",
+        bell_to: team,
+        email_to: team
+      )
+    end
+
     def notify_decision(title)
       Notifications.publish(
         status == "approved" ? "leave.approved" : "leave.rejected",