From 8e90434032a7f51f6a8ce3b32fc1e9b6038b4548 Mon Sep 17 00:00:00 2001
From: digua <i@digua.me>
Date: Mon, 10 Aug 2026 22:11:53 +0800
Subject: [PATCH] feat(insight): add cross-chat time investment

---
 apps/web-wasm/src/App.vue                     |   2 +-
 apps/web-wasm/src/routes.test.ts              |  18 +
 apps/web-wasm/src/routes.ts                   |  12 +
 packages/core/src/index.ts                    |   3 +
 .../query/__tests__/time-investment.test.ts   | 158 ++++++
 packages/core/src/query/index.ts              |   2 +
 packages/core/src/query/time-investment.ts    | 386 ++++++++++++++
 packages/http-routes/src/context/services.ts  |   2 +
 .../src/routes/web/global-insight.test.ts     |  71 ++-
 .../src/routes/web/global-insight.ts          |  27 +-
 packages/node-runtime/src/database-manager.ts |  10 +-
 packages/node-runtime/src/index.ts            |   6 +
 .../adapters/database-manager-adapter.test.ts |  21 +-
 .../src/services/global-insight/index.ts      |  10 +
 .../src/services/global-insight/paths.ts      |   8 +
 .../time-investment-compute.test.ts           |  52 ++
 .../global-insight/time-investment-compute.ts | 110 ++++
 .../time-investment-facts-cache.ts            |  79 +++
 .../time-investment-service.test.ts           |  76 +++
 .../global-insight/time-investment-service.ts | 251 +++++++++
 .../time-investment-signature.ts              |  18 +
 .../time-investment-snapshot.ts               |  64 +++
 .../global-insight/time-investment-types.ts   |  27 +
 .../services/global-insight/worker-entry.ts   |  15 +
 .../services/global-insight/worker-runner.ts  |  68 ++-
 packages/node-runtime/src/services/index.ts   |  11 +-
 packages/shared-types/index.ts                |  40 ++
 .../src/import/session-runtime.test.ts        |  37 ++
 .../web-runtime/src/import/session-runtime.ts |  51 +-
 packages/web-runtime/src/rpc/protocol.ts      |   7 +-
 .../web-runtime/src/worker/controller.test.ts |  29 ++
 packages/web-runtime/src/worker/controller.ts |   7 +
 src/components/charts/EChartLine.vue          |   7 +-
 src/components/common/Sidebar.vue             |   5 +-
 src/i18n/locales/en-US/insight.json           |  28 +
 src/i18n/locales/ja-JP/insight.json           |  28 +
 src/i18n/locales/zh-CN/insight.json           |  28 +
 src/i18n/locales/zh-TW/insight.json           |  28 +
 .../components/AnnualInsightBoard.vue         |   5 +-
 src/pages/insight/annual-summary/index.vue    |   6 +-
 .../InsightCalendarGrid.vue}                  |  13 +-
 src/pages/insight/index.vue                   |  43 +-
 ...nge.test.ts => insight-time-range.test.ts} |   4 +-
 ...ry-time-range.ts => insight-time-range.ts} |  19 +-
 src/pages/insight/time-investment/index.vue   | 478 +++++++++++++++++-
 src/services/data/browser.test.ts             |  45 ++
 src/services/data/browser.ts                  |  43 +-
 src/services/data/fetch.ts                    |   9 +
 src/services/data/types.ts                    |   3 +
 49 files changed, 2406 insertions(+), 64 deletions(-)
 create mode 100644 apps/web-wasm/src/routes.test.ts
 create mode 100644 packages/core/src/query/__tests__/time-investment.test.ts
 create mode 100644 packages/core/src/query/time-investment.ts
 create mode 100644 packages/node-runtime/src/services/global-insight/time-investment-compute.test.ts
 create mode 100644 packages/node-runtime/src/services/global-insight/time-investment-compute.ts
 create mode 100644 packages/node-runtime/src/services/global-insight/time-investment-facts-cache.ts
 create mode 100644 packages/node-runtime/src/services/global-insight/time-investment-service.test.ts
 create mode 100644 packages/node-runtime/src/services/global-insight/time-investment-service.ts
 create mode 100644 packages/node-runtime/src/services/global-insight/time-investment-signature.ts
 create mode 100644 packages/node-runtime/src/services/global-insight/time-investment-snapshot.ts
 create mode 100644 packages/node-runtime/src/services/global-insight/time-investment-types.ts
 rename src/pages/insight/{annual-summary/components/AnnualCalendarGrid.vue => components/InsightCalendarGrid.vue} (93%)
 rename src/pages/insight/{annual-summary-time-range.test.ts => insight-time-range.test.ts} (72%)
 rename src/pages/insight/{annual-summary-time-range.ts => insight-time-range.ts} (73%)

diff --git a/apps/web-wasm/src/App.vue b/apps/web-wasm/src/App.vue
index a8c595a5..7a0e71da 100644
--- a/apps/web-wasm/src/App.vue
+++ b/apps/web-wasm/src/App.vue
@@ -102,7 +102,7 @@ onMounted(() => {
         </div>
       </template>
       <template v-else>
-        <Sidebar v-if="shouldShowSidebar" :backend-features="false" settings-enabled />
+        <Sidebar v-if="shouldShowSidebar" :backend-features="false" insight-enabled settings-enabled />
         <main class="relative flex-1 overflow-hidden">
           <router-view v-slot="{ Component }">
             <Transition name="page-fade" mode="out-in">
diff --git a/apps/web-wasm/src/routes.test.ts b/apps/web-wasm/src/routes.test.ts
new file mode 100644
index 00000000..cb4b99ad
--- /dev/null
+++ b/apps/web-wasm/src/routes.test.ts
@@ -0,0 +1,18 @@
+/**
+ * Run: pnpm test -- apps/web-wasm/src/routes.test.ts
+ */
+
+import assert from 'node:assert/strict'
+import test from 'node:test'
+import { webWasmRoutes } from './routes'
+
+test('registers time investment as the Web WASM insight route', () => {
+  const insightRoute = webWasmRoutes.find((route) => route.path === '/insight')
+
+  assert.ok(insightRoute)
+  assert.deepEqual(insightRoute.redirect, { name: 'insight-time-investment' })
+  assert.deepEqual(
+    insightRoute.children?.map((route) => ({ path: route.path, name: route.name })),
+    [{ path: 'time-investment', name: 'insight-time-investment' }]
+  )
+})
diff --git a/apps/web-wasm/src/routes.ts b/apps/web-wasm/src/routes.ts
index 8345931e..b39244b8 100644
--- a/apps/web-wasm/src/routes.ts
+++ b/apps/web-wasm/src/routes.ts
@@ -16,4 +16,16 @@ export const webWasmRoutes: RouteRecordRaw[] = [
     name: 'private-chat',
     component: () => import('./pages/SessionDetailPage.vue'),
   },
+  {
+    path: '/insight',
+    component: () => import('@/pages/insight/index.vue'),
+    redirect: { name: 'insight-time-investment' },
+    children: [
+      {
+        path: 'time-investment',
+        name: 'insight-time-investment',
+        component: () => import('@/pages/insight/time-investment/index.vue'),
+      },
+    ],
+  },
 ]
diff --git a/packages/core/src/index.ts b/packages/core/src/index.ts
index 4c4bff9d..fffb0bd0 100644
--- a/packages/core/src/index.ts
+++ b/packages/core/src/index.ts
@@ -118,6 +118,8 @@ export {
   escapeLikePattern,
   buildExcludeKeywordsConditions,
   computeResponseTimeStats,
+  aggregateTimeInvestmentFacts,
+  getTimeInvestmentSessionFacts,
   fetchMessagesBefore,
   fetchMessagesAfter,
   searchMessagesLikeAsync,
@@ -170,6 +172,7 @@ export type {
   AnnualSummaryAnalyzedFacts,
   AnnualSummaryRange,
   AnnualSummarySessionFacts,
+  TimeInvestmentSessionFacts,
   ContactScoringResult,
   FriendScoreComponents,
   FriendScoreInput,
diff --git a/packages/core/src/query/__tests__/time-investment.test.ts b/packages/core/src/query/__tests__/time-investment.test.ts
new file mode 100644
index 00000000..40ee5978
--- /dev/null
+++ b/packages/core/src/query/__tests__/time-investment.test.ts
@@ -0,0 +1,158 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+import Database from 'better-sqlite3'
+import { ChatType, MessageType, type AnnualSummaryRange } from '@openchatlab/shared-types'
+import { SqliteTestAdapter } from './sqlite-test-adapter'
+import {
+  aggregateTimeInvestmentFacts,
+  estimateTimeInvestmentIntervals,
+  getTimeInvestmentSessionFacts,
+  type TimeInvestmentMessagePoint,
+  type TimeInvestmentSessionFacts,
+} from '../time-investment'
+
+const range: AnnualSummaryRange = {
+  mode: 'year',
+  year: 2026,
+  startTs: localTs(2026, 1, 1),
+  endTs: localTs(2026, 12, 31, 23, 59, 59),
+}
+
+test('estimates bounded investment intervals from owner message anchors', () => {
+  const points: TimeInvestmentMessagePoint[] = [
+    { ts: 1_000, senderId: 2 },
+    { ts: 1_060, senderId: 1 },
+    { ts: 1_240, senderId: 1 },
+    { ts: 1_300, senderId: 2 },
+    { ts: 1_600, senderId: 2 },
+  ]
+
+  assert.deepEqual(estimateTimeInvestmentIntervals(points, 1, { startTs: 0, endTs: 10_000 }), [
+    { startTs: 1_000, endTs: 1_360 },
+  ])
+})
+
+test('includes non-system media anchors and caps a busy reply tail at five minutes', () => {
+  const points: TimeInvestmentMessagePoint[] = [
+    { ts: 2_000, senderId: 1 },
+    { ts: 2_060, senderId: 2 },
+    { ts: 2_180, senderId: 2 },
+    { ts: 2_300, senderId: 2 },
+    { ts: 2_360, senderId: 2 },
+  ]
+
+  assert.deepEqual(estimateTimeInvestmentIntervals(points, 1, { startTs: 0, endTs: 10_000 }), [
+    { startTs: 2_000, endTs: 2_300 },
+  ])
+})
+
+test('merges overlaps globally and allocates overlapping investment across sessions', () => {
+  const facts: TimeInvestmentSessionFacts[] = [
+    analyzedFacts('a', ChatType.PRIVATE, [interval(100, 300)]),
+    analyzedFacts('b', ChatType.GROUP, [interval(200, 400)]),
+  ]
+
+  const result = aggregateTimeInvestmentFacts(facts, {
+    mode: 'year',
+    year: 1970,
+    startTs: 0,
+    endTs: 86_399,
+  })
+
+  assert.equal(result.metrics.estimatedSeconds, 300)
+  assert.equal(result.metrics.activeDayCount, 1)
+  assert.equal(
+    result.sessionRanking.reduce((sum, item) => sum + item.seconds, 0),
+    300
+  )
+  assert.deepEqual(
+    result.sessionRanking.map(({ sessionId, seconds }) => ({ sessionId, seconds })),
+    [
+      { sessionId: 'a', seconds: 150 },
+      { sessionId: 'b', seconds: 150 },
+    ]
+  )
+})
+
+test('queries real chat data, excludes system messages, and reports missing owners', () => {
+  const raw = createDb('owner')
+  const insert = raw.prepare('INSERT INTO message (sender_id, ts, type, content) VALUES (?, ?, ?, ?)')
+  insert.run(2, localTs(2026, 5, 1, 9, 59), MessageType.TEXT, 'trigger')
+  insert.run(1, localTs(2026, 5, 1, 10, 0), MessageType.IMAGE, '[image]')
+  insert.run(3, localTs(2026, 5, 1, 10, 1), MessageType.SYSTEM, 'system')
+  insert.run(2, localTs(2026, 5, 1, 10, 2), MessageType.TEXT, 'reply')
+
+  const facts = getTimeInvestmentSessionFacts(new SqliteTestAdapter(raw), 'session-a', range)
+  assert.equal(facts.kind, 'analyzed')
+  if (facts.kind !== 'analyzed') return
+  assert.equal(facts.sessionName, 'Example')
+  assert.deepEqual(facts.investmentIntervals, [
+    { startTs: localTs(2026, 5, 1, 9, 59), endTs: localTs(2026, 5, 1, 10, 3) },
+  ])
+
+  raw.prepare('UPDATE meta SET owner_id = NULL').run()
+  assert.equal(getTimeInvestmentSessionFacts(new SqliteTestAdapter(raw), 'session-a', range).kind, 'missing_owner')
+})
+
+function createDb(ownerId: string | null): Database.Database {
+  const db = new Database(':memory:')
+  db.exec(`
+    CREATE TABLE meta (
+      name TEXT,
+      platform TEXT,
+      type TEXT,
+      imported_at INTEGER,
+      owner_id TEXT
+    );
+    CREATE TABLE member (
+      id INTEGER PRIMARY KEY,
+      platform_id TEXT NOT NULL,
+      account_name TEXT,
+      group_nickname TEXT,
+      aliases TEXT DEFAULT '[]',
+      avatar TEXT
+    );
+    CREATE TABLE message (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      sender_id INTEGER,
+      ts INTEGER,
+      type INTEGER,
+      content TEXT
+    );
+  `)
+  db.prepare('INSERT INTO meta (name, platform, type, imported_at, owner_id) VALUES (?, ?, ?, ?, ?)').run(
+    'Example',
+    'qq',
+    ChatType.PRIVATE,
+    0,
+    ownerId
+  )
+  db.prepare('INSERT INTO member (id, platform_id, account_name) VALUES (1, ?, ?)').run('owner', 'Me')
+  db.prepare('INSERT INTO member (id, platform_id, account_name) VALUES (2, ?, ?)').run('friend', 'Friend')
+  db.prepare('INSERT INTO member (id, platform_id, account_name) VALUES (3, ?, ?)').run('system', '系统消息')
+  return db
+}
+
+function analyzedFacts(
+  sessionId: string,
+  chatType: ChatType,
+  investmentIntervals: Array<{ startTs: number; endTs: number }>
+): TimeInvestmentSessionFacts {
+  return {
+    kind: 'analyzed',
+    sessionId,
+    sessionName: sessionId,
+    platform: 'qq',
+    chatType,
+    availableDataYears: [1970],
+    investmentIntervals,
+  }
+}
+
+function interval(startTs: number, endTs: number) {
+  return { startTs, endTs }
+}
+
+function localTs(year: number, month: number, day: number, hour = 0, minute = 0, second = 0): number {
+  return Math.floor(new Date(year, month - 1, day, hour, minute, second).getTime() / 1000)
+}
diff --git a/packages/core/src/query/index.ts b/packages/core/src/query/index.ts
index 81c4cf2f..fe34cddb 100644
--- a/packages/core/src/query/index.ts
+++ b/packages/core/src/query/index.ts
@@ -97,6 +97,8 @@ export type {
   AnnualSummaryRange,
   AnnualSummarySessionFacts,
 } from './global-insight'
+export { aggregateTimeInvestmentFacts, getTimeInvestmentSessionFacts } from './time-investment'
+export type { TimeInvestmentSessionFacts } from './time-investment'
 export type {
   ContactFactsOptions,
   ContactMemberRef,
diff --git a/packages/core/src/query/time-investment.ts b/packages/core/src/query/time-investment.ts
new file mode 100644
index 00000000..9eb62959
--- /dev/null
+++ b/packages/core/src/query/time-investment.ts
@@ -0,0 +1,386 @@
+import {
+  ChatType,
+  MessageType,
+  type AnnualSummaryCoverage,
+  type AnnualSummaryRange,
+  type ChatPlatform,
+  type TimeInvestmentActivityPoint,
+  type TimeInvestmentChatTypeItem,
+  type TimeInvestmentMetrics,
+  type TimeInvestmentSessionRankItem,
+} from '@openchatlab/shared-types'
+import type { DatabaseAdapter } from '../interfaces'
+import { resolveOwnerMember } from './contact-queries'
+import { getSessionMeta, isChatSessionDb } from './session-queries'
+
+const TIME_INVESTMENT_ACTIVITY_GAP_SECONDS = 5 * 60
+const TIME_INVESTMENT_TAIL_SECONDS = 60
+const TIME_INVESTMENT_SELF_INITIATED_SECONDS = 2 * 60
+const TIME_INVESTMENT_CONTEXT_SECONDS = 5 * 60
+
+export interface TimeInvestmentInterval {
+  startTs: number
+  endTs: number
+}
+
+export interface TimeInvestmentMessagePoint {
+  ts: number
+  senderId: number
+}
+
+export interface TimeInvestmentAnalyzedFacts {
+  kind: 'analyzed'
+  sessionId: string
+  sessionName: string
+  platform: ChatPlatform
+  chatType: ChatType
+  availableDataYears: number[]
+  investmentIntervals: TimeInvestmentInterval[]
+}
+
+export type TimeInvestmentSessionFacts =
+  | TimeInvestmentAnalyzedFacts
+  | {
+      kind: 'not_chat_db' | 'missing_meta' | 'unsupported_type' | 'missing_owner' | 'unresolved_owner' | 'failed'
+      availableDataYears: number[]
+    }
+
+export interface TimeInvestmentAggregatedData {
+  availableDataYears: number[]
+  latestDataYear: number | null
+  metrics: TimeInvestmentMetrics
+  monthlyActivity: TimeInvestmentActivityPoint[]
+  dailyActivity: TimeInvestmentActivityPoint[]
+  sessionRanking: TimeInvestmentSessionRankItem[]
+  chatTypes: TimeInvestmentChatTypeItem[]
+  coverage: AnnualSummaryCoverage
+}
+
+const EXCLUDED_MESSAGE_TYPES = [MessageType.SYSTEM, MessageType.RECALL]
+
+export function getTimeInvestmentSessionFacts(
+  db: DatabaseAdapter,
+  sessionId: string,
+  range: AnnualSummaryRange
+): TimeInvestmentSessionFacts {
+  if (!isChatSessionDb(db)) return emptyFacts('not_chat_db')
+  const meta = getSessionMeta(db)
+  if (!meta) return emptyFacts('missing_meta')
+  if (meta.type !== ChatType.PRIVATE && meta.type !== ChatType.GROUP) return emptyFacts('unsupported_type')
+  if (!meta.ownerId?.trim()) return emptyFacts('missing_owner')
+  const owner = resolveOwnerMember(db)
+  if (!owner) return emptyFacts('unresolved_owner')
+
+  const contextStartTs = range.startTs - TIME_INVESTMENT_CONTEXT_SECONDS
+  const contextEndTs = range.endTs + TIME_INVESTMENT_CONTEXT_SECONDS
+  const points = db
+    .prepare(
+      `SELECT msg.ts, msg.sender_id as senderId
+       FROM message msg
+       JOIN member m ON msg.sender_id = m.id
+       WHERE msg.ts >= ? AND msg.ts <= ?
+         AND msg.type NOT IN (${EXCLUDED_MESSAGE_TYPES.join(', ')})
+         AND COALESCE(m.account_name, '') != '系统消息'
+       ORDER BY msg.ts ASC, msg.id ASC`
+    )
+    .all(contextStartTs, contextEndTs) as unknown as TimeInvestmentMessagePoint[]
+  const availableDataYears = (
+    db
+      .prepare(
+        `SELECT DISTINCT CAST(strftime('%Y', msg.ts, 'unixepoch', 'localtime') AS INTEGER) as year
+         FROM message msg
+         JOIN member m ON msg.sender_id = m.id
+         WHERE msg.sender_id = ?
+           AND msg.type NOT IN (${EXCLUDED_MESSAGE_TYPES.join(', ')})
+           AND COALESCE(m.account_name, '') != '系统消息'
+         ORDER BY year DESC`
+      )
+      .all(owner.id) as Array<{ year: number }>
+  ).map((row) => row.year)
+  const investmentIntervals = estimateTimeInvestmentIntervals(points, owner.id, range)
+
+  return {
+    kind: 'analyzed',
+    sessionId,
+    sessionName: meta.name,
+    platform: meta.platform,
+    chatType: meta.type,
+    availableDataYears,
+    investmentIntervals,
+  }
+}
+
+export function estimateTimeInvestmentIntervals(
+  points: TimeInvestmentMessagePoint[],
+  ownerId: number,
+  range: Pick<AnnualSummaryRange, 'startTs' | 'endTs'>
+): TimeInvestmentInterval[] {
+  const ordered = [...points].sort((a, b) => a.ts - b.ts)
+  const ownerPoints = ordered.filter((point) => point.senderId === ownerId)
+  if (ownerPoints.length === 0) return []
+
+  const clusters: TimeInvestmentMessagePoint[][] = []
+  let current: TimeInvestmentMessagePoint[] = []
+  for (const point of ownerPoints) {
+    const previous = current.at(-1)
+    if (previous && point.ts - previous.ts > TIME_INVESTMENT_ACTIVITY_GAP_SECONDS) {
+      clusters.push(current)
+      current = []
+    }
+    current.push(point)
+  }
+  if (current.length > 0) clusters.push(current)
+
+  const investment: TimeInvestmentInterval[] = []
+  for (const cluster of clusters) {
+    const first = cluster[0]
+    const last = cluster.at(-1)!
+    const trigger = findLastOtherPoint(ordered, ownerId, first.ts - TIME_INVESTMENT_CONTEXT_SECONDS, first.ts)
+    const reply = findLastOtherPoint(ordered, ownerId, last.ts + 1, last.ts + TIME_INVESTMENT_CONTEXT_SECONDS + 1)
+    const startTs = trigger?.ts ?? first.ts
+    let endTs = last.ts + TIME_INVESTMENT_TAIL_SECONDS
+    if (reply) {
+      endTs = Math.max(
+        endTs,
+        Math.min(last.ts + TIME_INVESTMENT_CONTEXT_SECONDS, reply.ts + TIME_INVESTMENT_TAIL_SECONDS)
+      )
+    }
+    if (cluster.length === 1 && !trigger) {
+      endTs = Math.max(endTs, first.ts + TIME_INVESTMENT_SELF_INITIATED_SECONDS)
+    }
+    const investmentInterval = clipInterval({ startTs, endTs }, range)
+    if (investmentInterval) investment.push(investmentInterval)
+  }
+
+  return mergeIntervals(investment)
+}
+
+export function aggregateTimeInvestmentFacts(
+  facts: TimeInvestmentSessionFacts[],
+  range: AnnualSummaryRange
+): TimeInvestmentAggregatedData {
+  const analyzed = facts.filter((item): item is TimeInvestmentAnalyzedFacts => item.kind === 'analyzed')
+  const availableDataYears = [...new Set(analyzed.flatMap((item) => item.availableDataYears))].sort((a, b) => b - a)
+  const investmentIntervals = mergeIntervals(analyzed.flatMap((item) => item.investmentIntervals))
+  const estimatedSeconds = sumIntervals(investmentIntervals)
+  const dailyEstimated = splitIntervalsByLocalDay(investmentIntervals)
+  const dailyActivity = buildDailyActivity(dailyEstimated)
+  const allocations = allocateIntervalsBySession(analyzed)
+  const sessionRanking = analyzed
+    .map((item) => {
+      const seconds = normalizeSeconds(allocations.get(item.sessionId) ?? 0)
+      return {
+        sessionId: item.sessionId,
+        name: item.sessionName,
+        platform: item.platform,
+        type: item.chatType,
+        seconds,
+        share: percentage(seconds, estimatedSeconds),
+      }
+    })
+    .filter((item) => item.seconds > 0)
+    .sort((a, b) => b.seconds - a.seconds || a.name.localeCompare(b.name))
+  const chatTypes = buildChatTypeBreakdown(sessionRanking, estimatedSeconds)
+
+  return {
+    availableDataYears,
+    latestDataYear: availableDataYears[0] ?? null,
+    metrics: {
+      estimatedSeconds,
+      activeDayCount: dailyActivity.length,
+      averagePerActiveDaySeconds: dailyActivity.length ? Math.round(estimatedSeconds / dailyActivity.length) : 0,
+    },
+    monthlyActivity: buildMonthlyActivity(range, dailyEstimated),
+    dailyActivity,
+    sessionRanking,
+    chatTypes,
+    coverage: buildCoverage(facts),
+  }
+}
+
+function mergeIntervals(intervals: TimeInvestmentInterval[]): TimeInvestmentInterval[] {
+  const ordered = intervals
+    .filter((item) => Number.isFinite(item.startTs) && Number.isFinite(item.endTs) && item.endTs > item.startTs)
+    .sort((a, b) => a.startTs - b.startTs || a.endTs - b.endTs)
+  const merged: TimeInvestmentInterval[] = []
+  for (const interval of ordered) {
+    const previous = merged.at(-1)
+    if (!previous || interval.startTs > previous.endTs) merged.push({ ...interval })
+    else previous.endTs = Math.max(previous.endTs, interval.endTs)
+  }
+  return merged
+}
+
+function findLastOtherPoint(
+  points: TimeInvestmentMessagePoint[],
+  ownerId: number,
+  startTs: number,
+  endTsExclusive: number
+): TimeInvestmentMessagePoint | undefined {
+  for (let index = lowerBoundByTimestamp(points, endTsExclusive) - 1; index >= 0; index--) {
+    const point = points[index]
+    if (point.ts < startTs) break
+    if (point.senderId !== ownerId) return point
+  }
+  return undefined
+}
+
+function lowerBoundByTimestamp(points: TimeInvestmentMessagePoint[], targetTs: number): number {
+  let low = 0
+  let high = points.length
+  while (low < high) {
+    const middle = low + Math.floor((high - low) / 2)
+    if (points[middle].ts < targetTs) low = middle + 1
+    else high = middle
+  }
+  return low
+}
+
+function clipInterval(
+  interval: TimeInvestmentInterval,
+  range: Pick<AnnualSummaryRange, 'startTs' | 'endTs'>
+): TimeInvestmentInterval | null {
+  const startTs = Math.max(interval.startTs, range.startTs)
+  const endTs = Math.min(interval.endTs, range.endTs + 1)
+  return endTs > startTs ? { startTs, endTs } : null
+}
+
+function sumIntervals(intervals: TimeInvestmentInterval[]): number {
+  return normalizeSeconds(intervals.reduce((sum, item) => sum + item.endTs - item.startTs, 0))
+}
+
+function splitIntervalsByLocalDay(intervals: TimeInvestmentInterval[]): Map<string, number> {
+  const result = new Map<string, number>()
+  for (const interval of intervals) {
+    let cursor = interval.startTs
+    while (cursor < interval.endTs) {
+      const current = new Date(cursor * 1000)
+      const key = formatLocalDate(current)
+      const nextMidnight = Math.floor(
+        new Date(current.getFullYear(), current.getMonth(), current.getDate() + 1).getTime() / 1000
+      )
+      const segmentEnd = Math.min(interval.endTs, nextMidnight)
+      result.set(key, (result.get(key) ?? 0) + segmentEnd - cursor)
+      cursor = segmentEnd
+    }
+  }
+  return result
+}
+
+function buildDailyActivity(estimated: Map<string, number>): TimeInvestmentActivityPoint[] {
+  return [...estimated.keys()]
+    .sort()
+    .map((key) => ({
+      key,
+      estimatedSeconds: normalizeSeconds(estimated.get(key) ?? 0),
+    }))
+    .filter((item) => item.estimatedSeconds > 0)
+}
+
+function buildMonthlyActivity(
+  range: AnnualSummaryRange,
+  dailyEstimated: Map<string, number>
+): TimeInvestmentActivityPoint[] {
+  const estimated = groupDaysByMonth(dailyEstimated)
+  const points: TimeInvestmentActivityPoint[] = []
+  const cursor = new Date(range.startTs * 1000)
+  cursor.setDate(1)
+  cursor.setHours(0, 0, 0, 0)
+  const end = new Date(range.endTs * 1000)
+  end.setDate(1)
+  end.setHours(0, 0, 0, 0)
+  while (cursor <= end) {
+    const key = `${cursor.getFullYear()}-${String(cursor.getMonth() + 1).padStart(2, '0')}`
+    points.push({
+      key,
+      estimatedSeconds: normalizeSeconds(estimated.get(key) ?? 0),
+    })
+    cursor.setMonth(cursor.getMonth() + 1)
+  }
+  return points
+}
+
+function groupDaysByMonth(days: Map<string, number>): Map<string, number> {
+  const months = new Map<string, number>()
+  for (const [day, seconds] of days) {
+    const month = day.slice(0, 7)
+    months.set(month, (months.get(month) ?? 0) + seconds)
+  }
+  return months
+}
+
+function allocateIntervalsBySession(facts: TimeInvestmentAnalyzedFacts[]): Map<string, number> {
+  const events = facts
+    .flatMap((item) =>
+      item.investmentIntervals.flatMap((interval) => [
+        { ts: interval.startTs, sessionId: item.sessionId, delta: 1 },
+        { ts: interval.endTs, sessionId: item.sessionId, delta: -1 },
+      ])
+    )
+    .sort((a, b) => a.ts - b.ts)
+  const allocations = new Map<string, number>()
+  const active = new Set<string>()
+  let previousTs: number | null = null
+  let index = 0
+  while (index < events.length) {
+    const ts = events[index].ts
+    if (previousTs !== null && ts > previousTs && active.size > 0) {
+      const share = (ts - previousTs) / active.size
+      active.forEach((sessionId) => allocations.set(sessionId, (allocations.get(sessionId) ?? 0) + share))
+    }
+    while (index < events.length && events[index].ts === ts) {
+      const event = events[index]
+      if (event.delta > 0) active.add(event.sessionId)
+      else active.delete(event.sessionId)
+      index++
+    }
+    previousTs = ts
+  }
+  return allocations
+}
+
+function buildChatTypeBreakdown(
+  sessions: TimeInvestmentSessionRankItem[],
+  totalSeconds: number
+): TimeInvestmentChatTypeItem[] {
+  const totals = new Map<ChatType, number>()
+  sessions.forEach((item) => totals.set(item.type, (totals.get(item.type) ?? 0) + item.seconds))
+  return [...totals.entries()]
+    .map(([type, seconds]) => ({ type, seconds: normalizeSeconds(seconds), share: percentage(seconds, totalSeconds) }))
+    .sort((a, b) => b.seconds - a.seconds)
+}
+
+function buildCoverage(facts: TimeInvestmentSessionFacts[]): AnnualSummaryCoverage {
+  const coverage: AnnualSummaryCoverage = {
+    totalSessions: 0,
+    analyzedSessions: 0,
+    missingOwnerSessions: 0,
+    unresolvedOwnerSessions: 0,
+    failedSessions: 0,
+  }
+  for (const item of facts) {
+    if (item.kind === 'not_chat_db' || item.kind === 'missing_meta' || item.kind === 'unsupported_type') continue
+    coverage.totalSessions++
+    if (item.kind === 'analyzed') coverage.analyzedSessions++
+    else if (item.kind === 'missing_owner') coverage.missingOwnerSessions++
+    else if (item.kind === 'unresolved_owner') coverage.unresolvedOwnerSessions++
+    else coverage.failedSessions++
+  }
+  return coverage
+}
+
+function emptyFacts(kind: Exclude<TimeInvestmentSessionFacts['kind'], 'analyzed'>): TimeInvestmentSessionFacts {
+  return { kind, availableDataYears: [] }
+}
+
+function formatLocalDate(date: Date): string {
+  return `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}-${String(date.getDate()).padStart(2, '0')}`
+}
+
+function percentage(value: number, total: number): number {
+  return total > 0 ? Math.round((value / total) * 10_000) / 100 : 0
+}
+
+function normalizeSeconds(value: number): number {
+  return Math.round(value * 1_000) / 1_000
+}
diff --git a/packages/http-routes/src/context/services.ts b/packages/http-routes/src/context/services.ts
index d069fc23..be7b71e8 100644
--- a/packages/http-routes/src/context/services.ts
+++ b/packages/http-routes/src/context/services.ts
@@ -2,6 +2,7 @@ import type {
   AnalyticsService,
   ContactsService,
   GlobalInsightService,
+  TimeInvestmentService,
   PeopleRelationshipsService,
   PreferencesManager,
 } from '@openchatlab/node-runtime'
@@ -11,6 +12,7 @@ export interface ServiceRouteContext {
   contactsService?: ContactsService
   peopleRelationshipsService?: PeopleRelationshipsService
   globalInsightService?: GlobalInsightService
+  timeInvestmentService?: TimeInvestmentService
   preferencesManager?: PreferencesManager
   analyticsService?: AnalyticsService
 }
diff --git a/packages/http-routes/src/routes/web/global-insight.test.ts b/packages/http-routes/src/routes/web/global-insight.test.ts
index 86dd0386..3aa83558 100644
--- a/packages/http-routes/src/routes/web/global-insight.test.ts
+++ b/packages/http-routes/src/routes/web/global-insight.test.ts
@@ -1,11 +1,13 @@
 import assert from 'node:assert/strict'
 import test from 'node:test'
 import Fastify from 'fastify'
-import type { AnnualSummaryResponse } from '@openchatlab/shared-types'
+import type { AnnualSummaryResponse, TimeInvestmentResponse } from '@openchatlab/shared-types'
 import type {
   GlobalInsightService,
   GlobalInsightServiceOptions,
   SessionRuntimeAdapter,
+  TimeInvestmentService,
+  TimeInvestmentServiceOptions,
 } from '@openchatlab/node-runtime'
 import type { PathProvider } from '@openchatlab/core'
 import { registerGlobalInsightRoutes } from './global-insight'
@@ -42,6 +44,23 @@ function emptyResponse(): AnnualSummaryResponse {
   }
 }
 
+function emptyTimeInvestmentResponse(): TimeInvestmentResponse {
+  const annual = emptyResponse()
+  return {
+    range: annual.range,
+    availableDataYears: [],
+    latestDataYear: null,
+    metrics: null,
+    monthlyActivity: [],
+    dailyActivity: [],
+    sessionRanking: [],
+    chatTypes: [],
+    coverage: annual.coverage,
+    cache: annual.cache,
+    task: annual.task,
+  }
+}
+
 class FakeService implements GlobalInsightService {
   getCalls: GlobalInsightServiceOptions[] = []
   recomputeCalls: GlobalInsightServiceOptions[] = []
@@ -68,9 +87,30 @@ class FakeService implements GlobalInsightService {
   }
 }
 
-function context(service: GlobalInsightService): GlobalInsightRouteContext {
+class FakeTimeInvestmentService implements TimeInvestmentService {
+  getCalls: TimeInvestmentServiceOptions[] = []
+  recomputeCalls: TimeInvestmentServiceOptions[] = []
+  closeCalls = 0
+  getTimeInvestment(options: TimeInvestmentServiceOptions = {}) {
+    this.getCalls.push(options)
+    return emptyTimeInvestmentResponse()
+  }
+  startRecompute(options: TimeInvestmentServiceOptions = {}) {
+    this.recomputeCalls.push(options)
+    return emptyTimeInvestmentResponse()
+  }
+  async close() {
+    this.closeCalls++
+  }
+}
+
+function context(
+  service: GlobalInsightService,
+  timeInvestmentService: TimeInvestmentService = new FakeTimeInvestmentService()
+): GlobalInsightRouteContext {
   return {
     globalInsightService: service,
+    timeInvestmentService,
     sessionAdapter: {} as SessionRuntimeAdapter,
     pathProvider: {} as PathProvider,
   }
@@ -93,6 +133,29 @@ test('GET forwards year mode and stale preference', async (t) => {
   assert.deepEqual(response.json().monthlyDirectContacts, [])
 })
 
+test('time investment routes forward range, stale, and recompute options', async (t) => {
+  const service = new FakeService()
+  const timeInvestmentService = new FakeTimeInvestmentService()
+  const app = Fastify()
+  t.after(() => app.close())
+  registerGlobalInsightRoutes(app, context(service, timeInvestmentService))
+  await app.ready()
+
+  const getResponse = await app.inject({
+    method: 'GET',
+    url: '/_web/global-insight/time-investment?mode=year&year=2025&acceptStale=true',
+  })
+  const recomputeResponse = await app.inject({
+    method: 'POST',
+    url: '/_web/global-insight/time-investment/recompute?mode=recent&days=365',
+  })
+
+  assert.equal(getResponse.statusCode, 200)
+  assert.equal(recomputeResponse.statusCode, 200)
+  assert.deepEqual(timeInvestmentService.getCalls, [{ mode: 'year', year: 2025, days: undefined, acceptStale: true }])
+  assert.deepEqual(timeInvestmentService.recomputeCalls, [{ mode: 'recent', year: undefined, days: 365 }])
+})
+
 test('GET normalizes unsupported values before calling the service', async (t) => {
   const service = new FakeService()
   const app = Fastify()
@@ -107,8 +170,9 @@ test('GET normalizes unsupported values before calling the service', async (t) =
 
 test('POST recompute forwards recent mode and closes the injected service', async () => {
   const service = new FakeService()
+  const timeInvestmentService = new FakeTimeInvestmentService()
   const app = Fastify()
-  registerGlobalInsightRoutes(app, context(service))
+  registerGlobalInsightRoutes(app, context(service, timeInvestmentService))
   await app.ready()
 
   const response = await app.inject({
@@ -120,4 +184,5 @@ test('POST recompute forwards recent mode and closes the injected service', asyn
   assert.deepEqual(service.recomputeCalls, [{ mode: 'recent', year: undefined, days: 365 }])
   await app.close()
   assert.equal(service.closeCalls, 1)
+  assert.equal(timeInvestmentService.closeCalls, 1)
 })
diff --git a/packages/http-routes/src/routes/web/global-insight.ts b/packages/http-routes/src/routes/web/global-insight.ts
index aa00c856..39a40721 100644
--- a/packages/http-routes/src/routes/web/global-insight.ts
+++ b/packages/http-routes/src/routes/web/global-insight.ts
@@ -1,5 +1,5 @@
 import type { FastifyInstance } from 'fastify'
-import { createGlobalInsightService } from '@openchatlab/node-runtime'
+import { createGlobalInsightService, createTimeInvestmentService } from '@openchatlab/node-runtime'
 import type { RuntimeRouteContext } from '../../context/runtime'
 import type { ServiceRouteContext } from '../../context/services'
 
@@ -14,7 +14,7 @@ type GlobalInsightRouteContext = Pick<
   RuntimeRouteContext,
   'sessionAdapter' | 'pathProvider' | 'runtimeIdentity' | 'nativeBinding'
 > &
-  Pick<ServiceRouteContext, 'globalInsightService'>
+  Pick<ServiceRouteContext, 'globalInsightService' | 'timeInvestmentService'>
 
 export function registerGlobalInsightRoutes(server: FastifyInstance, ctx: GlobalInsightRouteContext): void {
   const service =
@@ -25,7 +25,17 @@ export function registerGlobalInsightRoutes(server: FastifyInstance, ctx: Global
       runtimeIdentity: ctx.runtimeIdentity,
       nativeBinding: ctx.nativeBinding,
     })
-  server.addHook('onClose', async () => service.close())
+  const timeInvestmentService =
+    ctx.timeInvestmentService ??
+    createTimeInvestmentService({
+      adapter: ctx.sessionAdapter,
+      pathProvider: ctx.pathProvider,
+      runtimeIdentity: ctx.runtimeIdentity,
+      nativeBinding: ctx.nativeBinding,
+    })
+  server.addHook('onClose', async () => {
+    await Promise.all([service.close(), timeInvestmentService.close()])
+  })
 
   server.get<{ Querystring: GlobalInsightQuery }>('/_web/global-insight/annual-summary', async (request) => {
     return service.getAnnualSummary({
@@ -37,6 +47,17 @@ export function registerGlobalInsightRoutes(server: FastifyInstance, ctx: Global
   server.post<{ Querystring: GlobalInsightQuery }>('/_web/global-insight/annual-summary/recompute', async (request) =>
     service.startRecompute(parseRange(request.query))
   )
+
+  server.get<{ Querystring: GlobalInsightQuery }>('/_web/global-insight/time-investment', async (request) =>
+    timeInvestmentService.getTimeInvestment({
+      ...parseRange(request.query),
+      acceptStale: isTruthy(request.query.acceptStale),
+    })
+  )
+
+  server.post<{ Querystring: GlobalInsightQuery }>('/_web/global-insight/time-investment/recompute', async (request) =>
+    timeInvestmentService.startRecompute(parseRange(request.query))
+  )
 }
 
 function parseRange(query: GlobalInsightQuery) {
diff --git a/packages/node-runtime/src/database-manager.ts b/packages/node-runtime/src/database-manager.ts
index 73716628..5500473e 100644
--- a/packages/node-runtime/src/database-manager.ts
+++ b/packages/node-runtime/src/database-manager.ts
@@ -22,8 +22,14 @@ import { deleteSessionCache } from './cache/session-cache'
 import { assertDataDirCompatible, type RuntimeIdentity } from './data-dir-compat'
 import { CHAT_DB_COMPATIBILITY_RAISES, getChatDbMigrations, raiseChatDbCompatibilityGate } from './migrations'
 import { getContactsFactsCacheDir } from './services/contacts/paths'
-import { getGlobalInsightDir, getGlobalInsightFactsCacheDir } from './services/global-insight/paths'
+import {
+  getGlobalInsightDir,
+  getGlobalInsightFactsCacheDir,
+  getTimeInvestmentDir,
+  getTimeInvestmentFactsCacheDir,
+} from './services/global-insight/paths'
 import { deleteAnnualSummarySnapshots } from './services/global-insight/snapshot'
+import { deleteTimeInvestmentSnapshots } from './services/global-insight/time-investment-snapshot'
 import { getPeopleRelationshipsFactsCacheDir } from './services/people/relationships/paths'
 import { assertSessionChatTopicsIdle, deleteSessionChatTopics } from './services/topics'
 
@@ -273,6 +279,8 @@ export class DatabaseManager {
     deleteSessionCache(sessionId, getContactsFactsCacheDir(this.pathProvider.getUserDataDir()))
     deleteSessionCache(sessionId, getGlobalInsightFactsCacheDir(this.pathProvider.getUserDataDir()))
     deleteAnnualSummarySnapshots(getGlobalInsightDir(this.pathProvider.getUserDataDir()))
+    deleteSessionCache(sessionId, getTimeInvestmentFactsCacheDir(this.pathProvider.getUserDataDir()))
+    deleteTimeInvestmentSnapshots(getTimeInvestmentDir(this.pathProvider.getUserDataDir()))
     deleteSessionCache(sessionId, getPeopleRelationshipsFactsCacheDir(this.pathProvider.getUserDataDir()))
     return existed
   }
diff --git a/packages/node-runtime/src/index.ts b/packages/node-runtime/src/index.ts
index 9be4c21f..09e8669b 100644
--- a/packages/node-runtime/src/index.ts
+++ b/packages/node-runtime/src/index.ts
@@ -480,6 +480,7 @@ export {
   CONTACTS_ALGORITHM_VERSION,
   PEOPLE_RELATIONSHIPS_ALGORITHM_VERSION,
   ANNUAL_SUMMARY_ALGORITHM_VERSION,
+  TIME_INVESTMENT_ALGORITHM_VERSION,
   MergeSessionCache,
   createContactsService,
   createPeopleRelationshipsService,
@@ -492,6 +493,7 @@ export {
   deleteSessionChatTopics,
   getChatTopicsDbPath,
   getChatTopicsDir,
+  createTimeInvestmentService,
   createDatabaseManagerAdapter,
   executePushImportUnlocked,
   DEFAULT_IMPORT_IDEMPOTENCY_TTL_MS,
@@ -529,6 +531,10 @@ export type {
   GlobalInsightServiceOptions,
   FinalizeTopicDayInput,
   TopicDayCheckpoint,
+  TimeInvestmentComputeRunner,
+  TimeInvestmentService,
+  TimeInvestmentServiceDeps,
+  TimeInvestmentServiceOptions,
   PushImportPayload,
   PushImportResult,
   PushImportOutcome,
diff --git a/packages/node-runtime/src/services/adapters/database-manager-adapter.test.ts b/packages/node-runtime/src/services/adapters/database-manager-adapter.test.ts
index 690fe83c..ff51efca 100644
--- a/packages/node-runtime/src/services/adapters/database-manager-adapter.test.ts
+++ b/packages/node-runtime/src/services/adapters/database-manager-adapter.test.ts
@@ -7,7 +7,12 @@ import type { PathProvider } from '@openchatlab/core'
 import { DatabaseManager } from '../../database-manager'
 import { createDatabaseManagerAdapter } from './database-manager-adapter'
 import { getContactsFactsCacheDir } from '../contacts/paths'
-import { getGlobalInsightDir, getGlobalInsightFactsCacheDir } from '../global-insight/paths'
+import {
+  getGlobalInsightDir,
+  getGlobalInsightFactsCacheDir,
+  getTimeInvestmentDir,
+  getTimeInvestmentFactsCacheDir,
+} from '../global-insight/paths'
 
 function makeTempDir(): string {
   const baseDir = process.env.CHATLAB_TEST_TMPDIR ?? (fs.existsSync('/private/tmp') ? '/private/tmp' : os.tmpdir())
@@ -52,6 +57,10 @@ test('DatabaseManager adapter deletes session database sidecar files and caches'
     getGlobalInsightFactsCacheDir(pathProvider.getUserDataDir()),
     `${sessionId}.cache.json`
   )
+  const timeInvestmentFactsCachePath = path.join(
+    getTimeInvestmentFactsCacheDir(pathProvider.getUserDataDir()),
+    `${sessionId}.cache.json`
+  )
   const annualSummaryYearSnapshotPath = path.join(
     getGlobalInsightDir(pathProvider.getUserDataDir()),
     'annual-summary-year-2026.json'
@@ -60,17 +69,25 @@ test('DatabaseManager adapter deletes session database sidecar files and caches'
     getGlobalInsightDir(pathProvider.getUserDataDir()),
     'annual-summary-recent-365.json'
   )
+  const timeInvestmentSnapshotPath = path.join(
+    getTimeInvestmentDir(pathProvider.getUserDataDir()),
+    'time-investment-year-2026.json'
+  )
   fs.mkdirSync(path.dirname(cachePath), { recursive: true })
   fs.mkdirSync(path.dirname(queryCachePath), { recursive: true })
   fs.mkdirSync(path.dirname(contactsFactsCachePath), { recursive: true })
   fs.mkdirSync(path.dirname(globalInsightFactsCachePath), { recursive: true })
+  fs.mkdirSync(path.dirname(timeInvestmentFactsCachePath), { recursive: true })
   fs.mkdirSync(path.dirname(annualSummaryYearSnapshotPath), { recursive: true })
+  fs.mkdirSync(path.dirname(timeInvestmentSnapshotPath), { recursive: true })
   fs.writeFileSync(cachePath, '{}', 'utf-8')
   fs.writeFileSync(queryCachePath, '{}', 'utf-8')
   fs.writeFileSync(contactsFactsCachePath, '{}', 'utf-8')
   fs.writeFileSync(globalInsightFactsCachePath, '{}', 'utf-8')
+  fs.writeFileSync(timeInvestmentFactsCachePath, '{}', 'utf-8')
   fs.writeFileSync(annualSummaryYearSnapshotPath, '{}', 'utf-8')
   fs.writeFileSync(annualSummaryRecentSnapshotPath, '{}', 'utf-8')
+  fs.writeFileSync(timeInvestmentSnapshotPath, '{}', 'utf-8')
 
   assert.equal(adapter.deleteSessionFile(sessionId), true)
   assert.equal(fs.existsSync(dbPath), false)
@@ -80,6 +97,8 @@ test('DatabaseManager adapter deletes session database sidecar files and caches'
   assert.equal(fs.existsSync(queryCachePath), false)
   assert.equal(fs.existsSync(contactsFactsCachePath), false)
   assert.equal(fs.existsSync(globalInsightFactsCachePath), false)
+  assert.equal(fs.existsSync(timeInvestmentFactsCachePath), false)
   assert.equal(fs.existsSync(annualSummaryYearSnapshotPath), false)
   assert.equal(fs.existsSync(annualSummaryRecentSnapshotPath), false)
+  assert.equal(fs.existsSync(timeInvestmentSnapshotPath), false)
 })
diff --git a/packages/node-runtime/src/services/global-insight/index.ts b/packages/node-runtime/src/services/global-insight/index.ts
index e66eba12..d200b73a 100644
--- a/packages/node-runtime/src/services/global-insight/index.ts
+++ b/packages/node-runtime/src/services/global-insight/index.ts
@@ -4,3 +4,13 @@ export { ANNUAL_SUMMARY_ALGORITHM_VERSION } from './types'
 export type { AnnualSummaryComputeRunner, AnnualSummaryRunnerOptions } from './worker-runner'
 export { getGlobalInsightDir, getGlobalInsightFactsCacheDir } from './paths'
 export { deleteAnnualSummarySnapshots } from './snapshot'
+export { createTimeInvestmentService } from './time-investment-service'
+export type {
+  TimeInvestmentService,
+  TimeInvestmentServiceDeps,
+  TimeInvestmentServiceOptions,
+} from './time-investment-service'
+export { TIME_INVESTMENT_ALGORITHM_VERSION } from './time-investment-types'
+export type { TimeInvestmentComputeRunner } from './worker-runner'
+export { getTimeInvestmentDir, getTimeInvestmentFactsCacheDir } from './paths'
+export { deleteTimeInvestmentSnapshots } from './time-investment-snapshot'
diff --git a/packages/node-runtime/src/services/global-insight/paths.ts b/packages/node-runtime/src/services/global-insight/paths.ts
index 6311ed46..4c8b3db3 100644
--- a/packages/node-runtime/src/services/global-insight/paths.ts
+++ b/packages/node-runtime/src/services/global-insight/paths.ts
@@ -7,3 +7,11 @@ export function getGlobalInsightDir(userDataDir: string): string {
 export function getGlobalInsightFactsCacheDir(userDataDir: string): string {
   return path.join(getGlobalInsightDir(userDataDir), 'facts')
 }
+
+export function getTimeInvestmentDir(userDataDir: string): string {
+  return path.join(userDataDir, 'insight', 'time-investment')
+}
+
+export function getTimeInvestmentFactsCacheDir(userDataDir: string): string {
+  return path.join(getTimeInvestmentDir(userDataDir), 'facts')
+}
diff --git a/packages/node-runtime/src/services/global-insight/time-investment-compute.test.ts b/packages/node-runtime/src/services/global-insight/time-investment-compute.test.ts
new file mode 100644
index 00000000..ac697ab0
--- /dev/null
+++ b/packages/node-runtime/src/services/global-insight/time-investment-compute.test.ts
@@ -0,0 +1,52 @@
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import test from 'node:test'
+import Database from 'better-sqlite3'
+import { BetterSqliteAdapter } from '../../better-sqlite3-adapter'
+import type { SessionRuntimeAdapter } from '../adapters'
+import { computeTimeInvestmentSnapshot } from './time-investment-compute'
+
+const nativeBinding = path.resolve('apps/cli/native/better_sqlite3.node')
+
+test('computes time investment across sessions and reuses versioned facts', (t) => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'chatlab-time-investment-compute-'))
+  t.after(() => fs.rmSync(dir, { recursive: true, force: true }))
+  const dbPath = path.join(dir, 'chat.db')
+  const raw = new Database(dbPath, { nativeBinding })
+  t.after(() => raw.close())
+  raw.exec(`
+    CREATE TABLE meta (name TEXT, platform TEXT, type TEXT, imported_at INTEGER, owner_id TEXT);
+    CREATE TABLE member (id INTEGER PRIMARY KEY, platform_id TEXT, account_name TEXT, group_nickname TEXT, aliases TEXT, avatar TEXT);
+    CREATE TABLE message (id INTEGER PRIMARY KEY, sender_id INTEGER, ts INTEGER, type INTEGER, content TEXT);
+    INSERT INTO meta VALUES ('Private', 'qq', 'private', 1, 'owner');
+    INSERT INTO member VALUES (1, 'owner', 'Me', NULL, '[]', NULL), (2, 'alice', 'Alice', NULL, '[]', NULL);
+  `)
+  const ts = Math.floor(new Date(2026, 0, 2, 12).getTime() / 1000)
+  raw.prepare('INSERT INTO message VALUES (?, ?, ?, ?, ?)').run(1, 2, ts - 60, 0, 'trigger')
+  raw.prepare('INSERT INTO message VALUES (?, ?, ?, ?, ?)').run(2, 1, ts, 1, '[image]')
+  raw.prepare('INSERT INTO message VALUES (?, ?, ?, ?, ?)').run(3, 2, ts + 60, 0, 'reply')
+  const db = new BetterSqliteAdapter(raw)
+  const adapter = {
+    listSessionIds: () => ['chat-1'],
+    getDbPath: () => dbPath,
+    openReadonly: () => db,
+  } as unknown as SessionRuntimeAdapter
+  const range = {
+    mode: 'year' as const,
+    year: 2026,
+    startTs: Math.floor(new Date(2026, 0, 1).getTime() / 1000),
+    endTs: Math.floor(new Date(2026, 11, 31, 23, 59, 59).getTime() / 1000),
+  }
+  const factsCacheDir = path.join(dir, 'facts')
+
+  const first = computeTimeInvestmentSnapshot({ adapter, signature: 'sig', range, factsCacheDir, now: () => 1000 })
+  const second = computeTimeInvestmentSnapshot({ adapter, signature: 'sig', range, factsCacheDir, now: () => 2000 })
+
+  assert.equal(first.metrics.estimatedSeconds, 180)
+  assert.equal(first.sessionRanking[0].sessionId, 'chat-1')
+  assert.equal(first.workerStats.cacheMisses, 1)
+  assert.equal(second.workerStats.cacheHits, 1)
+  assert.equal(second.computedAt, 2000)
+})
diff --git a/packages/node-runtime/src/services/global-insight/time-investment-compute.ts b/packages/node-runtime/src/services/global-insight/time-investment-compute.ts
new file mode 100644
index 00000000..cf9b7cb7
--- /dev/null
+++ b/packages/node-runtime/src/services/global-insight/time-investment-compute.ts
@@ -0,0 +1,110 @@
+import {
+  aggregateTimeInvestmentFacts,
+  getTimeInvestmentSessionFacts,
+  type TimeInvestmentSessionFacts,
+} from '@openchatlab/core'
+import type { AnnualSummaryRange } from '@openchatlab/shared-types'
+import { getDbFileVersion } from '../../cache/analytics-cache'
+import { appLogger } from '../../logging/app-logger'
+import type { SessionRuntimeAdapter } from '../adapters'
+import {
+  buildTimeInvestmentFactsCacheKey,
+  readCachedTimeInvestmentSessionFacts,
+  writeCachedTimeInvestmentSessionFacts,
+} from './time-investment-facts-cache'
+import { TIME_INVESTMENT_ALGORITHM_VERSION, type TimeInvestmentSnapshot } from './time-investment-types'
+import type { AnnualSummaryComputeProgress } from './types'
+
+export interface ComputeTimeInvestmentSnapshotOptions {
+  adapter: SessionRuntimeAdapter
+  signature: string
+  range: AnnualSummaryRange
+  factsCacheDir: string
+  onProgress?: (progress: AnnualSummaryComputeProgress) => void
+  now?: () => number
+}
+
+export function computeTimeInvestmentSnapshot(options: ComputeTimeInvestmentSnapshotOptions): TimeInvestmentSnapshot {
+  const startedAt = options.now?.() ?? Date.now()
+  const sessionIds = options.adapter.listSessionIds()
+  const facts: TimeInvestmentSessionFacts[] = []
+  let cacheHits = 0
+  let cacheMisses = 0
+  const cacheKey = buildTimeInvestmentFactsCacheKey(TIME_INVESTMENT_ALGORITHM_VERSION, options.range)
+
+  appLogger.info('global-insight', 'time investment compute started', {
+    mode: options.range.mode,
+    year: options.range.year,
+    totalSessions: sessionIds.length,
+  })
+
+  for (const [index, sessionId] of sessionIds.entries()) {
+    options.onProgress?.({ processedSessions: index, totalSessions: sessionIds.length, currentSessionId: sessionId })
+    const dbPath = options.adapter.getDbPath(sessionId)
+    const dbVersion = getDbFileVersion(dbPath)
+    const cached = readCachedTimeInvestmentSessionFacts(
+      sessionId,
+      options.factsCacheDir,
+      cacheKey,
+      dbVersion,
+      options.range
+    )
+    if (cached.hit) {
+      cacheHits++
+      facts.push(cached.data)
+      continue
+    }
+
+    cacheMisses++
+    try {
+      const db = options.adapter.openReadonly(sessionId)
+      if (!db) {
+        facts.push({ kind: 'failed', availableDataYears: [] })
+        continue
+      }
+      const sessionFacts = getTimeInvestmentSessionFacts(db, sessionId, options.range)
+      facts.push(sessionFacts)
+      if (dbVersion === getDbFileVersion(dbPath)) {
+        writeCachedTimeInvestmentSessionFacts(
+          sessionId,
+          options.factsCacheDir,
+          cacheKey,
+          dbVersion,
+          options.range,
+          sessionFacts
+        )
+      } else {
+        appLogger.debug('global-insight', 'skipped time investment facts cache write because DB changed')
+      }
+    } catch (error) {
+      facts.push({ kind: 'failed', availableDataYears: [] })
+      appLogger.error('global-insight', 'failed to process time investment session', error)
+    }
+  }
+
+  options.onProgress?.({ processedSessions: sessionIds.length, totalSessions: sessionIds.length })
+  const aggregated = aggregateTimeInvestmentFacts(facts, options.range)
+  const finishedAt = options.now?.() ?? Date.now()
+  const snapshot: TimeInvestmentSnapshot = {
+    algorithmVersion: TIME_INVESTMENT_ALGORITHM_VERSION,
+    signature: options.signature,
+    computedAt: finishedAt,
+    range: options.range,
+    ...aggregated,
+    workerStats: {
+      durationMs: Math.max(0, finishedAt - startedAt),
+      totalSessions: sessionIds.length,
+      processedSessions: sessionIds.length,
+      cacheHits,
+      cacheMisses,
+    },
+  }
+  appLogger.info('global-insight', 'time investment compute completed', {
+    totalSessions: sessionIds.length,
+    analyzedSessions: snapshot.coverage.analyzedSessions,
+    cacheHits,
+    cacheMisses,
+    durationMs: snapshot.workerStats.durationMs,
+  })
+  return snapshot
+}
diff --git a/packages/node-runtime/src/services/global-insight/time-investment-facts-cache.ts b/packages/node-runtime/src/services/global-insight/time-investment-facts-cache.ts
new file mode 100644
index 00000000..d557aff6
--- /dev/null
+++ b/packages/node-runtime/src/services/global-insight/time-investment-facts-cache.ts
@@ -0,0 +1,79 @@
+import type { TimeInvestmentSessionFacts } from '@openchatlab/core'
+import type { AnnualSummaryRange } from '@openchatlab/shared-types'
+import { getCache, setCache } from '../../cache/session-cache'
+import { toAnnualSummaryRangeKey } from './time-range'
+
+const FACTS_FORMAT_VERSION = 1
+
+interface CachedFactsEntry {
+  v: string
+  rangeIdentity: string
+  data: TimeInvestmentSessionFacts
+}
+
+export type TimeInvestmentFactsCacheReadResult = { hit: true; data: TimeInvestmentSessionFacts } | { hit: false }
+
+export function buildTimeInvestmentFactsCacheKey(algorithmVersion: string, range: AnnualSummaryRange): string {
+  return `global-insight:time-investment:facts:v${FACTS_FORMAT_VERSION}:${algorithmVersion}:${toAnnualSummaryRangeKey(range)}`
+}
+
+export function readCachedTimeInvestmentSessionFacts(
+  sessionId: string,
+  cacheDir: string,
+  key: string,
+  dbVersion: string,
+  range: AnnualSummaryRange
+): TimeInvestmentFactsCacheReadResult {
+  const cached = getCache<CachedFactsEntry>(sessionId, key, cacheDir)
+  if (
+    !cached ||
+    cached.v !== dbVersion ||
+    cached.rangeIdentity !== buildRangeIdentity(range) ||
+    !isTimeInvestmentSessionFacts(cached.data)
+  ) {
+    return { hit: false }
+  }
+  return { hit: true, data: cached.data }
+}
+
+export function writeCachedTimeInvestmentSessionFacts(
+  sessionId: string,
+  cacheDir: string,
+  key: string,
+  dbVersion: string,
+  range: AnnualSummaryRange,
+  data: TimeInvestmentSessionFacts
+): void {
+  setCache<CachedFactsEntry>(sessionId, key, { v: dbVersion, rangeIdentity: buildRangeIdentity(range), data }, cacheDir)
+}
+
+function buildRangeIdentity(range: AnnualSummaryRange): string {
+  return `${toAnnualSummaryRangeKey(range)}:${range.startTs}:${range.endTs}`
+}
+
+function isTimeInvestmentSessionFacts(value: unknown): value is TimeInvestmentSessionFacts {
+  if (!value || typeof value !== 'object') return false
+  const record = value as Record<string, unknown>
+  if (typeof record.kind !== 'string' || !Array.isArray(record.availableDataYears)) return false
+  if (record.kind !== 'analyzed') return true
+  return (
+    typeof record.sessionId === 'string' &&
+    typeof record.sessionName === 'string' &&
+    typeof record.platform === 'string' &&
+    typeof record.chatType === 'string' &&
+    isIntervals(record.investmentIntervals)
+  )
+}
+
+function isIntervals(value: unknown): boolean {
+  return (
+    Array.isArray(value) &&
+    value.every(
+      (item) =>
+        item !== null &&
+        typeof item === 'object' &&
+        typeof (item as Record<string, unknown>).startTs === 'number' &&
+        typeof (item as Record<string, unknown>).endTs === 'number'
+    )
+  )
+}
diff --git a/packages/node-runtime/src/services/global-insight/time-investment-service.test.ts b/packages/node-runtime/src/services/global-insight/time-investment-service.test.ts
new file mode 100644
index 00000000..e5491080
--- /dev/null
+++ b/packages/node-runtime/src/services/global-insight/time-investment-service.test.ts
@@ -0,0 +1,76 @@
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import test from 'node:test'
+import type { AnnualSummaryRange } from '@openchatlab/shared-types'
+import type { SessionRuntimeAdapter } from '../adapters'
+import { createTimeInvestmentService } from './time-investment-service'
+import type { TimeInvestmentSnapshot } from './time-investment-types'
+import type { TimeInvestmentComputeRunner } from './worker-runner'
+
+test('starts one time investment task and exposes its persisted snapshot', async (t) => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'chatlab-time-investment-service-'))
+  t.after(() => fs.rmSync(dir, { recursive: true, force: true }))
+  const dbPath = path.join(dir, 'chat.db')
+  fs.writeFileSync(dbPath, '')
+  let now = new Date(2026, 5, 1).getTime()
+  const adapter = {
+    listSessionIds: () => ['chat-1'],
+    getDbPath: () => dbPath,
+  } as unknown as SessionRuntimeAdapter
+  let runnerCalls = 0
+  const runner: TimeInvestmentComputeRunner = async ({ signature, range: normalizedRange }) => {
+    runnerCalls++
+    return snapshot(normalizedRange, signature)
+  }
+  const service = createTimeInvestmentService({ adapter, userDataDir: dir, runner, now: () => now })
+
+  const first = service.getTimeInvestment({ mode: 'year', year: 2026 })
+  const duplicate = service.getTimeInvestment({ mode: 'year', year: 2026 })
+  assert.equal(first.task.status, 'running')
+  assert.equal(duplicate.task.status, 'running')
+  assert.equal(runnerCalls, 1)
+
+  await new Promise((resolve) => setImmediate(resolve))
+  now += 100
+  const completed = service.getTimeInvestment({ mode: 'year', year: 2026 })
+  assert.equal(completed.cache.status, 'fresh')
+  assert.equal(completed.metrics?.estimatedSeconds, 300)
+  assert.equal(completed.task.status, 'succeeded')
+  await service.close()
+})
+
+function snapshot(range: AnnualSummaryRange, signature: string): TimeInvestmentSnapshot {
+  return {
+    algorithmVersion: 'time-investment-v2',
+    signature,
+    computedAt: 150,
+    range,
+    availableDataYears: [2026],
+    latestDataYear: 2026,
+    metrics: {
+      estimatedSeconds: 300,
+      activeDayCount: 1,
+      averagePerActiveDaySeconds: 300,
+    },
+    monthlyActivity: [],
+    dailyActivity: [],
+    sessionRanking: [],
+    chatTypes: [],
+    coverage: {
+      totalSessions: 1,
+      analyzedSessions: 1,
+      missingOwnerSessions: 0,
+      unresolvedOwnerSessions: 0,
+      failedSessions: 0,
+    },
+    workerStats: {
+      durationMs: 50,
+      totalSessions: 1,
+      processedSessions: 1,
+      cacheHits: 0,
+      cacheMisses: 1,
+    },
+  }
+}
diff --git a/packages/node-runtime/src/services/global-insight/time-investment-service.ts b/packages/node-runtime/src/services/global-insight/time-investment-service.ts
new file mode 100644
index 00000000..826a5195
--- /dev/null
+++ b/packages/node-runtime/src/services/global-insight/time-investment-service.ts
@@ -0,0 +1,251 @@
+import fs from 'node:fs'
+import type { PathProvider } from '@openchatlab/core'
+import type { AnnualSummaryRange, AnnualSummaryTaskState, TimeInvestmentResponse } from '@openchatlab/shared-types'
+import type { RuntimeIdentity } from '../../data-dir-compat'
+import { appLogger } from '../../logging/app-logger'
+import type { SessionRuntimeAdapter } from '../adapters'
+import { getTimeInvestmentDir } from './paths'
+import { normalizeAnnualSummaryRange, toAnnualSummaryRangeKey, type AnnualSummaryRangeInput } from './time-range'
+import { buildTimeInvestmentSignature } from './time-investment-signature'
+import {
+  cleanupTimeInvestmentSnapshotTempFiles,
+  getTimeInvestmentSnapshotPath,
+  readTimeInvestmentSnapshot,
+  writeTimeInvestmentSnapshot,
+} from './time-investment-snapshot'
+import type { TimeInvestmentSnapshot } from './time-investment-types'
+import { createTimeInvestmentWorkerRunner, type TimeInvestmentComputeRunner } from './worker-runner'
+
+export interface TimeInvestmentServiceOptions extends AnnualSummaryRangeInput {
+  acceptStale?: boolean
+}
+
+export interface TimeInvestmentServiceDeps {
+  adapter: SessionRuntimeAdapter
+  pathProvider?: PathProvider
+  userDataDir?: string
+  runtimeIdentity?: RuntimeIdentity
+  nativeBinding?: string
+  workerEntryUrl?: string | URL
+  runner?: TimeInvestmentComputeRunner
+  now?: () => number
+}
+
+export interface TimeInvestmentService {
+  getTimeInvestment(options?: TimeInvestmentServiceOptions): TimeInvestmentResponse
+  startRecompute(options?: TimeInvestmentServiceOptions): TimeInvestmentResponse
+  close(): Promise<void>
+}
+
+interface InFlightTask {
+  id: string
+  promise: Promise<TimeInvestmentSnapshot>
+  abortController: AbortController
+}
+
+export function createTimeInvestmentService(deps: TimeInvestmentServiceDeps): TimeInvestmentService {
+  return new DefaultTimeInvestmentService(deps)
+}
+
+class DefaultTimeInvestmentService implements TimeInvestmentService {
+  private readonly snapshots = new Map<string, TimeInvestmentSnapshot | null>()
+  private readonly snapshotDir: string
+  private readonly runner: TimeInvestmentComputeRunner
+  private inFlight: InFlightTask | null = null
+  private task: AnnualSummaryTaskState = createIdleTaskState()
+
+  constructor(private readonly deps: TimeInvestmentServiceDeps) {
+    this.snapshotDir = deps.userDataDir
+      ? getTimeInvestmentDir(deps.userDataDir)
+      : getTimeInvestmentDir(requirePathProvider(deps).getUserDataDir())
+    cleanupTimeInvestmentSnapshotTempFiles(this.snapshotDir)
+    this.runner =
+      deps.runner ??
+      createTimeInvestmentWorkerRunner({
+        pathProvider: requirePathProvider(deps),
+        runtimeIdentity: deps.runtimeIdentity,
+        nativeBinding: deps.nativeBinding,
+        workerEntryUrl: deps.workerEntryUrl,
+      })
+  }
+
+  getTimeInvestment(options: TimeInvestmentServiceOptions = {}): TimeInvestmentResponse {
+    const range = this.normalizeRange(options)
+    const signature = buildTimeInvestmentSignature(this.deps.adapter, range)
+    const status = this.getCacheStatus(signature, range)
+    if (this.shouldStartTask(status)) this.ensureTaskStarted(signature, range)
+    return this.toResponse(signature, range, options.acceptStale === true)
+  }
+
+  startRecompute(options: TimeInvestmentServiceOptions = {}): TimeInvestmentResponse {
+    const range = this.normalizeRange(options)
+    const signature = buildTimeInvestmentSignature(this.deps.adapter, range)
+    this.ensureTaskStarted(signature, range)
+    return this.toResponse(signature, range, true)
+  }
+
+  async close(): Promise<void> {
+    const inFlight = this.inFlight
+    if (!inFlight) return
+    this.inFlight = null
+    inFlight.abortController.abort()
+    this.task = {
+      ...this.task,
+      status: 'failed',
+      finishedAt: this.now(),
+      lastError: 'time investment task aborted',
+    }
+  }
+
+  private shouldStartTask(status: TimeInvestmentResponse['cache']['status']): boolean {
+    if (status === 'fresh') return false
+    return this.task.status !== 'failed'
+  }
+
+  private normalizeRange(input: AnnualSummaryRangeInput = {}): AnnualSummaryRange {
+    return normalizeAnnualSummaryRange(input, new Date(this.now()))
+  }
+
+  private ensureTaskStarted(signature: string, range: AnnualSummaryRange): void {
+    if (this.inFlight) return
+    const id = `time_investment_${this.now()}_${Math.random().toString(36).slice(2)}`
+    this.task = {
+      id,
+      status: 'running',
+      startedAt: this.now(),
+      finishedAt: null,
+      processedSessions: 0,
+      totalSessions: this.deps.adapter.listSessionIds().length,
+    }
+    const abortController = new AbortController()
+    const promise = this.runner({
+      signature,
+      range,
+      signal: abortController.signal,
+      onProgress: (progress) => {
+        if (this.task.id !== id || this.task.status !== 'running') return
+        this.task = { ...this.task, ...progress }
+      },
+    })
+    this.inFlight = { id, promise, abortController }
+    promise
+      .then((snapshot) => this.handleTaskSuccess(id, signature, snapshot))
+      .catch((error) => this.handleTaskFailure(id, error))
+  }
+
+  private handleTaskSuccess(id: string, inputSignature: string, snapshot: TimeInvestmentSnapshot): void {
+    if (this.inFlight?.id !== id) return
+    const latestSignature = buildTimeInvestmentSignature(this.deps.adapter, snapshot.range)
+    const finishedAt = this.now()
+    if (inputSignature !== latestSignature || snapshot.signature !== latestSignature) {
+      this.inFlight = null
+      this.task = { ...this.task, status: 'superseded', finishedAt, currentSessionId: undefined }
+      appLogger.info('global-insight', 'time investment worker result discarded because signature changed')
+      return
+    }
+    try {
+      writeTimeInvestmentSnapshot(this.snapshotDir, snapshot)
+      this.inFlight = null
+      this.snapshots.set(toAnnualSummaryRangeKey(snapshot.range), snapshot)
+      this.task = {
+        ...this.task,
+        status: 'succeeded',
+        finishedAt,
+        processedSessions: snapshot.workerStats.processedSessions,
+        totalSessions: snapshot.workerStats.totalSessions,
+        currentSessionId: undefined,
+      }
+      appLogger.info('global-insight', 'time investment snapshot persisted', {
+        analyzedSessions: snapshot.coverage.analyzedSessions,
+        durationMs: snapshot.workerStats.durationMs,
+      })
+    } catch (error) {
+      this.handleTaskFailure(id, error)
+    }
+  }
+
+  private handleTaskFailure(id: string, error: unknown): void {
+    if (this.inFlight?.id !== id) return
+    this.inFlight = null
+    this.task = {
+      ...this.task,
+      status: 'failed',
+      finishedAt: this.now(),
+      currentSessionId: undefined,
+      lastError: error instanceof Error ? error.message : String(error),
+    }
+    appLogger.error('global-insight', 'time investment worker failed', error)
+  }
+
+  private toResponse(signature: string, range: AnnualSummaryRange, acceptStale: boolean): TimeInvestmentResponse {
+    const snapshot = this.getSnapshot(range)
+    const status = this.getCacheStatus(signature, range)
+    const includeSnapshot = status === 'fresh' || (status === 'stale' && acceptStale)
+    return {
+      range,
+      availableDataYears: includeSnapshot ? (snapshot?.availableDataYears ?? []) : [],
+      latestDataYear: includeSnapshot ? (snapshot?.latestDataYear ?? null) : null,
+      metrics: includeSnapshot ? (snapshot?.metrics ?? null) : null,
+      monthlyActivity: includeSnapshot ? (snapshot?.monthlyActivity ?? []) : [],
+      dailyActivity: includeSnapshot ? (snapshot?.dailyActivity ?? []) : [],
+      sessionRanking: includeSnapshot ? (snapshot?.sessionRanking ?? []) : [],
+      chatTypes: includeSnapshot ? (snapshot?.chatTypes ?? []) : [],
+      coverage: includeSnapshot ? (snapshot?.coverage ?? emptyCoverage()) : emptyCoverage(),
+      cache: {
+        status,
+        computedAt: snapshot?.computedAt ?? null,
+        signature: snapshot?.signature,
+        staleReason: status === 'stale' ? 'signature_changed' : undefined,
+      },
+      task: this.task,
+    }
+  }
+
+  private getCacheStatus(signature: string, range: AnnualSummaryRange): TimeInvestmentResponse['cache']['status'] {
+    const snapshot = this.getSnapshot(range)
+    if (!snapshot) return 'missing'
+    return snapshot.signature === signature ? 'fresh' : 'stale'
+  }
+
+  private getSnapshot(range: AnnualSummaryRange): TimeInvestmentSnapshot | null {
+    const key = toAnnualSummaryRangeKey(range)
+    if (this.snapshots.has(key) && !fs.existsSync(getTimeInvestmentSnapshotPath(this.snapshotDir, range))) {
+      this.snapshots.delete(key)
+    }
+    if (!this.snapshots.has(key)) {
+      this.snapshots.set(key, readTimeInvestmentSnapshot(this.snapshotDir, range, { now: this.deps.now }))
+    }
+    return this.snapshots.get(key) ?? null
+  }
+
+  private now(): number {
+    return this.deps.now?.() ?? Date.now()
+  }
+}
+
+function requirePathProvider(deps: TimeInvestmentServiceDeps): PathProvider {
+  if (!deps.pathProvider)
+    throw new Error('TimeInvestmentService requires pathProvider unless userDataDir and runner are provided')
+  return deps.pathProvider
+}
+
+function createIdleTaskState(): AnnualSummaryTaskState {
+  return {
+    id: null,
+    status: 'idle',
+    startedAt: null,
+    finishedAt: null,
+    processedSessions: 0,
+    totalSessions: 0,
+  }
+}
+
+function emptyCoverage(): TimeInvestmentResponse['coverage'] {
+  return {
+    totalSessions: 0,
+    analyzedSessions: 0,
+    missingOwnerSessions: 0,
+    unresolvedOwnerSessions: 0,
+    failedSessions: 0,
+  }
+}
diff --git a/packages/node-runtime/src/services/global-insight/time-investment-signature.ts b/packages/node-runtime/src/services/global-insight/time-investment-signature.ts
new file mode 100644
index 00000000..7c80dd85
--- /dev/null
+++ b/packages/node-runtime/src/services/global-insight/time-investment-signature.ts
@@ -0,0 +1,18 @@
+import type { AnnualSummaryRange } from '@openchatlab/shared-types'
+import { getDbFileVersion } from '../../cache/analytics-cache'
+import type { SessionRuntimeAdapter } from '../adapters'
+import { toAnnualSummaryLocalDate, toAnnualSummaryRangeKey } from './time-range'
+import { TIME_INVESTMENT_ALGORITHM_VERSION } from './time-investment-types'
+
+export function buildTimeInvestmentSignature(adapter: SessionRuntimeAdapter, range: AnnualSummaryRange): string {
+  const parts = [
+    `algorithm:${TIME_INVESTMENT_ALGORITHM_VERSION}`,
+    `range:${toAnnualSummaryRangeKey(range)}`,
+    `start:${range.startTs}`,
+    `day:${toAnnualSummaryLocalDate(range)}`,
+  ]
+  for (const sessionId of [...adapter.listSessionIds()].sort()) {
+    parts.push(`${sessionId}:${getDbFileVersion(adapter.getDbPath(sessionId))}`)
+  }
+  return parts.join('|')
+}
diff --git a/packages/node-runtime/src/services/global-insight/time-investment-snapshot.ts b/packages/node-runtime/src/services/global-insight/time-investment-snapshot.ts
new file mode 100644
index 00000000..5b454275
--- /dev/null
+++ b/packages/node-runtime/src/services/global-insight/time-investment-snapshot.ts
@@ -0,0 +1,64 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import type { AnnualSummaryRange } from '@openchatlab/shared-types'
+import { appLogger } from '../../logging/app-logger'
+import { toAnnualSummaryRangeKey } from './time-range'
+import type { TimeInvestmentSnapshot } from './time-investment-types'
+
+const SNAPSHOT_TMP_PREFIX = 'time-investment.tmp-'
+
+export function getTimeInvestmentSnapshotPath(snapshotDir: string, range: AnnualSummaryRange): string {
+  return path.join(snapshotDir, `time-investment-${toAnnualSummaryRangeKey(range)}.json`)
+}
+
+export function readTimeInvestmentSnapshot(
+  snapshotDir: string,
+  range: AnnualSummaryRange,
+  options: { now?: () => number } = {}
+): TimeInvestmentSnapshot | null {
+  const snapshotPath = getTimeInvestmentSnapshotPath(snapshotDir, range)
+  if (!fs.existsSync(snapshotPath)) return null
+  try {
+    return JSON.parse(fs.readFileSync(snapshotPath, 'utf-8')) as TimeInvestmentSnapshot
+  } catch (error) {
+    const backupPath = path.join(snapshotDir, `time-investment.corrupt-${options.now?.() ?? Date.now()}.json`)
+    try {
+      fs.renameSync(snapshotPath, backupPath)
+    } catch (renameError) {
+      appLogger.warn('global-insight', 'failed to backup corrupt time investment snapshot', renameError)
+    }
+    appLogger.warn('global-insight', 'time investment snapshot is corrupt', error)
+    return null
+  }
+}
+
+export function writeTimeInvestmentSnapshot(snapshotDir: string, snapshot: TimeInvestmentSnapshot): void {
+  fs.mkdirSync(snapshotDir, { recursive: true })
+  const tmpPath = path.join(snapshotDir, `${SNAPSHOT_TMP_PREFIX}${process.pid}-${Date.now()}`)
+  fs.writeFileSync(tmpPath, JSON.stringify(snapshot, null, 2), 'utf-8')
+  fs.renameSync(tmpPath, getTimeInvestmentSnapshotPath(snapshotDir, snapshot.range))
+}
+
+export function cleanupTimeInvestmentSnapshotTempFiles(snapshotDir: string): void {
+  if (!fs.existsSync(snapshotDir)) return
+  for (const name of fs.readdirSync(snapshotDir)) {
+    if (!name.startsWith(SNAPSHOT_TMP_PREFIX)) continue
+    try {
+      fs.rmSync(path.join(snapshotDir, name), { force: true })
+    } catch (error) {
+      appLogger.warn('global-insight', 'failed to remove time investment snapshot temp file', error)
+    }
+  }
+}
+
+export function deleteTimeInvestmentSnapshots(snapshotDir: string): void {
+  if (!fs.existsSync(snapshotDir)) return
+  for (const name of fs.readdirSync(snapshotDir)) {
+    if (!name.startsWith('time-investment-') && !name.startsWith('time-investment.')) continue
+    try {
+      fs.rmSync(path.join(snapshotDir, name), { force: true })
+    } catch (error) {
+      appLogger.warn('global-insight', 'failed to remove time investment snapshot', error)
+    }
+  }
+}
diff --git a/packages/node-runtime/src/services/global-insight/time-investment-types.ts b/packages/node-runtime/src/services/global-insight/time-investment-types.ts
new file mode 100644
index 00000000..d67a1b70
--- /dev/null
+++ b/packages/node-runtime/src/services/global-insight/time-investment-types.ts
@@ -0,0 +1,27 @@
+import type {
+  AnnualSummaryCoverage,
+  AnnualSummaryRange,
+  TimeInvestmentActivityPoint,
+  TimeInvestmentChatTypeItem,
+  TimeInvestmentMetrics,
+  TimeInvestmentSessionRankItem,
+} from '@openchatlab/shared-types'
+import type { AnnualSummaryWorkerStats } from './types'
+
+export const TIME_INVESTMENT_ALGORITHM_VERSION = 'time-investment-v2'
+
+export interface TimeInvestmentSnapshot {
+  algorithmVersion: string
+  signature: string
+  computedAt: number
+  range: AnnualSummaryRange
+  availableDataYears: number[]
+  latestDataYear: number | null
+  metrics: TimeInvestmentMetrics
+  monthlyActivity: TimeInvestmentActivityPoint[]
+  dailyActivity: TimeInvestmentActivityPoint[]
+  sessionRanking: TimeInvestmentSessionRankItem[]
+  chatTypes: TimeInvestmentChatTypeItem[]
+  coverage: AnnualSummaryCoverage
+  workerStats: AnnualSummaryWorkerStats
+}
diff --git a/packages/node-runtime/src/services/global-insight/worker-entry.ts b/packages/node-runtime/src/services/global-insight/worker-entry.ts
index 1325788d..f16a76f3 100644
--- a/packages/node-runtime/src/services/global-insight/worker-entry.ts
+++ b/packages/node-runtime/src/services/global-insight/worker-entry.ts
@@ -7,8 +7,11 @@ import { StaticPathProvider, type StaticPathProviderSnapshot } from '../../seman
 import { createDatabaseManagerAdapter } from '../adapters'
 import { computeAnnualSummarySnapshot, type ComputeAnnualSummarySnapshotOptions } from './compute'
 import { getGlobalInsightFactsCacheDir } from './paths'
+import { getTimeInvestmentFactsCacheDir } from './paths'
+import { computeTimeInvestmentSnapshot, type ComputeTimeInvestmentSnapshotOptions } from './time-investment-compute'
 
 interface StartupOptions {
+  reportType?: 'annual-summary' | 'time-investment'
   paths: StaticPathProviderSnapshot
   runtimeIdentity?: RuntimeIdentity
   nativeBinding?: string
@@ -27,6 +30,18 @@ async function main(): Promise<void> {
     allowMissingRuntimeForTests: !options.runtimeIdentity,
   })
   const adapter = createDatabaseManagerAdapter(dbManager)
+  if (options.reportType === 'time-investment') {
+    const computeOptions: ComputeTimeInvestmentSnapshotOptions = {
+      adapter,
+      signature: options.signature,
+      range: options.range,
+      factsCacheDir: getTimeInvestmentFactsCacheDir(pathProvider.getUserDataDir()),
+      onProgress: (progress) => parentPort?.postMessage({ type: 'progress', progress }),
+    }
+    const snapshot = computeTimeInvestmentSnapshot(computeOptions)
+    parentPort.postMessage({ type: 'success', snapshot })
+    return
+  }
   const computeOptions: ComputeAnnualSummarySnapshotOptions = {
     adapter,
     signature: options.signature,
diff --git a/packages/node-runtime/src/services/global-insight/worker-runner.ts b/packages/node-runtime/src/services/global-insight/worker-runner.ts
index 9ad1f196..f49a7068 100644
--- a/packages/node-runtime/src/services/global-insight/worker-runner.ts
+++ b/packages/node-runtime/src/services/global-insight/worker-runner.ts
@@ -5,6 +5,7 @@ import type { AnnualSummaryRange } from '@openchatlab/shared-types'
 import type { RuntimeIdentity } from '../../data-dir-compat'
 import { snapshotPathProvider } from '../../semantic-index/static-path-provider'
 import type { AnnualSummaryComputeProgress, AnnualSummarySnapshot } from './types'
+import type { TimeInvestmentSnapshot } from './time-investment-types'
 
 type ModuleWorkerOptions = WorkerOptions & { type: 'module' }
 type EntryExists = (url: URL) => boolean
@@ -17,6 +18,7 @@ export interface AnnualSummaryRunnerOptions {
 }
 
 export type AnnualSummaryComputeRunner = (options: AnnualSummaryRunnerOptions) => Promise<AnnualSummarySnapshot>
+export type TimeInvestmentComputeRunner = (options: AnnualSummaryRunnerOptions) => Promise<TimeInvestmentSnapshot>
 
 export interface AnnualSummaryWorkerRunnerOptions {
   pathProvider: PathProvider
@@ -28,7 +30,7 @@ export interface AnnualSummaryWorkerRunnerOptions {
 interface WorkerMessage {
   type: 'progress' | 'success' | 'error'
   progress?: AnnualSummaryComputeProgress
-  snapshot?: AnnualSummarySnapshot
+  snapshot?: AnnualSummarySnapshot | TimeInvestmentSnapshot
   error?: string
 }
 
@@ -76,7 +78,7 @@ export function createAnnualSummaryWorkerRunner(options: AnnualSummaryWorkerRunn
         if (message.type === 'success' && message.snapshot) {
           settled = true
           signal.removeEventListener('abort', abort)
-          resolve(message.snapshot)
+          resolve(message.snapshot as AnnualSummarySnapshot)
           void worker.terminate()
           return
         }
@@ -102,6 +104,68 @@ export function createAnnualSummaryWorkerRunner(options: AnnualSummaryWorkerRunn
     })
 }
 
+export function createTimeInvestmentWorkerRunner(
+  options: AnnualSummaryWorkerRunnerOptions
+): TimeInvestmentComputeRunner {
+  return ({ signature, range, signal, onProgress }) =>
+    new Promise<TimeInvestmentSnapshot>((resolve, reject) => {
+      if (signal.aborted) {
+        reject(new Error('time investment worker aborted'))
+        return
+      }
+      const worker = createWorker(
+        {
+          reportType: 'time-investment',
+          paths: snapshotPathProvider(options.pathProvider),
+          runtimeIdentity: options.runtimeIdentity,
+          nativeBinding: options.nativeBinding,
+          signature,
+          range,
+        },
+        options.workerEntryUrl
+      )
+      let settled = false
+      const abort = () => {
+        if (settled) return
+        settled = true
+        void worker.terminate()
+        reject(new Error('time investment worker aborted'))
+      }
+      signal.addEventListener('abort', abort, { once: true })
+      worker.on('message', (message: WorkerMessage) => {
+        if (message.type === 'progress' && message.progress) {
+          onProgress(message.progress)
+          return
+        }
+        if (message.type === 'success' && message.snapshot) {
+          settled = true
+          signal.removeEventListener('abort', abort)
+          resolve(message.snapshot as TimeInvestmentSnapshot)
+          void worker.terminate()
+          return
+        }
+        if (message.type === 'error') {
+          settled = true
+          signal.removeEventListener('abort', abort)
+          reject(new Error(message.error ?? 'time investment worker failed'))
+          void worker.terminate()
+        }
+      })
+      worker.on('error', (error) => {
+        if (settled) return
+        settled = true
+        signal.removeEventListener('abort', abort)
+        reject(error)
+      })
+      worker.on('exit', (code) => {
+        if (settled || code === 0) return
+        settled = true
+        signal.removeEventListener('abort', abort)
+        reject(new Error(`time investment worker exited with code ${code}`))
+      })
+    })
+}
+
 function createWorker(workerData: unknown, entryUrlInput?: string | URL): Worker {
   const entryUrl = entryUrlInput
     ? typeof entryUrlInput === 'string'
diff --git a/packages/node-runtime/src/services/index.ts b/packages/node-runtime/src/services/index.ts
index dce3c66f..a87d2776 100644
--- a/packages/node-runtime/src/services/index.ts
+++ b/packages/node-runtime/src/services/index.ts
@@ -62,12 +62,21 @@ export type {
 } from './people/relationships'
 
 // Global insight service
-export { ANNUAL_SUMMARY_ALGORITHM_VERSION, createGlobalInsightService } from './global-insight'
+export {
+  ANNUAL_SUMMARY_ALGORITHM_VERSION,
+  TIME_INVESTMENT_ALGORITHM_VERSION,
+  createGlobalInsightService,
+  createTimeInvestmentService,
+} from './global-insight'
 export type {
   AnnualSummaryComputeRunner,
   GlobalInsightService,
   GlobalInsightServiceDeps,
   GlobalInsightServiceOptions,
+  TimeInvestmentComputeRunner,
+  TimeInvestmentService,
+  TimeInvestmentServiceDeps,
+  TimeInvestmentServiceOptions,
 } from './global-insight'
 
 // User-triggered chat topics
diff --git a/packages/shared-types/index.ts b/packages/shared-types/index.ts
index 1686ce0e..54cad099 100644
--- a/packages/shared-types/index.ts
+++ b/packages/shared-types/index.ts
@@ -516,6 +516,46 @@ export interface AnnualSummaryResponse {
   task: AnnualSummaryTaskState
 }
 
+export interface TimeInvestmentMetrics {
+  estimatedSeconds: number
+  activeDayCount: number
+  averagePerActiveDaySeconds: number
+}
+
+export interface TimeInvestmentActivityPoint {
+  key: string
+  estimatedSeconds: number
+}
+
+export interface TimeInvestmentSessionRankItem {
+  sessionId: string
+  name: string
+  platform: ChatPlatform
+  type: ChatType
+  seconds: number
+  share: number
+}
+
+export interface TimeInvestmentChatTypeItem {
+  type: ChatType
+  seconds: number
+  share: number
+}
+
+export interface TimeInvestmentResponse {
+  range: AnnualSummaryRange
+  availableDataYears: number[]
+  latestDataYear: number | null
+  metrics: TimeInvestmentMetrics | null
+  monthlyActivity: TimeInvestmentActivityPoint[]
+  dailyActivity: TimeInvestmentActivityPoint[]
+  sessionRanking: TimeInvestmentSessionRankItem[]
+  chatTypes: TimeInvestmentChatTypeItem[]
+  coverage: AnnualSummaryCoverage
+  cache: AnnualSummaryCacheState
+  task: AnnualSummaryTaskState
+}
+
 // ==================== People Relationships (galaxy graph) ====================
 
 /**
diff --git a/packages/web-runtime/src/import/session-runtime.test.ts b/packages/web-runtime/src/import/session-runtime.test.ts
index 30dc1458..1fcb767c 100644
--- a/packages/web-runtime/src/import/session-runtime.test.ts
+++ b/packages/web-runtime/src/import/session-runtime.test.ts
@@ -1001,6 +1001,43 @@ describe('BrowserSessionRuntime', () => {
     database.dispose()
   })
 
+  it('computes owner time investment across Browser Runtime session databases', async () => {
+    const sqlite3 = await sqlite3InitModule()
+    const database = new MemoryWorkspaceDatabase(sqlite3)
+    const runtime = new BrowserSessionRuntime(database, {
+      createSessionId: () => 'time-investment-session',
+      now: () => 100,
+    })
+    const timestamp = Math.floor(new Date(2024, 0, 2, 10, 0, 0).getTime() / 1000)
+    const fixture = {
+      chatlab: { version: '1', exportedAt: timestamp },
+      meta: { name: 'Time Investment', platform: 'wechat', type: 'private', ownerId: 'alice' },
+      members: [
+        { platformId: 'alice', accountName: 'Alice' },
+        { platformId: 'bob', accountName: 'Bob' },
+      ],
+      messages: [
+        { sender: 'bob', accountName: 'Bob', timestamp: timestamp - 60, type: 0, content: 'trigger' },
+        { sender: 'alice', accountName: 'Alice', timestamp, type: 1, content: '[image]' },
+        { sender: 'bob', accountName: 'Bob', timestamp: timestamp + 60, type: 0, content: 'reply' },
+      ],
+    }
+
+    await runtime.importSource(source('time-investment.json', fixture), { formatId: 'chatlab' })
+
+    const result = await runtime.getTimeInvestment({
+      mode: 'year',
+      year: 2024,
+      startTs: Math.floor(new Date(2024, 0, 1).getTime() / 1000),
+      endTs: Math.floor(new Date(2024, 11, 31, 23, 59, 59).getTime() / 1000),
+    })
+
+    assert.equal(result.metrics?.estimatedSeconds, 180)
+    assert.equal(result.sessionRanking[0]?.sessionId, 'time-investment-session')
+    assert.equal(result.task.status, 'succeeded')
+    database.dispose()
+  })
+
   it('connects the remaining insight queries and builds relationship indexes on demand', async () => {
     const sqlite3 = await sqlite3InitModule()
     const database = new MemoryWorkspaceDatabase(sqlite3)
diff --git a/packages/web-runtime/src/import/session-runtime.ts b/packages/web-runtime/src/import/session-runtime.ts
index 12ff3544..bd9009e7 100644
--- a/packages/web-runtime/src/import/session-runtime.ts
+++ b/packages/web-runtime/src/import/session-runtime.ts
@@ -25,6 +25,8 @@ import {
   getTimeRange as queryTimeRange,
   getWeekdayActivity as queryWeekdayActivity,
   getYearlyActivity as queryYearlyActivity,
+  aggregateTimeInvestmentFacts,
+  getTimeInvestmentSessionFacts,
   hasSessionIndex,
   writeParseResultToDb,
   type ClusterGraphData,
@@ -45,8 +47,14 @@ import {
   type WordFrequencyParams,
   type WordFrequencyResult,
   type YearlyActivity,
+  type TimeInvestmentSessionFacts,
 } from '@openchatlab/core'
-import type { GroupRelationshipGalaxyData } from '@openchatlab/shared-types'
+import type {
+  AnnualSummaryRange,
+  ChatType,
+  GroupRelationshipGalaxyData,
+  TimeInvestmentResponse,
+} from '@openchatlab/shared-types'
 import { PARSER_FORMAT_IDS } from '@openchatlab/parser/browser'
 import { WebRuntimeError } from '../runtime-error'
 import type { WorkspaceDatabasePort, WorkspaceDatabaseStage } from '../storage/workspace-database'
@@ -459,6 +467,47 @@ export class BrowserSessionRuntime {
     return this.withSessionDatabase(id, (db) => queryBrowserWordFrequency(db, { ...params, sessionId: id }))
   }
 
+  async getTimeInvestment(range: AnnualSummaryRange): Promise<TimeInvestmentResponse> {
+    const sessions = await this.catalog.list()
+    const facts: TimeInvestmentSessionFacts[] = []
+    for (const session of sessions) {
+      try {
+        const sessionFacts = await this.database.withDatabase(
+          sessionDatabaseFilename(session.id),
+          CHAT_DB_TABLES,
+          (db) => getTimeInvestmentSessionFacts(db, session.id, range)
+        )
+        facts.push(
+          sessionFacts.kind === 'analyzed'
+            ? {
+                ...sessionFacts,
+                sessionName: session.name,
+                platform: session.platform,
+                chatType: session.type as ChatType,
+              }
+            : sessionFacts
+        )
+      } catch {
+        facts.push({ kind: 'failed', availableDataYears: [] })
+      }
+    }
+    const data = aggregateTimeInvestmentFacts(facts, range)
+    const now = Date.now()
+    return {
+      range,
+      ...data,
+      cache: { status: 'fresh', computedAt: now },
+      task: {
+        id: null,
+        status: 'succeeded',
+        startedAt: now,
+        finishedAt: now,
+        processedSessions: sessions.length,
+        totalSessions: sessions.length,
+      },
+    }
+  }
+
   private async withSessionDatabase<T>(id: string, operation: (db: import('@openchatlab/core').DatabaseAdapter) => T) {
     validateSessionId(id)
     const session = await this.catalog.get(id)
diff --git a/packages/web-runtime/src/rpc/protocol.ts b/packages/web-runtime/src/rpc/protocol.ts
index e69ccc30..3f12361e 100644
--- a/packages/web-runtime/src/rpc/protocol.ts
+++ b/packages/web-runtime/src/rpc/protocol.ts
@@ -29,7 +29,7 @@ import type {
   WordFrequencyResult,
   YearlyActivity,
 } from '@openchatlab/core'
-import type { GroupRelationshipGalaxyData } from '@openchatlab/shared-types'
+import type { AnnualSummaryRange, GroupRelationshipGalaxyData, TimeInvestmentResponse } from '@openchatlab/shared-types'
 import type {
   BrowserImportFormatInfo,
   BrowserMultiChatEntry,
@@ -251,6 +251,10 @@ export interface WebRuntimeTaskMap {
     payload: { sessionId: string; params: Omit<WordFrequencyParams, 'sessionId'> }
     result: WordFrequencyResult
   }
+  'globalInsight.timeInvestment': {
+    payload: { range: AnnualSummaryRange }
+    result: TimeInvestmentResponse
+  }
 }
 
 export type WebRuntimeTaskType = keyof WebRuntimeTaskMap
@@ -386,4 +390,5 @@ const WEB_RUNTIME_TASK_TYPES: Record<WebRuntimeTaskType, true> = {
   'analysis.journey': true,
   'analysis.languagePreference': true,
   'analysis.wordFrequency': true,
+  'globalInsight.timeInvestment': true,
 }
diff --git a/packages/web-runtime/src/worker/controller.test.ts b/packages/web-runtime/src/worker/controller.test.ts
index 849b6af3..e800c550 100644
--- a/packages/web-runtime/src/worker/controller.test.ts
+++ b/packages/web-runtime/src/worker/controller.test.ts
@@ -329,6 +329,35 @@ class FakeSessionRuntime implements WorkerSessionRuntime {
   async getWordFrequency(_id: string) {
     return { words: [], totalWords: 0, totalMessages: 0, uniqueWords: 0 }
   }
+
+  async getTimeInvestment(range: import('@openchatlab/shared-types').AnnualSummaryRange) {
+    return {
+      range,
+      availableDataYears: [],
+      latestDataYear: null,
+      metrics: null,
+      monthlyActivity: [],
+      dailyActivity: [],
+      sessionRanking: [],
+      chatTypes: [],
+      coverage: {
+        totalSessions: 0,
+        analyzedSessions: 0,
+        missingOwnerSessions: 0,
+        unresolvedOwnerSessions: 0,
+        failedSessions: 0,
+      },
+      cache: { status: 'fresh' as const, computedAt: Date.now() },
+      task: {
+        id: null,
+        status: 'succeeded' as const,
+        startedAt: Date.now(),
+        finishedAt: Date.now(),
+        processedSessions: 0,
+        totalSessions: 0,
+      },
+    }
+  }
 }
 
 describe('WebRuntimeWorkerController', () => {
diff --git a/packages/web-runtime/src/worker/controller.ts b/packages/web-runtime/src/worker/controller.ts
index c2013569..284f7f50 100644
--- a/packages/web-runtime/src/worker/controller.ts
+++ b/packages/web-runtime/src/worker/controller.ts
@@ -58,6 +58,7 @@ export type WorkerSessionRuntime = Pick<
   | 'getJourneyStats'
   | 'getLanguagePreferenceAnalysis'
   | 'getWordFrequency'
+  | 'getTimeInvestment'
 >
 
 export type WorkerAIRepository = Pick<
@@ -545,6 +546,12 @@ export class WebRuntimeWorkerController {
         this.emitAnalysisQueryCompleted(request, startedAt)
         return result
       }
+      case 'globalInsight.timeInvestment': {
+        const startedAt = this.startAnalysisQuery()
+        const result = await this.sessionRuntime.getTimeInvestment(request.payload.range)
+        this.emitAnalysisQueryCompleted(request, startedAt)
+        return result
+      }
     }
   }
 
diff --git a/src/components/charts/EChartLine.vue b/src/components/charts/EChartLine.vue
index ff4fc8c3..e0d90bc2 100644
--- a/src/components/charts/EChartLine.vue
+++ b/src/components/charts/EChartLine.vue
@@ -106,10 +106,11 @@ const option = computed<EChartsOption>(() => {
       },
     },
     grid: {
-      left: 50,
-      right: 20,
+      left: isCompact ? 8 : 50,
+      right: isCompact ? 4 : 20,
       top: hasSeries ? (isCompact ? 44 : 56) : 20,
-      bottom: useDataZoom ? 66 : 34,
+      bottom: useDataZoom ? 66 : isCompact ? 20 : 34,
+      containLabel: isCompact,
       outerBoundsMode: 'same',
     },
     legend: hasSeries
diff --git a/src/components/common/Sidebar.vue b/src/components/common/Sidebar.vue
index ddf0d7db..79b26ff1 100644
--- a/src/components/common/Sidebar.vue
+++ b/src/components/common/Sidebar.vue
@@ -32,9 +32,11 @@ interface SidebarInputExpose {
 const props = withDefaults(
   defineProps<{
     backendFeatures: boolean
+    insightEnabled?: boolean
     settingsEnabled?: boolean
   }>(),
   {
+    insightEnabled: false,
     settingsEnabled: false,
   }
 )
@@ -66,6 +68,7 @@ const showContactsEntry = computed(() =>
     groupSessionCount: groupSessionCount.value,
   })
 )
+const showInsightEntry = computed(() => props.backendFeatures || props.insightEnabled)
 
 // 是否在足迹页
 const isInsightPage = computed(() => String(route.name ?? '').startsWith('insight-'))
@@ -509,7 +512,7 @@ function getAvatarColorClass(session: AnalysisSession, isActive: boolean) {
 
         <!-- 足迹 -->
         <SidebarButton
-          v-if="props.backendFeatures"
+          v-if="showInsightEntry"
           icon="i-heroicons-presentation-chart-bar"
           :title="t('layout.insight')"
           :active="isInsightPage"
diff --git a/src/i18n/locales/en-US/insight.json b/src/i18n/locales/en-US/insight.json
index 902453b1..573ef7b6 100644
--- a/src/i18n/locales/en-US/insight.json
+++ b/src/i18n/locales/en-US/insight.json
@@ -49,6 +49,34 @@
     "medianLength": "Median text length",
     "p90Length": "P90 text length"
   },
+  "timeInvestment": {
+    "yearTitle": "Time invested in {year}",
+    "recentTitle": "Time invested in the last year",
+    "estimateNote": "Estimated from message timing with overlapping conversations merged. It shows engagement trends, not exact screen time.",
+    "loading": "Loading time investment…",
+    "failed": "Time investment calculation failed. You can retry it.",
+    "privateChat": "Private chats",
+    "groupChat": "Group chats",
+    "chatTypeTitle": "Conversation types",
+    "monthlyTitle": "Monthly trend",
+    "monthlyDescription": "Estimated chat investment by month, in hours",
+    "calendarTitle": "Investment calendar",
+    "calendarDescription": "Darker days represent more estimated investment",
+    "rankingTitle": "Where the time went",
+    "rankingDescription": "Shows the 10 private and group chats with the most invested time; overlapping time is divided evenly between conversations",
+    "rankingCount": "{count} chats",
+    "kpis": {
+      "estimated": "Estimated chat investment",
+      "activeDays": "Investment days",
+      "dailyAverage": "Average per active day"
+    },
+    "duration": {
+      "lessThanMinute": "Less than 1 min",
+      "minutes": "{count} min",
+      "hours": "{count} hr",
+      "hoursMinutes": "{hours} hr {minutes} min"
+    }
+  },
   "sections": {
     "overview": "Annual overview",
     "overviewDescription": "Non-system messages I sent each month; missing months count as zero",
diff --git a/src/i18n/locales/ja-JP/insight.json b/src/i18n/locales/ja-JP/insight.json
index 0208eb11..e55d0c18 100644
--- a/src/i18n/locales/ja-JP/insight.json
+++ b/src/i18n/locales/ja-JP/insight.json
@@ -49,6 +49,34 @@
     "medianLength": "テキスト長の中央値",
     "p90Length": "テキスト長 P90"
   },
+  "timeInvestment": {
+    "yearTitle": "{year} 年の時間投入",
+    "recentTitle": "直近1年間の時間投入",
+    "estimateNote": "メッセージの時間間隔から推定し、複数の会話で重なる時間帯を統合しています。正確な画面使用時間ではなく、会話への投入傾向を示します。",
+    "loading": "時間投入を読み込んでいます…",
+    "failed": "時間投入の計算に失敗しました。再試行できます。",
+    "privateChat": "個別チャット",
+    "groupChat": "グループチャット",
+    "chatTypeTitle": "会話タイプ",
+    "monthlyTitle": "月別推移",
+    "monthlyDescription": "月ごとの推定チャット投入時間。縦軸は時間です",
+    "calendarTitle": "投入カレンダー",
+    "calendarDescription": "色が濃いほど、その日の推定投入時間が長いことを示します",
+    "rankingTitle": "時間を使った会話",
+    "rankingDescription": "個別チャットとグループチャットで投入時間の多い上位10件を表示します。重なる時間は会話間で均等に配分されます",
+    "rankingCount": "{count} 件",
+    "kpis": {
+      "estimated": "推定チャット投入時間",
+      "activeDays": "投入日数",
+      "dailyAverage": "活動日あたりの平均"
+    },
+    "duration": {
+      "lessThanMinute": "1分未満",
+      "minutes": "{count}分",
+      "hours": "{count}時間",
+      "hoursMinutes": "{hours}時間{minutes}分"
+    }
+  },
   "sections": {
     "overview": "年間概要",
     "overviewDescription": "自分が送信したシステム以外のメッセージを月別に集計します",
diff --git a/src/i18n/locales/zh-CN/insight.json b/src/i18n/locales/zh-CN/insight.json
index c4dec331..aa0723cb 100644
--- a/src/i18n/locales/zh-CN/insight.json
+++ b/src/i18n/locales/zh-CN/insight.json
@@ -49,6 +49,34 @@
     "medianLength": "文本长度中位数",
     "p90Length": "文本长度 P90"
   },
+  "timeInvestment": {
+    "yearTitle": "{year} 年的时间投入",
+    "recentTitle": "最近一年的时间投入",
+    "estimateNote": "根据消息时间间隔估算，并合并多个会话的重叠时段；它反映聊天投入趋势，不是精确的屏幕使用时间。",
+    "loading": "正在读取时间投入…",
+    "failed": "时间投入计算失败，可以重试",
+    "privateChat": "私聊",
+    "groupChat": "群聊",
+    "chatTypeTitle": "对话类型",
+    "monthlyTitle": "月度趋势",
+    "monthlyDescription": "每月预估聊天投入，纵轴单位为小时",
+    "calendarTitle": "投入日历",
+    "calendarDescription": "颜色越深，代表当天预估投入越多",
+    "rankingTitle": "时间都去了哪里",
+    "rankingDescription": "私聊与群聊分别展示投入时间最多的 10 个会话；重叠时间会在会话之间平均分配",
+    "rankingCount": "{count} 个会话",
+    "kpis": {
+      "estimated": "预估聊天投入",
+      "activeDays": "投入天数",
+      "dailyAverage": "活跃日均投入"
+    },
+    "duration": {
+      "lessThanMinute": "不足 1 分钟",
+      "minutes": "{count} 分钟",
+      "hours": "{count} 小时",
+      "hoursMinutes": "{hours} 小时 {minutes} 分"
+    }
+  },
   "sections": {
     "overview": "年度概览",
     "overviewDescription": "按月统计我发出的非系统消息，缺失月份按零计算",
diff --git a/src/i18n/locales/zh-TW/insight.json b/src/i18n/locales/zh-TW/insight.json
index a9f6a5ac..1abf536a 100644
--- a/src/i18n/locales/zh-TW/insight.json
+++ b/src/i18n/locales/zh-TW/insight.json
@@ -49,6 +49,34 @@
     "medianLength": "文字長度中位數",
     "p90Length": "文字長度 P90"
   },
+  "timeInvestment": {
+    "yearTitle": "{year} 年的時間投入",
+    "recentTitle": "最近一年的時間投入",
+    "estimateNote": "根據訊息時間間隔估算，並合併多個會話的重疊時段；它反映聊天投入趨勢，不是精確的螢幕使用時間。",
+    "loading": "正在讀取時間投入…",
+    "failed": "時間投入計算失敗，可以重試",
+    "privateChat": "私聊",
+    "groupChat": "群聊",
+    "chatTypeTitle": "對話類型",
+    "monthlyTitle": "月度趨勢",
+    "monthlyDescription": "每月預估聊天投入，縱軸單位為小時",
+    "calendarTitle": "投入日曆",
+    "calendarDescription": "顏色越深，代表當天預估投入越多",
+    "rankingTitle": "時間都去了哪裡",
+    "rankingDescription": "私聊與群聊分別展示投入時間最多的 10 個會話；重疊時間會在會話之間平均分配",
+    "rankingCount": "{count} 個會話",
+    "kpis": {
+      "estimated": "預估聊天投入",
+      "activeDays": "投入天數",
+      "dailyAverage": "活躍日均投入"
+    },
+    "duration": {
+      "lessThanMinute": "不足 1 分鐘",
+      "minutes": "{count} 分鐘",
+      "hours": "{count} 小時",
+      "hoursMinutes": "{hours} 小時 {minutes} 分"
+    }
+  },
   "sections": {
     "overview": "年度概覽",
     "overviewDescription": "按月統計我發出的非系統訊息，缺少月份以零計算",
diff --git a/src/pages/insight/annual-summary/components/AnnualInsightBoard.vue b/src/pages/insight/annual-summary/components/AnnualInsightBoard.vue
index 9df64686..2d5f8233 100644
--- a/src/pages/insight/annual-summary/components/AnnualInsightBoard.vue
+++ b/src/pages/insight/annual-summary/components/AnnualInsightBoard.vue
@@ -11,7 +11,7 @@ import { MessageType, getMessageTypeName } from '@/types/base'
 import { formatDateRange } from '@/utils'
 import { CardDecoration, ThemeCard } from '@/components/UI'
 import { deriveAnnualActivityRhythm } from '../annual-activity-rhythm'
-import AnnualCalendarGrid from './AnnualCalendarGrid.vue'
+import InsightCalendarGrid from '../../components/InsightCalendarGrid.vue'
 import AnnualMonthlyTrend from './AnnualMonthlyTrend.vue'
 
 const props = defineProps<{
@@ -73,6 +73,7 @@ const monthlyTrendData = computed(() =>
     ? props.monthlyActivity.map((item) => ({ month: item.month, value: item.messageCount }))
     : props.monthlyDirectContacts.map((item) => ({ month: item.month, value: item.contactCount }))
 )
+const calendarData = computed(() => props.dailyActivity.map((item) => ({ date: item.date, value: item.messageCount })))
 const monthlyTrendDescription = computed(() =>
   t(
     monthlyTrendMode.value === 'messages'
@@ -246,7 +247,7 @@ function kpiIcon(key: string): string {
           </div>
         </div>
         <div class="mt-5">
-          <AnnualCalendarGrid :range="range" :data="dailyActivity" />
+          <InsightCalendarGrid :range="range" :data="calendarData" />
         </div>
       </section>
     </ThemeCard>
diff --git a/src/pages/insight/annual-summary/index.vue b/src/pages/insight/annual-summary/index.vue
index a08774e8..81321cf4 100644
--- a/src/pages/insight/annual-summary/index.vue
+++ b/src/pages/insight/annual-summary/index.vue
@@ -8,14 +8,14 @@ import type { AnnualSummaryResponse } from '@openchatlab/shared-types'
 import LoadingState from '@/components/UI/LoadingState.vue'
 import { useDataService } from '@/services'
 import { reportError } from '@/services/log-report'
-import { useAnnualSummaryTimeRange, watchAnnualSummarySettingsClose } from '../annual-summary-time-range'
+import { useInsightTimeRange, watchInsightSettingsClose } from '../insight-time-range'
 import AnnualInsightBoard from './components/AnnualInsightBoard.vue'
 
 const { t } = useI18n()
 const layoutStore = useLayoutStore()
 const { showSettings } = storeToRefs(layoutStore)
 const currentYear = new Date().getFullYear()
-const timeRange = useAnnualSummaryTimeRange()
+const timeRange = useInsightTimeRange()
 const response = ref<AnnualSummaryResponse | null>(null)
 const errorMessage = ref('')
 let pollTimer: ReturnType<typeof setTimeout> | null = null
@@ -61,7 +61,7 @@ watch(
   },
   { immediate: true }
 )
-watchAnnualSummarySettingsClose(showSettings, () => void loadSummary(false))
+watchInsightSettingsClose(showSettings, () => void loadSummary(false))
 
 onBeforeUnmount(clearPoll)
 
diff --git a/src/pages/insight/annual-summary/components/AnnualCalendarGrid.vue b/src/pages/insight/components/InsightCalendarGrid.vue
similarity index 93%
rename from src/pages/insight/annual-summary/components/AnnualCalendarGrid.vue
rename to src/pages/insight/components/InsightCalendarGrid.vue
index 107a7454..866dfafd 100644
--- a/src/pages/insight/annual-summary/components/AnnualCalendarGrid.vue
+++ b/src/pages/insight/components/InsightCalendarGrid.vue
@@ -20,13 +20,14 @@ interface CalendarMonth {
 
 const props = defineProps<{
   range: AnnualSummaryRange
-  data: Array<{ date: string; messageCount: number }>
+  data: Array<{ date: string; value: number }>
+  formatValue?: (value: number) => string
 }>()
 
 const { t } = useI18n()
 
-const maxCount = computed(() => Math.max(...props.data.map((item) => item.messageCount), 1))
-const counts = computed(() => new Map(props.data.map((item) => [item.date, item.messageCount])))
+const maxCount = computed(() => Math.max(...props.data.map((item) => item.value), 1))
+const counts = computed(() => new Map(props.data.map((item) => [item.date, item.value])))
 const startDate = computed(() => new Date(props.range.startTs * 1000))
 const endDate = computed(() => new Date(props.range.endTs * 1000))
 
@@ -74,6 +75,10 @@ const months = computed<CalendarMonth[]>(() => {
 function startOfDay(date: Date): Date {
   return new Date(date.getFullYear(), date.getMonth(), date.getDate())
 }
+
+function formatDayValue(value: number): string {
+  return props.formatValue?.(value) ?? `${value} ${t('insight.messages')}`
+}
 </script>
 
 <template>
@@ -101,7 +106,7 @@ function startOfDay(date: Date): Date {
               'bg-pink-400 dark:bg-pink-500/50': day.level === 3,
               'bg-pink-600 dark:bg-pink-500/80': day.level === 4,
             }"
-            :title="`${day.key}: ${day.count} ${t('insight.messages')}`"
+            :title="`${day.key}: ${formatDayValue(day.count)}`"
           />
         </div>
       </div>
diff --git a/src/pages/insight/index.vue b/src/pages/insight/index.vue
index 65292e48..76d9c1ec 100644
--- a/src/pages/insight/index.vue
+++ b/src/pages/insight/index.vue
@@ -5,39 +5,44 @@ import { useI18n } from 'vue-i18n'
 import PageHeader from '@/components/layout/PageHeader.vue'
 import TimeSelect from '@/components/common/TimeSelect.vue'
 import { PageTabs } from '@/components/navigation'
-import { provideAnnualSummaryTimeRange } from './annual-summary-time-range'
+import { PLATFORM_CAPABILITIES } from '@/utils/platform-capabilities'
+import { provideInsightTimeRange } from './insight-time-range'
 
 type InsightSubpage = 'annual-summary' | 'time-investment' | 'relationship-changes'
 
 const { t } = useI18n()
 const route = useRoute()
-const timeRange = provideAnnualSummaryTimeRange()
+const timeRange = provideInsightTimeRange()
 const { modelValue, componentKey, initialState, rangeSource } = timeRange
 const activeSubpage = computed<InsightSubpage>(() => {
   if (route.name === 'insight-time-investment') return 'time-investment'
   if (route.name === 'insight-relationship-changes') return 'relationship-changes'
   return 'annual-summary'
 })
-const navigationItems = computed(() => [
-  {
-    id: 'annual-summary',
-    label: t('insight.tabs.annualSummary'),
-    icon: 'i-lucide-calendar-range',
-    to: { name: 'insight-annual-summary' },
-  },
-  {
+const navigationItems = computed(() => {
+  const timeInvestment = {
     id: 'time-investment',
     label: t('insight.tabs.timeInvestment'),
     icon: 'i-lucide-clock-3',
     to: { name: 'insight-time-investment' },
-  },
-  {
-    id: 'relationship-changes',
-    label: t('insight.tabs.relationshipChanges'),
-    icon: 'i-lucide-git-compare-arrows',
-    to: { name: 'insight-relationship-changes' },
-  },
-])
+  }
+  if (PLATFORM_CAPABILITIES.usesBrowserRuntime) return [timeInvestment]
+  return [
+    {
+      id: 'annual-summary',
+      label: t('insight.tabs.annualSummary'),
+      icon: 'i-lucide-calendar-range',
+      to: { name: 'insight-annual-summary' },
+    },
+    timeInvestment,
+    {
+      id: 'relationship-changes',
+      label: t('insight.tabs.relationshipChanges'),
+      icon: 'i-lucide-git-compare-arrows',
+      to: { name: 'insight-relationship-changes' },
+    },
+  ]
+})
 </script>
 
 <template>
@@ -57,7 +62,7 @@ const navigationItems = computed(() => [
         :items="navigationItems"
         :aria-label="t('insight.tabs.nav')"
       >
-        <template v-if="activeSubpage === 'annual-summary'" #right>
+        <template v-if="activeSubpage !== 'relationship-changes'" #right>
           <TimeSelect
             :key="componentKey"
             v-model="modelValue"
diff --git a/src/pages/insight/annual-summary-time-range.test.ts b/src/pages/insight/insight-time-range.test.ts
similarity index 72%
rename from src/pages/insight/annual-summary-time-range.test.ts
rename to src/pages/insight/insight-time-range.test.ts
index e355d12d..7693abe3 100644
--- a/src/pages/insight/annual-summary-time-range.test.ts
+++ b/src/pages/insight/insight-time-range.test.ts
@@ -1,12 +1,12 @@
 import assert from 'node:assert/strict'
 import test from 'node:test'
 import { nextTick, ref } from 'vue'
-import { watchAnnualSummarySettingsClose } from './annual-summary-time-range'
+import { watchInsightSettingsClose } from './insight-time-range'
 
 test('refreshes annual summary after the settings modal closes', async () => {
   const showSettings = ref(false)
   let refreshCalls = 0
-  const stop = watchAnnualSummarySettingsClose(showSettings, () => refreshCalls++)
+  const stop = watchInsightSettingsClose(showSettings, () => refreshCalls++)
 
   showSettings.value = true
   await nextTick()
diff --git a/src/pages/insight/annual-summary-time-range.ts b/src/pages/insight/insight-time-range.ts
similarity index 73%
rename from src/pages/insight/annual-summary-time-range.ts
rename to src/pages/insight/insight-time-range.ts
index 22e7450d..e5cc5341 100644
--- a/src/pages/insight/annual-summary-time-range.ts
+++ b/src/pages/insight/insight-time-range.ts
@@ -1,7 +1,7 @@
 import { computed, inject, provide, ref, watch, type ComputedRef, type InjectionKey, type Ref } from 'vue'
 import type { TimeRangeValue, TimeSelectRangeSource, TimeSelectState } from '@/components/common/TimeSelect.vue'
 
-interface AnnualSummaryTimeRangeContext {
+interface InsightTimeRangeContext {
   modelValue: Ref<TimeRangeValue | null>
   componentKey: Ref<number>
   initialState: ComputedRef<Partial<TimeSelectState>>
@@ -10,9 +10,9 @@ interface AnnualSummaryTimeRangeContext {
   switchToYear: (year: number) => void
 }
 
-const ANNUAL_SUMMARY_TIME_RANGE_KEY: InjectionKey<AnnualSummaryTimeRangeContext> = Symbol('AnnualSummaryTimeRange')
+const INSIGHT_TIME_RANGE_KEY: InjectionKey<InsightTimeRangeContext> = Symbol('InsightTimeRange')
 
-export function provideAnnualSummaryTimeRange(): AnnualSummaryTimeRangeContext {
+export function provideInsightTimeRange(): InsightTimeRangeContext {
   const currentYear = new Date().getFullYear()
   const rangeEndTs = Math.floor(Date.now() / 1000)
   const modelValue = ref<TimeRangeValue | null>(null)
@@ -43,20 +43,17 @@ export function provideAnnualSummaryTimeRange(): AnnualSummaryTimeRangeContext {
   }
 
   const context = { modelValue, componentKey, initialState, rangeSource, setAvailableYears, switchToYear }
-  provide(ANNUAL_SUMMARY_TIME_RANGE_KEY, context)
+  provide(INSIGHT_TIME_RANGE_KEY, context)
   return context
 }
 
-export function useAnnualSummaryTimeRange(): AnnualSummaryTimeRangeContext {
-  const context = inject(ANNUAL_SUMMARY_TIME_RANGE_KEY)
-  if (!context) throw new Error('Annual summary time range context is unavailable')
+export function useInsightTimeRange(): InsightTimeRangeContext {
+  const context = inject(INSIGHT_TIME_RANGE_KEY)
+  if (!context) throw new Error('Insight time range context is unavailable')
   return context
 }
 
-export function watchAnnualSummarySettingsClose(
-  showSettings: Ref<boolean>,
-  refresh: () => void
-): ReturnType<typeof watch> {
+export function watchInsightSettingsClose(showSettings: Ref<boolean>, refresh: () => void): ReturnType<typeof watch> {
   return watch(showSettings, (visible, wasVisible) => {
     if (wasVisible && !visible) refresh()
   })
diff --git a/src/pages/insight/time-investment/index.vue b/src/pages/insight/time-investment/index.vue
index 88b8503e..d49abfbe 100644
--- a/src/pages/insight/time-investment/index.vue
+++ b/src/pages/insight/time-investment/index.vue
@@ -1,14 +1,484 @@
 <script setup lang="ts">
+import { computed, onBeforeUnmount, ref, watch } from 'vue'
+import { storeToRefs } from 'pinia'
 import { useI18n } from 'vue-i18n'
+import { ChatType, type TimeInvestmentResponse } from '@openchatlab/shared-types'
+import { useLayoutStore } from '@/stores/layout'
+import type { AnnualSummaryFetchOptions } from '@/services/data/types'
+import { useDataService } from '@/services'
+import { reportError } from '@/services/log-report'
+import { formatDateRange } from '@/utils'
+import LoadingState from '@/components/UI/LoadingState.vue'
+import { CardDecoration, ThemeCard } from '@/components/UI'
+import { EChartLine } from '@/components/charts'
+import { PLATFORM_CAPABILITIES } from '@/utils/platform-capabilities'
+import InsightCalendarGrid from '../components/InsightCalendarGrid.vue'
+import { useInsightTimeRange, watchInsightSettingsClose } from '../insight-time-range'
 
 const { t } = useI18n()
+const layoutStore = useLayoutStore()
+const { showSettings } = storeToRefs(layoutStore)
+const currentYear = new Date().getFullYear()
+const timeRange = useInsightTimeRange()
+const response = ref<TimeInvestmentResponse | null>(null)
+const errorMessage = ref('')
+let pollTimer: ReturnType<typeof setTimeout> | null = null
+let requestToken = 0
+
+const requestOptions = computed<AnnualSummaryFetchOptions | null>(() => {
+  const state = timeRange.modelValue.value?.state
+  if (!state) return null
+  return state.mode === 'recent'
+    ? { mode: 'recent', days: 365, acceptStale: true }
+    : { mode: 'year', year: state.year ?? currentYear, acceptStale: true }
+})
+const requestKey = computed(() => JSON.stringify(requestOptions.value))
+const ownerIssueCount = computed(
+  () => (response.value?.coverage.missingOwnerSessions ?? 0) + (response.value?.coverage.unresolvedOwnerSessions ?? 0)
+)
+const hasSnapshot = computed(() => response.value?.metrics !== null && response.value?.metrics !== undefined)
+const isUpdating = computed(() => response.value?.task.status === 'running')
+const isZeroData = computed(() => hasSnapshot.value && response.value?.metrics?.estimatedSeconds === 0)
+const hasNoAnalyzableOwner = computed(
+  () =>
+    (response.value?.coverage.totalSessions ?? 0) > 0 &&
+    response.value?.coverage.analyzedSessions === 0 &&
+    ownerIssueCount.value > 0
+)
+const canConfigureOwner = !PLATFORM_CAPABILITIES.usesBrowserRuntime
+const selectedYear = computed(() =>
+  timeRange.modelValue.value?.state.mode === 'year' ? timeRange.modelValue.value.state.year : undefined
+)
+const latestYearSuggestion = computed(() => {
+  const year = selectedYear.value
+  const latestYear = response.value?.latestDataYear
+  if (year === undefined || latestYear === null || latestYear === undefined || year === latestYear) return null
+  return { year, latestYear }
+})
+const title = computed(() =>
+  response.value?.range.mode === 'year'
+    ? t('insight.timeInvestment.yearTitle', { year: response.value.range.year })
+    : t('insight.timeInvestment.recentTitle')
+)
+const timeRangeText = computed(() => {
+  const range = response.value?.range
+  return range ? formatDateRange(range.startTs, range.endTs, 'YYYY/MM/DD') : ''
+})
+const primaryStats = computed(() => {
+  const metrics = response.value?.metrics
+  if (!metrics) return []
+  return [
+    { key: 'estimated', value: formatDuration(metrics.estimatedSeconds) },
+    { key: 'activeDays', value: metrics.activeDayCount.toLocaleString() },
+    { key: 'dailyAverage', value: formatDuration(metrics.averagePerActiveDaySeconds) },
+  ]
+})
+const monthlyChartData = computed(() => {
+  const range = response.value?.range
+  const data = response.value?.monthlyActivity ?? []
+  return {
+    labels: data.map((item) =>
+      range?.mode === 'year'
+        ? t('insight.monthLabel', { month: Number(item.key.slice(5)) })
+        : item.key.replace('-', '/')
+    ),
+    values: data.map((item) => secondsToHours(item.estimatedSeconds)),
+  }
+})
+const calendarData = computed(() =>
+  (response.value?.dailyActivity ?? []).map((item) => ({ date: item.key, value: item.estimatedSeconds }))
+)
+const chatTypeComparisonItems = computed(() =>
+  [ChatType.GROUP, ChatType.PRIVATE]
+    .map((type) => response.value?.chatTypes.find((item) => item.type === type))
+    .filter((item) => item !== undefined)
+)
+const sessionRankingsByType = computed(() =>
+  [ChatType.PRIVATE, ChatType.GROUP].map((type) => {
+    const items = (response.value?.sessionRanking ?? [])
+      .filter((item) => item.type === type)
+      .slice(0, 10)
+      .map((item, index) => ({ ...item, rank: index + 1 }))
+    return {
+      type,
+      items,
+      maxSeconds: Math.max(...items.map((item) => item.seconds), 1),
+    }
+  })
+)
+const hasRankedSessions = computed(() => sessionRankingsByType.value.some((ranking) => ranking.items.length > 0))
+
+watch(
+  requestKey,
+  () => {
+    clearPoll()
+    if (!requestOptions.value) return
+    response.value = null
+    void loadTimeInvestment(false)
+  },
+  { immediate: true }
+)
+watchInsightSettingsClose(showSettings, () => void loadTimeInvestment(false))
+onBeforeUnmount(clearPoll)
+
+async function loadTimeInvestment(recompute: boolean): Promise<void> {
+  const options = requestOptions.value
+  if (!options) return
+  const token = ++requestToken
+  errorMessage.value = ''
+  try {
+    const result = recompute
+      ? await useDataService().recomputeTimeInvestment(options)
+      : await useDataService().getTimeInvestment(options)
+    if (token !== requestToken) return
+    response.value = result
+    if (result.metrics) timeRange.setAvailableYears(result.availableDataYears)
+    if (result.task.status === 'running') schedulePoll()
+  } catch (error) {
+    if (token !== requestToken) return
+    const message = error instanceof Error ? error.message : String(error)
+    errorMessage.value = message
+    reportError(`Global insight time investment failed: ${message}`, error instanceof Error ? error.stack : undefined)
+  }
+}
+
+function schedulePoll(): void {
+  clearPoll()
+  pollTimer = setTimeout(() => void loadTimeInvestment(false), 900)
+}
+
+function clearPoll(): void {
+  if (!pollTimer) return
+  clearTimeout(pollTimer)
+  pollTimer = null
+}
+
+function switchToLatestYear(): void {
+  const year = response.value?.latestDataYear
+  if (year) timeRange.switchToYear(year)
+}
+
+function openSessions(): void {
+  layoutStore.openSettings('data', 'missing-owner')
+}
+
+function formatDuration(seconds: number): string {
+  const roundedMinutes = Math.round(seconds / 60)
+  if (seconds > 0 && roundedMinutes < 1) return t('insight.timeInvestment.duration.lessThanMinute')
+  if (roundedMinutes < 60) return t('insight.timeInvestment.duration.minutes', { count: roundedMinutes })
+  const hours = Math.floor(roundedMinutes / 60)
+  const minutes = roundedMinutes % 60
+  return minutes
+    ? t('insight.timeInvestment.duration.hoursMinutes', { hours, minutes })
+    : t('insight.timeInvestment.duration.hours', { count: hours })
+}
+
+function secondsToHours(seconds: number): number {
+  return Math.round((seconds / 3600) * 10) / 10
+}
+
+function chatTypeLabel(type: ChatType): string {
+  return t(type === ChatType.PRIVATE ? 'insight.timeInvestment.privateChat' : 'insight.timeInvestment.groupChat')
+}
 </script>
 
 <template>
-  <main class="flex min-h-0 flex-1 items-center justify-center px-6 py-12">
-    <div class="text-center text-sm text-gray-500 dark:text-gray-400">
-      <UIcon name="i-lucide-clock-3" class="mx-auto mb-3 h-8 w-8 text-pink-500" />
-      <p>{{ t('insight.reserved') }}</p>
+  <main class="min-h-0 flex-1 overflow-y-auto">
+    <div class="mx-auto w-full max-w-[1120px] space-y-6 px-4 py-5 sm:px-6 sm:py-6">
+      <button
+        v-if="ownerIssueCount > 0 && canConfigureOwner"
+        type="button"
+        class="inline-flex w-fit max-w-full items-center gap-2 rounded-lg bg-amber-50 px-3 py-2 text-left text-xs text-amber-800 transition-colors hover:bg-amber-100 dark:bg-amber-950/20 dark:text-amber-300 dark:hover:bg-amber-950/30"
+        @click="openSessions"
+      >
+        <UIcon name="i-heroicons-user-circle" class="h-4 w-4 shrink-0" />
+        <span class="min-w-0">{{ t('insight.status.ownerIssues', { count: ownerIssueCount }) }}</span>
+        <UIcon name="i-heroicons-arrow-right" class="h-3.5 w-3.5 shrink-0 opacity-70" />
+      </button>
+
+      <div
+        v-if="response?.cache.status === 'stale' || (isUpdating && hasSnapshot)"
+        class="flex items-center gap-2 rounded-xl border border-amber-100 bg-amber-50/50 px-4 py-2.5 text-xs text-amber-800 dark:border-amber-950/40 dark:bg-amber-950/20 dark:text-amber-300"
+      >
+        <UIcon name="i-heroicons-arrow-path" class="h-4 w-4 shrink-0 animate-spin" />
+        {{ t('insight.status.updating') }}
+      </div>
+
+      <div
+        v-if="errorMessage || response?.task.status === 'failed'"
+        class="flex flex-wrap items-center justify-between gap-3 rounded-xl border border-red-200 bg-red-50/50 px-4 py-2.5 text-xs text-red-800 dark:border-red-950/40 dark:bg-red-950/20 dark:text-red-300"
+      >
+        <span>{{ t('insight.timeInvestment.failed') }}</span>
+        <UButton size="xs" color="error" variant="soft" icon="i-heroicons-arrow-path" @click="loadTimeInvestment(true)">
+          {{ t('insight.actions.retry') }}
+        </UButton>
+      </div>
+
+      <LoadingState
+        v-if="!hasSnapshot && !errorMessage && response?.task.status !== 'failed'"
+        height="min(52vh, 420px)"
+        :text="
+          response?.task.status === 'running'
+            ? t('insight.status.computingProgress', {
+                processed: response.task.processedSessions,
+                total: response.task.totalSessions,
+              })
+            : t('insight.timeInvestment.loading')
+        "
+      />
+
+      <template v-else-if="response?.metrics">
+        <div
+          v-if="isZeroData"
+          class="flex flex-wrap items-center justify-between gap-3 rounded-xl border border-gray-200 bg-white p-4 text-xs text-gray-600 dark:border-zinc-800 dark:bg-zinc-900/50 dark:text-zinc-300"
+        >
+          <span v-if="hasNoAnalyzableOwner">{{ t('insight.status.noAnalyzableOwner') }}</span>
+          <span v-else-if="latestYearSuggestion">{{ t('insight.status.noDataWithLatest', latestYearSuggestion) }}</span>
+          <span v-else>{{ t('insight.noData') }}</span>
+          <UButton
+            v-if="latestYearSuggestion"
+            size="xs"
+            variant="soft"
+            color="neutral"
+            icon="i-heroicons-arrow-right"
+            @click="switchToLatestYear"
+          >
+            {{ t('insight.actions.switchYear', { year: latestYearSuggestion.latestYear }) }}
+          </UButton>
+        </div>
+
+        <div class="grid gap-4 xl:grid-cols-12">
+          <ThemeCard class="relative isolate overflow-hidden xl:col-span-8">
+            <CardDecoration />
+            <section class="relative z-10 min-w-0 p-5 sm:p-6">
+              <div class="flex flex-col gap-5 lg:flex-row lg:items-start lg:justify-between">
+                <div class="min-w-0">
+                  <h2 class="text-2xl font-bold text-gray-900 dark:text-white sm:text-3xl">{{ title }}</h2>
+                  <div class="mt-3 space-y-1.5 text-xs font-medium text-gray-500 dark:text-zinc-400">
+                    <div class="flex items-center gap-2">
+                      <UIcon name="i-heroicons-calendar" class="h-4 w-4 opacity-70" />
+                      <span class="font-mono">{{ timeRangeText }}</span>
+                    </div>
+                    <div class="flex items-center gap-2">
+                      <UIcon name="i-heroicons-circle-stack" class="h-4 w-4 opacity-70" />
+                      <span>
+                        {{
+                          t('insight.status.coverage', {
+                            analyzed: response.coverage.analyzedSessions,
+                            total: response.coverage.totalSessions,
+                          })
+                        }}
+                      </span>
+                    </div>
+                  </div>
+                </div>
+
+                <div class="min-w-0 lg:w-[330px] lg:shrink-0">
+                  <h3 class="text-xs font-semibold text-gray-700 dark:text-zinc-300">
+                    {{ t('insight.timeInvestment.chatTypeTitle') }}
+                  </h3>
+                  <div
+                    v-if="chatTypeComparisonItems.length"
+                    class="mt-3 grid grid-cols-2 divide-x divide-gray-200/70 dark:divide-white/5"
+                  >
+                    <div
+                      v-for="item in chatTypeComparisonItems"
+                      :key="item.type"
+                      class="min-w-0 px-4 first:pl-0 last:pr-0"
+                    >
+                      <div class="flex items-center gap-2">
+                        <span
+                          class="h-2 w-2 shrink-0 rounded-full"
+                          :class="
+                            item.type === ChatType.PRIVATE
+                              ? 'bg-pink-500 dark:bg-pink-400'
+                              : 'bg-blue-500 dark:bg-blue-400'
+                          "
+                        />
+                        <span class="truncate text-[10px] font-medium text-gray-500 dark:text-zinc-400">
+                          {{ chatTypeLabel(item.type) }}
+                        </span>
+                      </div>
+                      <div
+                        class="mt-2 whitespace-nowrap font-mono text-xl leading-none font-black tabular-nums"
+                        :class="
+                          item.type === ChatType.PRIVATE
+                            ? 'text-pink-500 dark:text-pink-400'
+                            : 'text-blue-500 dark:text-blue-400'
+                        "
+                      >
+                        {{ item.share }}%
+                      </div>
+                      <div class="mt-1.5 whitespace-nowrap font-mono text-[10px] text-gray-400 dark:text-zinc-500">
+                        {{ formatDuration(item.seconds) }}
+                      </div>
+                    </div>
+                  </div>
+                  <p v-else class="mt-3 text-xs text-gray-400">{{ t('insight.noData') }}</p>
+                </div>
+              </div>
+
+              <div
+                class="mt-6 grid divide-y divide-gray-200/70 border-y border-gray-200/60 py-4 sm:grid-cols-3 sm:divide-x sm:divide-y-0 dark:divide-white/5 dark:border-white/5"
+              >
+                <div
+                  v-for="stat in primaryStats"
+                  :key="stat.key"
+                  class="min-w-0 px-0 py-3 first:pt-0 last:pb-0 sm:px-5 sm:py-0 sm:first:pl-0 sm:last:pr-0"
+                >
+                  <div
+                    class="whitespace-nowrap font-mono text-lg font-black tabular-nums text-gray-900 dark:text-white sm:text-xl"
+                  >
+                    {{ stat.value }}
+                  </div>
+                  <div class="mt-1.5 text-xs leading-tight font-medium text-gray-500 dark:text-zinc-400">
+                    {{ t(`insight.timeInvestment.kpis.${stat.key}`) }}
+                  </div>
+                </div>
+              </div>
+
+              <div class="mt-5">
+                <div>
+                  <h3 class="text-sm font-semibold text-gray-800 dark:text-zinc-200">
+                    {{ t('insight.timeInvestment.monthlyTitle') }}
+                  </h3>
+                  <p class="mt-1 text-[11px] text-gray-400 dark:text-zinc-500">
+                    {{ t('insight.timeInvestment.monthlyDescription') }}
+                  </p>
+                </div>
+                <div class="mt-2">
+                  <EChartLine
+                    :data="monthlyChartData"
+                    :height="210"
+                    mode="compact"
+                    :smooth="false"
+                    :show-area="false"
+                  />
+                </div>
+                <p class="mt-2 text-[11px] leading-5 text-gray-400 dark:text-zinc-500">
+                  {{ t('insight.timeInvestment.estimateNote') }}
+                </p>
+              </div>
+            </section>
+          </ThemeCard>
+
+          <div class="grid content-start gap-4 xl:col-span-4">
+            <ThemeCard>
+              <section class="min-w-0 p-5 sm:p-6">
+                <h3
+                  class="flex items-center gap-2 text-xs font-bold uppercase tracking-wider text-gray-700 dark:text-zinc-300"
+                >
+                  <span class="inline-block h-2 w-2 rounded-full bg-pink-500 dark:bg-pink-400" />
+                  {{ t('insight.timeInvestment.calendarTitle') }}
+                </h3>
+                <p class="mt-1 text-[11px] text-gray-400 dark:text-zinc-500">
+                  {{ t('insight.timeInvestment.calendarDescription') }}
+                </p>
+                <div class="mt-5">
+                  <InsightCalendarGrid :range="response.range" :data="calendarData" :format-value="formatDuration" />
+                </div>
+              </section>
+            </ThemeCard>
+          </div>
+
+          <ThemeCard class="xl:col-span-12">
+            <section class="min-w-0 p-5 sm:p-6">
+              <div class="flex flex-wrap items-end justify-between gap-x-6 gap-y-2">
+                <div>
+                  <h3 class="text-base font-semibold text-gray-800 dark:text-zinc-200">
+                    {{ t('insight.timeInvestment.rankingTitle') }}
+                  </h3>
+                  <p class="mt-1 text-[11px] text-gray-400 dark:text-zinc-500">
+                    {{ t('insight.timeInvestment.rankingDescription') }}
+                  </p>
+                </div>
+              </div>
+
+              <div
+                v-if="hasRankedSessions"
+                class="mt-5 grid gap-8 lg:grid-cols-2 lg:gap-0 lg:divide-x lg:divide-gray-200/60 dark:lg:divide-white/5"
+              >
+                <div
+                  v-for="ranking in sessionRankingsByType"
+                  :key="ranking.type"
+                  class="min-w-0 lg:px-10 lg:first:pl-0 lg:last:pr-0"
+                >
+                  <div
+                    class="flex items-center justify-between gap-4 border-b border-gray-200/60 pb-3 dark:border-white/5"
+                  >
+                    <div class="flex min-w-0 items-center gap-2">
+                      <span
+                        class="h-2.5 w-2.5 shrink-0 rounded-full"
+                        :class="
+                          ranking.type === ChatType.PRIVATE
+                            ? 'bg-pink-500 dark:bg-pink-400'
+                            : 'bg-blue-500 dark:bg-blue-400'
+                        "
+                      />
+                      <h4 class="truncate text-sm font-semibold text-gray-700 dark:text-zinc-200">
+                        {{ chatTypeLabel(ranking.type) }}
+                      </h4>
+                    </div>
+                    <span class="shrink-0 text-[10px] text-gray-400 dark:text-zinc-500">
+                      {{ t('insight.timeInvestment.rankingCount', { count: ranking.items.length }) }}
+                    </span>
+                  </div>
+
+                  <div v-if="ranking.items.length" class="divide-y divide-gray-200/60 dark:divide-white/5">
+                    <div v-for="item in ranking.items" :key="item.sessionId" class="min-w-0 py-3 last:pb-0">
+                      <div class="grid grid-cols-[28px_minmax(0,1fr)_auto] items-center gap-3">
+                        <span
+                          class="flex h-6 w-6 items-center justify-center rounded-full font-mono text-[10px] font-bold"
+                          :class="
+                            item.rank <= 3
+                              ? ranking.type === ChatType.PRIVATE
+                                ? 'bg-pink-50 text-pink-600 dark:bg-pink-950/30 dark:text-pink-400'
+                                : 'bg-blue-50 text-blue-600 dark:bg-blue-950/30 dark:text-blue-400'
+                              : 'bg-gray-100 text-gray-500 dark:bg-zinc-800 dark:text-zinc-400'
+                          "
+                        >
+                          {{ item.rank }}
+                        </span>
+                        <div class="min-w-0">
+                          <span class="block truncate text-sm font-semibold text-gray-700 dark:text-zinc-200">
+                            {{ item.name }}
+                          </span>
+                          <span class="mt-1 block truncate text-[10px] text-gray-400 dark:text-zinc-500">
+                            {{ item.platform }}
+                          </span>
+                        </div>
+                        <div class="shrink-0 text-right">
+                          <div
+                            class="whitespace-nowrap font-mono text-xs font-black tabular-nums text-gray-900 dark:text-white"
+                          >
+                            {{ formatDuration(item.seconds) }}
+                          </div>
+                          <div class="mt-1 font-mono text-[10px] tabular-nums text-gray-400 dark:text-zinc-500">
+                            {{ item.share }}%
+                          </div>
+                        </div>
+                      </div>
+                      <div class="mt-2 ml-10 h-1 overflow-hidden rounded-full bg-gray-100 dark:bg-zinc-800">
+                        <div
+                          class="h-full rounded-full"
+                          :class="
+                            ranking.type === ChatType.PRIVATE
+                              ? 'bg-pink-500 dark:bg-pink-400'
+                              : 'bg-blue-500 dark:bg-blue-400'
+                          "
+                          :style="{ width: `${(item.seconds / ranking.maxSeconds) * 100}%` }"
+                        />
+                      </div>
+                    </div>
+                  </div>
+                  <p v-else class="pt-4 text-xs text-gray-400">{{ t('insight.noData') }}</p>
+                </div>
+              </div>
+              <p v-else class="mt-5 text-xs text-gray-400">{{ t('insight.noData') }}</p>
+            </section>
+          </ThemeCard>
+        </div>
+      </template>
     </div>
   </main>
 </template>
diff --git a/src/services/data/browser.test.ts b/src/services/data/browser.test.ts
index d45ae8b3..42bb96d8 100644
--- a/src/services/data/browser.test.ts
+++ b/src/services/data/browser.test.ts
@@ -313,4 +313,49 @@ describe('BrowserDataAdapter', () => {
     await assert.rejects(adapter.getContacts(), /getContacts is not available in Web WASM/)
     await assert.rejects(adapter.executeSQL('session-one', 'SELECT 1'), /executeSQL is not available/)
   })
+
+  it('forwards time investment through the global browser runtime task', async () => {
+    const requests: Array<{ type: WebRuntimeTaskType; payload: unknown }> = []
+    const rpc = {
+      async request<T extends WebRuntimeTaskType>(
+        type: T,
+        payload: WebRuntimeTaskPayload<T>
+      ): Promise<WebRuntimeTaskResult<T>> {
+        requests.push({ type, payload })
+        return {
+          range: (payload as { range: unknown }).range,
+          availableDataYears: [],
+          latestDataYear: null,
+          metrics: null,
+          monthlyActivity: [],
+          dailyActivity: [],
+          sessionRanking: [],
+          chatTypes: [],
+          coverage: {
+            totalSessions: 0,
+            analyzedSessions: 0,
+            missingOwnerSessions: 0,
+            unresolvedOwnerSessions: 0,
+            failedSessions: 0,
+          },
+          cache: { status: 'fresh', computedAt: Date.now() },
+          task: {
+            id: null,
+            status: 'succeeded',
+            startedAt: Date.now(),
+            finishedAt: Date.now(),
+            processedSessions: 0,
+            totalSessions: 0,
+          },
+        } as WebRuntimeTaskResult<T>
+      },
+      dispose: () => undefined,
+    }
+    const adapter = createBrowserDataAdapter(rpc)
+
+    await adapter.getTimeInvestment({ mode: 'year', year: 2024 })
+
+    assert.equal(requests[0]?.type, 'globalInsight.timeInvestment')
+    assert.equal((requests[0]?.payload as { range: { year?: number } }).range.year, 2024)
+  })
 })
diff --git a/src/services/data/browser.ts b/src/services/data/browser.ts
index 81bd3ea7..b5b64451 100644
--- a/src/services/data/browser.ts
+++ b/src/services/data/browser.ts
@@ -20,7 +20,7 @@ import type {
 } from '@/types/analysis'
 import type { LanguagePreferenceResult } from '@/types/quotes/languagePreference'
 import type { JourneyStats, MemberMonthlyTrend, WordFrequencyParams, WordFrequencyResult } from '@openchatlab/core'
-import type { TimeFilter } from '@openchatlab/shared-types'
+import type { AnnualSummaryRange, TimeFilter, TimeInvestmentResponse } from '@openchatlab/shared-types'
 import type { BrowserRuntimeRpcPort } from '../browser-runtime/types'
 import { withAnalyticsRequestEpoch } from '../utils/http'
 import type { DataAdapter } from './types'
@@ -53,6 +53,8 @@ type BrowserSessionDataAdapter = Pick<
   | 'getJourneyStats'
   | 'getLanguagePreferenceAnalysis'
   | 'getWordFrequency'
+  | 'getTimeInvestment'
+  | 'recomputeTimeInvestment'
 >
 
 export class BrowserDataAdapter implements BrowserSessionDataAdapter {
@@ -187,6 +189,45 @@ export class BrowserDataAdapter implements BrowserSessionDataAdapter {
   getWordFrequency(sessionId: string, params: Omit<WordFrequencyParams, 'sessionId'>): Promise<WordFrequencyResult> {
     return this.requestAnalysis('analysis.wordFrequency', { sessionId, params })
   }
+
+  getTimeInvestment(options?: import('./types').AnnualSummaryFetchOptions): Promise<TimeInvestmentResponse> {
+    return this.rpc.request('globalInsight.timeInvestment', { range: normalizeBrowserRange(options) })
+  }
+
+  recomputeTimeInvestment(options?: import('./types').AnnualSummaryFetchOptions): Promise<TimeInvestmentResponse> {
+    return this.getTimeInvestment(options)
+  }
+}
+
+function normalizeBrowserRange(options?: import('./types').AnnualSummaryFetchOptions): AnnualSummaryRange {
+  const now = new Date()
+  if (options?.mode === 'recent') {
+    const start = new Date(now)
+    start.setHours(0, 0, 0, 0)
+    start.setDate(start.getDate() - 364)
+    return {
+      mode: 'recent',
+      days: 365,
+      startTs: Math.floor(start.getTime() / 1000),
+      endTs: Math.floor(now.getTime() / 1000),
+    }
+  }
+  const currentYear = now.getFullYear()
+  const requestedYear = options?.year
+  const year =
+    typeof requestedYear === 'number' &&
+    Number.isInteger(requestedYear) &&
+    requestedYear >= 1970 &&
+    requestedYear <= currentYear
+      ? requestedYear
+      : currentYear
+  const end = year === currentYear ? now : new Date(year, 11, 31, 23, 59, 59)
+  return {
+    mode: 'year',
+    year,
+    startTs: Math.floor(new Date(year, 0, 1).getTime() / 1000),
+    endTs: Math.floor(end.getTime() / 1000),
+  }
 }
 
 export function createBrowserDataAdapter(rpc: BrowserRuntimeRpcPort): DataAdapter {
diff --git a/src/services/data/fetch.ts b/src/services/data/fetch.ts
index 8cc45318..b8186639 100644
--- a/src/services/data/fetch.ts
+++ b/src/services/data/fetch.ts
@@ -15,6 +15,7 @@ import type {
   PeopleRelationshipsNeighborhoodResponse,
   AnnualSummaryResponse,
   GroupRelationshipGalaxyData,
+  TimeInvestmentResponse,
 } from '@openchatlab/shared-types'
 import type {
   MemberActivity,
@@ -226,6 +227,14 @@ export class FetchDataAdapter implements DataAdapter {
     return post(`/global-insight/annual-summary/recompute${buildAnnualSummaryParams(options)}`, {})
   }
 
+  getTimeInvestment(options?: AnnualSummaryFetchOptions): Promise<TimeInvestmentResponse> {
+    return get(`/global-insight/time-investment${buildAnnualSummaryParams(options)}`)
+  }
+
+  recomputeTimeInvestment(options?: AnnualSummaryFetchOptions): Promise<TimeInvestmentResponse> {
+    return post(`/global-insight/time-investment/recompute${buildAnnualSummaryParams(options)}`, {})
+  }
+
   // ==================== 时间范围 ====================
 
   getAvailableYears(sessionId: string): Promise<number[]> {
diff --git a/src/services/data/types.ts b/src/services/data/types.ts
index d5339456..5ea56bde 100644
--- a/src/services/data/types.ts
+++ b/src/services/data/types.ts
@@ -20,6 +20,7 @@ import type {
   AnnualSummaryMode,
   AnnualSummaryResponse,
   GroupRelationshipGalaxyData,
+  TimeInvestmentResponse,
 } from '@openchatlab/shared-types'
 import type { JourneyStats, WordFrequencyParams, WordFrequencyResult } from '@openchatlab/core'
 import type {
@@ -176,6 +177,8 @@ export interface DataAdapter {
 
   getAnnualSummary(options?: AnnualSummaryFetchOptions): Promise<AnnualSummaryResponse>
   recomputeAnnualSummary(options?: AnnualSummaryFetchOptions): Promise<AnnualSummaryResponse>
+  getTimeInvestment(options?: AnnualSummaryFetchOptions): Promise<TimeInvestmentResponse>
+  recomputeTimeInvestment(options?: AnnualSummaryFetchOptions): Promise<TimeInvestmentResponse>
 
   // ==================== 时间范围 ====================