idlewatch 0.1.5 → 0.1.7

package/README.md

@@ -23,13 +23,13 @@ npx idlewatch --dry-run
 
 - `quickstart`: run first-run enrollment wizard
 - `--help`: show usage
-- `--dry-run`: collect one sample and exit (no Firebase write)
-- `--once`: collect one sample, publish to Firebase when configured, then exit
+- `--dry-run`: collect one sample and exit without remote writes
+- `--once`: collect one sample, publish it using the active configured path, then exit
 
 ## Reliability improvements
 
 - Local NDJSON durability log at `~/.idlewatch/logs/<host>-metrics.ndjson` (override via `IDLEWATCH_LOCAL_LOG_PATH`)
-- Retry-once+ for transient Firestore write failures
+- Retry-once+ for transient publish failures (cloud ingest and Firebase paths)
 - Non-overlapping scheduler loop (prevents concurrent sample overlap when host is busy)
 - Non-blocking CPU sampling using per-tick CPU deltas (no `Atomics.wait` stall)
 - Darwin GPU probing fallback chain (AGX/IOGPU `ioreg` → `powermetrics` → `top` grep) with provenance fields (`gpuSource`, `gpuConfidence`, `gpuSampleWindowMs`)
@@ -57,6 +57,8 @@ Use `gpuSource` + `gpuConfidence` in dashboards to decide whether to trust value
 npx idlewatch quickstart
 ```
 
+`idlewatch` is the primary package/command name. `idlewatch-skill` still works as a compatibility alias, but treat it as legacy in user-facing docs.
+
 The wizard keeps setup small:
 - asks for a **device name**
 - asks for your **API key** from `idlewatch.com/api`

package/bin/idlewatch-agent.js

@@ -13,12 +13,13 @@ import { memUsedPct, memoryPressureDarwin } from '../src/memory.js'
 import { deriveUsageFreshness } from '../src/usage-freshness.js'
 import { deriveUsageAlert } from '../src/usage-alert.js'
 import { loadLastGoodUsageSnapshot, persistLastGoodUsageSnapshot } from '../src/openclaw-cache.js'
+import { DAY_WINDOW_MS, loadOpenClawActivitySummary } from '../src/openclaw-activity.js'
 import { runEnrollmentWizard } from '../src/enrollment.js'
 import { enrichWithOpenClawFleetTelemetry } from '../src/telemetry-mapping.js'
 import pkg from '../package.json' with { type: 'json' }
 
 function printHelp() {
-  console.log(`idlewatch\n\nUsage:\n  idlewatch [quickstart|configure|dashboard|run] [--dry-run] [--once] [--help]\n\nOptions:\n  quickstart  Run first-run setup and save local IdleWatch config\n  configure   Alias for quickstart; reopen setup to change device name, API key, or metrics\n  dashboard   Launch local dashboard from local IdleWatch logs\n  run         Start the background collector using saved local config\n  --no-tui    Skip the Rust TUI and use plain text setup without installing Cargo\n  --dry-run   Collect and print one telemetry sample, then exit without remote writes\n  --once      Collect and publish one telemetry sample, then exit\n  --help      Show this help message\n\nQuickstart:\n  1. Create an API key on idlewatch.com/api\n  2. Run: idlewatch quickstart\n  3. Pick a device name and metrics\n  4. IdleWatch saves your local config and sends a first sample\n\nEnvironment:\n  IDLEWATCH_HOST                     Optional custom host label (default: hostname)\n  IDLEWATCH_INTERVAL_MS              Sampling interval in ms (default: 10000)\n  IDLEWATCH_LOCAL_LOG_PATH           Optional NDJSON file path for local sample durability\n  IDLEWATCH_DASHBOARD_PORT           Local dashboard HTTP port (default: 4373)\n  IDLEWATCH_OPENCLAW_USAGE           OpenClaw usage lookup mode: auto|off (default: auto)\n  IDLEWATCH_OPENCLAW_PROBE_TIMEOUT_MS OpenClaw command timeout per probe in ms (default: 2500)\n  IDLEWATCH_OPENCLAW_PROBE_RETRIES   Extra OpenClaw probe sweep retries after first pass (default: 1)\n  IDLEWATCH_OPENCLAW_MAX_OUTPUT_BYTES   Max per-command OpenClaw probe output capture in bytes before truncation (default: 2097152 / 2MB)\n  IDLEWATCH_OPENCLAW_MAX_OUTPUT_BYTES_HARD_CAP  Hard cap for auto-retry output capture escalation (default: 16777216 / 16MB)\n  IDLEWATCH_USAGE_STALE_MS           Mark OpenClaw usage stale beyond this age in ms (default: max(interval*3,60000))\n  IDLEWATCH_USAGE_NEAR_STALE_MS      Mark OpenClaw usage as aging beyond this age in ms (default: floor((stale+grace)*0.85))\n  IDLEWATCH_USAGE_STALE_GRACE_MS     Extra grace window before status becomes stale (default: min(interval,10000))\n  IDLEWATCH_USAGE_REFRESH_REPROBES   Forced uncached reprobes when usage crosses stale threshold (default: 1)\n  IDLEWATCH_USAGE_REFRESH_DELAY_MS   Delay between forced stale-threshold reprobes in ms (default: 250)\n  IDLEWATCH_USAGE_REFRESH_ON_NEAR_STALE Trigger refresh when usage is near-stale: 1|0 (default: 1)\n  IDLEWATCH_USAGE_IDLE_AFTER_MS      Downgrade stale usage alerts to idle notice beyond this age in ms (default: 21600000)\n  IDLEWATCH_OPENCLAW_LAST_GOOD_MAX_AGE_MS  Reuse last successful usage snapshot after probe failures up to this age in ms\n  IDLEWATCH_OPENCLAW_LAST_GOOD_CACHE_PATH Persist/reuse last successful usage snapshot across restarts (default: ~/.idlewatch/cache/<host>-openclaw-last-good.json)\n  IDLEWATCH_CLOUD_INGEST_URL         Optional cloud ingest endpoint (e.g. https://idlewatch.com/api/ingest)\n  IDLEWATCH_CLOUD_API_KEY            Cloud API key from idlewatch.com/api for device linking\n  IDLEWATCH_REQUIRE_CLOUD_WRITES     Require cloud publish path in --once mode: 1|0 (default: 0)\n\nAdvanced Firebase / emulator mode:\n  IDLEWATCH_REQUIRE_FIREBASE_WRITES  Require Firebase publish path in --once mode: 1|0 (default: 0)\n  FIREBASE_PROJECT_ID                Firebase project id\n  FIREBASE_SERVICE_ACCOUNT_FILE      Path to service account JSON file (preferred for production)\n  FIREBASE_SERVICE_ACCOUNT_JSON      Raw JSON service account (supported, less secure than file path)\n  FIREBASE_SERVICE_ACCOUNT_B64       Base64-encoded JSON service account (legacy)\n  FIRESTORE_EMULATOR_HOST            Optional Firestore emulator host; allows local writes without service-account creds\n`)
+  console.log(`idlewatch\n\nUsage:\n  idlewatch [quickstart|configure|status|dashboard|run] [--no-tui] [--dry-run] [--once] [--help]\n\nOptions:\n  quickstart  Run first-run setup and save local IdleWatch config\n  configure   Alias for quickstart; reopen setup to change device name, API key, or metrics\n  status      Show current device config, publish mode, and last sample age\n  dashboard   Launch local dashboard from local IdleWatch logs\n  run         Start the background collector using saved local config\n  --no-tui    Skip the Rust TUI and use plain text setup without installing Cargo\n  --dry-run   Collect and print one telemetry sample, then exit without remote writes\n  --once      Collect and publish one telemetry sample, then exit\n  --help      Show this help message\n\nQuickstart:\n  1. Create an API key on idlewatch.com/api\n  2. Run: idlewatch quickstart\n  3. Pick a device name and metrics\n  4. IdleWatch saves your local config and sends a first sample\n\nCommon env (optional):\n  IDLEWATCH_CLOUD_API_KEY            Cloud API key from idlewatch.com/api for device linking\n  IDLEWATCH_CLOUD_INGEST_URL         Cloud ingest endpoint (default: https://api.idlewatch.com/api/ingest)\n  IDLEWATCH_LOCAL_LOG_PATH           Optional NDJSON file path for local sample durability\n  IDLEWATCH_DASHBOARD_PORT           Local dashboard HTTP port (default: 4373)\n  IDLEWATCH_OPENCLAW_USAGE           OpenClaw usage lookup mode: auto|off (default: auto)\n  IDLEWATCH_REQUIRE_CLOUD_WRITES     Require cloud publish path in --once mode: 1|0 (default: 0)\n\nAdvanced env tuning:\n  IDLEWATCH_HOST                     Optional custom host label (default: hostname)\n  IDLEWATCH_INTERVAL_MS              Sampling interval in ms (default: 10000)\n  IDLEWATCH_OPENCLAW_PROBE_TIMEOUT_MS OpenClaw command timeout per probe in ms (default: 2500)\n  IDLEWATCH_OPENCLAW_PROBE_RETRIES   Extra OpenClaw probe sweep retries after first pass (default: 1)\n  IDLEWATCH_OPENCLAW_MAX_OUTPUT_BYTES   Max per-command OpenClaw probe output capture in bytes before truncation (default: 2097152 / 2MB)\n  IDLEWATCH_OPENCLAW_MAX_OUTPUT_BYTES_HARD_CAP  Hard cap for auto-retry output capture escalation (default: 16777216 / 16MB)\n  IDLEWATCH_USAGE_STALE_MS           Mark OpenClaw usage stale beyond this age in ms (default: max(interval*3,60000))\n  IDLEWATCH_USAGE_NEAR_STALE_MS      Mark OpenClaw usage as aging beyond this age in ms (default: floor((stale+grace)*0.85))\n  IDLEWATCH_USAGE_STALE_GRACE_MS     Extra grace window before status becomes stale (default: min(interval,10000))\n  IDLEWATCH_USAGE_REFRESH_REPROBES   Forced uncached reprobes when usage crosses stale threshold (default: 1)\n  IDLEWATCH_USAGE_REFRESH_DELAY_MS   Delay between forced stale-threshold reprobes in ms (default: 250)\n  IDLEWATCH_USAGE_REFRESH_ON_NEAR_STALE Trigger refresh when usage is near-stale: 1|0 (default: 1)\n  IDLEWATCH_USAGE_IDLE_AFTER_MS      Downgrade stale usage alerts to idle notice beyond this age in ms (default: 21600000)\n  IDLEWATCH_OPENCLAW_LAST_GOOD_MAX_AGE_MS  Reuse last successful usage snapshot after probe failures up to this age in ms\n  IDLEWATCH_OPENCLAW_LAST_GOOD_CACHE_PATH Persist/reuse last successful usage snapshot across restarts (default: ~/.idlewatch/cache/<host>-openclaw-last-good.json)\n\nAdvanced Firebase / emulator mode:\n  IDLEWATCH_REQUIRE_FIREBASE_WRITES  Require Firebase publish path in --once mode: 1|0 (default: 0)\n  FIREBASE_PROJECT_ID                Firebase project id\n  FIREBASE_SERVICE_ACCOUNT_FILE      Path to service account JSON file (preferred for production)\n  FIREBASE_SERVICE_ACCOUNT_JSON      Raw JSON service account (supported, less secure than file path)\n  FIREBASE_SERVICE_ACCOUNT_B64       Base64-encoded JSON service account (legacy)\n  FIRESTORE_EMULATOR_HOST            Optional Firestore emulator host; allows local writes without service-account creds\n`)
 }
 
 const require = createRequire(import.meta.url)
@@ -54,8 +55,17 @@ function resolveEnvPath(value) {
   return path.resolve(expandSupportedPathVars(value))
 }
 
+function defaultPersistedEnvFilePath() {
+  return path.join(os.homedir(), '.idlewatch', 'idlewatch.env')
+}
+
+function usesDefaultPersistedEnvFile(envFilePath) {
+  if (!envFilePath) return false
+  return path.resolve(envFilePath) === path.resolve(defaultPersistedEnvFilePath())
+}
+
 function loadPersistedEnvIntoProcess() {
-  const envFile = path.join(os.homedir(), '.idlewatch', 'idlewatch.env')
+  const envFile = defaultPersistedEnvFilePath()
   if (!fs.existsSync(envFile)) return null
 
   try {
@@ -71,6 +81,27 @@ function loadPersistedEnvIntoProcess() {
   }
 }
 
+function buildSetupTestEnv(enrolledEnv) {
+  const nextEnv = { ...process.env }
+
+  for (const key of Object.keys(nextEnv)) {
+    if (
+      key.startsWith('IDLEWATCH_') ||
+      key.startsWith('FIREBASE_') ||
+      key === 'GOOGLE_APPLICATION_CREDENTIALS'
+    ) {
+      delete nextEnv[key]
+    }
+  }
+
+  for (const [key, value] of Object.entries(enrolledEnv || {})) {
+    nextEnv[key] = key.endsWith('_PATH') ? expandSupportedPathVars(value) : value
+  }
+
+  nextEnv.IDLEWATCH_SETUP_VERIFY = '1'
+  return nextEnv
+}
+
 const persistedEnv = loadPersistedEnvIntoProcess()
 
 function parseMonitorTargets(raw) {
@@ -203,6 +234,26 @@ function buildLocalDashboardPayload(logPath) {
   }
 }
 
+function buildRollingLoadSummary(logPath, nowMs = Date.now(), windowMs = DAY_WINDOW_MS) {
+  const rows = parseLocalRows(logPath, 20000).filter((row) => Number(row.ts || 0) >= nowMs - windowMs)
+  if (rows.length === 0) return null
+
+  const average = (values) => {
+    const valid = values.filter((value) => Number.isFinite(value))
+    if (valid.length === 0) return null
+    return Number((valid.reduce((sum, value) => sum + value, 0) / valid.length).toFixed(2))
+  }
+
+  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))),
+    tokensAvgPerMin: average(rows.map((row) => Number(row.tokensPerMin)))
+  }
+}
+
 function renderLocalDashboardHtml() {
   return `<!doctype html>
 <html>
@@ -355,10 +406,11 @@ function runLocalDashboard({ host }) {
 
 const argv = process.argv.slice(2)
 const args = new Set(argv)
+const statusRequested = argv[0] === 'status' || argv.includes('--status')
 const dashboardRequested = argv[0] === 'dashboard' || argv.includes('--dashboard')
 const runRequested = argv[0] === 'run' || argv.includes('--run')
 const interactiveDefaultRequested = argv.length === 0 && process.stdin.isTTY && process.stdout.isTTY
-const quickstartRequested = argv[0] === 'quickstart' || argv[0] === 'configure' || argv.includes('--quickstart') || argv.includes('--configure') || (interactiveDefaultRequested && !dashboardRequested && !runRequested)
+const quickstartRequested = argv[0] === 'quickstart' || argv[0] === 'configure' || argv.includes('--quickstart') || argv.includes('--configure') || (interactiveDefaultRequested && !dashboardRequested && !runRequested && !statusRequested)
 if (args.has('--help') || args.has('-h')) {
   printHelp()
   process.exit(0)
@@ -374,28 +426,48 @@ if (quickstartRequested) {
   try {
     const result = await runEnrollmentWizard({ noTui: args.has('--no-tui') })
 
+    if (!result?.outputEnvFile || !fs.existsSync(result.outputEnvFile)) {
+      throw new Error(`setup_did_not_write_env_file:${result?.outputEnvFile || 'unknown'}`)
+    }
+
     const enrolledEnv = parseEnvFileToObject(result.outputEnvFile)
     const onceRun = spawnSync(process.execPath, [process.argv[1], '--once'], {
       stdio: 'inherit',
-      env: {
-        ...process.env,
-        ...enrolledEnv
-      }
+      env: buildSetupTestEnv(enrolledEnv)
     })
 
     if (onceRun.status === 0) {
       console.log(`✅ Setup complete. Mode=${result.mode} device=${result.deviceName} envFile=${result.outputEnvFile}`)
-      console.log('Initial telemetry sample sent successfully.')
+      if (result.mode === 'local') {
+        console.log('Initial local telemetry check completed successfully.')
+      } else {
+        console.log('Initial telemetry sample sent successfully.')
+      }
+      console.log('To keep this device online continuously, run: idlewatch run')
+      if (process.platform === 'darwin') {
+        console.log('On macOS, you can also enable login startup with the bundled LaunchAgent install script.')
+      }
       process.exit(0)
     }
 
     console.error(`⚠️ Setup is not finished yet. Mode=${result.mode} device=${result.deviceName} envFile=${result.outputEnvFile}`)
     console.error('The first required telemetry sample did not publish successfully, so this device may not be linked yet.')
-    console.error(`Retry with: set -a; source "${result.outputEnvFile}"; set +a && idlewatch --once`)
-    console.error('Or rerun: idlewatch quickstart')
+    if (usesDefaultPersistedEnvFile(result.outputEnvFile)) {
+      console.error('Retry with: idlewatch --once')
+      console.error('Or rerun: idlewatch quickstart')
+    } else {
+      console.error('Retry with: idlewatch quickstart')
+      console.error(`Use the saved config directly: set -a; source "${result.outputEnvFile}"; set +a && idlewatch --once`)
+    }
     process.exit(onceRun.status ?? 1)
   } catch (err) {
-    console.error(`Enrollment failed: ${err.message}`)
+    if (String(err?.message || '') === 'setup_cancelled') {
+      console.error('Enrollment cancelled before saving config.')
+    } else if (String(err?.message || '').startsWith('setup_did_not_write_env_file:')) {
+      console.error(`Enrollment failed: setup did not save idlewatch.env (${String(err.message).split(':').slice(1).join(':')}).`)
+    } else {
+      console.error(`Enrollment failed: ${err.message}`)
+    }
     process.exit(1)
   }
 }
@@ -624,9 +696,68 @@ if (firebaseConfigError) {
   process.exit(1)
 }
 
-if (!appReady && !(CLOUD_INGEST_URL && CLOUD_API_KEY)) {
+const hasAnyFirebaseConfig = Boolean(PROJECT_ID || CREDS_FILE || CREDS_JSON || CREDS_B64 || FIRESTORE_EMULATOR_HOST)
+const hasCloudConfig = Boolean(CLOUD_INGEST_URL && CLOUD_API_KEY)
+const shouldWarnAboutMissingPublishConfig = !appReady && !hasCloudConfig && !DRY_RUN && !hasAnyFirebaseConfig
+
+function getPublishModeLabel() {
+  if (hasCloudConfig) return 'cloud'
+  if (appReady) return 'firebase'
+  return 'local-only'
+}
+
+if (statusRequested) {
+  const envFile = defaultPersistedEnvFilePath()
+  const hasConfig = fs.existsSync(envFile)
+  const publishMode = getPublishModeLabel()
+
+  console.log('IdleWatch status')
+  console.log('')
+  console.log(`  Device:       ${DEVICE_NAME}`)
+  console.log(`  Device ID:    ${DEVICE_ID}`)
+  console.log(`  Publish mode: ${publishMode}`)
+  if (hasCloudConfig) {
+    console.log(`  Cloud link:   ${CLOUD_INGEST_URL}`)
+    console.log(`  API key:      ${CLOUD_API_KEY.slice(0, 8)}..${CLOUD_API_KEY.slice(-4)}`)
+  }
+  console.log(`  Metrics:      ${[...MONITOR_TARGETS].join(', ')}`)
+  console.log(`  Local log:    ${LOCAL_LOG_PATH || '(none)'}`)
+  console.log(`  Config:       ${hasConfig ? envFile : '(no saved config)'}`)
+
+  let hasSamples = false
+  if (LOCAL_LOG_PATH && fs.existsSync(LOCAL_LOG_PATH)) {
+    try {
+      const stat = fs.statSync(LOCAL_LOG_PATH)
+      console.log(`  Log size:     ${formatBytes(stat.size)}`)
+      const rows = parseLocalRows(LOCAL_LOG_PATH, 1)
+      if (rows.length > 0 && rows[0].ts) {
+        hasSamples = true
+        const ageMs = Date.now() - Number(rows[0].ts)
+        const ageSec = Math.round(ageMs / 1000)
+        const agoText = ageSec < 60 ? `${ageSec}s ago` : ageSec < 3600 ? `${Math.round(ageSec / 60)}m ago` : ageSec < 86400 ? `${Math.round(ageSec / 3600)}h ago` : `${Math.round(ageSec / 86400)}d ago`
+        console.log(`  Last sample:  ${agoText}`)
+      } else {
+        console.log('  Last sample:  (none yet)')
+      }
+    } catch { /* ignore stat errors */ }
+  } else if (hasConfig) {
+    console.log('  Last sample:  (none yet)')
+  }
+
+  console.log('')
+  if (!hasConfig) {
+    console.log('  Run idlewatch quickstart to set up this device.')
+  } else if (!hasSamples) {
+    console.log('  Run idlewatch --once to collect a test sample, or idlewatch run for continuous monitoring.')
+  } else {
+    console.log('  Run idlewatch configure to change device name, metrics, or API key.')
+  }
+  process.exit(0)
+}
+
+if (shouldWarnAboutMissingPublishConfig) {
   console.error(
-    'Firebase is not configured. Running without Firebase writes. Set FIREBASE_PROJECT_ID + FIREBASE_SERVICE_ACCOUNT_FILE (preferred, or FIREBASE_SERVICE_ACCOUNT_JSON / FIREBASE_SERVICE_ACCOUNT_B64), use FIREBASE_PROJECT_ID + FIRESTORE_EMULATOR_HOST for emulator writes, or run idlewatch quickstart to link cloud ingest.'
+    'Local-only mode: this run will stay on this Mac until you link a publish target. Run idlewatch quickstart any time if you want cloud ingest.'
   )
 }
 
@@ -1188,7 +1319,9 @@ 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 disabledProbe = {
     result: 'disabled',
@@ -1308,6 +1441,8 @@ 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,
     memPressureSource: memPressure.source,
     cloudIngestionStatus: CLOUD_INGEST_URL && CLOUD_API_KEY
       ? cloudIngestKickedOut ? 'kicked-out' : 'enabled'
@@ -1332,16 +1467,30 @@ async function collectSample() {
     memPressurePct: MONITOR_MEMORY ? memPressure.pct : null,
     memPressureClass: MONITOR_MEMORY ? memPressure.cls : 'disabled',
     gpuPct: MONITOR_GPU ? gpu.pct : null,
+    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,
     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 ?? []) : [],
     localLogPath: LOCAL_LOG_PATH,
     localLogBytes: null,
     source
@@ -1355,21 +1504,43 @@ async function collectSample() {
   })
 }
 
+function summarizeSetupVerification(row) {
+  const metrics = []
+  if (row.cpuPct !== null && row.cpuPct !== undefined) metrics.push('cpu')
+  if (row.memPct !== null && row.memPct !== undefined) metrics.push('memory')
+  if (row.gpuPct !== null && row.gpuPct !== undefined) metrics.push('gpu')
+  if (row.tokensPerMin !== null && row.tokensPerMin !== undefined) metrics.push('openclaw')
+
+  const details = [
+    `mode=${getPublishModeLabel()}`,
+    `metrics=${metrics.length ? metrics.join(',') : 'none'}`
+  ]
+
+  if (row.localLogPath) details.push(`localLog=${row.localLogPath}`)
+  return `Initial sample ready (${details.join(' ')})`
+}
+
 async function tick() {
   const row = await collectSample()
   const localUsage = appendLocal(row)
   row.localLogPath = localUsage.path
   row.localLogBytes = localUsage.bytes
 
-  console.log(JSON.stringify(row))
+  if (process.env.IDLEWATCH_SETUP_VERIFY === '1') {
+    console.log(summarizeSetupVerification(row))
+  } else {
+    console.log(JSON.stringify(row))
+  }
 
   const published = await publish(row)
 
   if (cloudIngestKickedOut && !cloudIngestKickoutNotified) {
     cloudIngestKickoutNotified = true
-    console.error(
-      `Cloud ingest disabled: API key rejected (${cloudIngestKickoutReason || 'unauthorized'}). Run idlewatch quickstart to link a new key.`
-    )
+    if (!(REQUIRE_CLOUD_WRITES && ONCE)) {
+      console.error(
+        `Cloud ingest disabled: API key rejected (${cloudIngestKickoutReason || 'unauthorized'}). Run idlewatch quickstart to link a new key.`
+      )
+    }
   }
 
   if (REQUIRE_FIREBASE_WRITES && ONCE && !published) {
@@ -1422,7 +1593,7 @@ process.on('SIGTERM', () => gracefulShutdown('SIGTERM'))
 if (DRY_RUN || ONCE) {
   const mode = DRY_RUN ? 'dry-run' : 'once'
   console.log(
-    `idlewatch ${mode} host=${HOST} device=${DEVICE_NAME} deviceId=${DEVICE_ID} intervalMs=${INTERVAL_MS} firebase=${appReady} localLog=${LOCAL_LOG_PATH} env=${persistedEnv?.envFile || 'process'}`
+    `idlewatch ${mode} host=${HOST} device=${DEVICE_NAME} deviceId=${DEVICE_ID} intervalMs=${INTERVAL_MS} publish=${getPublishModeLabel()} localLog=${LOCAL_LOG_PATH} env=${persistedEnv?.envFile || 'process'}`
   )
   tick()
     .then(() => process.exit(0))
@@ -1432,7 +1603,7 @@ if (DRY_RUN || ONCE) {
     })
 } else {
   console.log(
-    `idlewatch started host=${HOST} device=${DEVICE_NAME} deviceId=${DEVICE_ID} intervalMs=${INTERVAL_MS} firebase=${appReady} localLog=${LOCAL_LOG_PATH} monitorTargets=${[...MONITOR_TARGETS].join(',')} openclawUsage=${EFFECTIVE_OPENCLAW_MODE} env=${persistedEnv?.envFile || 'process'}`
+    `idlewatch started host=${HOST} device=${DEVICE_NAME} deviceId=${DEVICE_ID} intervalMs=${INTERVAL_MS} publish=${getPublishModeLabel()} localLog=${LOCAL_LOG_PATH} monitorTargets=${[...MONITOR_TARGETS].join(',')} openclawUsage=${EFFECTIVE_OPENCLAW_MODE} env=${persistedEnv?.envFile || 'process'}`
   )
   loop()
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "idlewatch",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "Host telemetry collector for IdleWatch",
   "type": "module",
   "files": [
@@ -25,7 +25,7 @@
     "quickstart": "node bin/idlewatch-agent.js quickstart",
     "validate:bin": "node scripts/validate-bin.mjs",
     "validate:onboarding": "node scripts/validate-onboarding.mjs",
-    "test:unit": "node --test 'test/*.test.mjs'",
+    "test:unit": "node --test --test-concurrency=1 'test/*.test.mjs'",
     "smoke:help": "node bin/idlewatch-agent.js --help",
     "smoke:dry-run": "node bin/idlewatch-agent.js --dry-run",
     "smoke:once": "IDLEWATCH_OPENCLAW_USAGE=off node bin/idlewatch-agent.js --once",

package/scripts/install-macos-launch-agent.sh

@@ -13,6 +13,18 @@ if [[ $START_INTERVAL_SEC -lt 60 ]]; then
 fi
 
 PLIST_PATH="$PLIST_ROOT/$PLIST_LABEL.plist"
+CONFIG_ENV_PATH="${IDLEWATCH_CONFIG_ENV_PATH:-$HOME/.idlewatch/idlewatch.env}"
+DEFAULT_APP_PATH="/Applications/IdleWatch.app"
+DEFAULT_PLIST_ROOT="$HOME/Library/LaunchAgents"
+DEFAULT_PLIST_LABEL="com.idlewatch.agent"
+
+if [[ "$PLIST_LABEL" == "$DEFAULT_PLIST_LABEL" ]] && \
+   [[ "$PLIST_ROOT" != "$DEFAULT_PLIST_ROOT" || "$APP_PATH" != "$DEFAULT_APP_PATH" ]]; then
+  echo "Refusing to reuse the default LaunchAgent label ($DEFAULT_PLIST_LABEL) with a custom app path or plist root." >&2
+  echo "launchd uses the label as the real identity, so this could replace your already-loaded IdleWatch agent." >&2
+  echo "Use IDLEWATCH_LAUNCH_AGENT_LABEL to pick a different label for side-by-side QA/dev installs." >&2
+  exit 1
+fi
 
 if [[ ! -d "$PLIST_ROOT" ]]; then
   mkdir -p "$PLIST_ROOT"
@@ -77,3 +89,20 @@ launchctl bootstrap "gui/$USER_GUID" "$PLIST_PATH"
 launchctl enable "$PLIST_ID"
 echo "Installed LaunchAgent: $PLIST_ID"
 echo "Plist: $PLIST_PATH"
+echo "Logs: $LOG_DIR/idlewatch.out.log and $LOG_DIR/idlewatch.err.log"
+if [[ -f "$CONFIG_ENV_PATH" ]]; then
+  echo "Saved IdleWatch config found: $CONFIG_ENV_PATH"
+  if [[ "$CONFIG_ENV_PATH" == "$HOME/.idlewatch/idlewatch.env" ]]; then
+    echo "Background runs will auto-load it."
+  else
+    echo "Background runs auto-load only the default path: $HOME/.idlewatch/idlewatch.env"
+    echo "Move or copy this config there if you want login startup to reuse it automatically."
+  fi
+else
+  echo "No saved IdleWatch config found yet at: $CONFIG_ENV_PATH"
+  echo "Finish setup once before relying on login startup:"
+  echo "  \"$BIN_PATH\" quickstart"
+  if command -v idlewatch >/dev/null 2>&1; then
+    echo "If you already installed the CLI on PATH, 'idlewatch quickstart' works too."
+  fi
+fi

package/scripts/validate-onboarding.mjs

@@ -68,9 +68,9 @@ try {
     IDLEWATCH_CLOUD_INGEST_URL: cloudIngestUrl,
     IDLEWATCH_ENROLL_OUTPUT_ENV_FILE: envOut,
     IDLEWATCH_ENROLL_CONFIG_DIR: configDir,
-    IDLEWATCH_DEVICE_NAME: 'Validator Box',
+    IDLEWATCH_ENROLL_DEVICE_NAME: 'Validator Box',
     IDLEWATCH_DEVICE_ID: 'validator-box',
-    IDLEWATCH_MONITOR_TARGETS: 'cpu,memory',
+    IDLEWATCH_ENROLL_MONITOR_TARGETS: 'cpu,memory',
     IDLEWATCH_OPENCLAW_USAGE: 'off'
   })
 

package/src/enrollment.js

@@ -10,6 +10,24 @@ function defaultConfigDir() {
   return path.join(os.homedir(), '.idlewatch')
 }
 
+function machineName() {
+  if (process.platform === 'darwin') {
+    const macName = spawnSync('scutil', ['--get', 'ComputerName'], { encoding: 'utf8' })
+    if (macName.status === 0) {
+      const value = String(macName.stdout || '').trim()
+      if (value) return value
+    }
+  }
+
+  const hostName = String(os.hostname() || '').trim()
+  if (hostName) return hostName
+
+  const envHost = String(process.env.HOSTNAME || '').trim()
+  if (envHost) return envHost
+
+  return 'IdleWatch Device'
+}
+
 function ensureDir(dirPath) {
   fs.mkdirSync(dirPath, { recursive: true })
 }
@@ -80,12 +98,12 @@ function looksLikeCloudApiKey(value) {
   return /^iwk_[A-Za-z0-9_-]{20,}$/.test(String(value || '').trim())
 }
 
-function normalizeDeviceName(raw, fallback = os.hostname()) {
+function normalizeDeviceName(raw, fallback = machineName()) {
   const value = String(raw || '').trim().replace(/\s+/g, ' ')
   return value || fallback
 }
 
-function sanitizeDeviceId(raw, fallback = os.hostname()) {
+function sanitizeDeviceId(raw, fallback = machineName()) {
   const base = normalizeDeviceName(raw, fallback).toLowerCase()
   const sanitized = base
     .replace(/[^a-z0-9._-]+/g, '-')
@@ -100,12 +118,51 @@ function cargoAvailable() {
 }
 
 function bundledTuiBinaryPath() {
+  const override = String(process.env.IDLEWATCH_TUI_BIN || '').trim()
+  if (override) return path.resolve(override)
+
   const platform = process.platform
   const arch = process.arch
   const ext = platform === 'win32' ? '.exe' : ''
   return path.join(PACKAGE_ROOT, 'tui', 'bin', `${platform}-${arch}`, `idlewatch-setup${ext}`)
 }
 
+function parseEnrollmentResultFromEnvFile(outputEnvFile, { configDir, fallbackDeviceName }) {
+  if (!outputEnvFile || !fs.existsSync(outputEnvFile)) return null
+
+  let raw = ''
+  try {
+    raw = fs.readFileSync(outputEnvFile, 'utf8')
+  } catch {
+    return null
+  }
+
+  const parsed = {}
+  for (const line of raw.split(/\r?\n/)) {
+    const trimmed = line.trim()
+    if (!trimmed || trimmed.startsWith('#')) continue
+    const idx = trimmed.indexOf('=')
+    if (idx <= 0) continue
+    const key = trimmed.slice(0, idx).trim()
+    const value = trimmed.slice(idx + 1).trim()
+    if (key) parsed[key] = value
+  }
+
+  const deviceName = normalizeDeviceName(parsed.IDLEWATCH_DEVICE_NAME || fallbackDeviceName || machineName())
+  const deviceId = sanitizeDeviceId(parsed.IDLEWATCH_DEVICE_ID || deviceName, machineName())
+  const monitorTargets = normalizeMonitorTargets(parsed.IDLEWATCH_MONITOR_TARGETS || '', detectAvailableMonitorTargets())
+  const mode = looksLikeCloudApiKey(parsed.IDLEWATCH_CLOUD_API_KEY || '') ? 'production' : 'local'
+
+  return {
+    mode,
+    configDir,
+    outputEnvFile,
+    monitorTargets,
+    deviceName,
+    deviceId
+  }
+}
+
 function tryBundledRustTui({ configDir, outputEnvFile }) {
   const binPath = bundledTuiBinaryPath()
   if (!fs.existsSync(binPath)) return { ok: false, reason: 'bundled-binary-missing', binPath }
@@ -161,8 +218,12 @@ function tryRustTui({ configDir, outputEnvFile }) {
   return { ok: false, reason: `cargo-run-failed:${run.status ?? 'unknown'}`, manifestPath }
 }
 
-function promptModeText() {
-  return `\n╭───────────────────────────────────────────────╮\n│              IdleWatch Setup Wizard           │\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 promptModeText({ isReconfigure = false, currentMode = null } = {}) {
+  const title = isReconfigure ? 'IdleWatch Reconfigure' : 'IdleWatch Setup Wizard'
+  const pad = Math.max(0, Math.floor((47 - title.length) / 2))
+  const titleLine = ' '.repeat(pad) + title
+  const defaultHint = currentMode === 'local' ? ' (default 2)' : ' (default 1)'
+  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`
 }
 
 export async function runEnrollmentWizard(options = {}) {
@@ -171,27 +232,40 @@ export async function runEnrollmentWizard(options = {}) {
   const configDir = path.resolve(options.configDir || process.env.IDLEWATCH_ENROLL_CONFIG_DIR || defaultConfigDir())
   const outputEnvFile = path.resolve(options.outputEnvFile || process.env.IDLEWATCH_ENROLL_OUTPUT_ENV_FILE || path.join(configDir, 'idlewatch.env'))
 
+  // Load existing saved config for reconfigure defaults
+  let existingConfig = null
+  if (fs.existsSync(outputEnvFile)) {
+    existingConfig = parseEnrollmentResultFromEnvFile(outputEnvFile, { configDir, fallbackDeviceName: machineName() })
+  }
+
   let mode = options.mode || process.env.IDLEWATCH_ENROLL_MODE || null
   let cloudApiKey = normalizeCloudApiKey(options.cloudApiKey || process.env.IDLEWATCH_CLOUD_API_KEY || null)
   let cloudIngestUrl = options.cloudIngestUrl || process.env.IDLEWATCH_CLOUD_INGEST_URL || 'https://api.idlewatch.com/api/ingest'
-  let deviceName = normalizeDeviceName(options.deviceName || process.env.IDLEWATCH_DEVICE_NAME || os.hostname())
+  let deviceName = normalizeDeviceName(
+    options.deviceName || process.env.IDLEWATCH_ENROLL_DEVICE_NAME || process.env.IDLEWATCH_DEVICE_NAME || (existingConfig?.deviceName) || machineName()
+  )
 
   const availableMonitorTargets = detectAvailableMonitorTargets()
   let monitorTargets = normalizeMonitorTargets(
-    options.monitorTargets || process.env.IDLEWATCH_MONITOR_TARGETS || '',
+    options.monitorTargets || process.env.IDLEWATCH_ENROLL_MONITOR_TARGETS || process.env.IDLEWATCH_MONITOR_TARGETS || '',
     availableMonitorTargets
   )
 
   if (!nonInteractive && !noTui) {
     const tuiResult = tryRustTui({ configDir, outputEnvFile })
+    const tuiEnrollment = parseEnrollmentResultFromEnvFile(outputEnvFile, { configDir, fallbackDeviceName: deviceName })
     if (tuiResult.ok) {
-      return {
+      return tuiEnrollment || {
         mode: 'tui',
         configDir,
         outputEnvFile
       }
     }
 
+    if (tuiEnrollment) {
+      return tuiEnrollment
+    }
+
     if (tuiResult.reason === 'bundled-binary-missing-and-cargo-missing') {
       console.warn('IdleWatch TUI is not bundled for this platform and Cargo is not installed. Falling back to text setup. Use --no-tui to skip this check.')
     } else if (!['disabled', 'cargo-missing', 'bundled-binary-missing'].includes(tuiResult.reason || '')) {
@@ -202,10 +276,16 @@ export async function runEnrollmentWizard(options = {}) {
   let rl = null
   if (!nonInteractive) {
     rl = readline.createInterface({ input: process.stdin, output: process.stdout })
-    console.log(promptModeText())
+    const isReconfigure = !!existingConfig
+    const currentMode = existingConfig?.mode || null
+    const modeDefault = currentMode === 'local' ? '2' : '1'
+    console.log(promptModeText({ isReconfigure, currentMode }))
     console.log(`Storage path: ${configDir}`)
     console.log(`Environment file: ${outputEnvFile}`)
-    const modeInput = (await rl.question('\nMode [1/2] (default 1): ')).trim() || '1'
+    if (isReconfigure) {
+      console.log(`Current device: ${existingConfig.deviceName} (${currentMode === 'production' ? 'cloud' : 'local-only'})`)
+    }
+    const modeInput = (await rl.question(`\nMode [1/2] (default ${modeDefault}): `)).trim() || modeDefault
     mode = modeInput === '2' ? 'local' : 'production'
     const deviceNameInput = (await rl.question(`Device name [${deviceName}]: `)).trim()
     deviceName = normalizeDeviceName(deviceNameInput || deviceName)
@@ -217,9 +297,36 @@ export async function runEnrollmentWizard(options = {}) {
   }
 
   if ((mode === 'production') && !cloudApiKey) {
-    if (!rl) throw new Error('Missing cloud API key (IDLEWATCH_CLOUD_API_KEY).')
-    console.log('\nPaste the API key from idlewatch.com/api.')
-    cloudApiKey = normalizeCloudApiKey(await rl.question('Cloud API key: '))
+    // Try to reuse existing saved API key when reconfiguring
+    if (existingConfig?.mode === 'production' && fs.existsSync(outputEnvFile)) {
+      try {
+        const raw = fs.readFileSync(outputEnvFile, 'utf8')
+        for (const line of raw.split(/\r?\n/)) {
+          const trimmed = line.trim()
+          if (trimmed.startsWith('IDLEWATCH_CLOUD_API_KEY=')) {
+            const savedKey = normalizeCloudApiKey(trimmed.slice('IDLEWATCH_CLOUD_API_KEY='.length))
+            if (looksLikeCloudApiKey(savedKey)) {
+              cloudApiKey = savedKey
+              break
+            }
+          }
+        }
+      } catch { /* ignore */ }
+    }
+
+    if (!cloudApiKey) {
+      if (!rl) throw new Error('Missing cloud API key (IDLEWATCH_CLOUD_API_KEY).')
+      console.log('\nPaste the API key from idlewatch.com/api.')
+      cloudApiKey = normalizeCloudApiKey(await rl.question('Cloud API key: '))
+    } else if (rl) {
+      const masked = cloudApiKey.slice(0, 8) + '…' + cloudApiKey.slice(-4)
+      console.log(`\nUsing saved API key: ${masked}`)
+      const changeKey = (await rl.question('Keep this key? [Y/n]: ')).trim().toLowerCase()
+      if (changeKey === 'n' || changeKey === 'no') {
+        console.log('Paste the new API key from idlewatch.com/api.')
+        cloudApiKey = normalizeCloudApiKey(await rl.question('Cloud API key: '))
+      }
+    }
   }
 
   if (!nonInteractive && rl) {
@@ -229,7 +336,10 @@ export async function runEnrollmentWizard(options = {}) {
     monitorTargets = normalizeMonitorTargets(monitorInput || suggested, availableMonitorTargets)
   }
 
-  const safeDeviceId = sanitizeDeviceId(options.deviceId || process.env.IDLEWATCH_DEVICE_ID || deviceName, os.hostname())
+  const safeDeviceId = sanitizeDeviceId(
+    options.deviceId || process.env.IDLEWATCH_ENROLL_DEVICE_ID || deviceName,
+    machineName()
+  )
   const localLogPath = path.join(configDir, 'logs', `${safeDeviceId}-metrics.ndjson`)
   const localCachePath = path.join(configDir, 'cache', `${safeDeviceId}-openclaw-last-good.json`)
 

package/src/openclaw-activity.js

@@ -0,0 +1,163 @@
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+
+export const DAY_WINDOW_MS = 24 * 60 * 60 * 1000
+
+function readJson(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'))
+  } catch {
+    return null
+  }
+}
+
+function readJsonLines(filePath) {
+  try {
+    return fs.readFileSync(filePath, 'utf8')
+      .split(/\r?\n/)
+      .filter(Boolean)
+      .map((line) => {
+        try {
+          return JSON.parse(line)
+        } catch {
+          return null
+        }
+      })
+      .filter(Boolean)
+  } catch {
+    return []
+  }
+}
+
+export function parseCronIntervalMs(expr) {
+  const value = String(expr || '').trim()
+  if (!value) return null
+
+  const parts = value.split(/\s+/)
+  if (parts.length !== 5) return null
+
+  const [minute, hour] = parts
+  const minuteStepMatch = minute.match(/^(?:\*|\d+-\d+)\/(\d+)$/)
+  if (minuteStepMatch && hour === '*') {
+    const minutes = Number(minuteStepMatch[1])
+    return Number.isFinite(minutes) && minutes > 0 ? minutes * 60 * 1000 : null
+  }
+
+  if (/^\d+$/.test(minute) && /^\*\/(\d+)$/.test(hour)) {
+    const hours = Number(hour.slice(2))
+    return Number.isFinite(hours) && hours > 0 ? hours * 60 * 60 * 1000 : null
+  }
+
+  if (/^\d+$/.test(minute) && hour === '*') return 60 * 60 * 1000
+  if (/^\d+$/.test(minute) && /^\d+$/.test(hour)) return 24 * 60 * 60 * 1000
+  return null
+}
+
+function round(value, digits = 1) {
+  if (!Number.isFinite(value)) return null
+  const factor = 10 ** digits
+  return Math.round(value * factor) / factor
+}
+
+export function loadOpenClawActivitySummary(options = {}) {
+  const homeDir = options.homeDir || os.homedir()
+  const nowMs = Number.isFinite(options.nowMs) ? options.nowMs : Date.now()
+  const windowMs = Number.isFinite(options.windowMs) ? options.windowMs : DAY_WINDOW_MS
+  const cutoffMs = nowMs - windowMs
+  const openclawDir = path.join(homeDir, '.openclaw')
+  const jobsPath = path.join(openclawDir, 'cron', 'jobs.json')
+  const runsDir = path.join(openclawDir, 'cron', 'runs')
+
+  const jobsPayload = readJson(jobsPath)
+  const jobs = Array.isArray(jobsPayload?.jobs) ? jobsPayload.jobs : []
+
+  if (jobs.length === 0 || !fs.existsSync(runsDir)) return null
+
+  const jobsById = new Map(jobs.map((job) => [String(job.id || ''), job]).filter(([id]) => id))
+  const summaries = new Map()
+
+  for (const entry of fs.readdirSync(runsDir, { withFileTypes: true })) {
+    if (!entry.isFile() || !entry.name.endsWith('.jsonl')) continue
+
+    const jobId = entry.name.replace(/\.jsonl$/, '')
+    const job = jobsById.get(jobId)
+    const runs = readJsonLines(path.join(runsDir, entry.name))
+
+    for (const run of runs) {
+      const runAtMs = Number(run.runAtMs ?? run.ts ?? 0)
+      const durationMs = Number(run.durationMs ?? 0)
+      const runStatus = String(run.status || 'unknown')
+
+      if (!Number.isFinite(runAtMs) || runAtMs < cutoffMs) continue
+      if (!Number.isFinite(durationMs) || durationMs <= 0) continue
+      if (run.action && run.action !== 'finished') continue
+
+      const intervalMs = parseCronIntervalMs(job?.schedule?.expr)
+      const summary = summaries.get(jobId) || {
+        id: jobId,
+        label: String(job?.name || run.summary || jobId).trim() || jobId,
+        kind: String(job?.schedule?.kind || '').trim() || 'cron',
+        intervalMs,
+        enabled: Boolean(job?.enabled),
+        totalDurationMs: 0,
+        runCount: 0,
+        okCount: 0,
+        errorCount: 0,
+        maxDurationMs: 0,
+        lastRunAtMs: 0,
+        lastStatus: 'unknown'
+      }
+
+      summary.totalDurationMs += durationMs
+      summary.runCount += 1
+      summary.maxDurationMs = Math.max(summary.maxDurationMs, durationMs)
+      summary.lastRunAtMs = Math.max(summary.lastRunAtMs, runAtMs)
+      summary.lastStatus = runStatus
+
+      if (runStatus === 'error') summary.errorCount += 1
+      else summary.okCount += 1
+
+      summaries.set(jobId, summary)
+    }
+  }
+
+  const jobsSummary = [...summaries.values()]
+    .filter((item) => item.runCount > 0 && item.totalDurationMs > 0)
+    .sort((a, b) => b.totalDurationMs - a.totalDurationMs)
+    .map((item) => {
+      const avgDurationMs = item.totalDurationMs / item.runCount
+      const cycleOccupancyPct = item.intervalMs && item.intervalMs > 0
+        ? round(Math.min(100, (avgDurationMs / item.intervalMs) * 100), 1)
+        : null
+
+      return {
+        id: item.id,
+        label: item.label,
+        kind: item.kind,
+        enabled: item.enabled,
+        intervalMs: item.intervalMs,
+        runCount: item.runCount,
+        okCount: item.okCount,
+        errorCount: item.errorCount,
+        seconds: round(item.totalDurationMs / 1000, 1) ?? 0,
+        avgDurationMs: round(avgDurationMs, 0) ?? 0,
+        maxDurationMs: round(item.maxDurationMs, 0) ?? 0,
+        cycleOccupancyPct,
+        lastRunAtMs: item.lastRunAtMs,
+        lastStatus: item.lastStatus
+      }
+    })
+
+  if (jobsSummary.length === 0) return null
+
+  const totalActiveSeconds = jobsSummary.reduce((sum, item) => sum + Math.max(0, Number(item.seconds || 0)), 0)
+
+  return {
+    source: 'openclaw-cron-runs',
+    windowMs,
+    totalActiveSeconds: round(totalActiveSeconds, 1) ?? 0,
+    idleSeconds: round(Math.max(0, windowMs / 1000 - totalActiveSeconds), 1) ?? 0,
+    jobs: jobsSummary
+  }
+}

package/src/openclaw-usage.js

@@ -49,6 +49,67 @@ function pickString(...vals) {
   return null
 }
 
+function normalizeProviderName(value) {
+  const normalized = pickString(value)?.toLowerCase()
+  if (!normalized) return null
+
+  if (['openai', 'anthropic', 'google', 'local', 'other'].includes(normalized)) return normalized
+  if (normalized === 'claude') return 'anthropic'
+  if (normalized === 'gemini') return 'google'
+  if (normalized === 'ollama') return 'local'
+  return normalized
+}
+
+function inferProviderFromModel(model) {
+  const normalized = pickString(model)?.toLowerCase()
+  if (!normalized) return null
+
+  if (
+    normalized.startsWith('openai/') ||
+    normalized.startsWith('gpt-') ||
+    normalized.startsWith('chatgpt') ||
+    normalized.startsWith('codex') ||
+    /^o[1345](?:$|[-.:/])/.test(normalized)
+  ) return 'openai'
+
+  if (normalized.startsWith('anthropic/') || normalized.includes('claude')) return 'anthropic'
+  if (normalized.startsWith('google/') || normalized.includes('gemini')) return 'google'
+
+  if (
+    normalized.startsWith('ollama/') ||
+    normalized.includes('qwen') ||
+    normalized.includes('llama') ||
+    normalized.includes('mistral') ||
+    normalized.includes('mixtral') ||
+    normalized.includes('deepseek') ||
+    normalized.includes('gemma') ||
+    normalized.includes('phi') ||
+    normalized.includes('qwq') ||
+    /:[0-9]+[a-z]?$/.test(normalized)
+  ) return 'local'
+
+  return 'other'
+}
+
+function deriveRemainingTokens(totalTokens, contextTokens) {
+  if (!Number.isFinite(totalTokens) || !Number.isFinite(contextTokens)) return null
+  if (contextTokens < totalTokens) return null
+  return contextTokens - totalTokens
+}
+
+function derivePercentUsed(totalTokens, contextTokens, remainingTokens = null) {
+  if (!Number.isFinite(contextTokens) || contextTokens <= 0) return null
+
+  const usedTokens = Number.isFinite(totalTokens)
+    ? totalTokens
+    : Number.isFinite(remainingTokens)
+      ? contextTokens - remainingTokens
+      : null
+
+  if (!Number.isFinite(usedTokens) || usedTokens < 0) return null
+  return Math.max(0, Math.min(100, Math.round((usedTokens / contextTokens) * 100)))
+}
+
 function isFreshTokenMarker(value) {
   if (value === false || value === 0) return false
   if (value === null || typeof value === 'undefined') return true
@@ -615,6 +676,40 @@ function parseFromStatusJson(parsed) {
     deriveTokensPerMinute(session),
     pickNumber(session?.derived?.tokensPerMinute, session?.derived?.tpm)
   )
+  const contextTokens = pickNumber(
+    session.contextTokens,
+    session.context_tokens,
+    session?.usage?.contextTokens,
+    session?.usage?.context_tokens,
+    defaults.contextTokens,
+    defaults.context_tokens,
+    parsed?.contextTokens,
+    parsed?.context_tokens,
+    parsed?.status?.contextTokens,
+    parsed?.status?.context_tokens
+  )
+  const remainingTokens = pickNumber(
+    session.remainingTokens,
+    session.remaining_tokens,
+    session?.usage?.remainingTokens,
+    session?.usage?.remaining_tokens,
+    parsed?.remainingTokens,
+    parsed?.remaining_tokens,
+    parsed?.status?.remainingTokens,
+    parsed?.status?.remaining_tokens,
+    deriveRemainingTokens(totalTokens, contextTokens)
+  )
+  const percentUsed = pickNumber(
+    session.percentUsed,
+    session.percent_used,
+    session?.usage?.percentUsed,
+    session?.usage?.percent_used,
+    parsed?.percentUsed,
+    parsed?.percent_used,
+    parsed?.status?.percentUsed,
+    parsed?.status?.percent_used,
+    derivePercentUsed(totalTokens, contextTokens, remainingTokens)
+  )
   const sessionAgeMs = pickNumber(session.age, session.ageMs)
   const usageTimestampMs =
     pickTimestamp(
@@ -676,11 +771,31 @@ function parseFromStatusJson(parsed) {
 
   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),
     totalTokens,
     tokensPerMin,
+    remainingTokens,
+    percentUsed,
+    contextTokens,
     sessionId: pickString(session.sessionId, session.id, session?.usage?.sessionId, session?.usage?.id, session?.session_id),
     agentId: pickString(session.agentId, session?.usage?.agentId, session?.agent_id),
     usageTimestampMs,
+    budgetKind: contextTokens !== null ? 'context-window' : null,
     integrationStatus: hasStrongUsage ? 'ok' : 'partial'
   }
 }
@@ -837,13 +952,73 @@ function parseGenericUsage(parsed) {
     parsed?.rps,
     parsed?.requestsPerMinute
   )
+  const contextTokens = pickNumber(
+    usageRecord?.contextTokens,
+    usageRecord?.context_tokens,
+    usageRecord?.usage?.contextTokens,
+    usageRecord?.usage?.context_tokens,
+    usageTotals?.contextTokens,
+    usageTotals?.context_tokens,
+    parsed?.contextTokens,
+    parsed?.context_tokens,
+    parsed?.status?.contextTokens,
+    parsed?.status?.context_tokens
+  )
+  const remainingTokens = pickNumber(
+    usageRecord?.remainingTokens,
+    usageRecord?.remaining_tokens,
+    usageRecord?.usage?.remainingTokens,
+    usageRecord?.usage?.remaining_tokens,
+    usageTotals?.remainingTokens,
+    usageTotals?.remaining_tokens,
+    parsed?.remainingTokens,
+    parsed?.remaining_tokens,
+    parsed?.status?.remainingTokens,
+    parsed?.status?.remaining_tokens,
+    deriveRemainingTokens(totalTokens, contextTokens)
+  )
+  const percentUsed = pickNumber(
+    usageRecord?.percentUsed,
+    usageRecord?.percent_used,
+    usageRecord?.usage?.percentUsed,
+    usageRecord?.usage?.percent_used,
+    usageTotals?.percentUsed,
+    usageTotals?.percent_used,
+    parsed?.percentUsed,
+    parsed?.percent_used,
+    parsed?.status?.percentUsed,
+    parsed?.status?.percent_used,
+    derivePercentUsed(totalTokens, contextTokens, remainingTokens)
+  )
 
   if (model === null && totalTokens === null && tokensPerMin === null) return null
 
   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),
     totalTokens,
     tokensPerMin,
+    remainingTokens,
+    percentUsed,
+    contextTokens,
     sessionId: pickString(
       parsed?.sessionId,
       parsed?.session_id,
@@ -935,6 +1110,7 @@ function parseGenericUsage(parsed) {
       parsed?.status?.usage_time,
       parsed?.status?.usageTsMs
     ),
+    budgetKind: contextTokens !== null ? 'context-window' : null,
     integrationStatus: 'ok'
   }
 }
@@ -947,6 +1123,8 @@ function usageCandidateScore(usage) {
   if (usage.model !== null) score += 2
   if (usage.totalTokens !== null) score += 2
   if (usage.tokensPerMin !== null) score += 1
+  if (usage.remainingTokens !== null) score += 1
+  if (usage.contextTokens !== null) score += 1
   if (usage.sessionId !== null) score += 1
   if (usage.agentId !== null) score += 1
   if (usage.usageTimestampMs !== null) score += 1

package/src/telemetry-mapping.js

@@ -26,7 +26,12 @@ export function enrichWithOpenClawFleetTelemetry(sample, context = {}) {
       },
       usage: {
         model: sample.openclawModel ?? null,
+        provider: sample.openclawProvider ?? null,
         totalTokens: sample.openclawTotalTokens ?? null,
+        remainingTokens: sample.openclawRemainingTokens ?? null,
+        percentUsed: sample.openclawPercentUsed ?? null,
+        contextTokens: sample.openclawContextTokens ?? null,
+        budgetKind: sample.openclawBudgetKind ?? null,
         tokensPerMin: sample.tokensPerMin ?? null,
         sessionId: sample.openclawSessionId ?? null,
         agentId: sample.openclawAgentId ?? null,

package/tui/src/main.rs

@@ -70,6 +70,34 @@ fn command_exists(cmd: &str, args: &[&str]) -> bool {
         .unwrap_or(false)
 }
 
+fn machine_name() -> String {
+    if cfg!(target_os = "macos") {
+        if let Ok(output) = Command::new("scutil").args(["--get", "ComputerName"]).output() {
+            if output.status.success() {
+                let name = String::from_utf8_lossy(&output.stdout).trim().to_string();
+                if !name.is_empty() {
+                    return name;
+                }
+            }
+        }
+    }
+
+    if let Ok(output) = Command::new("hostname").output() {
+        if output.status.success() {
+            let name = String::from_utf8_lossy(&output.stdout).trim().to_string();
+            if !name.is_empty() {
+                return name;
+            }
+        }
+    }
+
+    std::env::var("HOSTNAME")
+        .ok()
+        .map(|value| value.trim().to_string())
+        .filter(|value| !value.is_empty())
+        .unwrap_or_else(|| "IdleWatch Device".to_string())
+}
+
 fn parse_env_file(path: &Path) -> ExistingConfig {
     let mut config = ExistingConfig::default();
     let Ok(raw) = fs::read_to_string(path) else {
@@ -443,7 +471,7 @@ fn main() -> Result<()> {
     let env_file = std::env::var("IDLEWATCH_ENROLL_OUTPUT_ENV_FILE")
         .map(PathBuf::from)
         .unwrap_or_else(|_| config_dir.join("idlewatch.env"));
-    let host = sanitize_host(&std::env::var("HOSTNAME").unwrap_or_else(|_| "host".to_string()));
+    let host = sanitize_host(&machine_name());
     let existing = parse_env_file(&env_file);
 
     enable_raw_mode()?;
@@ -464,7 +492,7 @@ fn main() -> Result<()> {
                     KeyCode::Char('q') | KeyCode::Esc => {
                         disable_raw_mode()?;
                         execute!(terminal.backend_mut(), LeaveAlternateScreen)?;
-                        return Ok(());
+                        return Err(anyhow!("setup_cancelled"));
                     }
                     _ => {}
                 }
@@ -503,7 +531,7 @@ fn main() -> Result<()> {
                     KeyCode::Char('q') | KeyCode::Esc => {
                         disable_raw_mode()?;
                         execute!(terminal.backend_mut(), LeaveAlternateScreen)?;
-                        return Ok(());
+                        return Err(anyhow!("setup_cancelled"));
                     }
                     _ => {}
                 }
@@ -545,7 +573,7 @@ fn main() -> Result<()> {
                     KeyCode::Char('q') | KeyCode::Esc => {
                         disable_raw_mode()?;
                         execute!(terminal.backend_mut(), LeaveAlternateScreen)?;
-                        return Ok(());
+                        return Err(anyhow!("setup_cancelled"));
                     }
                     KeyCode::Char(c) => {
                         device_name_input.push(c);
@@ -592,7 +620,7 @@ fn main() -> Result<()> {
                         KeyCode::Char('q') | KeyCode::Esc => {
                             disable_raw_mode()?;
                             execute!(terminal.backend_mut(), LeaveAlternateScreen)?;
-                            return Ok(());
+                            return Err(anyhow!("setup_cancelled"));
                         }
                         KeyCode::Char(c) => {
                             cloud_api_key_input.push(c);
@@ -673,6 +701,6 @@ fn main() -> Result<()> {
     println!("Saved device name: {}", device_name);
     println!("You can rerun this TUI anytime to update device name, API key, or metrics.");
     println!("Next step: idlewatch-agent --once");
-    println!("For background startup on macOS: npm run install:macos-launch-agent");
+    println!("For background startup on macOS: /Applications/IdleWatch.app/Contents/Resources/payload/package/scripts/install-macos-launch-agent.sh");
     Ok(())
 }