The ultimate harness for coding agents and beyond. All your agents. All your machines. One command center. Start with code, then follow your curiosity and build across disciplines: CAD, circuits, robots, games and music.
TypeScript 3d-modelingagent-frameworkagent-harnessai-agentscadclaude-codecodexcoding-agentsdeveloper-toolsesp32game-developmentmcp-servermulti-agentopen-hardwareopencodeopenharnesspcbroboticsterminaltmux
// Settings ▸ Usage. What matters here is the pane's job as a *reader*: an
// off provider must not look like an empty one, a cost that is short must say
// so, and the switches have to be reachable from the state the pane rests in.
// A screen that renders "nothing switched on" and "nothing spent" the same is
// the screen that sends somebody looking for a bug in the scanners.
import 'package:flutter/material.dart';
import 'package:flutter/rendering.dart';
import 'package:flutter/services.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:harness/core/local_key_value_store.dart';
import 'package:harness/settings/sections/usage_detail_panels.dart';
import 'package:harness/settings/sections/usage_panels.dart';
import 'package:harness/settings/sections/usage_provider_pane.dart';
import 'package:harness/settings/sections/usage_section.dart';
import 'package:harness/stats/harness_stats.dart';
import 'package:harness/shared/theme/app_theme.dart';
import 'package:harness/shared/widgets/app_menu.dart';
import 'package:harness/shared/widgets/app_select_field.dart';
import 'package:harness/usage/ledger/ledger_scanner.dart';
import 'package:harness/core/snapshot_store.dart';
import 'package:harness/usage/ledger/ledger_types.dart';
import 'package:harness/usage/ledger/usage_ledger_controller.dart';
import 'package:harness/usage/ledger/usage_ledger_store.dart';
import 'package:harness/usage/ledger/usage_report.dart';
import 'support/real_fonts.dart';
class _MemorySettings implements LocalKeyValueStore {
final values = <String, String>{};
@override
Future<String?> read(String key) async => values[key];
@override
Future<void> write(String key, String value) async => values[key] = value;
@override
Future<void> delete(String key) async => values.remove(key);
}
class _FixedScanner implements LedgerScanner {
_FixedScanner(this.provider, this.result);
@override
final LedgerProvider provider;
final LedgerScanResult result;
@override
Future<LedgerScanResult> scan(Map<String, ScannedSource> previous) async =>
result;
}
LedgerEntry _entry({
required LedgerProvider provider,
String sessionId = 's1',
String? model = 'claude-opus-5',
UsageTotals totals = const UsageTotals(
freshInput: 1000,
output: 500,
cacheRead: 8000,
),
double? costUsd,
}) => LedgerEntry(
provider: provider,
sessionId: sessionId,
timestamp: DateTime.now().subtract(const Duration(hours: 2)),
totals: totals,
model: model,
costUsd: costUsd,
dedupeKey: '$provider-$sessionId-$model',
);
/// The lens picker. Found by type rather than by its text, because the closed
/// field and the overview's own provider rows print the same words — and the
/// repo's `app_select_field_test` drives it exactly this way.
final _lensField = find.byWidgetPredicate(
(widget) =>
widget.runtimeType.toString() == 'AppSelectField<LedgerProvider?>',
);
/// The overview's range picker, found the same way as the lens.
final _rangeField = find.byWidgetPredicate(
(widget) => widget.runtimeType.toString() == 'AppSelectField<UsageRange>',
);
/// Open the lens picker and choose [label].
Future<void> _pickLens(WidgetTester tester, String label) async {
await tester.tap(_lensField);
await tester.pumpAndSettle();
await tester.tap(
find.descendant(of: find.byType(AppMenuItem), matching: find.text(label)),
);
await tester.pumpAndSettle();
}
void main() {
setUpAll(loadRealFonts);
/// A controller over fake scanners and in-memory storage — never a real
/// `~/.claude` or a real `~/.harness`, and never real disk.
UsageLedgerController controllerWith(
Map<LedgerProvider, LedgerScanResult> results,
) {
final settings = _MemorySettings();
return UsageLedgerController(
stores: [
for (final provider in LedgerProvider.values)
UsageLedgerStore(
scanner: _FixedScanner(
provider,
results[provider] ?? const LedgerScanResult(),
),
settings: settings,
snapshots: MemorySnapshotStore(),
),
],
);
}
Future<void> pumpUsage(
WidgetTester tester,
UsageLedgerController controller, {
HarnessStats? stats,
Size size = const Size(1000, 900),
double textScale = 1,
}) async {
tester.view.physicalSize = size * 2;
tester.view.devicePixelRatio = 2;
addTearDown(tester.view.reset);
addTearDown(controller.dispose);
await tester.pumpWidget(
MaterialApp(
theme: buildAppTheme(brightness: Brightness.light),
builder: (context, child) => MediaQuery(
data: MediaQuery.of(context)
.copyWith(textScaler: TextScaler.linear(textScale)),
child: child!,
),
home: Builder(
builder: (context) {
AppTheme.brightness.value = Brightness.light;
return BrightnessScope(
child: Scaffold(
body: UsageSection(
controller: controller,
// Injected always: the singleton is shared across the whole
// run, so a test that used it would see whatever the previous
// one counted.
stats: stats ?? HarnessStats(store: MemorySnapshotStore()),
),
),
);
},
),
),
);
await tester.pumpAndSettle();
}
testWidgets(
'overview and provider ranges stay readable and keyboard operable at large text',
(tester) async {
final controller = controllerWith(const {});
await controller.load();
await controller.storeFor(LedgerProvider.claude).setEnabled(true);
await pumpUsage(
tester,
controller,
size: const Size(620, 800),
textScale: 1.8,
);
for (final provider in [null, 'Claude']) {
if (provider != null) {
await tester.scrollUntilVisible(_lensField, -250);
await _pickLens(tester, provider);
}
await tester.ensureVisible(_rangeField);
await tester.pumpAndSettle();
final label = tester.renderObject<RenderParagraph>(
find.descendant(of: _rangeField, matching: find.text('Last 30 days')),
);
expect(
label.getMaxIntrinsicWidth(double.infinity),
lessThanOrEqualTo(label.size.width + 0.1),
);
final anchor = tester.widget<InkWell>(
find.descendant(of: _rangeField, matching: find.byType(InkWell)),
);
anchor.focusNode!.requestFocus();
await tester.pump();
await tester.sendKeyEvent(LogicalKeyboardKey.arrowDown);
await tester.pumpAndSettle();
await tester.sendKeyEvent(LogicalKeyboardKey.arrowDown);
await tester.sendKeyEvent(LogicalKeyboardKey.enter);
await tester.pumpAndSettle();
expect(
tester.widget<AppSelectField<UsageRange>>(_rangeField).value,
UsageRange.d90,
);
expect(anchor.focusNode!.hasPrimaryFocus, isTrue);
await tester.sendKeyEvent(LogicalKeyboardKey.arrowDown);
await tester.pumpAndSettle();
await tester.sendKeyEvent(LogicalKeyboardKey.escape);
await tester.pumpAndSettle();
expect(find.byType(AppMenuItem), findsNothing);
expect(
tester.widget<AppSelectField<UsageRange>>(_rangeField).value,
UsageRange.d90,
);
expect(anchor.focusNode!.hasPrimaryFocus, isTrue);
expect(tester.takeException(), isNull);
}
},
);
testWidgets('usage selectors announce purpose as well as current scope', (
tester,
) async {
final semantics = tester.ensureSemantics();
try {
final controller = controllerWith(const {});
await controller.load();
await pumpUsage(tester, controller);
final provider = tester
.getSemantics(find.bySemanticsLabel('Usage provider'))
.getSemanticsData();
final range = tester
.getSemantics(find.bySemanticsLabel('Usage date range'))
.getSemanticsData();
expect(provider.label, 'Usage provider');
expect(provider.value, 'Overview');
expect(range.label, 'Usage date range');
expect(
range.value,
tester.widget<AppSelectField<UsageRange>>(_rangeField).value.label,
);
} finally {
semantics.dispose();
}
});
testWidgets('rests with nothing switched on, and offers the switches', (
tester,
) async {
final controller = controllerWith(const {});
await controller.load();
await pumpUsage(tester, controller);
expect(find.byType(UsageEmptyState), findsOneWidget);
expect(find.text('Nothing is being read yet.'), findsOneWidget);
for (final provider in LedgerProvider.values) {
expect(find.text('Enable ${provider.label}'), findsOneWidget);
}
// The ledger figures are absent, not zeroed: a "0 tokens" card here would
// be a claim about a machine nothing has been read from.
expect(find.text('Total tokens'), findsNothing);
});
group('stats', () {
testWidgets(
'an app that has done nothing says so, rather than three zeroes',
(tester) async {
final controller = controllerWith(const {});
await controller.load();
await pumpUsage(tester, controller);
expect(
find.text('Start your first harness to begin tracking.'),
findsOneWidget,
);
expect(find.text('Harnesses started'), findsNothing);
},
);
testWidgets('draws the three counters and the date they run from', (
tester,
) async {
final stats = HarnessStats(store: MemorySnapshotStore());
addTearDown(stats.dispose);
final at = DateTime(2026, 9, 1, 9);
stats.onAgentSpawned(at: at);
stats.onAgentSpawned(at: at);
stats.onTurnStarted('k', at: at);
stats.onTurnEnded('k', at: at.add(const Duration(hours: 2, minutes: 30)));
final controller = controllerWith(const {});
await controller.load();
await pumpUsage(tester, controller, stats: stats);
expect(find.text('Harnesses started'), findsOneWidget);
expect(find.text('2'), findsOneWidget);
expect(find.text('2h 30m'), findsOneWidget);
expect(find.text('Tracking since Sep 1, 2026'), findsOneWidget);
});
testWidgets('the counters move while the screen is open', (tester) async {
final stats = HarnessStats(store: MemorySnapshotStore());
addTearDown(stats.dispose);
final controller = controllerWith(const {});
await controller.load();
await pumpUsage(tester, controller, stats: stats);
expect(find.text('Harnesses started'), findsNothing);
stats.onAgentSpawned();
await tester.pumpAndSettle();
expect(find.text('Harnesses started'), findsOneWidget);
});
});
group('overview range', () {
testWidgets('opens on the last 30 days, and says which window it is', (
tester,
) async {
final controller = controllerWith({
LedgerProvider.claude: LedgerScanResult(
sources: [
ScannedSource(
path: 'a.jsonl',
mtimeMs: 1,
size: 1,
entries: [_entry(provider: LedgerProvider.claude)],
),
],
),
});
await controller.load();
await controller.storeFor(LedgerProvider.claude).setEnabled(true);
await pumpUsage(tester, controller);
expect(find.textContaining('Last 30 days · updated'), findsOneWidget);
});
testWidgets('a session older than the window is left out of the figures', (
tester,
) async {
final old = DateTime.now().subtract(const Duration(days: 60));
final controller = controllerWith({
LedgerProvider.claude: LedgerScanResult(
sources: [
ScannedSource(
path: 'a.jsonl',
mtimeMs: 1,
size: 1,
entries: [
_entry(provider: LedgerProvider.claude, sessionId: 'recent'),
LedgerEntry(
provider: LedgerProvider.claude,
sessionId: 'ancient',
timestamp: old,
totals: const UsageTotals(freshInput: 500000),
model: 'claude-opus-5',
dedupeKey: 'ancient',
),
],
),
],
),
});
await controller.load();
await controller.storeFor(LedgerProvider.claude).setEnabled(true);
await pumpUsage(tester, controller);
// Only the recent entry's 9,500 — the 60-day-old half-million is outside
// the default window and must not be added in.
expect(find.text('9.5k'), findsOneWidget);
expect(find.text('509.5k'), findsNothing);
});
testWidgets('all time brings the older session back', (tester) async {
final old = DateTime.now().subtract(const Duration(days: 60));
final controller = controllerWith({
LedgerProvider.claude: LedgerScanResult(
sources: [
ScannedSource(
path: 'a.jsonl',
mtimeMs: 1,
size: 1,
entries: [
_entry(provider: LedgerProvider.claude, sessionId: 'recent'),
LedgerEntry(
provider: LedgerProvider.claude,
sessionId: 'ancient',
timestamp: old,
totals: const UsageTotals(freshInput: 500000),
model: 'claude-opus-5',
dedupeKey: 'ancient',
),
],
),
],
),
});
await controller.load();
await controller.storeFor(LedgerProvider.claude).setEnabled(true);
await pumpUsage(tester, controller);
await tester.tap(_rangeField);
await tester.pumpAndSettle();
await tester.tap(
find.descendant(
of: find.byType(AppMenuItem),
matching: find.text('All time'),
),
);
await tester.pumpAndSettle();
expect(find.text('509.5k'), findsOneWidget);
});
});
group('overview panels', () {
testWidgets('the heatmap keeps its six weeks even on a narrower range', (
tester,
) async {
final old = DateTime.now().subtract(const Duration(days: 60));
final controller = controllerWith({
LedgerProvider.claude: LedgerScanResult(
sources: [
ScannedSource(
path: 'a.jsonl',
mtimeMs: 1,
size: 1,
entries: [
_entry(provider: LedgerProvider.claude, sessionId: 'recent'),
LedgerEntry(
provider: LedgerProvider.claude,
sessionId: 'ancient',
timestamp: old,
totals: const UsageTotals(freshInput: 500000),
model: 'claude-opus-5',
dedupeKey: 'ancient',
),
],
),
],
),
});
await controller.load();
await controller.storeFor(LedgerProvider.claude).setEnabled(true);
await pumpUsage(tester, controller);
final grid = tester.widget<DailyIntensityGrid>(
find.byType(DailyIntensityGrid),
);
// Six weeks of cells on the default 30-day range: the twelve days before
// the window are drawn EMPTY rather than dropped, which is what keeps the
// strip readable as a rhythm.
expect(grid.days, hasLength(42));
expect(grid.days.where((d) => d.totals.total > 0), hasLength(1));
// And the 60-day-old entry is still outside the figures.
expect(find.text('9.5k'), findsOneWidget);
});
testWidgets('the heatmap names its best day and carries a scale', (
tester,
) async {
final controller = controllerWith({
LedgerProvider.claude: LedgerScanResult(
sources: [
ScannedSource(
path: 'a.jsonl',
mtimeMs: 1,
size: 1,
entries: [_entry(provider: LedgerProvider.claude)],
),
],
),
});
await controller.load();
await controller.storeFor(LedgerProvider.claude).setEnabled(true);
await pumpUsage(tester, controller);
expect(find.text('Daily intensity'), findsOneWidget);
expect(find.textContaining('Best: '), findsOneWidget);
expect(find.text('Less'), findsOneWidget);
expect(find.text('More'), findsOneWidget);
});
testWidgets('the mix is three slices, with reasoning as a badge', (
tester,
) async {
final controller = controllerWith({
LedgerProvider.claude: LedgerScanResult(
sources: [
ScannedSource(
path: 'a.jsonl',
mtimeMs: 1,
size: 1,
entries: [
_entry(
provider: LedgerProvider.claude,
totals: const UsageTotals(
freshInput: 1000,
output: 4000,
cacheRead: 5000,
reasoning: 3500,
),
),
],
),
],
),
});
await controller.load();
await controller.storeFor(LedgerProvider.claude).setEnabled(true);
await pumpUsage(tester, controller);
expect(find.text('Token mix'), findsOneWidget);
expect(find.text('New input: 1.0k'), findsOneWidget);
expect(find.text('Output: 4.0k'), findsOneWidget);
// Cache read and cache write are one slice on the overview.
expect(find.text('Cache: 5.0k'), findsOneWidget);
// Reasoning is a SUBSET of output, so it is a badge and not a fourth
// slice — 10k total, not 13.5k.
expect(find.text('3.5k reasoning'), findsOneWidget);
expect(find.text('10.0k'), findsOneWidget);
});
});
group('provider lens', () {
testWidgets('opens on the overview, not on a provider', (tester) async {
final controller = controllerWith(const {});
await controller.load();
await pumpUsage(tester, controller);
expect(find.text('Usage analytics'), findsOneWidget);
expect(find.byType(UsageProviderPane), findsNothing);
expect(find.byType(UsageEmptyState), findsOneWidget);
});
testWidgets('picking a provider swaps in its detail pane', (tester) async {
final controller = controllerWith({
LedgerProvider.claude: LedgerScanResult(
sources: [
ScannedSource(
path: 'a.jsonl',
mtimeMs: 1,
size: 1,
entries: [_entry(provider: LedgerProvider.claude)],
),
],
),
});
await controller.load();
await controller.storeFor(LedgerProvider.claude).setEnabled(true);
await pumpUsage(tester, controller);
await _pickLens(tester, 'Claude');
expect(find.byType(UsageProviderPane), findsOneWidget);
// The eight figures, the range it is showing, and the panels under them.
expect(find.text('Cache reuse rate'), findsOneWidget);
expect(find.text('Conversations / turns'), findsOneWidget);
expect(
find.text('All local Claude usage · Last 30 days'),
findsOneWidget,
);
expect(find.byType(UsageDailyChart), findsOneWidget);
expect(find.text('By model'), findsOneWidget);
expect(find.text('By project'), findsOneWidget);
expect(find.byType(UsageSessionsTable), findsOneWidget);
});
testWidgets('a provider that is off offers its own switch', (tester) async {
final controller = controllerWith(const {});
await controller.load();
await pumpUsage(tester, controller);
await _pickLens(tester, 'Codex');
expect(find.byType(UsageProviderPane), findsOneWidget);
expect(find.text('Enable Codex'), findsOneWidget);
expect(find.text('Cache reuse rate'), findsNothing);
});
});
testWidgets('enabling a provider from the empty state draws its figures', (
tester,
) async {
final controller = controllerWith({
LedgerProvider.claude: LedgerScanResult(
sources: [
ScannedSource(
path: 'a.jsonl',
mtimeMs: 1,
size: 1,
entries: [_entry(provider: LedgerProvider.claude)],
),
],
),
});
await controller.load();
await pumpUsage(tester, controller);
await tester.tap(find.text('Enable Claude'));
await tester.pumpAndSettle();
expect(find.byType(UsageEmptyState), findsNothing);
expect(find.byType(UsageStatCard), findsNWidgets(4));
expect(find.text('Total tokens'), findsOneWidget);
// 1000 + 500 + 8000
expect(find.text('9.5k'), findsOneWidget);
expect(find.text('1 enabled · 1 with data'), findsOneWidget);
});
testWidgets('an unpriced model makes the cost a floor rather than a total', (
tester,
) async {
final controller = controllerWith({
LedgerProvider.claude: LedgerScanResult(
sources: [
ScannedSource(
path: 'a.jsonl',
mtimeMs: 1,
size: 1,
entries: [
_entry(provider: LedgerProvider.claude),
_entry(
provider: LedgerProvider.claude,
sessionId: 's2',
model: 'a-grid-model-nobody-prices',
),
],
),
],
),
});
await controller.load();
await controller.storeFor(LedgerProvider.claude).setEnabled(true);
await pumpUsage(tester, controller);
expect(find.text('at least — some models unpriced'), findsOneWidget);
expect(
find.textContaining('some model prices are unavailable'),
findsOneWidget,
);
});
testWidgets(
'an incomplete empty scan does not claim zero sessions or tokens',
(tester) async {
final controller = controllerWith({
LedgerProvider.claude: const LedgerScanResult(
status: LedgerStatus.partial,
message:
'Some transcripts could not be read. Figures are incomplete.',
),
});
await controller.load();
await controller.storeFor(LedgerProvider.claude).setEnabled(true);
await pumpUsage(tester, controller);
expect(find.text('Incomplete'), findsOneWidget);
expect(find.text('No figures available.'), findsOneWidget);
expect(find.text('0 conversations'), findsNothing);
expect(find.text('0 tokens'), findsNothing);
expect(find.textContaining('0 with data'), findsNothing);
},
);
testWidgets('a complete empty scan can report zero sessions', (tester) async {
final controller = controllerWith({
LedgerProvider.claude: const LedgerScanResult(),
});
await controller.load();
await controller.storeFor(LedgerProvider.claude).setEnabled(true);
await pumpUsage(tester, controller);
expect(find.text('0 conversations'), findsOneWidget);
expect(find.text('0 tokens'), findsOneWidget);
expect(find.text('Incomplete'), findsNothing);
});
testWidgets('an absent CLI reads as not found, never as nothing spent', (
tester,
) async {
final controller = controllerWith({
LedgerProvider.opencode: const LedgerScanResult.unavailable(
'No OpenCode database on this computer',
),
});
await controller.load();
await controller.storeFor(LedgerProvider.opencode).setEnabled(true);
await pumpUsage(tester, controller);
expect(find.text('Not found'), findsOneWidget);
expect(
find.text('No OpenCode database on this computer'),
findsOneWidget,
reason: "the scanner's own sentence, not a re-worded one",
);
});
testWidgets('a provider that is off says so rather than showing a zero', (
tester,
) async {
final controller = controllerWith(const {});
await controller.load();
await pumpUsage(tester, controller);
expect(find.text('Off'), findsNWidgets(LedgerProvider.values.length));
});
testWidgets('every provider keeps a row whether it is on or not', (
tester,
) async {
final controller = controllerWith(const {});
await controller.load();
await pumpUsage(tester, controller);
expect(
find.byType(ProviderUsageRow),
findsNWidgets(LedgerProvider.values.length),
);
for (final provider in LedgerProvider.values) {
expect(find.text(provider.label), findsOneWidget);
}
});
}