idlewatch 0.1.0

package/test/openclaw-usage.test.mjs

@@ -0,0 +1,555 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { parseOpenClawUsage } from '../src/openclaw-usage.js'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+
+function fixture(name) {
+  return fs.readFileSync(path.join(__dirname, 'fixtures', name), 'utf8')
+}
+
+test('parses openclaw status --json output and chooses best recent session', () => {
+  const usage = parseOpenClawUsage(fixture('openclaw-status.json'))
+  assert.ok(usage)
+  assert.equal(usage.model, 'gpt-5.3-codex')
+  assert.equal(usage.totalTokens, 70500)
+  assert.equal(usage.sessionId, '90d2a820-6d77-42f0-8db4-12b90f9f7203')
+  assert.equal(usage.agentId, 'main')
+  assert.equal(usage.usageTimestampMs, 1771278893678)
+  assert.equal(usage.integrationStatus, 'ok')
+  assert.equal(usage.tokensPerMin, 384545.45)
+})
+
+test('parses noisy openclaw output and alternate sessions key names', () => {
+  const usage = parseOpenClawUsage(fixture('openclaw-status-noisy.txt'))
+  assert.ok(usage)
+  assert.equal(usage.model, 'gpt-5.3-codex')
+  assert.equal(usage.totalTokens, 222)
+  assert.equal(usage.sessionId, 'new')
+  assert.equal(usage.usageTimestampMs, 1771278999999)
+  assert.equal(usage.integrationStatus, 'ok')
+})
+
+test('ignores non-usage JSON noise and parses later status payload', () => {
+  const usage = parseOpenClawUsage(fixture('openclaw-status-multi-json.txt'))
+  assert.ok(usage)
+  assert.equal(usage.model, 'gpt-5.3-codex')
+  assert.equal(usage.totalTokens, 333)
+  assert.equal(usage.sessionId, 'new')
+  assert.equal(usage.usageTimestampMs, 1771279012345)
+  assert.equal(usage.integrationStatus, 'ok')
+})
+
+test('parses generic usage payloads', () => {
+  const usage = parseOpenClawUsage(JSON.stringify({
+    usage: {
+      model: 'gpt-5.3-codex',
+      totalTokens: 1234,
+      tokensPerMinute: 45.67
+    },
+    sessionId: 'abc',
+    agentId: 'main',
+    updatedAt: 123456
+  }))
+
+  assert.deepEqual(usage, {
+    model: 'gpt-5.3-codex',
+    totalTokens: 1234,
+    tokensPerMin: 45.67,
+    sessionId: 'abc',
+    agentId: 'main',
+    usageTimestampMs: 123456000,
+    integrationStatus: 'ok'
+  })
+})
+
+
+
+test('supports model_name in generic usage payloads', () => {
+  const usage = parseOpenClawUsage(fixture('openclaw-usage-model-name-generic.json'))
+  assert.ok(usage)
+  assert.equal(usage.model, 'llama-3.3')
+  assert.equal(usage.totalTokens, 135)
+  assert.equal(usage.tokensPerMin, 21.5)
+  assert.equal(usage.sessionId, 'generic-model-name')
+  assert.equal(usage.agentId, 'agent-generic')
+  assert.equal(usage.usageTimestampMs, 1771324000000)
+  assert.equal(usage.integrationStatus, 'ok')
+})
+
+test('prefers most recent candidate when scores tie', () => {
+  const usage = parseOpenClawUsage(fixture('openclaw-mixed-equal-score-status-vs-generic-newest.txt'))
+  assert.ok(usage)
+  assert.equal(usage.model, 'claude-3')
+  assert.equal(usage.totalTokens, 999)
+  assert.equal(usage.tokensPerMin, 4.4)
+  assert.equal(usage.sessionId, 'generic-newer')
+  assert.equal(usage.agentId, 'agent-generic')
+  assert.equal(usage.usageTimestampMs, 1771290000000)
+  assert.equal(usage.integrationStatus, 'ok')
+})
+
+test('prefers most recent candidate when timestamps are ISO strings', () => {
+  const usage = parseOpenClawUsage(fixture('openclaw-mixed-equal-score-status-vs-generic-iso-ts.txt'))
+  assert.ok(usage)
+  assert.equal(usage.model, 'qwen-3')
+  assert.equal(usage.totalTokens, 100)
+  assert.equal(usage.tokensPerMin, 2.2)
+  assert.equal(usage.sessionId, 'generic-newer')
+  assert.equal(usage.agentId, 'agent-generic')
+  assert.equal(usage.integrationStatus, 'ok')
+})
+
+test('parses latest candidate when timestamp fields are strings', () => {
+  const usage = parseOpenClawUsage(fixture('openclaw-mixed-equal-score-status-vs-generic-string-ts.txt'))
+  assert.ok(usage)
+  assert.equal(usage.model, 'qwen-2.5')
+  assert.equal(usage.totalTokens, 100)
+  assert.equal(usage.tokensPerMin, 3.3)
+  assert.equal(usage.sessionId, 'generic-newer')
+  assert.equal(usage.agentId, 'agent-generic')
+  assert.equal(usage.usageTimestampMs, 1771290000000)
+  assert.equal(usage.integrationStatus, 'ok')
+})
+
+test('prefers richer generic usage candidate when status candidate is partial', () => {
+  const usage = parseOpenClawUsage(fixture('openclaw-mixed-status-then-generic-output.txt'))
+  assert.ok(usage)
+  assert.equal(usage.model, 'gpt-5.3-codex')
+  assert.equal(usage.totalTokens, 777)
+  assert.equal(usage.tokensPerMin, 11.1)
+  assert.equal(usage.sessionId, 'standalone')
+  assert.equal(usage.agentId, 'agent-stand')
+  assert.equal(usage.usageTimestampMs, 1771281000000)
+  assert.equal(usage.integrationStatus, 'ok')
+})
+
+test('parses status wrapper payloads under status.current', () => {
+  const usage = parseOpenClawUsage(fixture('openclaw-status-status-wrapper.json'))
+  assert.ok(usage)
+  assert.equal(usage.model, 'gpt-5.3-codex-spark')
+  assert.equal(usage.totalTokens, 4321)
+  assert.equal(usage.sessionId, 'status-wrap-session')
+  assert.equal(usage.agentId, 'agent-status-wrap')
+  assert.equal(usage.usageTimestampMs, 1771300100000)
+  assert.equal(usage.integrationStatus, 'ok')
+})
+
+test('returns null for invalid payload', () => {
+  assert.equal(parseOpenClawUsage('not-json'), null)
+})
+
+test('parses status payloads with stringified numeric fields and stale token marker fallback', () => {
+  const usage = parseOpenClawUsage(fixture('openclaw-status-strings.json'))
+  assert.ok(usage)
+  assert.equal(usage.model, 'claude-opus-4-6')
+  assert.equal(usage.totalTokens, 450)
+  assert.equal(usage.tokensPerMin, 45)
+  assert.equal(usage.sessionId, 'b7e1f8')
+  assert.equal(usage.agentId, 'agent-2')
+  assert.equal(usage.usageTimestampMs, 1771278820000)
+  assert.equal(usage.integrationStatus, 'ok')
+})
+
+test('converts epoch-seconds usage timestamps to milliseconds', () => {
+  const usage = parseOpenClawUsage(fixture('openclaw-status-epoch-seconds.json'))
+  assert.ok(usage)
+  assert.equal(usage.sessionId, 'sec-session')
+  assert.equal(usage.agentId, 'agent-sec')
+  assert.equal(usage.usageTimestampMs, 1771278800000)
+  assert.equal(usage.integrationStatus, 'ok')
+})
+
+test('parses stats payloads with nested usage totals', () => {
+  const usage = parseOpenClawUsage(fixture('openclaw-stats.json'))
+  assert.ok(usage)
+  assert.equal(usage.model, 'claude-opus-4-6')
+  assert.equal(usage.totalTokens, 4560)
+  assert.equal(usage.tokensPerMin, 123.45)
+  assert.equal(usage.sessionId, 'sess-stats-01')
+  assert.equal(usage.agentId, 'agent-stats')
+  assert.equal(usage.usageTimestampMs, 1771279012345)
+  assert.equal(usage.integrationStatus, 'ok')
+})
+
+
+test('parses stats payloads nested under data wrapper', () => {
+  const usage = parseOpenClawUsage(fixture('openclaw-stats-data-wrapper.json'))
+  assert.ok(usage)
+  assert.equal(usage.model, 'gpt-5.3-codex-spark')
+  assert.equal(usage.totalTokens, 999)
+  assert.equal(usage.tokensPerMin, 88.75)
+  assert.equal(usage.sessionId, 'data-wrap-session')
+  assert.equal(usage.agentId, 'agent-data-wrap')
+  assert.equal(usage.usageTimestampMs, 1771281010000)
+  assert.equal(usage.integrationStatus, 'ok')
+})
+
+test('parses stats payloads with camelCase usageTime', () => {
+  const usage = parseOpenClawUsage(fixture('openclaw-status-stats-current-usage-time-camelcase.json'))
+  assert.ok(usage)
+  assert.equal(usage.model, 'gpt-5.3-codex')
+  assert.equal(usage.totalTokens, 555)
+  assert.equal(usage.tokensPerMin, 22)
+  assert.equal(usage.sessionId, 'camelcase-session')
+  assert.equal(usage.agentId, 'agent-camel')
+  assert.equal(usage.usageTimestampMs, 1772191800000)
+  assert.equal(usage.integrationStatus, 'ok')
+})
+
+test('parses nested stats current.session wrapper payloads', () => {
+  const usage = parseOpenClawUsage(fixture('openclaw-stats-nested-session-wrapper.json'))
+  assert.ok(usage)
+  assert.equal(usage.model, 'claude-opus-4-6')
+  assert.equal(usage.totalTokens, 3141)
+  assert.equal(usage.tokensPerMin, 77.7)
+  assert.equal(usage.sessionId, 'stats-nested-session-1')
+  assert.equal(usage.agentId, 'agent-stats-nested')
+  assert.equal(usage.usageTimestampMs, 1771303100000)
+  assert.equal(usage.integrationStatus, 'ok')
+})
+
+test('parses status.stats.current.sessions as array', () => {
+  const usage = parseOpenClawUsage(fixture('openclaw-status-stats-current-sessions.json'))
+  assert.ok(usage)
+  assert.equal(usage.model, 'gpt-5.3-codex')
+  assert.equal(usage.totalTokens, 4321)
+  assert.equal(usage.tokensPerMin, 66.6)
+  assert.equal(usage.sessionId, 'active-session')
+  assert.equal(usage.agentId, 'agent-active')
+  assert.equal(usage.usageTimestampMs, 1771279100000)
+  assert.equal(usage.integrationStatus, 'ok')
+})
+
+test('parses session array payload with model in defaultModel field', () => {
+  const usage = parseOpenClawUsage(fixture('openclaw-status-stats-session-default-model.json'))
+  assert.ok(usage)
+  assert.equal(usage.model, 'claude-mini-3.7')
+  assert.equal(usage.totalTokens, 777)
+  assert.equal(usage.tokensPerMin, 12.34)
+  assert.equal(usage.sessionId, 'legacy-model')
+  assert.equal(usage.agentId, 'agent-default-model')
+  assert.equal(usage.usageTimestampMs, 1771274000000)
+  assert.equal(usage.integrationStatus, 'ok')
+})
+
+test('supports model_name alias in status sessions payload', () => {
+  const usage = parseOpenClawUsage(fixture('openclaw-status-session-model-name.json'))
+  assert.ok(usage)
+  assert.equal(usage.model, 'claude-3-opus')
+  assert.equal(usage.totalTokens, 888)
+  assert.equal(usage.tokensPerMin, 25.5)
+  assert.equal(usage.sessionId, 'name-case')
+  assert.equal(usage.agentId, 'agent-name')
+  assert.equal(usage.usageTimestampMs, 1771289000000)
+  assert.equal(usage.integrationStatus, 'ok')
+})
+
+test('supports string snake-case total_tokens in sessions array payloads', () => {
+  const usage = parseOpenClawUsage(fixture('openclaw-status-stats-current-sessions-snake-tokens.json'))
+  assert.ok(usage)
+  assert.equal(usage.model, 'gpt-5.3-codex')
+  assert.equal(usage.totalTokens, 4321)
+  assert.equal(usage.tokensPerMin, 42)
+  assert.equal(usage.sessionId, 'active-string-tokens')
+  assert.equal(usage.agentId, 'agent-legacy-2')
+  assert.equal(usage.usageTimestampMs, 1771279100000)
+  assert.equal(usage.integrationStatus, 'ok')
+})
+
+test('parses status payload with nested sessions object and totals in totals.nested field', () => {
+  const raw = fixture('openclaw-status-nested-recent.json')
+  const usage = parseOpenClawUsage(raw)
+  assert.ok(usage)
+  assert.equal(usage.model, 'gpt-5.3-codex-spark')
+  assert.equal(usage.totalTokens, 21737)
+  assert.equal(usage.tokensPerMin, 32502.31)
+  assert.equal(usage.sessionId, 'sess-1')
+  assert.equal(usage.agentId, 'agent-007')
+  assert.equal(usage.usageTimestampMs, 1739703000000)
+  assert.equal(usage.integrationStatus, 'ok')
+})
+
+test('parses status.current.stats.stats-in-legacy-shape payload', () => {
+  const usage = parseOpenClawUsage(fixture('openclaw-stats-status-current-wrapper.json'))
+  assert.ok(usage)
+  assert.equal(usage.model, 'gpt-5.3-codex-pro')
+  assert.equal(usage.totalTokens, 2048)
+  assert.equal(usage.tokensPerMin, 42)
+  assert.equal(usage.sessionId, 'status-current-stats-02')
+  assert.equal(usage.agentId, 'agent-status-current')
+  assert.equal(usage.usageTimestampMs, 1771304500000)
+  assert.equal(usage.integrationStatus, 'ok')
+})
+
+test('parses wrapped status payload with direct session array and nested usage totals', () => {
+  const usage = parseOpenClawUsage(fixture('openclaw-status-wrap-session-object.json'))
+  assert.ok(usage)
+  assert.equal(usage.model, 'claude-opus-4.6')
+  assert.equal(usage.totalTokens, 789)
+  assert.equal(usage.tokensPerMin, 12.5)
+  assert.equal(usage.sessionId, 'wrapped-session-a')
+  assert.equal(usage.agentId, 'agent-wrap')
+  assert.equal(usage.usageTimestampMs, Date.parse('2026-02-17T09:00:00Z'))
+  assert.equal(usage.integrationStatus, 'ok')
+})
+
+test('parses payloads wrapped under data.result with current session aliases', () => {
+  const usage = parseOpenClawUsage(fixture('openclaw-status-data-wrapper.json'))
+  assert.ok(usage)
+  assert.equal(usage.model, 'claude-opus-4-6')
+  assert.equal(usage.totalTokens, 3333)
+  assert.equal(usage.sessionId, 'data-wrapper-current')
+  assert.equal(usage.agentId, 'agent-wrapper')
+  assert.equal(usage.usageTimestampMs, 1771279300000)
+  assert.equal(usage.integrationStatus, 'ok')
+})
+
+test('parses status payload where sessions is an object map keyed by session id', () => {
+  const usage = parseOpenClawUsage(fixture('openclaw-status-session-map.json'))
+  assert.ok(usage)
+  assert.equal(usage.model, 'claude-opus-4-6')
+  assert.equal(usage.totalTokens, 1200)
+  assert.equal(usage.sessionId, 'map-backup-1')
+  assert.equal(usage.agentId, 'agent-map-backup')
+  assert.equal(usage.usageTimestampMs, 1771278950000)
+  assert.equal(usage.integrationStatus, 'ok')
+})
+
+test('selects active session from result.session payload shape', () => {
+  const usage = parseOpenClawUsage(fixture('openclaw-status-result-session.json'))
+  assert.ok(usage)
+  assert.equal(usage.model, 'gpt-5.3-codex')
+  assert.equal(usage.totalTokens, 1111)
+  assert.equal(usage.tokensPerMin, 1234.56)
+  assert.equal(usage.sessionId, 'result-session-1')
+  assert.equal(usage.agentId, 'agent-result')
+  assert.equal(usage.usageTimestampMs, 1771279000000)
+  assert.equal(usage.integrationStatus, 'ok')
+})
+
+test('ignores metadata defaults key in session maps and still selects most recent real session', () => {
+  const usage = parseOpenClawUsage(fixture('openclaw-status-session-map-with-defaults.json'))
+  assert.ok(usage)
+  assert.equal(usage.model, 'claude-opus-4-6')
+  assert.equal(usage.totalTokens, 2222)
+  assert.equal(usage.sessionId, 'map-main-2')
+  assert.equal(usage.agentId, 'agent-map-main-2')
+  assert.equal(usage.usageTimestampMs, 1771278960000)
+  assert.equal(usage.integrationStatus, 'ok')
+})
+
+test('parses data.current stats wrapper payloads', () => {
+  const usage = parseOpenClawUsage(fixture('openclaw-stats-current-wrapper.json'))
+  assert.ok(usage)
+  assert.equal(usage.model, 'claude-opus-4-6')
+  assert.equal(usage.totalTokens, 987)
+  assert.equal(usage.tokensPerMin, 12.34)
+  assert.equal(usage.sessionId, 'current-wrapper-session')
+  assert.equal(usage.agentId, 'agent-current')
+  assert.equal(usage.usageTimestampMs, 1771290000000)
+  assert.equal(usage.integrationStatus, 'ok')
+})
+
+test('parses payload wrapper stats payloads', () => {
+  const usage = parseOpenClawUsage(fixture('openclaw-stats-payload-wrapper.json'))
+  assert.ok(usage)
+  assert.equal(usage.model, 'gpt-5.3-codex-spark')
+  assert.equal(usage.totalTokens, 9876)
+  assert.equal(usage.tokensPerMin, null)
+  assert.equal(usage.sessionId, 'payload-wrap-session')
+  assert.equal(usage.agentId, 'agent-payload')
+  assert.equal(usage.usageTimestampMs, 1771302500000)
+  assert.equal(usage.integrationStatus, 'ok')
+})
+
+test('parses snake_case current_session payload aliases under status wrapper', () => {
+  const usage = parseOpenClawUsage(fixture('openclaw-status-snake-session-wrapper.json'))
+  assert.ok(usage)
+  assert.equal(usage.model, 'gpt-5.3-codex')
+  assert.equal(usage.totalTokens, 8888)
+  assert.equal(usage.sessionId, 'snake-current-1')
+  assert.equal(usage.agentId, 'agent-snake')
+  assert.equal(usage.usageTimestampMs, 1771299000000)
+  assert.equal(usage.integrationStatus, 'ok')
+})
+
+test('uses top-level default model when no sessions are available', () => {
+  const sample = '{"defaultModel":"claude-opus-4-6","sessions":{"recent":[]}}'
+  const usage = parseOpenClawUsage(sample)
+  assert.equal(usage.model, 'claude-opus-4-6')
+  assert.equal(usage.totalTokens, null)
+  assert.equal(usage.integrationStatus, 'partial')
+})
+
+test('parses stderr payload even when command exits non-zero', () => {
+  const sample = '{"not": "json"}\n{ "sessions": { "recent": [ { "model": "gpt", "totalTokens": 1 } ] } }'
+  const got = parseOpenClawUsage(sample)
+  assert.equal(got.model, 'gpt')
+  assert.equal(got.totalTokens, 1)
+  assert.equal(got.integrationStatus, 'ok')
+})
+
+test('ignores ANSI escape noise and parses JSON session payload', () => {
+  const got = parseOpenClawUsage(fixture('openclaw-status-ansi-noise.txt'))
+  assert.ok(got)
+  assert.equal(got.model, 'gpt-5.3-codex')
+  assert.equal(got.totalTokens, 4444)
+  assert.equal(got.sessionId, 'ansi1')
+  assert.equal(got.agentId, 'agent-ansi')
+  assert.equal(got.usageTimestampMs, 1771309900000)
+  assert.equal(got.integrationStatus, 'ok')
+})
+
+test('chooses strongest usage payload when earlier JSON is metadata-only', () => {
+  const got = parseOpenClawUsage(fixture('openclaw-status-noisy-default-then-usage.txt'))
+  assert.ok(got)
+  assert.equal(got.model, 'gpt-5.3-codex-pro')
+  assert.equal(got.totalTokens, 7777)
+  assert.equal(got.sessionId, 'main')
+  assert.equal(got.agentId, 'agent-priority')
+  assert.equal(got.usageTimestampMs, 1771312500000)
+  assert.equal(got.integrationStatus, 'ok')
+})
+
+test('strips complex ANSI cursor/control codes and parses JSON session payload', () => {
+  const got = parseOpenClawUsage(fixture('openclaw-status-ansi-complex-noise.txt'))
+  assert.ok(got)
+  assert.equal(got.model, 'claude-opus-4-6')
+  assert.equal(got.totalTokens, 9999)
+  assert.equal(got.sessionId, 'complex-ansi')
+  assert.equal(got.agentId, 'agent-ansi')
+  assert.equal(got.usageTimestampMs, 1771313300000)
+  assert.equal(got.integrationStatus, 'ok')
+})
+
+
+
+test('strips control characters (backspace/ctrl) before parsing JSON', () => {
+  const got = parseOpenClawUsage(fixture('openclaw-status-control-noise.txt'))
+  assert.ok(got)
+  assert.equal(got.model, 'gpt-4.1')
+  assert.equal(got.totalTokens, 3333)
+  assert.equal(got.sessionId, 'control-ansi')
+  assert.equal(got.agentId, 'agent-control')
+  assert.equal(got.usageTimestampMs, 1771314400000)
+  assert.equal(got.integrationStatus, 'ok')
+})
+
+test('strips OSC/title control sequences before parsing JSON', () => {
+  const got = parseOpenClawUsage(fixture('openclaw-status-osc-noise.txt'))
+  assert.ok(got)
+  assert.equal(got.model, 'qwen2.5-coder')
+  assert.equal(got.totalTokens, 5555)
+  assert.equal(got.sessionId, 'osc1')
+  assert.equal(got.agentId, 'agent-osc')
+  assert.equal(got.usageTimestampMs, 1771315500000)
+  assert.equal(got.integrationStatus, 'ok')
+})
+
+test('strips DCS control sequences before parsing JSON', () => {
+  const got = parseOpenClawUsage(fixture('openclaw-status-dcs-noise.txt'))
+  assert.ok(got)
+  assert.equal(got.model, 'deepseek-coder')
+  assert.equal(got.totalTokens, 6000)
+  assert.equal(got.sessionId, 'dcs1')
+  assert.equal(got.agentId, 'agent-dcs')
+  assert.equal(got.usageTimestampMs, 1771316600000)
+  assert.equal(got.integrationStatus, 'ok')
+})
+
+
+test('strips mixed terminal noise sequences together', () => {
+  const got = parseOpenClawUsage(fixture('openclaw-status-mixed-noise.txt'))
+  assert.ok(got)
+  assert.equal(got.model, 'gemini-pro')
+  assert.equal(got.totalTokens, 1010)
+  assert.equal(got.sessionId, 'mixed-ansi')
+  assert.equal(got.agentId, 'agent-mixed')
+  assert.equal(got.usageTimestampMs, 1771317600000)
+  assert.equal(got.integrationStatus, 'ok')
+})
+
+test('parses stats payload with nested current object under status.stats', () => {
+  const usage = parseOpenClawUsage(fixture('openclaw-stats-current-wrapper2.json'))
+  assert.ok(usage)
+  assert.equal(usage.model, 'gpt-5.3-codex-spark')
+  assert.equal(usage.totalTokens, 555)
+  assert.equal(usage.tokensPerMin, 21.5)
+  assert.equal(usage.sessionId, 'status-current-stats-01')
+  assert.equal(usage.agentId, 'agent-current-wrap')
+  assert.equal(usage.usageTimestampMs, 1771295000000)
+  assert.equal(usage.integrationStatus, 'ok')
+})
+
+test('parses usage timestamp aliases in snake_case ms fields', () => {
+  const usage = parseOpenClawUsage(fixture('openclaw-status-ts-ms-alias.json'))
+  assert.ok(usage)
+  assert.equal(usage.model, 'gpt-5.3-codex')
+  assert.equal(usage.totalTokens, 1500)
+  assert.equal(usage.tokensPerMin, 77)
+  assert.equal(usage.sessionId, 'ts-ms-session')
+  assert.equal(usage.agentId, 'agent-ts-ms')
+  assert.equal(usage.usageTimestampMs, 1771319900000)
+  assert.equal(usage.integrationStatus, 'ok')
+})
+
+test('parses usage timestamp aliases in usage_timestamp_ms fields', () => {
+  const usage = parseOpenClawUsage(fixture('openclaw-status-usage-timestamp-ms-alias.json'))
+  assert.ok(usage)
+  assert.equal(usage.model, 'qwen3')
+  assert.equal(usage.totalTokens, 1717)
+  assert.equal(usage.tokensPerMin, 22)
+  assert.equal(usage.sessionId, 'ts-ms-underscore-session')
+  assert.equal(usage.agentId, 'agent-ts-ms-underscore')
+  assert.equal(usage.usageTimestampMs, 1771321200000)
+  assert.equal(usage.integrationStatus, 'ok')
+})
+
+test('parses usage timestamp aliases in usage_ts fields', () => {
+  const usage = parseOpenClawUsage(fixture('openclaw-status-usage-ts-alias.json'))
+  assert.ok(usage)
+  assert.equal(usage.model, 'gpt-5.3-codex')
+  assert.equal(usage.totalTokens, 1900)
+  assert.equal(usage.tokensPerMin, 44)
+  assert.equal(usage.sessionId, 'usage-ts-session')
+  assert.equal(usage.agentId, 'agent-usage-ts')
+  assert.equal(usage.usageTimestampMs, 1771319000000)
+  assert.equal(usage.integrationStatus, 'ok')
+})
+
+test('parses usage_time timestamp alias in generic payloads', () => {
+  const usage = parseOpenClawUsage(JSON.stringify({
+    current: {
+      model: 'gpt-5.3-codex',
+      totalTokens: 1500,
+      sessionId: 'time-alias',
+      agentId: 'agent-time',
+      usage_time: '2026-02-28T00:00:00.000Z'
+    }
+  }))
+
+  assert.ok(usage)
+  assert.equal(usage.model, 'gpt-5.3-codex')
+  assert.equal(usage.totalTokens, 1500)
+  assert.equal(usage.sessionId, 'time-alias')
+  assert.equal(usage.agentId, 'agent-time')
+  assert.equal(usage.usageTimestampMs, Date.parse('2026-02-28T00:00:00.000Z'))
+  assert.equal(usage.integrationStatus, 'ok')
+})
+
+test('parses usage timestamp aliases in updated_at_ms fields', () => {
+  const usage = parseOpenClawUsage(fixture('openclaw-status-updated-at-ms-alias.json'))
+  assert.ok(usage)
+  assert.equal(usage.model, 'gpt-5.3-codex-spark')
+  assert.equal(usage.totalTokens, 2500)
+  assert.equal(usage.tokensPerMin, 31.2)
+  assert.equal(usage.sessionId, 'ts-ms-updated-at-session')
+  assert.equal(usage.agentId, 'agent-ts-ms-updated-at')
+  assert.equal(usage.usageTimestampMs, 1771325000000)
+  assert.equal(usage.integrationStatus, 'ok')
+})

package/test/telemetry-mapping.test.mjs

@@ -0,0 +1,69 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { OPENCLAW_FLEET_SCHEMA, enrichWithOpenClawFleetTelemetry } from '../src/telemetry-mapping.js'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+
+function fixture(name) {
+  return JSON.parse(fs.readFileSync(path.join(__dirname, 'fixtures', name), 'utf8'))
+}
+
+test('enriches legacy sample with fleet schema envelope while preserving legacy fields', () => {
+  const legacy = {
+    host: 'mac-mini-1',
+    ts: 1771278899999,
+    cpuPct: 12.5,
+    memPct: 63.2,
+    memUsedPct: 63.2,
+    memPressurePct: 42,
+    memPressureClass: 'normal',
+    tokensPerMin: 128.4,
+    openclawModel: 'gpt-5.3-codex',
+    openclawTotalTokens: 70500,
+    openclawSessionId: '90d2a820-6d77-42f0-8db4-12b90f9f7203',
+    openclawAgentId: 'main',
+    openclawUsageTs: 1771278893678,
+    openclawUsageAgeMs: 6321,
+    source: {
+      usage: 'openclaw',
+      usageIntegrationStatus: 'ok',
+      usageIngestionStatus: 'ok',
+      usageActivityStatus: 'fresh',
+      usageFreshnessState: 'fresh',
+      usageAlertLevel: 'ok',
+      usageAlertReason: 'healthy',
+      usageCommand: 'openclaw status --json',
+      usageProbeResult: 'ok',
+      usageProbeAttempts: 1,
+      usageUsedFallbackCache: false,
+      usageFallbackCacheSource: null
+    }
+  }
+
+  const enriched = enrichWithOpenClawFleetTelemetry(legacy, {
+    collector: 'idlewatch-agent',
+    collectorVersion: '0.1.0'
+  })
+
+  assert.equal(enriched.host, legacy.host)
+  assert.equal(enriched.openclawSessionId, legacy.openclawSessionId)
+  assert.equal(enriched.schemaFamily, OPENCLAW_FLEET_SCHEMA.family)
+  assert.equal(enriched.schemaVersion, OPENCLAW_FLEET_SCHEMA.version)
+  assert.deepEqual(enriched.schemaCompat, OPENCLAW_FLEET_SCHEMA.backwardCompatibleWith)
+  assert.equal(enriched.fleet.usage.tokensPerMin, legacy.tokensPerMin)
+  assert.equal(enriched.fleet.usage.totalTokens, legacy.openclawTotalTokens)
+  assert.equal(enriched.fleet.provenance.collectorVersion, '0.1.0')
+})
+
+test('fixture sample remains aligned with schema metadata', () => {
+  const sample = fixture('openclaw-fleet-sample-v1.json')
+  assert.equal(sample.schemaFamily, OPENCLAW_FLEET_SCHEMA.family)
+  assert.equal(sample.schemaVersion, OPENCLAW_FLEET_SCHEMA.version)
+  assert.deepEqual(sample.schemaCompat, OPENCLAW_FLEET_SCHEMA.backwardCompatibleWith)
+  assert.equal(sample.fleet.usage.model, sample.openclawModel)
+  assert.equal(sample.fleet.usage.sessionId, sample.openclawSessionId)
+})

package/test/telemetry-row-parser.test.mjs

@@ -0,0 +1,44 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+
+import {
+  extractJsonCandidates,
+  readTelemetryJsonRow,
+  stripControlNoise
+} from '../scripts/lib/telemetry-row-parser.mjs'
+
+test('extractJsonCandidates finds last JSON object in noisy multiline output', () => {
+  const noisy = `\x1b[32m[boot]\x1b[0m starting\n` +
+    '{"step":"init"}\n' +
+    'heartbeat\n' +
+    '{"host":"daemon","ts":123}'
+
+  const candidates = extractJsonCandidates(noisy)
+
+  assert.equal(candidates.length, 2)
+  assert.deepEqual(JSON.parse(candidates[1]), { host: 'daemon', ts: 123 })
+})
+
+test('extractJsonCandidates handles nested arrays and trailing text', () => {
+  const raw = '[{"a":1}]\nnoise\nother {"nested":{"k":2}} tail'
+  const candidates = extractJsonCandidates(raw)
+
+  assert.equal(candidates.length, 2)
+  assert.deepEqual(JSON.parse(candidates[0]), [{ a: 1 }])
+  assert.deepEqual(JSON.parse(candidates[1]), { nested: { k: 2 } })
+})
+
+test('readTelemetryJsonRow prefers the last valid JSON candidate', () => {
+  const output = `warn\n{"ts": 1,}` +
+    `\n{\"ts\": 2, \"host\": \"edge\"}\n`
+
+  const row = readTelemetryJsonRow(output)
+  assert.deepEqual(row, { ts: 2, host: 'edge' })
+})
+
+test('stripControlNoise removes ANSI control sequences that can break parser', () => {
+  const raw = '\x1b[33mwarn\x1b[0m\n{\"host\":\"x\",\"ts\":123}\x1b[?1049l'
+  const clean = stripControlNoise(raw)
+  assert.ok(clean.includes('{"host":"x","ts":123}'))
+  assert.ok(!clean.includes('\u001b['))
+})