diff --git a/src/components/Header.vue b/src/components/Header.vue
index 9a4a7827..c7f37db3 100644
--- a/src/components/Header.vue
+++ b/src/components/Header.vue
@@ -59,6 +59,9 @@ div(:class="{'fixed-top-padding': fixedTopMenu}")
           b-dropdown-item(to="/search")
             icon(name="search")
             | Search
+          b-dropdown-item(to="/work-report")
+            icon(name="briefcase")
+            | Work Report
           b-dropdown-item(to="/trends" v-if="devmode")
             icon(name="chart-line")
             | Trends
@@ -98,6 +101,7 @@ div(:class="{'fixed-top-padding': fixedTopMenu}")
 <script lang="ts">
 // only import the icons you use to reduce bundle size
 import 'vue-awesome/icons/calendar-day';
+import 'vue-awesome/icons/briefcase';
 import 'vue-awesome/icons/calendar-week';
 import 'vue-awesome/icons/stream';
 import 'vue-awesome/icons/database';
diff --git a/src/queries.ts b/src/queries.ts
index 816b6cab..406a3431 100644
--- a/src/queries.ts
+++ b/src/queries.ts
@@ -15,7 +15,7 @@ function escape_doublequote(s: string) {
 }
 
 // Hostname safe for using as a variable name
-function safeHostname(hostname: string): string {
+export function safeHostname(hostname: string): string {
   return hostname.replace(/[^a-zA-Z0-9_]/g, '');
 }
 
diff --git a/src/route.js b/src/route.js
index 9f41c203..3cc3177c 100644
--- a/src/route.js
+++ b/src/route.js
@@ -15,6 +15,7 @@ const Trends = () => import('./views/Trends.vue');
 const Settings = () => import('./views/settings/Settings.vue');
 const CategoryBuilder = () => import('./views/settings/CategoryBuilder.vue');
 const Stopwatch = () => import('./views/Stopwatch.vue');
+const WorkReport = () => import('./views/WorkReport.vue');
 const Alerts = () => import('./views/Alerts.vue');
 const Search = () => import('./views/Search.vue');
 const Report = () => import('./views/Report.vue');
@@ -66,6 +67,7 @@ const router = new VueRouter({
     { path: '/settings', component: Settings },
     { path: '/settings/category-builder', component: CategoryBuilder },
     { path: '/stopwatch', component: Stopwatch },
+    { path: '/work-report', component: WorkReport },
     { path: '/search', component: Search },
     { path: '/graph', component: Graph },
     { path: '/dev', component: Dev },
diff --git a/src/util/workReport.ts b/src/util/workReport.ts
new file mode 100644
index 00000000..15f58f94
--- /dev/null
+++ b/src/util/workReport.ts
@@ -0,0 +1,47 @@
+import { IBucket } from '~/util/interfaces';
+
+export interface WorkReportHostOption {
+  value: string;
+  text: string;
+  disabled: boolean;
+}
+
+function getWindowHosts(buckets: IBucket[]): string[] {
+  const hosts = buckets
+    .filter(bucket => bucket.type === 'currentwindow')
+    .map(bucket => bucket.id.replace('aw-watcher-window_', ''));
+  return [...new Set(hosts)];
+}
+
+function getAFKHosts(buckets: IBucket[]): Set<string> {
+  return new Set(
+    buckets
+      .filter(bucket => bucket.type === 'afkstatus')
+      .map(bucket => bucket.id.replace('aw-watcher-afk_', ''))
+  );
+}
+
+export function getWorkReportHostOptions(buckets: IBucket[]): WorkReportHostOption[] {
+  const afkHosts = getAFKHosts(buckets);
+  return getWindowHosts(buckets).map(host => {
+    const hasAFK = afkHosts.has(host);
+    return {
+      value: host,
+      text: hasAFK ? host : `${host} (requires aw-watcher-afk)`,
+      disabled: !hasAFK,
+    };
+  });
+}
+
+export function getUnsupportedWorkReportHosts(
+  selectedHosts: string[],
+  buckets: IBucket[]
+): string[] {
+  const afkHosts = getAFKHosts(buckets);
+  return selectedHosts.filter(host => !afkHosts.has(host));
+}
+
+export function getSupportedWorkReportHosts(selectedHosts: string[], buckets: IBucket[]): string[] {
+  const unsupportedHosts = new Set(getUnsupportedWorkReportHosts(selectedHosts, buckets));
+  return selectedHosts.filter(host => !unsupportedHosts.has(host));
+}
diff --git a/src/views/WorkReport.vue b/src/views/WorkReport.vue
new file mode 100644
index 00000000..0c51e27e
--- /dev/null
+++ b/src/views/WorkReport.vue
@@ -0,0 +1,363 @@
+<template lang="pug">
+div
+  h3.mb-3 Work Time Report
+
+  div.row.mb-4
+    div.col-md-3
+      b-form-group(label="Hosts" label-class="font-weight-bold")
+        b-form-select(v-model="selectedHosts" :options="hostOptions" multiple :select-size="4")
+        small.text-muted Select devices to include
+
+    div.col-md-3
+      b-form-group(label="Categories" label-class="font-weight-bold")
+        b-form-select(v-model="selectedCategories" :options="categoryOptions" multiple :select-size="3")
+
+    div.col-md-3
+      b-form-group(label="Break Time" label-class="font-weight-bold")
+        div.d-flex.align-items-center
+          b-form-input(
+            v-model="breakTime"
+            type="range"
+            min="0"
+            max="30"
+            step="1"
+          )
+          span.ml-2.text-nowrap {{ breakTime }} min
+        small.text-muted Gaps shorter than this will be counted as work time
+
+    div.col-md-3
+      b-form-group(label="Date Range" label-class="font-weight-bold")
+        b-form-select(v-model="dateRange" :options="dateRangeOptions")
+
+  div.mb-3
+    b-button(@click="loadData" variant="primary")
+      icon(name="sync")
+      |  Calculate Work Time
+    b-button.ml-2(@click="exportCSV" variant="outline-secondary" :disabled="!hasData")
+      icon(name="download")
+      |  Export CSV
+    b-button.ml-2(@click="exportJSON" variant="outline-secondary" :disabled="!hasData")
+      icon(name="download")
+      |  Export JSON
+
+  div(v-if="loading")
+    b-spinner.mr-2
+    | Loading...
+
+  div(v-if="hasData && !loading")
+    h5.mt-4 Daily Breakdown
+
+    table.table.table-sm.table-hover
+      thead
+        tr
+          th Date
+          th.text-right Work Time
+          th.text-right Sessions
+          th.text-right Avg Session
+      tbody
+        tr(v-for="day in dailyData" :key="day.date")
+          td {{ day.date }}
+          td.text-right {{ formatDuration(day.duration) }}
+          td.text-right {{ day.sessions }}
+          td.text-right {{ formatDuration(day.avgSession) }}
+      tfoot
+        tr.font-weight-bold
+          td Total
+          td.text-right {{ formatDuration(totalDuration) }}
+          td.text-right {{ totalSessions }}
+          td.text-right {{ formatDuration(avgSessionLength) }}
+
+</template>
+
+<script lang="ts">
+import moment from 'moment';
+import { getClient } from '~/util/awclient';
+import { useCategoryStore } from '~/stores/categories';
+import { useSettingsStore } from '~/stores/settings';
+import { useBucketsStore } from '~/stores/buckets';
+import { get_day_start_with_offset, get_day_end_with_offset } from '~/util/time';
+import {
+  getSupportedWorkReportHosts,
+  getWorkReportHostOptions,
+  getUnsupportedWorkReportHosts,
+} from '~/util/workReport';
+
+import 'vue-awesome/icons/sync';
+import 'vue-awesome/icons/download';
+
+interface DailyData {
+  date: string;
+  duration: number;
+  sessions: number;
+  avgSession: number;
+  events: any[];
+}
+
+export default {
+  name: 'WorkReport',
+  data() {
+    return {
+      categoryStore: useCategoryStore(),
+      settingsStore: useSettingsStore(),
+      bucketsStore: useBucketsStore(),
+
+      selectedHosts: [] as string[],
+      selectedCategories: [JSON.stringify(['Work'])],
+      breakTime: 5,
+      dateRange: 'last7d',
+
+      loading: false,
+      dailyData: [] as DailyData[],
+      rawData: {} as Record<string, any>,
+    };
+  },
+  computed: {
+    hostOptions() {
+      return getWorkReportHostOptions(this.bucketsStore.buckets || []);
+    },
+
+    categoryOptions() {
+      const cats = this.categoryStore.all_categories || [];
+      return cats.map(cat => ({
+        value: JSON.stringify(cat),
+        text: cat.join(' > '),
+      }));
+    },
+    dateRangeOptions() {
+      return [
+        { value: 'last7d', text: 'Last 7 days' },
+        { value: 'last30d', text: 'Last 30 days' },
+        { value: 'thisWeek', text: 'This week' },
+        { value: 'thisMonth', text: 'This month' },
+      ];
+    },
+    hasData() {
+      return this.dailyData.length > 0;
+    },
+    totalDuration() {
+      return this.dailyData.reduce((sum, day) => sum + day.duration, 0);
+    },
+    totalSessions() {
+      return this.dailyData.reduce((sum, day) => sum + day.sessions, 0);
+    },
+    avgSessionLength() {
+      return this.totalSessions > 0 ? this.totalDuration / this.totalSessions : 0;
+    },
+  },
+  async mounted() {
+    this.categoryStore.load();
+    await this.bucketsStore.ensureLoaded();
+
+    if (this.hostOptions.length > 0) {
+      this.selectedHosts = this.hostOptions.filter(opt => !opt.disabled).map(opt => opt.value);
+    }
+  },
+  methods: {
+    async loadData() {
+      this.loading = true;
+      try {
+        const client = getClient();
+
+        if (this.selectedHosts.length === 0) {
+          alert('Please select at least one host');
+          this.loading = false;
+          return;
+        }
+
+        if (this.selectedCategories.length === 0) {
+          alert('Please select at least one category');
+          this.loading = false;
+          return;
+        }
+
+        const unsupportedHosts = getUnsupportedWorkReportHosts(
+          this.selectedHosts,
+          this.bucketsStore.buckets || []
+        );
+        if (unsupportedHosts.length > 0) {
+          const supportedHosts = getSupportedWorkReportHosts(
+            this.selectedHosts,
+            this.bucketsStore.buckets || []
+          );
+          if (supportedHosts.length === 0) {
+            alert(
+              `The selected hosts are missing aw-watcher-afk buckets and can't be included in Work Report: ${unsupportedHosts.join(
+                ', '
+              )}`
+            );
+            this.loading = false;
+            return;
+          }
+
+          alert(
+            `Skipping hosts without aw-watcher-afk buckets: ${unsupportedHosts.join(
+              ', '
+            )}. Work Report will use: ${supportedHosts.join(', ')}`
+          );
+          this.selectedHosts = supportedHosts;
+        }
+
+        const hostsToQuery = getSupportedWorkReportHosts(
+          this.selectedHosts,
+          this.bucketsStore.buckets || []
+        );
+        const timeperiods = this.getTimeperiods();
+        const breakTimeSeconds = this.breakTime * 60;
+        const categoriesFilter = this.selectedCategories.map(c => JSON.parse(c));
+
+        const categories = this.categoryStore.classes_for_query;
+        const categoriesStr = JSON.stringify(categories).replace(/\\\\/g, '\\');
+
+        // Build multi-device query with flood-based gap merging and AFK filtering
+        let query = '';
+
+        // Use indexed variable names to avoid collisions when hostnames
+        // differ only in non-alphanumeric chars (e.g., "my-laptop" vs "mylaptop").
+        for (let hi = 0; hi < hostsToQuery.length; hi++) {
+          const hostname = hostsToQuery[hi];
+          query += `
+            events_${hi} = flood(query_bucket("aw-watcher-window_${hostname}"), ${breakTimeSeconds});
+            not_afk_${hi} = flood(query_bucket("aw-watcher-afk_${hostname}"));
+            not_afk_${hi} = filter_keyvals(not_afk_${hi}, "status", ["not-afk"]);
+            events_${hi} = filter_period_intersect(events_${hi}, not_afk_${hi});
+            events_${hi} = categorize(events_${hi}, ${categoriesStr});
+            events_${hi} = filter_keyvals(events_${hi}, "$category", ${JSON.stringify(
+            categoriesFilter
+          )});
+          `;
+        }
+
+        // Combine events from all hosts
+        query += '\nevents = [];';
+        for (let hi = 0; hi < hostsToQuery.length; hi++) {
+          query += `\nevents = union_no_overlap(events, events_${hi});`;
+        }
+
+        query += `
+          duration = sum_durations(events);
+          RETURN = {"events": events, "duration": duration};
+        `;
+
+        const results = await client.query(timeperiods, [query]);
+
+        this.dailyData = timeperiods.map((tp, i) => {
+          const result = results[i];
+          const events = result.events || [];
+          const duration = result.duration || 0;
+
+          const startDate = tp.split('/')[0];
+
+          return {
+            date: moment(startDate).format('YYYY-MM-DD'),
+            duration,
+            sessions: events.length,
+            avgSession: events.length > 0 ? duration / events.length : 0,
+            events,
+          };
+        });
+
+        this.rawData = results;
+      } catch (error) {
+        console.error('Error loading work time data:', error);
+        alert('Error loading data. See console for details.');
+      } finally {
+        this.loading = false;
+      }
+    },
+
+    getTimeperiods(): string[] {
+      const offset = this.settingsStore.startOfDay;
+      const timeperiods: string[] = [];
+
+      let days: number;
+
+      if (this.dateRange === 'last7d') {
+        days = 7;
+      } else if (this.dateRange === 'last30d') {
+        days = 30;
+      } else if (this.dateRange === 'thisWeek') {
+        days = moment().isoWeekday(); // Mon=1 .. Sun=7
+      } else if (this.dateRange === 'thisMonth') {
+        days = moment().date(); // 1-based day of month
+      } else {
+        days = 7;
+      }
+
+      for (let i = days - 1; i >= 0; i--) {
+        const date = moment().subtract(i, 'days');
+        const start = get_day_start_with_offset(date, offset);
+        const end = get_day_end_with_offset(date, offset);
+        timeperiods.push(start + '/' + end);
+      }
+
+      return timeperiods;
+    },
+
+    formatDuration(seconds: number): string {
+      if (!seconds) return '0:00';
+      const hours = Math.floor(seconds / 3600);
+      const minutes = Math.floor((seconds % 3600) / 60);
+      return `${hours}:${minutes.toString().padStart(2, '0')}`;
+    },
+
+    exportCSV() {
+      const headers = ['Date', 'Duration (hours)', 'Sessions', 'Avg Session (minutes)'];
+      const rows = this.dailyData.map(day => [
+        day.date,
+        (day.duration / 3600).toFixed(2),
+        day.sessions,
+        (day.avgSession / 60).toFixed(1),
+      ]);
+
+      const csv = [
+        headers.join(','),
+        ...rows.map(row => row.join(',')),
+        '',
+        `Total,${(this.totalDuration / 3600).toFixed(2)},${this.totalSessions},${(
+          this.avgSessionLength / 60
+        ).toFixed(1)}`,
+      ].join('\n');
+
+      this.downloadFile(csv, 'work_time_report.csv', 'text/csv');
+    },
+
+    exportJSON() {
+      const data = {
+        parameters: {
+          categories: this.selectedCategories,
+          breakTime: this.breakTime,
+          dateRange: this.dateRange,
+        },
+        summary: {
+          totalDuration: this.totalDuration,
+          totalSessions: this.totalSessions,
+          avgSessionLength: this.avgSessionLength,
+        },
+        daily: this.dailyData,
+        rawEvents: this.rawData,
+      };
+
+      const json = JSON.stringify(data, null, 2);
+      this.downloadFile(json, 'work_time_report.json', 'application/json');
+    },
+
+    downloadFile(content: string, filename: string, mimeType: string) {
+      const blob = new Blob([content], { type: mimeType });
+      const url = URL.createObjectURL(blob);
+      const link = document.createElement('a');
+      link.href = url;
+      link.download = filename;
+      document.body.appendChild(link);
+      link.click();
+      document.body.removeChild(link);
+      URL.revokeObjectURL(url);
+    },
+  },
+};
+</script>
+
+<style scoped>
+.table {
+  font-size: 0.9rem;
+}
+</style>
diff --git a/test/unit/route.test.js b/test/unit/route.test.js
new file mode 100644
index 00000000..b9360c01
--- /dev/null
+++ b/test/unit/route.test.js
@@ -0,0 +1,24 @@
+import router from '~/route';
+
+describe('router', () => {
+  test('root redirect uses localStorage landingpage when set', () => {
+    const rootRoute = router.options.routes.find(route => route.path === '/');
+
+    localStorage.landingpage = '/work-report';
+    expect(rootRoute.redirect({})).toBe('/work-report');
+  });
+
+  test('root redirect falls back to /home when localStorage landingpage is missing', () => {
+    const rootRoute = router.options.routes.find(route => route.path === '/');
+
+    delete localStorage.landingpage;
+    expect(rootRoute.redirect({})).toBe('/home');
+  });
+
+  test('includes the work report route', () => {
+    const workReportRoute = router.options.routes.find(route => route.path === '/work-report');
+
+    expect(workReportRoute).toBeTruthy();
+    expect(typeof workReportRoute.component).toBe('function');
+  });
+});
diff --git a/test/unit/workReport.test.node.ts b/test/unit/workReport.test.node.ts
new file mode 100644
index 00000000..a79e4203
--- /dev/null
+++ b/test/unit/workReport.test.node.ts
@@ -0,0 +1,70 @@
+import {
+  getSupportedWorkReportHosts,
+  getUnsupportedWorkReportHosts,
+  getWorkReportHostOptions,
+} from '~/util/workReport';
+
+const buckets = [
+  {
+    id: 'aw-watcher-window_laptop',
+    hostname: 'laptop',
+    device_id: 'laptop',
+    type: 'currentwindow',
+    data: {},
+  },
+  {
+    id: 'aw-watcher-afk_laptop',
+    hostname: 'laptop',
+    device_id: 'laptop',
+    type: 'afkstatus',
+    data: {},
+  },
+  {
+    id: 'aw-watcher-window_phone',
+    hostname: 'phone',
+    device_id: 'phone',
+    type: 'currentwindow',
+    data: {},
+  },
+];
+
+describe('workReport host helpers', () => {
+  test('getWorkReportHostOptions disables hosts without AFK buckets', () => {
+    expect(getWorkReportHostOptions(buckets as any)).toEqual([
+      { value: 'laptop', text: 'laptop', disabled: false },
+      { value: 'phone', text: 'phone (requires aw-watcher-afk)', disabled: true },
+    ]);
+  });
+
+  test('getUnsupportedWorkReportHosts returns selected hosts missing AFK buckets', () => {
+    expect(getUnsupportedWorkReportHosts(['laptop', 'phone'], buckets as any)).toEqual(['phone']);
+  });
+
+  test('getSupportedWorkReportHosts returns only hosts with AFK buckets', () => {
+    expect(getSupportedWorkReportHosts(['laptop', 'phone'], buckets as any)).toEqual(['laptop']);
+  });
+
+  test('getSupportedWorkReportHosts preserves selected host order', () => {
+    const moreBuckets = [
+      ...buckets,
+      {
+        id: 'aw-watcher-window_desktop',
+        hostname: 'desktop',
+        device_id: 'desktop',
+        type: 'currentwindow',
+        data: {},
+      },
+      {
+        id: 'aw-watcher-afk_desktop',
+        hostname: 'desktop',
+        device_id: 'desktop',
+        type: 'afkstatus',
+        data: {},
+      },
+    ];
+
+    expect(getSupportedWorkReportHosts(['desktop', 'phone', 'laptop'], moreBuckets as any)).toEqual(
+      ['desktop', 'laptop']
+    );
+  });
+});