@open-mercato/core 0.7.1-develop.7178.1.ab93fbaf4e → 0.7.1-develop.7180.1.9717fbbb43

package/src/modules/staff/subscribers/time-project-access-requested-notification.ts

@@ -0,0 +1,95 @@
+import { createLogger } from '@open-mercato/shared/lib/logger'
+import { resolveNotificationService } from '../../notifications/lib/notificationService'
+import { buildFeatureNotificationFromType } from '../../notifications/lib/notificationBuilder'
+import { notificationTypes } from '../notifications'
+import { MANAGE_PROJECTS_FEATURE } from '../lib/time-tracking/access'
+
+const logger = createLogger('staff').child({ component: 'subscribers/time-project-access-requested' })
+
+const NOTIFICATION_TYPE = 'staff.timesheets.project_access.requested'
+const PROJECTS_LIST_HREF = '/backend/staff/time-tracking/projects'
+
+export const metadata = {
+  event: 'staff.timesheets.project_access.requested',
+  persistent: true,
+  id: 'staff:time-project-access-requested-notification',
+}
+
+export type ProjectAccessRequestedPayload = {
+  tenantId: string
+  organizationId?: string | null
+  requesterUserId: string
+  requesterName?: string | null
+  timeProjectId?: string | null
+  timeProjectName?: string | null
+  requestedAt?: string
+}
+
+type ResolverContext = {
+  resolve: <T = unknown>(name: string) => T
+}
+
+/**
+ * Spec D-6: the notification action opens the project team drawer with the
+ * requester pre-selected, so a Team Leader grants access without hunting for
+ * the row. A general request carries no project, so it lands on the list.
+ */
+export function buildProjectAccessRequestLinkHref(input: {
+  requesterUserId: string
+  timeProjectId?: string | null
+}): string {
+  if (!input.timeProjectId) return PROJECTS_LIST_HREF
+  const projectSegment = encodeURIComponent(input.timeProjectId)
+  const requesterParam = encodeURIComponent(input.requesterUserId)
+  return `${PROJECTS_LIST_HREF}/${projectSegment}?panel=team&requesterUserId=${requesterParam}`
+}
+
+export function buildProjectAccessRequestGroupKey(input: {
+  requesterUserId: string
+  timeProjectId?: string | null
+}): string {
+  return `staff:time-project-access:${input.requesterUserId}:${input.timeProjectId ?? 'general'}`
+}
+
+export default async function handle(payload: ProjectAccessRequestedPayload, ctx: ResolverContext) {
+  try {
+    if (!payload?.tenantId || !payload?.requesterUserId) return
+    const typeDef = notificationTypes.find((type) => type.type === NOTIFICATION_TYPE)
+    if (!typeDef) return
+
+    const notificationService = resolveNotificationService(ctx)
+    const requesterName = payload.requesterName?.trim() || payload.requesterUserId
+    const timeProjectId = payload.timeProjectId ?? null
+
+    const notificationInput = buildFeatureNotificationFromType(typeDef, {
+      requiredFeature: MANAGE_PROJECTS_FEATURE,
+      bodyVariables: {
+        requesterName,
+        ...(payload.timeProjectName ? { projectName: payload.timeProjectName } : {}),
+      },
+      sourceEntityType: 'staff:time_project',
+      sourceEntityId: timeProjectId ?? undefined,
+      linkHref: buildProjectAccessRequestLinkHref({
+        requesterUserId: payload.requesterUserId,
+        timeProjectId,
+      }),
+      groupKey: buildProjectAccessRequestGroupKey({
+        requesterUserId: payload.requesterUserId,
+        timeProjectId,
+      }),
+    })
+
+    await notificationService.createForFeature(
+      { ...notificationInput, restrictRecipientsToOrganization: true },
+      {
+        tenantId: payload.tenantId,
+        organizationId: payload.organizationId ?? null,
+      },
+    )
+  } catch (err) {
+    logger.error('Failed to create the project access request notification', {
+      subscriber: metadata.id,
+      err,
+    })
+  }
+}

package/src/modules/staff/subscribers/time-project-budget-threshold-notification.ts

@@ -0,0 +1,226 @@
+import type { EntityManager } from '@mikro-orm/postgresql'
+import { createLogger } from '@open-mercato/shared/lib/logger'
+import type { NotificationSeverity } from '@open-mercato/shared/modules/notifications/types'
+import { resolveNotificationService } from '../../notifications/lib/notificationService'
+import {
+  buildFeatureNotificationFromType,
+  buildNotificationFromType,
+} from '../../notifications/lib/notificationBuilder'
+import { notificationTypes } from '../notifications'
+import { emitStaffEvent } from '../events'
+import { MANAGE_PROJECTS_FEATURE } from '../lib/time-tracking/access'
+import { computeProjectFinancials } from '../lib/timesheets-projects/computeProjectFinancials'
+import { FULL_BUDGET_PERCENT, evaluateBudgetThreshold } from '../lib/timesheets-projects/budgetThreshold'
+import {
+  claimBudgetThresholdAlert,
+  loadTimeProjectBudgetStateForEntry,
+} from '../lib/timesheets-projects/budgetThresholdState'
+
+const logger = createLogger('staff').child({ component: 'subscribers/time-project-budget-threshold' })
+
+const NOTIFICATION_TYPE = 'staff.timesheets.time_project.budget_threshold_reached'
+const PROJECTS_LIST_HREF = '/backend/staff/time-tracking/projects'
+
+/**
+ * Every write that can move a project's logged minutes or cost travels as a
+ * `staff.timesheets.time_entry.*` event, but not all of them by the same route:
+ *
+ *  - create / update / delete (soft) are emitted by the time-entry **commands**
+ *    through `staffTimeEntryCrudEvents` (`lib/crud.ts`), which the CRUD route and
+ *    `/copy-day` and `/[id]/duplicate` all drive;
+ *  - `/bulk` emits the same config itself, once per changed row, because it writes
+ *    through the EntityManager instead of the command bus;
+ *  - the timer transitions emit `…timer_started` / `…timer_stopped` explicitly.
+ *
+ * All of those carry the `{ id, tenantId, organizationId }` payload this handler
+ * needs. The batch-level members of the family — `…bulk_updated`, `…locked`,
+ * `…unlocked` — deliberately carry no `id` and fall out at the guard below, because
+ * the per-row events of the same write already covered every affected project.
+ *
+ * Subscribing to the family rather than three exact ids is what keeps a future write
+ * path from silently skipping the budget check.
+ *
+ * `persistent: true`: this ends in a user-visible alert about money and hours
+ * already spent. It has to survive a worker restart and be retried on failure — an
+ * ephemeral subscription would drop the alert whenever the process handling the
+ * entry write went away, and nothing would ever raise it again.
+ */
+export const metadata = {
+  event: 'staff.timesheets.time_entry.*',
+  persistent: true,
+  id: 'staff:time-project-budget-threshold-notification',
+}
+
+export type TimeEntryWritePayload = {
+  id?: string | null
+  tenantId?: string | null
+  organizationId?: string | null
+}
+
+type ResolverContext = {
+  resolve: <T = unknown>(name: string) => T
+}
+
+export function buildBudgetThresholdLinkHref(timeProjectId: string): string {
+  return `${PROJECTS_LIST_HREF}/${encodeURIComponent(timeProjectId)}`
+}
+
+/**
+ * One group key per project AND threshold, so the 80% alert and the 100% alert are
+ * two separate items in the bell, while a retry of the same crossing refreshes the
+ * existing item instead of stacking a duplicate.
+ */
+export function buildBudgetThresholdGroupKey(input: {
+  timeProjectId: string
+  thresholdPercent: number
+}): string {
+  return `staff:time-project-budget:${input.timeProjectId}:${input.thresholdPercent}`
+}
+
+export function resolveBudgetThresholdSeverity(thresholdPercent: number): NotificationSeverity {
+  return thresholdPercent >= FULL_BUDGET_PERCENT ? 'error' : 'warning'
+}
+
+export default async function handle(payload: TimeEntryWritePayload, ctx: ResolverContext) {
+  try {
+    const timeEntryId = payload?.id ?? null
+    const tenantId = payload?.tenantId ?? null
+    const organizationId = payload?.organizationId ?? null
+    if (!timeEntryId || !tenantId || !organizationId) return
+
+    const typeDef = notificationTypes.find((type) => type.type === NOTIFICATION_TYPE)
+    if (!typeDef) return
+
+    const em = (ctx.resolve('em') as EntityManager).fork()
+    const project = await loadTimeProjectBudgetStateForEntry({ em, tenantId, organizationId, timeEntryId })
+    if (!project) return
+    // A project without a budget never notifies. It is also the common case, so it
+    // exits before the aggregate query — unless a stale marker from a budget that
+    // has since been switched off still needs clearing.
+    if (project.budgetKind === 'none' && project.budgetAlertedAtPercent === null) return
+
+    const financials = await computeProjectFinancials({
+      em,
+      tenantId,
+      organizationId,
+      projectIds: [project.timeProjectId],
+      hourlyRateByProjectId: new Map([[project.timeProjectId, project.hourlyRate]]),
+    })
+    const totals = financials.get(project.timeProjectId)
+
+    const evaluation = evaluateBudgetThreshold({
+      budgetKind: project.budgetKind,
+      budgetValue: project.budgetValue,
+      budgetWarnAtPercent: project.budgetWarnAtPercent,
+      budgetAlertedAtPercent: project.budgetAlertedAtPercent,
+      totalMinutes: totals?.totalMinutes ?? 0,
+      cost: totals?.cost ?? null,
+      currencyCode: project.currencyCode,
+    })
+
+    if (!evaluation.shouldPersistAlertedAt) return
+
+    // Compare-and-swap on the marker: the loser of a race between two concurrent
+    // entry writes stops here, so a threshold is announced exactly once. The marker
+    // is written before the alert, which makes this at-most-once by design — a
+    // repeated alert about the same crossing is worse than a missed retry.
+    const claimed = await claimBudgetThresholdAlert({
+      em,
+      tenantId,
+      organizationId,
+      timeProjectId: project.timeProjectId,
+      expectedAlertedAtPercent: project.budgetAlertedAtPercent,
+      nextAlertedAtPercent: evaluation.nextAlertedAtPercent,
+    })
+    if (!claimed) return
+
+    const thresholdPercent = evaluation.crossedThresholdPercent
+    // The marker moved down (usage fell back under the band it was raised for) or
+    // the budget was switched off. Nothing to announce; the reset is the point.
+    if (thresholdPercent === null) return
+
+    // This event is `clientBroadcast: true`, and the DOM Event Bridge filters only by
+    // tenant and organization — every signed-in user of the organization receives the
+    // payload, whether or not they hold `staff.timesheets.rates.view`. An `amount`
+    // budget states money (`budgetValue` is the contract value, `usedValue` the cost
+    // burned against it), so those two are carried only for an `hours` budget, exactly
+    // as `/my-work` withholds an amount budget from a caller who may not see money.
+    // The percentages are not money and are what a live budget badge actually renders.
+    const budgetIsMoney = evaluation.kind === 'amount'
+    await emitStaffEvent(
+      'staff.timesheets.time_project.budget_threshold_reached',
+      {
+        id: project.timeProjectId,
+        timeProjectId: project.timeProjectId,
+        tenantId,
+        organizationId,
+        thresholdPercent,
+        percent: evaluation.percent,
+        budgetKind: evaluation.kind,
+        ...(budgetIsMoney ? {} : { budgetValue: evaluation.budgetValue, usedValue: evaluation.usedValue }),
+      },
+      { persistent: true },
+    )
+
+    const notificationService = resolveNotificationService(ctx)
+    const scope = { tenantId, organizationId }
+    const severity = resolveBudgetThresholdSeverity(thresholdPercent)
+    const commonOptions = {
+      bodyVariables: {
+        projectName: project.name || project.timeProjectId,
+        percent: String(evaluation.percent ?? 0),
+        thresholdPercent: String(thresholdPercent),
+      },
+      sourceEntityType: 'staff:time_project',
+      sourceEntityId: project.timeProjectId,
+      linkHref: buildBudgetThresholdLinkHref(project.timeProjectId),
+      groupKey: buildBudgetThresholdGroupKey({ timeProjectId: project.timeProjectId, thresholdPercent }),
+    }
+
+    // Manage-feature holders are resolved through the notification service's feature
+    // fan-out, which matches grants with the shared feature policy — a `staff.*`
+    // wildcard counts — and then re-checks each candidate against this organization
+    // through the RBAC service.
+    const featureNotifications = await notificationService.createForFeature(
+      {
+        ...buildFeatureNotificationFromType(typeDef, {
+          ...commonOptions,
+          requiredFeature: MANAGE_PROJECTS_FEATURE,
+        }),
+        severity,
+        restrictRecipientsToOrganization: true,
+      },
+      scope,
+    )
+
+    const ownerUserId = project.ownerUserId
+    if (!ownerUserId) return
+    const ownerAlreadyNotified = featureNotifications.some(
+      (notification) => notification?.recipientUserId === ownerUserId,
+    )
+    if (ownerAlreadyNotified) return
+
+    // The owner is notified even without the manage feature — it is their project's
+    // budget. An owner who has left the scope is not an error worth failing on.
+    try {
+      await notificationService.create(
+        {
+          ...buildNotificationFromType(typeDef, { ...commonOptions, recipientUserId: ownerUserId }),
+          severity,
+        },
+        scope,
+      )
+    } catch (err) {
+      logger.warn('Skipped the budget threshold notification for an out-of-scope project owner', {
+        subscriber: metadata.id,
+        timeProjectId: project.timeProjectId,
+        err,
+      })
+    }
+  } catch (err) {
+    logger.error('Failed to evaluate the time project budget threshold', {
+      subscriber: metadata.id,
+      err,
+    })
+  }
+}

package/src/modules/staff/subscribers/time-report-approved-notification.ts

@@ -0,0 +1,116 @@
+import type { EntityManager } from '@mikro-orm/postgresql'
+import { createLogger } from '@open-mercato/shared/lib/logger'
+import { findOneWithDecryption } from '@open-mercato/shared/lib/encryption/find'
+import { resolveNotificationService } from '../../notifications/lib/notificationService'
+import { buildNotificationFromType } from '../../notifications/lib/notificationBuilder'
+import { notificationTypes } from '../notifications'
+import { StaffTimeReport } from '../data/entities'
+
+const logger = createLogger('staff').child({ component: 'subscribers/time-report-approved' })
+
+const NOTIFICATION_TYPE = 'staff.timesheets.time_report.approved'
+const REPORTS_LIST_HREF = '/backend/staff/time-tracking/reports'
+
+/**
+ * EP-48. Closing a report IS its approval in this module: the close freezes every
+ * per-entry rate and amount, locks the entries against further edits, and is
+ * gated on `staff.timesheets.lock`. There is no separate "approved" transition to
+ * subscribe to, and adding one would be a behaviour change, not an extension
+ * point — so this subscribes to the close and announces it to the one person who
+ * otherwise finds out by reopening the screen: whoever drafted the report.
+ *
+ * The closer is deliberately not notified about their own action, and a report
+ * with no recorded author is a normal outcome (a seeded or imported report), not
+ * an error.
+ *
+ * `persistent: true` — a report closing is a billing milestone; the alert has to
+ * survive a worker restart and be retried, the same reasoning as the budget
+ * threshold subscriber next to it.
+ */
+export const metadata = {
+  event: 'staff.timesheets.time_report.closed',
+  persistent: true,
+  id: 'staff:time-report-approved-notification',
+}
+
+export type TimeReportClosedPayload = {
+  id?: string | null
+  reportId?: string | null
+  reference?: string | null
+  tenantId?: string | null
+  organizationId?: string | null
+  closedByUserId?: string | null
+}
+
+type ResolverContext = {
+  resolve: <T = unknown>(name: string) => T
+}
+
+export function buildTimeReportLinkHref(reportId: string): string {
+  return `${REPORTS_LIST_HREF}/${encodeURIComponent(reportId)}`
+}
+
+/** One item per report, so a re-close after an unlock refreshes rather than stacks. */
+export function buildTimeReportApprovedGroupKey(reportId: string): string {
+  return `staff:time-report-approved:${reportId}`
+}
+
+function readId(...candidates: Array<unknown>): string | null {
+  for (const candidate of candidates) {
+    if (typeof candidate !== 'string') continue
+    const trimmed = candidate.trim()
+    if (trimmed.length > 0) return trimmed
+  }
+  return null
+}
+
+export default async function handle(
+  payload: TimeReportClosedPayload,
+  ctx: ResolverContext,
+): Promise<void> {
+  try {
+    const reportId = readId(payload?.reportId, payload?.id)
+    const tenantId = readId(payload?.tenantId)
+    const organizationId = readId(payload?.organizationId)
+    if (!reportId || !tenantId || !organizationId) return
+
+    const typeDef = notificationTypes.find((entry) => entry.type === NOTIFICATION_TYPE)
+    if (!typeDef) return
+
+    const em = ctx.resolve<EntityManager>('em').fork()
+    const scope = { tenantId, organizationId }
+    const report = await findOneWithDecryption(
+      em,
+      StaffTimeReport,
+      { id: reportId, tenantId, organizationId, deletedAt: null },
+      {},
+      scope,
+    )
+    if (!report) return
+
+    const recipientUserId = readId(report.createdByUserId)
+    if (!recipientUserId) return
+    if (recipientUserId === readId(report.closedByUserId, payload?.closedByUserId)) return
+
+    const notificationService = resolveNotificationService(ctx)
+    await notificationService.create(
+      buildNotificationFromType(typeDef, {
+        recipientUserId,
+        bodyVariables: {
+          reference: report.reference,
+          title: report.title,
+        },
+        sourceEntityType: 'staff:time_report',
+        sourceEntityId: report.id,
+        linkHref: buildTimeReportLinkHref(report.id),
+        groupKey: buildTimeReportApprovedGroupKey(report.id),
+      }),
+      scope,
+    )
+  } catch (err) {
+    logger.error('Failed to raise the time report approved notification', {
+      subscriber: metadata.id,
+      err,
+    })
+  }
+}

package/src/modules/staff/subscribers/time-report-portal-broadcast.ts

@@ -0,0 +1,120 @@
+import type { EntityManager } from '@mikro-orm/postgresql'
+import { createLogger } from '@open-mercato/shared/lib/logger'
+import { findOneWithDecryption } from '@open-mercato/shared/lib/encryption/find'
+import { emitStaffEvent } from '../events'
+import { StaffTimeReport } from '../data/entities'
+import { resolvePortalRecipientUserIds } from '../lib/time-tracking/portalRecipients'
+
+const logger = createLogger('staff').child({ component: 'subscribers/time-report-portal-broadcast' })
+
+/**
+ * EP-06 / EP-50. Mirrors a closed report to the customer portal — and is the only
+ * emitter of `staff.timesheets.time_report.portal_published`.
+ *
+ * The glue lives here, in an optional consumer, rather than in the close command,
+ * because resolving "which portal users belong to this customer" reads a
+ * `customer_accounts` table. As a subscriber it is skippable: if the query fails
+ * the recipient list is empty and nothing is emitted, so a deployment without the
+ * portal installed behaves exactly as it did before.
+ *
+ * Two invariants this file exists to hold:
+ *
+ *  1. **No recipients, no event.** The portal SSE stream falls back to an
+ *     organization-wide audience for a payload with no `recipientUserIds`, and one
+ *     organization serves many customers. Emitting an unpinned report event would
+ *     be a cross-customer disclosure.
+ *  2. **No money on the wire.** The payload carries the reference and the period
+ *     only. Amounts are gated on `staff.timesheets.rates.view`, which SSE cannot
+ *     apply, and a portal user never holds it in any case.
+ *
+ * `persistent: true`: a client-visible publication should survive a worker restart.
+ */
+export const metadata = {
+  event: 'staff.timesheets.time_report.closed',
+  persistent: true,
+  id: 'staff:time-report-portal-broadcast',
+}
+
+export type TimeReportClosedPayload = {
+  id?: string | null
+  reportId?: string | null
+  tenantId?: string | null
+  organizationId?: string | null
+}
+
+type ResolverContext = {
+  resolve: <T = unknown>(name: string) => T
+}
+
+function readId(...candidates: Array<unknown>): string | null {
+  for (const candidate of candidates) {
+    if (typeof candidate !== 'string') continue
+    const trimmed = candidate.trim()
+    if (trimmed.length > 0) return trimmed
+  }
+  return null
+}
+
+function toIsoDate(value: unknown): string | null {
+  if (value instanceof Date) {
+    if (Number.isNaN(value.getTime())) return null
+    return value.toISOString().slice(0, 10)
+  }
+  if (typeof value === 'string' && value.trim().length > 0) return value.trim().slice(0, 10)
+  return null
+}
+
+export default async function handle(
+  payload: TimeReportClosedPayload,
+  ctx: ResolverContext,
+): Promise<void> {
+  try {
+    const reportId = readId(payload?.reportId, payload?.id)
+    const tenantId = readId(payload?.tenantId)
+    const organizationId = readId(payload?.organizationId)
+    if (!reportId || !tenantId || !organizationId) return
+
+    const em = ctx.resolve<EntityManager>('em').fork()
+    const report = await findOneWithDecryption(
+      em,
+      StaffTimeReport,
+      { id: reportId, tenantId, organizationId, deletedAt: null },
+      {},
+      { tenantId, organizationId },
+    )
+    if (!report || report.status !== 'closed') return
+
+    const customerId = readId(report.customerId)
+    if (!customerId) return
+
+    const recipientUserIds = await resolvePortalRecipientUserIds(em, {
+      tenantId,
+      organizationId,
+      customerId,
+    })
+    if (recipientUserIds.length === 0) return
+
+    const periodFrom = toIsoDate(report.periodFrom)
+    const periodTo = toIsoDate(report.periodTo)
+    if (!periodFrom || !periodTo) return
+
+    await emitStaffEvent(
+      'staff.timesheets.time_report.portal_published',
+      {
+        id: report.id,
+        tenantId,
+        organizationId,
+        reference: report.reference,
+        periodFrom,
+        periodTo,
+        recipientUserIds,
+      },
+      { persistent: true },
+    )
+  } catch (err) {
+    logger.error('Failed to publish a closed time report to the customer portal', {
+      subscriber: metadata.id,
+      err,
+    })
+  }
+}

package/src/modules/staff/translations.ts

@@ -1,5 +1,22 @@
+/**
+ * EP-45 — entity fields a tenant may translate per locale.
+ *
+ * Keys are entity ids, values are **database column** names (snake_case), matching the
+ * `staff_team_member` entry this file shipped with. Adding a field here does not change
+ * any rendered output on its own: the translation overlay only substitutes a value when
+ * a translation row exists for the request locale, and there are none until a tenant
+ * writes one.
+ *
+ * Only columns that actually exist are listed. `staff_time_task_statuses` has no
+ * description column and `staff_time_tags` names its label `label`, so the spec's
+ * "name / description" reads as "the human-readable columns of each" rather than two
+ * literal column names.
+ */
 export const translatableFields: Record<string, string[]> = {
   'staff:staff_team_member': ['display_name', 'description'],
+  'staff:staff_time_project': ['name', 'description'],
+  'staff:staff_time_task_status': ['name'],
+  'staff:staff_time_tag': ['label'],
 }
 
 export default translatableFields

package/src/modules/staff/widgets/components.ts

@@ -0,0 +1,34 @@
+import type { ComponentOverride } from '@open-mercato/shared/modules/widgets/component-registry'
+
+/**
+ * Component replacement handles the staff module publishes (EP-31 of
+ * `.ai/specs/2026-08-24-time-tracking-umes-extension-points.md`).
+ *
+ * Each handle is registered by the component's own module through
+ * `registerComponent`, and the shipping component resolves itself through
+ * `useRegisteredComponent`, so another module can `replace`, `wrapper` or
+ * `props`-transform it without forking the screen that renders it. Every entry
+ * publishes a zod `propsSchema` — in development `useRegisteredComponent` parses
+ * the resolved props against it and falls back to the original component when a
+ * replacement does not satisfy it, so the schema is the contract, not a comment.
+ *
+ * | Handle | Registered by | Props |
+ * |---|---|---|
+ * | `staff.time_entry_dialog`      | `lib/time-tracking-ui/TimeEntryDialog.tsx`           | `TimeEntryDialogProps` |
+ * | `staff.timer_bar`              | `lib/timesheets-ui/TimerBar.tsx`                    | `TimerBarProps` |
+ * | `staff.kanban_card`            | `lib/time-tracking-ui/KanbanCard.tsx`               | `KanbanCardProps` |
+ * | `staff.kanban_column`          | `lib/time-tracking-ui/KanbanColumn.tsx`             | `KanbanColumnProps` |
+ * | `staff.timesheet_grid`         | `backend/staff/time-tracking/timesheet/GridView.tsx`| `GridViewProps` |
+ * | `staff.timesheet_list`         | `lib/timesheets-ui/ListView.tsx`                    | `ListViewProps` |
+ * | `staff.timesheet_calendar`     | `lib/time-tracking-ui/TimesheetCalendar.tsx`        | `TimesheetCalendarProps` |
+ * | `staff.report_sheet`           | `lib/time-tracking-ui/ReportSheet.tsx`              | `ReportSheetProps` |
+ * | `staff.project_card`           | `lib/timesheets-projects-ui/ProjectCard.tsx`        | `ProjectCardProps` |
+ * | `staff.entries_summary_footer` | `lib/time-tracking-ui/TimeEntriesSummaryFooter.tsx` | `TimeEntriesSummaryFooterProps` |
+ *
+ * The array below is the staff module's own *outgoing* overrides — it targets no
+ * other module's components today, so it is empty. Adding an entry here would
+ * override somebody else's component, not one of the handles above.
+ */
+export const componentOverrides: ComponentOverride[] = []
+
+export default componentOverrides

package/src/modules/staff/widgets/injection/timer-sidebar-indicator/widget.tsx

@@ -1,6 +1,7 @@
 "use client"
 
 import * as React from 'react'
+import Link from 'next/link'
 import { useT } from '@open-mercato/shared/lib/i18n/context'
 import type { InjectionWidgetModule } from '@open-mercato/shared/modules/widgets/injection'
 import { ProjectColorDot } from '../../../lib/timesheets-ui/ProjectColorDot'
@@ -40,14 +41,14 @@ function TimerSidebarIndicator() {
   if (!timer.running || !timer.entryId) return null
 
   return (
-    <a
-      href="/backend/staff/timesheets"
+    <Link
+      href="/backend/staff/time-tracking/timesheet"
       className="flex items-center gap-2 rounded-md px-2 py-1.5 text-xs hover:bg-muted transition-colors cursor-pointer"
       title={t('staff.timesheets.sidebar.timerRunning', 'Timer running — click to view')}
     >
       <span className="relative flex h-2.5 w-2.5 shrink-0">
-        <span className="absolute inline-flex h-full w-full animate-ping rounded-full bg-red-400 opacity-75" />
-        <span className="relative inline-flex h-2.5 w-2.5 rounded-full bg-red-500" />
+        <span className="absolute inline-flex h-full w-full animate-ping rounded-full bg-status-error-icon opacity-75" />
+        <span className="relative inline-flex h-2.5 w-2.5 rounded-full bg-status-error-icon" />
       </span>
       {timer.projectName ? (
         <span className="inline-flex items-center gap-1 truncate">
@@ -56,7 +57,7 @@ function TimerSidebarIndicator() {
         </span>
       ) : null}
       <span className="ml-auto font-mono tabular-nums shrink-0">{formatElapsed(elapsed)}</span>
-    </a>
+    </Link>
   )
 }