idlewatch 0.1.7 → 0.1.8

package/bin/idlewatch-agent.js

@@ -10,6 +10,7 @@ import { createRequire } from 'module'
 import { parseOpenClawUsage } from '../src/openclaw-usage.js'
 import { gpuSampleDarwin } from '../src/gpu.js'
 import { memUsedPct, memoryPressureDarwin } from '../src/memory.js'
+import { thermalSampleDarwin } from '../src/thermal.js'
 import { deriveUsageFreshness } from '../src/usage-freshness.js'
 import { deriveUsageAlert } from '../src/usage-alert.js'
 import { loadLastGoodUsageSnapshot, persistLastGoodUsageSnapshot } from '../src/openclaw-cache.js'
@@ -104,9 +105,12 @@ function buildSetupTestEnv(enrolledEnv) {
 
 const persistedEnv = loadPersistedEnvIntoProcess()
 
+const OPENCLAW_AGENT_TARGETS = ['agent_activity', 'token_usage', 'runtime_state']
+const OPENCLAW_DERIVED_TARGETS = [...OPENCLAW_AGENT_TARGETS]
+
 function parseMonitorTargets(raw) {
-  const allowed = new Set(['cpu', 'memory', 'gpu', 'openclaw'])
-  const fallback = ['cpu', 'memory', 'openclaw', 'gpu']
+  const allowed = new Set(['cpu', 'memory', 'gpu', 'temperature', 'openclaw', ...OPENCLAW_DERIVED_TARGETS])
+  const fallback = ['cpu', 'memory', 'gpu', 'temperature', ...OPENCLAW_DERIVED_TARGETS]
 
   if (!raw || typeof raw !== 'string') {
     return new Set(fallback)
@@ -116,6 +120,7 @@ function parseMonitorTargets(raw) {
     .split(',')
     .map((item) => item.trim().toLowerCase())
     .filter((item) => allowed.has(item))
+    .flatMap((item) => (item === 'openclaw' ? OPENCLAW_DERIVED_TARGETS : [item]))
 
   if (parsed.length === 0) return new Set(fallback)
   return new Set(parsed)
@@ -244,12 +249,20 @@ function buildRollingLoadSummary(logPath, nowMs = Date.now(), windowMs = DAY_WIN
     return Number((valid.reduce((sum, value) => sum + value, 0) / valid.length).toFixed(2))
   }
 
+  const maximum = (values) => {
+    const valid = values.filter((value) => Number.isFinite(value))
+    if (valid.length === 0) return null
+    return Number(Math.max(...valid).toFixed(1))
+  }
+
   return {
     windowMs,
     sampleCount: rows.length,
     cpuAvgPct: average(rows.map((row) => Number(row.cpuPct))),
     memAvgPct: average(rows.map((row) => Number(row.memPct))),
     gpuAvgPct: average(rows.map((row) => Number(row.gpuPct))),
+    tempAvgC: average(rows.map((row) => Number(row.deviceTempC))),
+    tempMaxC: maximum(rows.map((row) => Number(row.deviceTempC))),
     tokensAvgPerMin: average(rows.map((row) => Number(row.tokensPerMin)))
   }
 }
@@ -493,8 +506,12 @@ const MONITOR_TARGETS = parseMonitorTargets(process.env.IDLEWATCH_MONITOR_TARGET
 const MONITOR_CPU = MONITOR_TARGETS.has('cpu')
 const MONITOR_MEMORY = MONITOR_TARGETS.has('memory')
 const MONITOR_GPU = MONITOR_TARGETS.has('gpu')
-const MONITOR_OPENCLAW = MONITOR_TARGETS.has('openclaw')
-const EFFECTIVE_OPENCLAW_MODE = MONITOR_OPENCLAW ? OPENCLAW_USAGE_MODE : 'off'
+const MONITOR_TEMPERATURE = MONITOR_TARGETS.has('temperature')
+const MONITOR_AGENT_ACTIVITY = MONITOR_TARGETS.has('agent_activity')
+const MONITOR_TOKEN_USAGE = MONITOR_TARGETS.has('token_usage')
+const MONITOR_RUNTIME_STATE = MONITOR_TARGETS.has('runtime_state')
+const MONITOR_OPENCLAW_USAGE = MONITOR_TOKEN_USAGE || MONITOR_RUNTIME_STATE
+const EFFECTIVE_OPENCLAW_MODE = MONITOR_OPENCLAW_USAGE ? OPENCLAW_USAGE_MODE : 'off'
 const REQUIRE_FIREBASE_WRITES = process.env.IDLEWATCH_REQUIRE_FIREBASE_WRITES === '1'
 const CLOUD_INGEST_URL = (process.env.IDLEWATCH_CLOUD_INGEST_URL || '').trim()
 const CLOUD_API_KEY = (process.env.IDLEWATCH_CLOUD_API_KEY || '').trim().replace(/^['"]|['"]$/g, '')
@@ -1320,8 +1337,8 @@ async function publish(row, retries = 2) {
 async function collectSample() {
   const sampleStartMs = Date.now()
   const dayLoadSummary = buildRollingLoadSummary(LOCAL_LOG_PATH, sampleStartMs)
-  const openclawEnabled = EFFECTIVE_OPENCLAW_MODE !== 'off'
-  const activitySummary = openclawEnabled ? loadOpenClawActivitySummary({ nowMs: sampleStartMs }) : null
+  const openclawUsageEnabled = EFFECTIVE_OPENCLAW_MODE !== 'off'
+  const activitySummary = MONITOR_AGENT_ACTIVITY ? loadOpenClawActivitySummary({ nowMs: sampleStartMs }) : null
 
   const disabledProbe = {
     result: 'disabled',
@@ -1334,7 +1351,7 @@ async function collectSample() {
     fallbackCacheSource: null
   }
 
-  let usageProbe = openclawEnabled ? loadOpenClawUsage() : { usage: null, probe: disabledProbe }
+  let usageProbe = openclawUsageEnabled ? loadOpenClawUsage() : { usage: null, probe: disabledProbe }
   let usage = usageProbe.usage
   let usageFreshness = deriveUsageFreshness(usage, sampleStartMs, USAGE_STALE_MS, USAGE_NEAR_STALE_MS, USAGE_STALE_GRACE_MS)
   let usageRefreshAttempted = false
@@ -1346,7 +1363,7 @@ async function collectSample() {
   const shouldRefreshForNearStale = USAGE_REFRESH_ON_NEAR_STALE === 1 && usageFreshness.isNearStale
   const canRefreshFromCurrentState = usageProbe.probe.result === 'ok' || usageProbe.probe.result === 'fallback-cache'
 
-  if (openclawEnabled && usage && (usageFreshness.isPastStaleThreshold || shouldRefreshForNearStale) && canRefreshFromCurrentState) {
+  if (openclawUsageEnabled && usage && (usageFreshness.isPastStaleThreshold || shouldRefreshForNearStale) && canRefreshFromCurrentState) {
     usageRefreshAttempted = true
     usageRefreshStartMs = Date.now()
 
@@ -1390,6 +1407,9 @@ async function collectSample() {
     : { pct: null, cls: 'disabled', source: 'disabled' }
 
   const usedMemPct = MONITOR_MEMORY ? memUsedPct() : null
+  const thermals = MONITOR_TEMPERATURE && process.platform === 'darwin'
+    ? thermalSampleDarwin()
+    : { tempC: null, source: 'disabled', thermalLevel: null, thermalState: MONITOR_TEMPERATURE ? 'unavailable' : 'disabled' }
 
   const usageIntegrationStatus = usage
     ? usageFreshness.isStale
@@ -1397,20 +1417,20 @@ async function collectSample() {
       : usage?.integrationStatus === 'partial'
         ? 'ok'
         : (usage?.integrationStatus ?? 'ok')
-    : (openclawEnabled ? 'unavailable' : 'disabled')
+    : (openclawUsageEnabled ? 'unavailable' : 'disabled')
 
   const source = {
     monitorTargets: [...MONITOR_TARGETS],
-    usage: usage ? 'openclaw' : openclawEnabled ? 'unavailable' : 'disabled',
+    usage: usage ? 'openclaw' : openclawUsageEnabled ? 'unavailable' : 'disabled',
     usageIntegrationStatus,
-    usageIngestionStatus: openclawEnabled
+    usageIngestionStatus: openclawUsageEnabled
       ? usage && ['ok', 'fallback-cache'].includes(usageProbe.probe.result)
         ? 'ok'
         : 'unavailable'
       : 'disabled',
     usageActivityStatus: usage
       ? usageFreshness.freshnessState
-      : (openclawEnabled ? 'unavailable' : 'disabled'),
+      : (openclawUsageEnabled ? 'unavailable' : 'disabled'),
     usageProbeResult: usageProbe.probe.result,
     usageProbeAttempts: usageProbe.probe.attempts,
     usageProbeSweeps: usageProbe.probe.sweeps,
@@ -1421,7 +1441,7 @@ async function collectSample() {
     usageUsedFallbackCache: usageProbe.probe.usedFallbackCache,
     usageFallbackCacheAgeMs: usageProbe.probe.fallbackAgeMs,
     usageFallbackCacheSource: usageProbe.probe.fallbackCacheSource,
-    usageFreshnessState: openclawEnabled
+    usageFreshnessState: openclawUsageEnabled
       ? usage
         ? usageFreshness.freshnessState
         : null
@@ -1441,8 +1461,10 @@ async function collectSample() {
     usageStaleMsThreshold: USAGE_STALE_MS,
     usageNearStaleMsThreshold: USAGE_NEAR_STALE_MS,
     usageStaleGraceMs: USAGE_STALE_GRACE_MS,
-    activitySource: activitySummary?.source ?? (openclawEnabled ? 'unavailable' : 'disabled'),
-    activityWindowMs: activitySummary?.windowMs ?? null,
+    activitySource: activitySummary?.source ?? (MONITOR_AGENT_ACTIVITY ? 'unavailable' : 'disabled'),
+    activityWindowMs: MONITOR_AGENT_ACTIVITY ? (activitySummary?.windowMs ?? null) : null,
+    thermalSource: thermals.source,
+    thermalState: thermals.thermalState,
     memPressureSource: memPressure.source,
     cloudIngestionStatus: CLOUD_INGEST_URL && CLOUD_API_KEY
       ? cloudIngestKickedOut ? 'kicked-out' : 'enabled'
@@ -1467,30 +1489,37 @@ async function collectSample() {
     memPressurePct: MONITOR_MEMORY ? memPressure.pct : null,
     memPressureClass: MONITOR_MEMORY ? memPressure.cls : 'disabled',
     gpuPct: MONITOR_GPU ? gpu.pct : null,
+    deviceTempC: MONITOR_TEMPERATURE ? thermals.tempC : null,
+    thermalLevel: MONITOR_TEMPERATURE ? thermals.thermalLevel : null,
+    thermalState: MONITOR_TEMPERATURE ? thermals.thermalState : 'disabled',
     dayWindowMs: dayLoadSummary?.windowMs ?? DAY_WINDOW_MS,
     dayCpuAvgPct: MONITOR_CPU ? (dayLoadSummary?.cpuAvgPct ?? null) : null,
     dayMemAvgPct: MONITOR_MEMORY ? (dayLoadSummary?.memAvgPct ?? null) : null,
     dayGpuAvgPct: MONITOR_GPU ? (dayLoadSummary?.gpuAvgPct ?? null) : null,
-    dayTokensAvgPerMin: MONITOR_OPENCLAW ? (dayLoadSummary?.tokensAvgPerMin ?? null) : null,
+    dayTempAvgC: MONITOR_TEMPERATURE ? (dayLoadSummary?.tempAvgC ?? null) : null,
+    dayTempMaxC: MONITOR_TEMPERATURE ? (dayLoadSummary?.tempMaxC ?? null) : null,
+    dayTokensAvgPerMin: MONITOR_TOKEN_USAGE ? (dayLoadSummary?.tokensAvgPerMin ?? null) : null,
     gpuSource: gpu.source,
     gpuConfidence: gpu.confidence,
     gpuSampleWindowMs: gpu.sampleWindowMs,
-    tokensPerMin: MONITOR_OPENCLAW ? (usage?.tokensPerMin ?? null) : null,
-    openclawModel: MONITOR_OPENCLAW ? (usage?.model ?? null) : null,
-    openclawProvider: MONITOR_OPENCLAW ? (usage?.provider ?? null) : null,
-    openclawTotalTokens: MONITOR_OPENCLAW ? (usage?.totalTokens ?? null) : null,
-    openclawRemainingTokens: MONITOR_OPENCLAW ? (usage?.remainingTokens ?? null) : null,
-    openclawPercentUsed: MONITOR_OPENCLAW ? (usage?.percentUsed ?? null) : null,
-    openclawContextTokens: MONITOR_OPENCLAW ? (usage?.contextTokens ?? null) : null,
-    openclawBudgetKind: MONITOR_OPENCLAW ? (usage?.budgetKind ?? null) : null,
-    openclawSessionId: MONITOR_OPENCLAW ? (usage?.sessionId ?? null) : null,
-    openclawAgentId: MONITOR_OPENCLAW ? (usage?.agentId ?? null) : null,
-    openclawUsageTs: MONITOR_OPENCLAW ? (usage?.usageTimestampMs ?? null) : null,
-    openclawUsageAgeMs: MONITOR_OPENCLAW ? usageFreshness.usageAgeMs : null,
-    activityWindowMs: MONITOR_OPENCLAW ? (activitySummary?.windowMs ?? null) : null,
-    activityActiveSeconds: MONITOR_OPENCLAW ? (activitySummary?.totalActiveSeconds ?? null) : null,
-    activityIdleSeconds: MONITOR_OPENCLAW ? (activitySummary?.idleSeconds ?? null) : null,
-    activityJobs: MONITOR_OPENCLAW ? (activitySummary?.jobs ?? []) : [],
+    tokensPerMin: MONITOR_TOKEN_USAGE ? (usage?.tokensPerMin ?? null) : null,
+    openclawModel: MONITOR_RUNTIME_STATE ? (usage?.model ?? null) : null,
+    openclawProvider: MONITOR_RUNTIME_STATE ? (usage?.provider ?? null) : null,
+    openclawTotalTokens: MONITOR_TOKEN_USAGE ? (usage?.totalTokens ?? null) : null,
+    openclawInputTokens: MONITOR_TOKEN_USAGE ? (usage?.inputTokens ?? null) : null,
+    openclawOutputTokens: MONITOR_TOKEN_USAGE ? (usage?.outputTokens ?? null) : null,
+    openclawRemainingTokens: openclawUsageEnabled ? (usage?.remainingTokens ?? null) : null,
+    openclawPercentUsed: openclawUsageEnabled ? (usage?.percentUsed ?? null) : null,
+    openclawContextTokens: openclawUsageEnabled ? (usage?.contextTokens ?? null) : null,
+    openclawBudgetKind: openclawUsageEnabled ? (usage?.budgetKind ?? null) : null,
+    openclawSessionId: openclawUsageEnabled ? (usage?.sessionId ?? null) : null,
+    openclawAgentId: openclawUsageEnabled ? (usage?.agentId ?? null) : null,
+    openclawUsageTs: openclawUsageEnabled ? (usage?.usageTimestampMs ?? null) : null,
+    openclawUsageAgeMs: openclawUsageEnabled ? usageFreshness.usageAgeMs : null,
+    activityWindowMs: MONITOR_AGENT_ACTIVITY ? (activitySummary?.windowMs ?? null) : null,
+    activityActiveSeconds: MONITOR_AGENT_ACTIVITY ? (activitySummary?.totalActiveSeconds ?? null) : null,
+    activityIdleSeconds: MONITOR_AGENT_ACTIVITY ? (activitySummary?.idleSeconds ?? null) : null,
+    activityJobs: MONITOR_AGENT_ACTIVITY ? (activitySummary?.jobs ?? []) : [],
     localLogPath: LOCAL_LOG_PATH,
     localLogBytes: null,
     source

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "idlewatch",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "description": "Host telemetry collector for IdleWatch",
   "type": "module",
   "files": [

package/scripts/validate-dry-run-schema.mjs

@@ -92,6 +92,9 @@ function validateRow(row) {
   assert.equal(typeof row.gpuSource, 'string', 'gpuSource must be string')
   assert.ok(['high', 'medium', 'low', 'none'].includes(row.gpuConfidence), 'gpuConfidence invalid')
   assertNumberOrNull(row.gpuSampleWindowMs, 'gpuSampleWindowMs')
+  assertNumberOrNull(row.deviceTempC, 'deviceTempC')
+  assertNumberOrNull(row.dayTempAvgC, 'dayTempAvgC')
+  assertNumberOrNull(row.dayTempMaxC, 'dayTempMaxC')
 
   assertNumberOrNull(row.tokensPerMin, 'tokensPerMin')
   assert.ok(row.openclawModel === null || typeof row.openclawModel === 'string', 'openclawModel must be string or null')
@@ -115,6 +118,7 @@ function validateRow(row) {
   assertNumberOrNull(row.fleet.resources.memUsedPct, 'fleet.resources.memUsedPct')
   assertNumberOrNull(row.fleet.resources.memPressurePct, 'fleet.resources.memPressurePct')
   assert.ok(['normal', 'warning', 'critical', 'unavailable'].includes(row.fleet.resources.memPressureClass), 'fleet.resources.memPressureClass invalid')
+  assertNumberOrNull(row.fleet.resources.tempC, 'fleet.resources.tempC')
   assert.equal(typeof row.fleet.usage, 'object', 'fleet.usage must exist')
   assert.ok(row.fleet.usage.model === null || typeof row.fleet.usage.model === 'string', 'fleet.usage.model invalid')
   assertNumberOrNull(row.fleet.usage.totalTokens, 'fleet.usage.totalTokens')

package/src/enrollment.js

@@ -42,7 +42,9 @@ function writeSecureFile(filePath, content) {
   }
 }
 
-const MONITOR_TARGET_CHOICES = ['cpu', 'memory', 'gpu', 'openclaw']
+const OPENCLAW_AGENT_TARGETS = ['agent_activity', 'token_usage', 'runtime_state']
+const OPENCLAW_DERIVED_TARGETS = [...OPENCLAW_AGENT_TARGETS]
+const MONITOR_TARGET_CHOICES = ['cpu', 'memory', 'gpu', 'temperature', 'openclaw', ...OPENCLAW_DERIVED_TARGETS]
 const MODULE_DIR = path.dirname(fileURLToPath(import.meta.url))
 const PACKAGE_ROOT = path.resolve(MODULE_DIR, '..')
 
@@ -57,23 +59,28 @@ function detectAvailableMonitorTargets() {
   if (process.platform === 'darwin' || commandExists('nvidia-smi', ['--help'])) {
     available.add('gpu')
   }
+  if (process.platform === 'darwin') {
+    available.add('temperature')
+  }
 
   if (commandExists('openclaw', ['--help'])) {
-    available.add('openclaw')
+    OPENCLAW_DERIVED_TARGETS.forEach((target) => available.add(target))
   }
 
   return [...available]
 }
 
 function normalizeMonitorTargets(raw, available) {
-  const fallback = ['cpu', 'memory', ...(available.includes('openclaw') ? ['openclaw'] : []), ...(available.includes('gpu') ? ['gpu'] : [])]
+  const fallback = ['cpu', 'memory', ...(available.includes('gpu') ? ['gpu'] : []), ...(available.includes('temperature') ? ['temperature'] : []), ...OPENCLAW_DERIVED_TARGETS.filter((target) => available.includes(target))]
   if (!raw) return fallback
 
   const parsed = raw
     .split(',')
     .map((item) => item.trim().toLowerCase())
     .filter(Boolean)
-    .filter((item) => MONITOR_TARGET_CHOICES.includes(item) && available.includes(item))
+    .filter((item) => MONITOR_TARGET_CHOICES.includes(item))
+    .flatMap((item) => (item === 'openclaw' ? OPENCLAW_DERIVED_TARGETS : [item]))
+    .filter((item) => available.includes(item))
 
   if (parsed.length === 0) return fallback
   return [...new Set(parsed)]
@@ -226,6 +233,10 @@ function promptModeText({ isReconfigure = false, currentMode = null } = {}) {
   return `\n╭───────────────────────────────────────────────╮\n│${titleLine.padEnd(47)}│\n╰───────────────────────────────────────────────╯\n\nChoose setup mode:\n  1) Managed cloud (recommended)\n     Link this device with an API key from idlewatch.com/api\n  2) Local-only (no cloud writes)\n`
 }
 
+function monitorTargetsNeedOpenClawUsage(monitorTargets) {
+  return monitorTargets.some((item) => OPENCLAW_AGENT_TARGETS.includes(item) && item !== 'agent_activity')
+}
+
 export async function runEnrollmentWizard(options = {}) {
   const nonInteractive = options.nonInteractive || process.env.IDLEWATCH_ENROLL_NON_INTERACTIVE === '1'
   const noTui = options.noTui || process.env.IDLEWATCH_NO_TUI === '1'
@@ -348,7 +359,7 @@ export async function runEnrollmentWizard(options = {}) {
     `IDLEWATCH_DEVICE_NAME=${deviceName}`,
     `IDLEWATCH_DEVICE_ID=${safeDeviceId}`,
     `IDLEWATCH_MONITOR_TARGETS=${monitorTargets.join(',')}`,
-    `IDLEWATCH_OPENCLAW_USAGE=${monitorTargets.includes('openclaw') ? 'auto' : 'off'}`,
+    `IDLEWATCH_OPENCLAW_USAGE=${monitorTargetsNeedOpenClawUsage(monitorTargets) ? 'auto' : 'off'}`,
     `IDLEWATCH_LOCAL_LOG_PATH=${localLogPath}`,
     `IDLEWATCH_OPENCLAW_LAST_GOOD_CACHE_PATH=${localCachePath}`
   ]

package/src/openclaw-usage.js

@@ -166,6 +166,52 @@ function deriveTokensPerMinute(session) {
   return Number((totalTokens / minutes).toFixed(2))
 }
 
+function pickTokenBreakdown(record, totals = {}) {
+  const inputTokens = pickNumber(
+    record?.inputTokens,
+    record?.input_tokens,
+    record?.promptTokens,
+    record?.prompt_tokens,
+    record?.tokens?.input,
+    record?.tokens?.prompt,
+    record?.tokenUsage?.input,
+    record?.token_usage?.input,
+    record?.usage?.inputTokens,
+    record?.usage?.input_tokens,
+    record?.usage?.tokens?.input,
+    record?.usage?.tokens?.prompt,
+    totals?.inputTokens,
+    totals?.input_tokens,
+    totals?.promptTokens,
+    totals?.prompt_tokens,
+    totals?.tokens?.input,
+    totals?.tokens?.prompt
+  )
+
+  const outputTokens = pickNumber(
+    record?.outputTokens,
+    record?.output_tokens,
+    record?.completionTokens,
+    record?.completion_tokens,
+    record?.tokens?.output,
+    record?.tokens?.completion,
+    record?.tokenUsage?.output,
+    record?.token_usage?.output,
+    record?.usage?.outputTokens,
+    record?.usage?.output_tokens,
+    record?.usage?.tokens?.output,
+    record?.usage?.tokens?.completion,
+    totals?.outputTokens,
+    totals?.output_tokens,
+    totals?.completionTokens,
+    totals?.completion_tokens,
+    totals?.tokens?.output,
+    totals?.tokens?.completion
+  )
+
+  return { inputTokens, outputTokens }
+}
+
 function pickNewestSession(sessions = []) {
   return sessions.reduce((best, candidate) => {
     if (!best) return candidate
@@ -664,6 +710,7 @@ function parseFromStatusJson(parsed) {
     session?.usage?.tokenCount,
     session?.usage?.token_count
   )
+  const { inputTokens, outputTokens } = pickTokenBreakdown(session, session?.usage)
   const tokensPerMin = pickNumber(
     session.tokensPerMinute,
     session.tokens_per_minute,
@@ -768,26 +815,28 @@ function parseFromStatusJson(parsed) {
     (Number.isFinite(sessionAgeMs) && sessionAgeMs >= 0 ? Date.now() - sessionAgeMs : pickTimestamp(parsed?.ts, parsed?.time, parsed?.updatedAt, parsed?.updated_at, parsed?.updatedAtMs, parsed?.timestamp))
 
   const hasStrongUsage = model !== null || totalTokens !== null || tokensPerMin !== null
-
+  const provider = normalizeProviderName(
+    pickString(
+      session.provider,
+      session.providerName,
+      session.provider_name,
+      session?.usage?.provider,
+      session?.usage?.providerName,
+      session?.usage?.provider_name,
+      parsed?.provider,
+      parsed?.providerName,
+      parsed?.provider_name,
+      parsed?.status?.provider,
+      parsed?.status?.providerName,
+      parsed?.status?.provider_name
+    )
+  ) ?? inferProviderFromModel(model)
   return {
     model,
-    provider: normalizeProviderName(
-      pickString(
-        session.provider,
-        session.providerName,
-        session.provider_name,
-        session?.usage?.provider,
-        session?.usage?.providerName,
-        session?.usage?.provider_name,
-        parsed?.provider,
-        parsed?.providerName,
-        parsed?.provider_name,
-        parsed?.status?.provider,
-        parsed?.status?.providerName,
-        parsed?.status?.provider_name
-      )
-    ) ?? inferProviderFromModel(model),
+    provider,
     totalTokens,
+    inputTokens,
+    outputTokens,
     tokensPerMin,
     remainingTokens,
     percentUsed,
@@ -937,6 +986,7 @@ function parseGenericUsage(parsed) {
     parsed?.totals?.tokenCount,
     parsed?.totals?.total_tokens
   )
+  const { inputTokens, outputTokens } = pickTokenBreakdown(usageRecord, usageTotals)
   const tokensPerMin = pickNumber(
     usageRecord?.tokensPerMinute,
     usageRecord?.tokens_per_minute,
@@ -992,29 +1042,31 @@ function parseGenericUsage(parsed) {
   )
 
   if (model === null && totalTokens === null && tokensPerMin === null) return null
-
+  const provider = normalizeProviderName(
+    pickString(
+      usageRecord?.provider,
+      usageRecord?.providerName,
+      usageRecord?.provider_name,
+      usageRecord?.usage?.provider,
+      usageRecord?.usage?.providerName,
+      usageRecord?.usage?.provider_name,
+      usageTotals?.provider,
+      usageTotals?.providerName,
+      usageTotals?.provider_name,
+      parsed?.provider,
+      parsed?.providerName,
+      parsed?.provider_name,
+      parsed?.status?.provider,
+      parsed?.status?.providerName,
+      parsed?.status?.provider_name
+    )
+  ) ?? inferProviderFromModel(model)
   return {
     model,
-    provider: normalizeProviderName(
-      pickString(
-        usageRecord?.provider,
-        usageRecord?.providerName,
-        usageRecord?.provider_name,
-        usageRecord?.usage?.provider,
-        usageRecord?.usage?.providerName,
-        usageRecord?.usage?.provider_name,
-        usageTotals?.provider,
-        usageTotals?.providerName,
-        usageTotals?.provider_name,
-        parsed?.provider,
-        parsed?.providerName,
-        parsed?.provider_name,
-        parsed?.status?.provider,
-        parsed?.status?.providerName,
-        parsed?.status?.provider_name
-      )
-    ) ?? inferProviderFromModel(model),
+    provider,
     totalTokens,
+    inputTokens,
+    outputTokens,
     tokensPerMin,
     remainingTokens,
     percentUsed,

package/src/telemetry-mapping.js

@@ -22,12 +22,17 @@ export function enrichWithOpenClawFleetTelemetry(sample, context = {}) {
         cpuPct: sample.cpuPct ?? null,
         memUsedPct: sample.memUsedPct ?? sample.memPct ?? null,
         memPressurePct: sample.memPressurePct ?? null,
-        memPressureClass: sample.memPressureClass ?? 'unavailable'
+        memPressureClass: sample.memPressureClass ?? 'unavailable',
+        tempC: sample.deviceTempC ?? null,
+        thermalLevel: sample.thermalLevel ?? null,
+        thermalState: sample.thermalState ?? 'unavailable'
       },
       usage: {
         model: sample.openclawModel ?? null,
         provider: sample.openclawProvider ?? null,
         totalTokens: sample.openclawTotalTokens ?? null,
+        inputTokens: sample.openclawInputTokens ?? null,
+        outputTokens: sample.openclawOutputTokens ?? null,
         remainingTokens: sample.openclawRemainingTokens ?? null,
         percentUsed: sample.openclawPercentUsed ?? null,
         contextTokens: sample.openclawContextTokens ?? null,

package/src/thermal.js

@@ -0,0 +1,113 @@
+import { execSync } from 'child_process'
+
+function clampTempC(value) {
+  if (!Number.isFinite(value)) return null
+  return Number(value.toFixed(1))
+}
+
+function parseIstatsTemperature(text) {
+  if (!text) return null
+  const match = text.match(/(-?\d+(?:\.\d+)?)\s*(?:°\s*[CF]|deg(?:rees)?\s*[CF]?)/i) || text.match(/(-?\d+(?:\.\d+)?)/)
+  return match ? clampTempC(Number(match[1])) : null
+}
+
+function parseOsxCpuTemp(text) {
+  if (!text) return null
+  const match = text.match(/(-?\d+(?:\.\d+)?)\s*°?\s*C/i)
+  return match ? clampTempC(Number(match[1])) : null
+}
+
+function parsePmsetThermal(text) {
+  if (!text) return { level: null, state: 'unavailable' }
+  const normalized = text.toLowerCase()
+
+  if (normalized.includes('no thermal warning level has been recorded')) {
+    return { level: 0, state: 'nominal' }
+  }
+
+  const match = text.match(/thermal warning level[^0-9]*([0-9]+)/i)
+  if (!match) return { level: null, state: 'unavailable' }
+
+  const level = Number(match[1])
+  if (!Number.isFinite(level)) return { level: null, state: 'unavailable' }
+
+  if (level <= 0) return { level, state: 'nominal' }
+  if (level === 1) return { level, state: 'elevated' }
+  if (level === 2) return { level, state: 'high' }
+  return { level, state: 'critical' }
+}
+
+export function thermalSampleDarwin(exec = execSync) {
+  const probes = [
+    {
+      cmd: 'istats cpu temp',
+      source: 'istats',
+      parse: parseIstatsTemperature,
+      timeoutMs: 1200
+    },
+    {
+      cmd: 'osx-cpu-temp',
+      source: 'osx-cpu-temp',
+      parse: parseOsxCpuTemp,
+      timeoutMs: 1200
+    }
+  ]
+
+  for (const probe of probes) {
+    try {
+      const out = exec(probe.cmd, {
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'ignore'],
+        timeout: probe.timeoutMs
+      })
+      const tempC = probe.parse(out)
+      if (tempC != null) {
+        const pressure = parsePmsetThermal(
+          exec('pmset -g therm', {
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+            timeout: 1000
+          })
+        )
+        return {
+          tempC,
+          source: probe.source,
+          thermalLevel: pressure.level,
+          thermalState: pressure.state
+        }
+      }
+    } catch {
+      // keep probing
+    }
+  }
+
+  try {
+    const pressure = parsePmsetThermal(
+      exec('pmset -g therm', {
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'ignore'],
+        timeout: 1000
+      })
+    )
+    return {
+      tempC: null,
+      source: 'pmset-therm',
+      thermalLevel: pressure.level,
+      thermalState: pressure.state
+    }
+  } catch {
+    return {
+      tempC: null,
+      source: 'unavailable',
+      thermalLevel: null,
+      thermalState: 'unavailable'
+    }
+  }
+}
+
+export const __thermalTestUtils = {
+  clampTempC,
+  parseIstatsTemperature,
+  parseOsxCpuTemp,
+  parsePmsetThermal
+}

package/tui/src/main.rs

@@ -1,6 +1,6 @@
 use anyhow::{anyhow, Result};
 use crossterm::{
-    event::{self, Event, KeyCode},
+    event::{self, Event, KeyCode, KeyEvent, KeyModifiers},
     execute,
     terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
 };
@@ -19,7 +19,9 @@ use std::{
 #[derive(Clone)]
 struct MonitorTarget {
     key: &'static str,
+    group: &'static str,
     label: &'static str,
+    description: &'static str,
     available: bool,
     selected: bool,
 }
@@ -136,8 +138,9 @@ fn detect_monitor_targets(existing: &[String]) -> Vec<MonitorTarget> {
     let gpu_available = cfg!(target_os = "macos") || command_exists("nvidia-smi", &["--help"]);
     let has_existing = !existing.is_empty();
     let wants = |key: &str, fallback: bool| {
+        let has_legacy_openclaw = existing.iter().any(|item| item == "openclaw");
         if has_existing {
-            existing.iter().any(|item| item == key)
+            existing.iter().any(|item| item == key) || (has_legacy_openclaw && matches!(key, "agent_activity" | "token_usage" | "runtime_state"))
         } else {
             fallback
         }
@@ -146,27 +149,59 @@ fn detect_monitor_targets(existing: &[String]) -> Vec<MonitorTarget> {
     vec![
         MonitorTarget {
             key: "cpu",
+            group: "Compute",
             label: "CPU usage",
+            description: "machine load",
             available: true,
             selected: wants("cpu", true),
         },
         MonitorTarget {
             key: "memory",
+            group: "Compute",
             label: "Memory usage",
+            description: "resident memory pressure",
             available: true,
             selected: wants("memory", true),
         },
         MonitorTarget {
             key: "gpu",
+            group: "Compute",
             label: "GPU usage",
+            description: "accelerator load",
             available: gpu_available,
             selected: wants("gpu", gpu_available),
         },
         MonitorTarget {
-            key: "openclaw",
-            label: "OpenClaw token telemetry",
+            key: "temperature",
+            group: "Compute",
+            label: "Temperature",
+            description: "cpu temp when available, thermal state otherwise",
+            available: cfg!(target_os = "macos"),
+            selected: wants("temperature", cfg!(target_os = "macos")),
+        },
+        MonitorTarget {
+            key: "agent_activity",
+            group: "OpenClaw Agents",
+            label: "Idle / awake time",
+            description: "cron run history and idle wedges",
+            available: openclaw_available,
+            selected: wants("agent_activity", openclaw_available),
+        },
+        MonitorTarget {
+            key: "token_usage",
+            group: "OpenClaw Agents",
+            label: "Token usage",
+            description: "total, input, output, rate",
+            available: openclaw_available,
+            selected: wants("token_usage", openclaw_available),
+        },
+        MonitorTarget {
+            key: "runtime_state",
+            group: "OpenClaw Agents",
+            label: "Runtime metadata",
+            description: "provider, model, session state",
             available: openclaw_available,
-            selected: wants("openclaw", openclaw_available),
+            selected: wants("runtime_state", openclaw_available),
         },
     ]
 }
@@ -232,7 +267,7 @@ fn render_mode_menu(terminal: &mut Terminal<CrosstermBackend<io::Stdout>>, selec
             );
         f.render_widget(path, chunks[2]);
 
-        let help = Paragraph::new("↑/↓ move • Enter select • q quit")
+        let help = Paragraph::new("↑/↓ move • Enter select • Ctrl+C quit")
             .style(Style::default().fg(Color::LightMagenta).add_modifier(Modifier::BOLD));
         f.render_widget(help, chunks[3]);
     })?;
@@ -250,7 +285,7 @@ fn render_monitor_menu(
             .margin(1)
             .constraints([
                 Constraint::Length(4),
-                Constraint::Length(10),
+                Constraint::Length(16),
                 Constraint::Min(1),
             ])
             .split(f.area());
@@ -265,15 +300,22 @@ fn render_monitor_menu(
             );
         f.render_widget(title, chunks[0]);
 
-        let items = monitors
-            .iter()
-            .enumerate()
-            .map(|(idx, target)| {
+        let mut items = Vec::new();
+        let mut last_group = "";
+        for (idx, target) in monitors.iter().enumerate() {
+            if target.group != last_group {
+                last_group = target.group;
+                items.push(
+                    ListItem::new(format!("  {}", target.group))
+                        .style(Style::default().fg(Color::LightMagenta).add_modifier(Modifier::BOLD)),
+                );
+            }
+
                 let marker = if target.selected { "[x]" } else { "[ ]" };
                 let unavailable = if target.available { "" } else { " (not detected)" };
-                let line = format!("{} {}{}", marker, target.label, unavailable);
+                let line = format!("{} {} — {}{}", marker, target.label, target.description, unavailable);
 
-                if idx == cursor {
+                let item = if idx == cursor {
                     ListItem::new(format!("❯ {}", line)).style(
                         Style::default()
                             .fg(Color::White)
@@ -284,9 +326,9 @@ fn render_monitor_menu(
                     ListItem::new(format!("  {}", line)).style(Style::default().fg(Color::Cyan))
                 } else {
                     ListItem::new(format!("  {}", line)).style(Style::default().fg(Color::DarkGray))
-                }
-            })
-            .collect::<Vec<_>>();
+                };
+                items.push(item);
+        }
 
         let list = List::new(items).block(
             Block::default()
@@ -356,7 +398,7 @@ fn render_device_name_prompt(
         );
         f.render_widget(warning_widget, chunks[2]);
 
-        let help = Paragraph::new("Type name • Backspace edit • Enter continue • q quit")
+        let help = Paragraph::new("Type name • Backspace edit • Enter continue • Ctrl+C quit")
             .style(Style::default().fg(Color::LightMagenta).add_modifier(Modifier::BOLD));
         f.render_widget(help, chunks[3]);
     })?;
@@ -421,7 +463,7 @@ fn render_api_key_prompt(
         );
         f.render_widget(warning_widget, chunks[2]);
 
-        let help = Paragraph::new("Paste key • Backspace edit • Enter continue • q quit")
+        let help = Paragraph::new("Paste key • Backspace edit • Enter continue • Ctrl+C quit")
             .style(Style::default().fg(Color::LightMagenta).add_modifier(Modifier::BOLD));
         f.render_widget(help, chunks[3]);
     })?;
@@ -466,6 +508,11 @@ fn sanitize_device_id(raw: &str, fallback: &str) -> String {
     out.trim_matches('-').to_string()
 }
 
+fn is_quit_key(key: &KeyEvent) -> bool {
+    matches!(key.code, KeyCode::Esc | KeyCode::Char('q'))
+        || (matches!(key.code, KeyCode::Char('c')) && key.modifiers.contains(KeyModifiers::CONTROL))
+}
+
 fn main() -> Result<()> {
     let config_dir = default_config_dir();
     let env_file = std::env::var("IDLEWATCH_ENROLL_OUTPUT_ENV_FILE")
@@ -489,7 +536,7 @@ fn main() -> Result<()> {
                     KeyCode::Up => selected_mode = selected_mode.saturating_sub(1),
                     KeyCode::Down => selected_mode = (selected_mode + 1).min(1),
                     KeyCode::Enter => break,
-                    KeyCode::Char('q') | KeyCode::Esc => {
+                    _ if is_quit_key(&key) => {
                         disable_raw_mode()?;
                         execute!(terminal.backend_mut(), LeaveAlternateScreen)?;
                         return Err(anyhow!("setup_cancelled"));
@@ -528,7 +575,7 @@ fn main() -> Result<()> {
                         }
                         break;
                     }
-                    KeyCode::Char('q') | KeyCode::Esc => {
+                    _ if is_quit_key(&key) => {
                         disable_raw_mode()?;
                         execute!(terminal.backend_mut(), LeaveAlternateScreen)?;
                         return Err(anyhow!("setup_cancelled"));
@@ -570,7 +617,7 @@ fn main() -> Result<()> {
                         device_name_input.pop();
                         device_name_error = None;
                     }
-                    KeyCode::Char('q') | KeyCode::Esc => {
+                    _ if is_quit_key(&key) => {
                         disable_raw_mode()?;
                         execute!(terminal.backend_mut(), LeaveAlternateScreen)?;
                         return Err(anyhow!("setup_cancelled"));
@@ -617,7 +664,7 @@ fn main() -> Result<()> {
                             cloud_api_key_input.pop();
                             cloud_api_key_error = None;
                         }
-                        KeyCode::Char('q') | KeyCode::Esc => {
+                        _ if is_quit_key(&key) => {
                             disable_raw_mode()?;
                             execute!(terminal.backend_mut(), LeaveAlternateScreen)?;
                             return Err(anyhow!("setup_cancelled"));
@@ -653,7 +700,9 @@ fn main() -> Result<()> {
         selected_keys.join(",")
     };
 
-    let monitor_openclaw = monitor_targets_csv.split(',').any(|item| item == "openclaw");
+    let monitor_openclaw_usage = monitor_targets_csv
+        .split(',')
+        .any(|item| matches!(item, "token_usage" | "runtime_state"));
     let device_name = normalize_device_name(&device_name_input, &host);
     let safe_device_id = {
         let candidate = sanitize_device_id(
@@ -668,7 +717,7 @@ fn main() -> Result<()> {
         format!("IDLEWATCH_DEVICE_NAME={}", device_name),
         format!("IDLEWATCH_DEVICE_ID={}", safe_device_id),
         format!("IDLEWATCH_MONITOR_TARGETS={}", monitor_targets_csv),
-        format!("IDLEWATCH_OPENCLAW_USAGE={}", if monitor_openclaw { "auto" } else { "off" }),
+        format!("IDLEWATCH_OPENCLAW_USAGE={}", if monitor_openclaw_usage { "auto" } else { "off" }),
         format!(
             "IDLEWATCH_LOCAL_LOG_PATH={}",
             config_dir.join("logs").join(format!("{}-metrics.ndjson", safe_device_id)).display()