Skip to content

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.

Measure connected workspace CPU and wakeups in isolated native builds (#655)

Dee29e03783d3eb
diff --git a/desktop/tool/native_benchmark/ConnectedResourceHost.swift b/desktop/tool/native_benchmark/ConnectedResourceHost.swift
new file mode 100644
index 000000000..d131608e9
--- /dev/null
+++ b/desktop/tool/native_benchmark/ConnectedResourceHost.swift
@@ -0,0 +1,55 @@
+// Compiled only into a copied benchmark host. Never included in Runner.
+private enum ConnectedResourceHost {
+ static func validateEnvironment() {
+ let env = ProcessInfo.processInfo.environment
+ guard Bundle.main.bundleIdentifier == "ai.autonomous.harness.benchmark",
+ let root = env["HARNESS_CONNECTED_ROOT"],
+ root.hasPrefix("/private/tmp/harness-connected-"),
+ URL(fileURLWithPath: root).deletingLastPathComponent().path == "/private/tmp",
+ env["HOME"] == root + "/home",
+ env["CFFIXED_USER_HOME"] == root + "/home",
+ env["FLUTTER_TEST"] == nil else {
+ fputs("Connected fixture requires its private launcher environment\n", stderr)
+ exit(78)
+ }
+ }
+
+ static func install(window: NSWindow, messenger: FlutterBinaryMessenger) {
+ let bridge = FlutterMethodChannel(name: "harness/connected_resource_fixture", binaryMessenger: messenger)
+ var focusLosses = 0
+ // Observers live exactly as long as this isolated app.
+ _ = NotificationCenter.default.addObserver(
+ forName: NSWindow.didResignKeyNotification, object: window, queue: .main
+ ) { _ in focusLosses += 1 }
+ bridge.setMethodCallHandler { call, result in
+ switch call.method {
+ case "ready":
+ window.setContentSize(NSSize(width: 1280, height: 800))
+ window.center()
+ window.makeKeyAndOrderFront(nil)
+ NSApp.activate(ignoringOtherApps: true)
+ result(["bundle": Bundle.main.bundleIdentifier!, "pid": ProcessInfo.processInfo.processIdentifier])
+ case "captureState":
+ result([
+ "key": window.isKeyWindow, "active": NSApp.isActive,
+ "visible": window.isVisible, "hidden": NSApp.isHidden,
+ "focusLosses": focusLosses, "width": window.contentView?.bounds.width ?? 0,
+ "height": window.contentView?.bounds.height ?? 0, "scale": window.backingScaleFactor,
+ ])
+ case "hide":
+ NSApp.hide(nil)
+ result(nil)
+ case "show":
+ NSApp.unhide(nil)
+ window.makeKeyAndOrderFront(nil)
+ NSApp.activate(ignoringOtherApps: true)
+ result(nil)
+ case "finish":
+ result(nil)
+ DispatchQueue.main.async { NSApp.terminate(nil) }
+ default:
+ result(FlutterMethodNotImplemented)
+ }
+ }
+ }
+}
diff --git a/desktop/tool/native_benchmark/README.md b/desktop/tool/native_benchmark/README.md
index 1b60c292a..3de795e34 100644
--- a/desktop/tool/native_benchmark/README.md
+++ b/desktop/tool/native_benchmark/README.md
@@ -3,6 +3,88 @@
Start with the [September 22 wrap-up and resume notes](../../../docs/performance/2026-09-22-wrap-up.md)
for the ready PRs, measured improvements, rejected experiments and remaining priorities.
+## Connected local workspace resources
+
+The older fixtures below deliberately suppress real connections and several
+background services. Their component timings cannot establish total app energy
+savings. The connected fixture runs the Release desktop, its full local daemon,
+and real tmux terminals with a private home, identity, control port and socket.
+`FLUTTER_TEST` is absent: local background services and daemon supervision
+remain active. Environment installation, sign-in and update acquisition are
+substituted; the workspace is signed out. The injected discovery uses the
+externally owned test daemon and disables ownership-triggered restarts. It does
+not use real conversations, model accounts or the installed daemon.
+
+On macOS, build the CLI with `node build-bundle.mjs` in `cli/`, then:
+
+```sh
+DEVELOPER_DIR=/Applications/Xcode.app/Contents/Developer \
+ python3 tool/native_benchmark/prepare.py --flutter /path/to/pinned/flutter \
+ --connected-resource
+DEVELOPER_DIR=/Applications/Xcode.app/Contents/Developer \
+ python3 tool/native_benchmark/test_process_forest_usage.py
+HARNESS_BENCH_NODE=/absolute/path/to/pinned/node \
+ HARNESS_BENCH_TMUX=/absolute/path/to/tmux \
+ python3 tool/native_benchmark/test_connected_stack.py
+DEVELOPER_DIR=/Applications/Xcode.app/Contents/Developer \
+ xcrun swiftc tool/native_benchmark/process_forest_usage.swift \
+ -o /private/tmp/harness-process-forest-usage
+python3 tool/native_benchmark/connected_run.py \
+ --app '/private/tmp/harness-native-benchmark-PRINTED/desktop/build/macos/Build/Products/Release/Harness Benchmark.app' \
+ --root /private/tmp/harness-connected-UNUSED_NAME \
+ --node /absolute/path/to/pinned/node --tmux /absolute/path/to/tmux \
+ --sampler /private/tmp/harness-process-forest-usage \
+ --label current --terminals 10 --seconds 30
+```
+
+The launcher refuses an existing root or a normal installed app. Its additional
+macOS sandbox allows writes only inside that run and terminal devices, and
+outbound networking only over loopback or its private Unix sockets. macOS's
+setuid `/bin/ps` has a narrow execution exception for read-only discovery.
+Closing the owning launcher's stdin stops its daemon and its explicitly named
+tmux server; `cleanup.json` verifies the private socket has stopped listening.
+The app also refuses startup without the matching private-home environment.
+
+Every retained terminal runs a deterministic Node worker with 1,000 seeded
+lines. Four panes are visible; the remaining panes live in other tabs. The five
+phases are foreground idle with a visible cursor, foreground idle with a hidden
+cursor, foreground output, hidden-app idle, and hidden-app output. Active
+workers redraw eight rows at 20 Hz. Output must reach every retained terminal,
+connections must remain controlling, and actual output counts and skipped ticks
+are retained. A focus, visibility or geometry change during a phase rejects it.
+This controls terminal traffic, not model behavior, inference or cloud latency.
+
+`process_forest_usage.swift` samples the app, daemon and tmux process trees at
+1 Hz. CPU and wakeup accounting includes kernel-recorded exited children, so
+short-lived `ps` and Git helpers count. The process inventory includes zombies:
+their CPU remains attributed to them until their parent reaps them and receives
+the child counters. The regression calibration deliberately delays reaping;
+the earlier `proc_listallpids` inventory dropped that interval and was rejected.
+See Apple's [child-accounting implementation](https://github.com/apple-oss-distributions/xnu/blob/main/bsd/kern/kern_exit.c).
+Root overlap, root replacement, unstable
+membership and regressing counters reject a measurement. Calibration compares
+live and reaped child CPU against independent `getrusage` counters. Processes
+that escape/reparent out of these trees are outside its boundary. Summed
+physical footprints can include shared mappings. Neither this sampler nor the
+single-process sampler measures GPU joules, battery discharge, or macOS's
+“Using Significant Energy” classification.
+
+Use `prepare.py --source /path/to/baseline/desktop` and `connected_run.py
+--bundle /path/to/baseline/cli/dist/cli.js` to compare a second source variant
+with the same tooling. The copied build records its source revision, production
+patch digest and fixture hashes; the stack records the exact CLI bundle hash.
+Finish all builds before recording measurements. Run at least three paired
+trials, alternate their order, keep failed runs, and record host contention.
+Treat five-second runs as calibration only. Raw phase samples, output counters,
+native state, source identities, failures and cleanup results remain in the run
+directory. Never extrapolate one workload's CPU improvement to whole-device
+energy or unrelated signed-in workloads.
+
+The [October 2 connected comparison](../../../docs/performance/2026-10-02-connected-workspace-resources.md)
+records three pairs, the rejected initial accounting experiment, and both the
+hidden-cursor idle improvement and higher foreground active-output CPU. It does
+not establish overall energy savings.
+
## Core experiences and process resources
```sh
diff --git a/desktop/tool/native_benchmark/connected_main.dart b/desktop/tool/native_benchmark/connected_main.dart
new file mode 100644
index 000000000..16d685551
--- /dev/null
+++ b/desktop/tool/native_benchmark/connected_main.dart
@@ -0,0 +1,261 @@
+// A real, signed-out local workspace in an isolated Release application.
+// All terminal I/O, discovery, daemon supervision, UI and local background
+// services run normally. Only installer/auth/update acquisition is substituted.
+import 'dart:async';
+import 'dart:convert';
+import 'dart:io';
+
+import 'package:flutter/material.dart';
+import 'package:flutter/services.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:harness/app_shell.dart';
+import 'package:harness/auth/auth_session.dart';
+import 'package:harness/auth/cli_login.dart';
+import 'package:harness/bootstrap/environment_provisioner.dart';
+import 'package:harness/core/config.dart';
+import 'package:harness/core/connected_semantics.dart';
+import 'package:harness/core/crash_log.dart';
+import 'package:harness/core/desktop_window.dart';
+import 'package:harness/core/startup.dart';
+import 'package:harness/core/test_run.dart';
+import 'package:harness/desktop_workspace.dart';
+import 'package:harness/logging/install.dart';
+import 'package:harness/shortcuts/app_keymap.dart';
+import 'package:harness/state/app_state.dart';
+import 'package:harness/state/pane_layout_store.dart';
+import 'package:harness/terminal/terminal_session.dart';
+import 'package:harness/update/desktop_updater.dart';
+import 'package:harness/ws/local_cli_discovery.dart';
+
+const _host = MethodChannel('harness/connected_resource_fixture');
+
+class _PreparedEnvironment extends EnvironmentProvisioner {
+ @override
+ Future<EnvironmentReadiness> ensureReady({
+ required void Function(EnvironmentReadiness value) onProgress,
+ EnvironmentReadiness? resumeFrom,
+ bool install = true,
+ EnvironmentSetupMode? mode,
+ }) async {
+ if (install) throw StateError('The fixture never installs software');
+ final ready = EnvironmentReadiness(
+ steps: {
+ for (final step in EnvironmentStep.values)
+ step: EnvironmentStepStatus.ready,
+ },
+ phase: EnvironmentSetupPhase.ready,
+ );
+ onProgress(ready);
+ return ready;
+ }
+}
+
+class _SignedOut extends CliLogin {
+ @override
+ Future<CliAuthStatus> checkStatus() async =>
+ const CliAuthStatus(loggedIn: false);
+}
+
+class _NoUpdateAcquisition extends DesktopUpdater {
+ @override
+ Future<DesktopUpdateCheck> check({String? currentVersion}) async =>
+ const DesktopUpdateCheck.disabled();
+}
+
+Future<void> _until(bool Function() done, String operation) async {
+ final deadline = DateTime.now().add(const Duration(seconds: 30));
+ while (!done()) {
+ if (DateTime.now().isAfter(deadline)) {
+ throw StateError('$operation did not complete');
+ }
+ await Future<void>.delayed(const Duration(milliseconds: 50));
+ }
+}
+
+String _tail(TerminalSession session) {
+ final lines = session.terminal.buffer.lines;
+ return [
+ for (
+ var index = (lines.length - 50).clamp(0, lines.length);
+ index < lines.length;
+ index++
+ )
+ lines[index].getText(),
+ ].join('\n');
+}
+
+Future<void> main() async {
+ HarnessWidgetsBinding();
+ final root = Platform.environment['HARNESS_CONNECTED_ROOT']!;
+ if (kUnderTest || Platform.environment['HOME'] != '$root/home') {
+ throw StateError(
+ 'The connected fixture must use its private, non-test home',
+ );
+ }
+ final manifest = jsonDecode(
+ await File('$root/stack.json').readAsString(),
+ ) as Map<String, dynamic>;
+ if (manifest['ready'] != true || manifest['root'] != root) {
+ throw StateError('The connected fixture has no matching ready stack');
+ }
+ final machine = manifest['machineId'] as String;
+ final agents = (manifest['agents'] as List).cast<Map<String, dynamic>>();
+ final config = AppConfig(
+ apiBaseUrl: 'http://127.0.0.1:1',
+ localCliBaseUrl: 'http://127.0.0.1:${manifest['port']}',
+ );
+ final discovery = LocalCliDiscovery(
+ config: config,
+ spawnCommand: () async =>
+ throw StateError('Fixture daemon unexpectedly disappeared'),
+ stopCommand: () async =>
+ throw StateError('Only the fixture launcher owns its daemon'),
+ );
+ installFileLogs();
+ CrashLog.install();
+ final keymap = AppKeymap(store: AppKeymap.fileStore());
+ await Future.wait([loadPersistedSettings(), keymap.start()]);
+ final app = AppNotifier(
+ config: config,
+ authSession: AuthSession(),
+ localCliDiscovery: discovery,
+ environmentProvisioner: _PreparedEnvironment(),
+ cliLogin: _SignedOut(),
+ desktopUpdater: _NoUpdateAcquisition(),
+ paneLayoutStore: PaneLayoutStore(),
+ );
+ await configureDesktopWindow();
+ runApp(
+ ProviderScope(
+ overrides: [appStateProvider.overrideWithValue(app)],
+ child: HarnessApp(
+ keymap: keymap,
+ authenticatedScreen: authenticatedWorkspace,
+ frame: appFrame,
+ ),
+ ),
+ );
+ await _host.invokeMethod<void>('ready');
+ try {
+ await app.bootstrap();
+ await _until(
+ () => app.machineStates[machine]?.agents.length == agents.length,
+ 'Private agent discovery',
+ );
+ if (app.machineStates.length != 1 || app.signedIn) {
+ throw StateError('The fixture crossed its signed-out local boundary');
+ }
+ final first = app.activeSwarmId;
+ for (var index = 0; index < agents.length; index++) {
+ if (index % 4 == 0) {
+ if (index != 0) app.newSwarm();
+ app.renameSwarm(
+ app.activeSwarmId,
+ 'Resource fixture ${index ~/ 4 + 1}',
+ );
+ }
+ await app.addAgentToSwarm(machine, agents[index]['id'] as String);
+ }
+ await _until(
+ () =>
+ app.allPanes
+ .where(
+ (pane) =>
+ pane.session?.status == TerminalSessionStatus.controlling,
+ )
+ .length ==
+ agents.length,
+ 'Private terminal attachments',
+ );
+ app.selectSwarm(first);
+ await WidgetsBinding.instance.endOfFrame;
+ final server = await ServerSocket.bind(
+ InternetAddress('$root/app-control.sock', type: InternetAddressType.unix),
+ 0,
+ );
+ await File('$root/app-ready.json').writeAsString(
+ jsonEncode({
+ 'ready': true,
+ 'pid': pid,
+ 'terminals': agents.length,
+ 'sourceRevision': const String.fromEnvironment(
+ 'CONNECTED_SOURCE_REVISION',
+ ),
+ 'testMode': kUnderTest,
+ 'boundary':
+ 'Signed-out Release desktop, local daemon, real tmux terminals. '
+ 'No cloud accounts, model inference, installer or update acquisition.',
+ }),
+ );
+ server.listen((socket) {
+ socket
+ .cast<List<int>>()
+ .transform(utf8.decoder)
+ .transform(const LineSplitter())
+ .listen((line) async {
+ try {
+ final command = jsonDecode(line) as Map<String, dynamic>;
+ final operation = command['operation'];
+ if (operation == 'hide' || operation == 'show') {
+ await _host.invokeMethod<void>(operation as String);
+ } else if (operation == 'input') {
+ final agent = command['agentId'] as String;
+ final session = app.allPanes
+ .map((pane) => pane.session)
+ .whereType<TerminalSession>()
+ .singleWhere((item) => item.agentId == agent);
+ session.terminal.textInput(command['text'] as String);
+ } else if (operation != 'status' && operation != 'finish') {
+ throw StateError('Unknown fixture operation');
+ }
+ socket.writeln(
+ jsonEncode({
+ 'success': true,
+ 'pid': pid,
+ 'native': await _host.invokeMapMethod<String, dynamic>(
+ 'captureState',
+ ),
+ 'panes': [
+ for (final pane in app.allPanes)
+ {
+ 'agentId': pane.session?.agentId,
+ 'status': pane.session?.status.name,
+ 'rows': pane.session?.terminal.buffer.lines.length,
+ if (command['includeText'] == true &&
+ pane.session != null)
+ 'tail': _tail(pane.session!),
+ },
+ ],
+ }),
+ );
+ await socket.flush();
+ await socket.close();
+ if (operation == 'finish') {
+ app.dispose();
+ await _host.invokeMethod<void>('finish');
+ }
+ } catch (error, stack) {
+ socket.writeln(
+ jsonEncode({
+ 'success': false,
+ 'error': '$error',
+ 'stack': '$stack',
+ }),
+ );
+ await socket.close();
+ }
+ });
+ });
+ } catch (error, stack) {
+ await File('$root/app-failed.json').writeAsString(
+ jsonEncode({
+ 'success': false,
+ 'pid': pid,
+ 'error': '$error',
+ 'stack': '$stack',
+ }),
+ );
+ app.dispose();
+ await _host.invokeMethod<void>('finish');
+ }
+}
diff --git a/desktop/tool/native_benchmark/connected_run.py b/desktop/tool/native_benchmark/connected_run.py
new file mode 100644
index 000000000..a9701a1a6
--- /dev/null
+++ b/desktop/tool/native_benchmark/connected_run.py
@@ -0,0 +1,215 @@
+#!/usr/bin/env python3
+"""Measure a disposable Release app + daemon + tmux with four visible terminals.
+
+Requires a connected-resource build from prepare.py and a compiled/calibrated
+process_forest_usage.swift. Never installs or controls the user's Harness app.
+"""
+import argparse
+import hashlib
+import json
+import os
+from pathlib import Path
+import shlex
+import shutil
+import signal
+import socket
+import subprocess
+import time
+
+from isolation import validate_benchmark_bundle
+
+
+def rpc(path, command):
+ with socket.socket(socket.AF_UNIX) as client:
+ client.settimeout(5)
+ client.connect(str(path))
+ client.sendall((json.dumps(command) + '\n').encode())
+ data = b''
+ while b'\n' not in data:
+ part = client.recv(65536)
+ if not part:
+ raise RuntimeError('Fixture connection closed before its reply')
+ data += part
+ if len(data) > 1048576:
+ raise RuntimeError('Unexpectedly large fixture reply')
+ result = json.loads(data.split(b'\n', 1)[0])
+ if result.get('success') is not True:
+ raise RuntimeError(result)
+ return result
+
+
+def wait_for(path, process, seconds=45):
+ deadline = time.monotonic() + seconds
+ while not path.exists():
+ if process.poll() is not None:
+ raise RuntimeError(f'Owned process exited: {process.returncode}; waiting for {path.name}')
+ if time.monotonic() > deadline:
+ raise RuntimeError(f'Timed out waiting for {path.name}')
+ time.sleep(0.1)
+
+
+def run(args):
+ tooling = Path(__file__).resolve().parent
+ root = args.root.resolve()
+ if not root.name.startswith('harness-connected-') or root.parent != Path('/private/tmp') or root.exists():
+ raise ValueError('Use a new /private/tmp/harness-connected-NAME directory')
+ app = args.app.resolve()
+ validate_benchmark_bundle(app)
+ if not str(app).startswith('/private/tmp/harness-native-benchmark-'):
+ raise ValueError('Only a disposable benchmark build is permitted')
+ helper_args = [str(args.node.resolve()), str(tooling / 'connected_stack.mjs'),
+ f'--root={root}', f'--tmux={args.tmux.resolve()}', f'--terminals={args.terminals}']
+ if args.bundle:
+ helper_args.append(f'--bundle={args.bundle.resolve()}')
+ native = None
+ native_log = None
+ sampler = None
+ result = {'schema': 1, 'success': False, 'root': str(root), 'label': args.label,
+ 'app': str(app), 'terminals': args.terminals, 'phases': [],
+ 'toolingSha256': {path.name: hashlib.sha256(path.read_bytes()).hexdigest()
+ for path in [Path(__file__), tooling / 'connected_stack.mjs',
+ tooling / 'connected_worker.mjs', args.sampler.resolve()]},
+ 'startedAt': time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime())}
+ # Validate/hash every required input before starting an owned process. A
+ # missing sampler must not leave an unattended daemon/tmux launcher behind.
+ helper = subprocess.Popen(helper_args, stdin=subprocess.PIPE, stdout=subprocess.PIPE,
+ stderr=subprocess.PIPE, text=True)
+ try:
+ wait_for(root / 'stack.json', helper)
+ manifest = json.loads((root / 'stack.json').read_text())
+ result['daemonMetadata'] = {key: manifest[key] for key in
+ ['bundleSha256', 'sourceRevision', 'sourceDiffSha256', 'boundary']}
+ identity = app.parents[6] / 'build-identity.json'
+ if identity.exists():
+ result['buildIdentity'] = json.loads(identity.read_text())
+ env = json.loads((root / 'environment.json').read_text())
+ env['HARNESS_CONNECTED_ROOT'] = str(root)
+ worker = root / 'worker.mjs'
+ shutil.copyfile(tooling / 'connected_worker.mjs', worker)
+ native_log = (root / 'app.log').open('x')
+ native = subprocess.Popen(['/usr/bin/sandbox-exec', '-f', str(root / 'isolation.sb'),
+ str(app / 'Contents/MacOS/Harness Benchmark')],
+ env=env, cwd=root, stdin=subprocess.DEVNULL,
+ stdout=native_log, stderr=subprocess.STDOUT)
+ wait_for(root / 'app-ready.json', native)
+ app_ready = json.loads((root / 'app-ready.json').read_text())
+ if app_ready['pid'] != native.pid or app_ready['testMode'] is not False:
+ raise RuntimeError('Native fixture identity/test-mode mismatch')
+ result['appMetadata'] = app_ready
+ control = root / 'app-control.sock'
+ for index, agent in enumerate(manifest['agents']):
+ # New disposable panes only; normal terminal input starts each worker.
+ command = f'HARNESS_CONNECTED_ROOT={shlex.quote(str(root))} exec {shlex.quote(str(args.node.resolve()))} {shlex.quote(str(worker))} {index}\r'
+ rpc(control, {'operation': 'input', 'agentId': agent['id'], 'text': command})
+ for index in range(args.terminals):
+ wait_for(root / f'worker-{index}.sock', native)
+ time.sleep(2)
+ initial = rpc(control, {'operation': 'status', 'includeText': True})
+ if len(initial['panes']) != args.terminals:
+ raise RuntimeError('Wrong number of connected panes')
+ for index, pane in enumerate(initial['panes']):
+ if f'RESOURCE {index} READY' not in pane.get('tail', ''):
+ raise RuntimeError(f'Worker output did not reach pane {index}')
+ result['initial'] = initial
+ print(json.dumps({'ready': True, 'root': str(root), 'appPid': native.pid,
+ 'daemonPid': manifest['daemonPid'], 'terminals': args.terminals}), flush=True)
+ roots = ','.join(str(value) for value in [native.pid, manifest['daemonPid'], manifest['tmuxPid']])
+ for visibility, mode in [('foreground', 'idle-visible'), ('foreground', 'idle-hidden'),
+ ('foreground', 'active'), ('background', 'idle-hidden'),
+ ('background', 'active')]:
+ label = f'{visibility}-{mode}'
+ rpc(control, {'operation': 'show' if visibility == 'foreground' else 'hide'})
+ for index in range(args.terminals):
+ rpc(root / f'worker-{index}.sock', {'mode': mode})
+ time.sleep(args.settle)
+ before = rpc(control, {'operation': 'status'})
+ native_state = before['native']
+ if visibility == 'foreground' and not (native_state['key'] and native_state['active']):
+ raise RuntimeError('Foreground phase lost focus before sampling')
+ if visibility == 'background' and not native_state['hidden']:
+ raise RuntimeError('Background phase is not hidden')
+ workers_before = [rpc(root / f'worker-{index}.sock', {}) for index in range(args.terminals)]
+ output = root / (label + '.json')
+ sampler = subprocess.Popen([str(args.sampler.resolve()), roots, str(args.seconds), label, str(output)],
+ stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+ stdout, stderr = sampler.communicate(timeout=args.seconds + 20)
+ if sampler.returncode != 0:
+ raise RuntimeError(f'Sampler failed: {stderr}')
+ workers_after = [rpc(root / f'worker-{index}.sock', {}) for index in range(args.terminals)]
+ after = rpc(control, {'operation': 'status', 'includeText': True})
+ for field in ['key', 'active', 'hidden', 'focusLosses', 'width', 'height', 'scale']:
+ if native_state[field] != after['native'][field]:
+ raise RuntimeError(f'Native state changed during {label}: {field}')
+ if any(pane['status'] != 'controlling' for pane in after['panes']):
+ raise RuntimeError('A terminal disconnected during sampling')
+ for index, (start, end) in enumerate(zip(workers_before, workers_after)):
+ if start['pid'] != end['pid'] or start['mode'] != mode or end['mode'] != mode:
+ raise RuntimeError('Worker identity or workload changed')
+ if mode == 'active':
+ ticks = end['ticks'] - start['ticks']
+ skipped = end['skipped'] - start['skipped']
+ if ticks < args.seconds * 18 or skipped > ticks * 0.02:
+ raise RuntimeError('Workload missed its output-rate requirement')
+ pane = next(pane for pane in after['panes'] if pane['agentId'] == manifest['agents'][index]['id'])
+ if f'RESOURCE {index} FRAME ' not in pane.get('tail', ''):
+ raise RuntimeError('Active output failed to reach a retained terminal')
+ resource = json.loads(output.read_text())
+ phase = {'label': label, 'before': before, 'after': after,
+ 'workersBefore': workers_before, 'workersAfter': workers_after,
+ 'resources': output.name, 'summary': resource['summary']}
+ result['phases'].append(phase)
+ (root / 'run-progress.json').write_text(json.dumps(result, indent=2))
+ print(json.dumps({'phase': label, **resource['summary']}), flush=True)
+ result['success'] = True
+ except BaseException as error:
+ result['error'] = repr(error)
+ raise
+ finally:
+ if sampler and sampler.poll() is None:
+ sampler.terminate(); sampler.communicate(timeout=5)
+ if native and native.poll() is None:
+ try:
+ rpc(root / 'app-control.sock', {'operation': 'finish'})
+ native.wait(timeout=5)
+ except (OSError, RuntimeError, subprocess.TimeoutExpired):
+ if native.poll() is None:
+ native.terminate()
+ try: native.wait(timeout=5)
+ except subprocess.TimeoutExpired: native.kill(); native.wait(timeout=5)
+ if native_log:
+ native_log.close()
+ helper.stdin.close()
+ try: helper.wait(timeout=15)
+ except subprocess.TimeoutExpired:
+ helper.terminate(); helper.wait(timeout=15)
+ result['helperExit'] = helper.returncode
+ result['nativeExit'] = native.returncode if native else None
+ result['helperStdout'] = helper.stdout.read()
+ result['helperStderr'] = helper.stderr.read()
+ cleanup = root / 'cleanup.json'
+ result['cleanup'] = json.loads(cleanup.read_text()) if cleanup.exists() else None
+ if (not result['cleanup'] or result['cleanup'].get('success') is not True
+ or helper.returncode != 0 or (native and native.returncode != 0)):
+ result['success'] = False
+ if root.exists():
+ with (root / 'run.json').open('x') as output:
+ json.dump(result, output, indent=2)
+ print(json.dumps({'success': result['success'], 'result': str(root / 'run.json'),
+ 'cleanup': result['cleanup']}), flush=True)
+ if not result['success']:
+ raise RuntimeError('Connected fixture validation or cleanup did not pass')
+
+
+if __name__ == '__main__':
+ def interrupted(_signal, _frame):
+ raise KeyboardInterrupt('Connected fixture interrupted; cleaning up owned processes')
+ signal.signal(signal.SIGTERM, interrupted)
+ parser = argparse.ArgumentParser(description=__doc__)
+ for name in ['app', 'root', 'node', 'tmux', 'sampler']:
+ parser.add_argument('--' + name, required=True, type=Path)
+ parser.add_argument('--bundle', type=Path)
+ parser.add_argument('--label', required=True)
+ parser.add_argument('--terminals', type=int, choices=range(1, 49), default=10)
+ parser.add_argument('--seconds', type=int, choices=range(5, 181), default=30)
+ parser.add_argument('--settle', type=int, choices=range(1, 31), default=5)
+ run(parser.parse_args())
diff --git a/desktop/tool/native_benchmark/connected_stack.mjs b/desktop/tool/native_benchmark/connected_stack.mjs
new file mode 100644
index 000000000..a40c66bbc
--- /dev/null
+++ b/desktop/tool/native_benchmark/connected_stack.mjs
@@ -0,0 +1,218 @@
+/** Own a private, source-built daemon and tmux server for connected resource measurements.
+ * No account, model CLI, existing terminal or installed daemon is used. The macOS sandbox
+ * additionally rejects writes outside this run and network connections outside loopback.
+ * Keep stdin open while the desktop fixture runs; EOF cleans up only these owned processes.
+ */
+import assert from 'node:assert/strict'
+import { spawn, execFile } from 'node:child_process'
+import { promisify } from 'node:util'
+import { createServer, createConnection } from 'node:net'
+import { createWriteStream } from 'node:fs'
+import { mkdir, writeFile, readFile, realpath } from 'node:fs/promises'
+import { resolve, dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { createRequire } from 'node:module'
+import { randomUUID, createHash } from 'node:crypto'
+
+const repo = resolve(dirname(fileURLToPath(import.meta.url)), '../../..')
+const require = createRequire(join(repo, 'cli/package.json'))
+const { WebSocket } = require('ws')
+const exec = promisify(execFile)
+const options = Object.fromEntries(process.argv.slice(2).map(value => {
+ const equal = value.indexOf('=')
+ assert(equal > 2, 'Use --root=NEW_DIRECTORY --tmux=ABSOLUTE_BINARY [--terminals=10]')
+ return [value.slice(2, equal), value.slice(equal + 1)]
+}))
+assert(Object.keys(options).every(key => ['root', 'tmux', 'terminals', 'bundle'].includes(key)), 'Unknown option')
+assert(process.platform === 'darwin', 'This fixture requires the macOS isolation policy')
+const root = resolve(options.root ?? '')
+assert(root.startsWith('/private/tmp/harness-connected-') && dirname(root) === '/private/tmp', 'Use a fresh /private/tmp/harness-connected-NAME root')
+const tmux = await realpath(options.tmux ?? '')
+assert(tmux.startsWith('/') && !tmux.includes('\n'), 'An absolute tmux binary is required')
+const bundle = await realpath(options.bundle ?? join(repo, 'cli/dist/cli.js'))
+const count = Number(options.terminals ?? 10)
+assert(Number.isInteger(count) && count >= 1 && count <= 48, 'Use 1–48 terminals')
+await mkdir(root, { mode: 0o700 }) // Refuse an existing run; never erase another run's evidence.
+const childHome = join(root, 'home')
+const bin = join(root, 'bin')
+for (const path of [childHome, bin, join(root, 'workspace'), join(root, 'data'), join(root, 'auth')]) {
+ await mkdir(path, { recursive: true, mode: 0o700 })
+}
+const shellQuote = text => `'${text.replaceAll("'", "'\\''")}'`
+const socket = join(root, 'tmux.sock')
+await writeFile(join(bin, 'tmux'), `#!/bin/sh\nexec ${shellQuote(tmux)} -S ${shellQuote(socket)} "$@"\n`, { mode: 0o700 })
+// A fixture must never request a real Keychain item, even if a future bootstrap adds a reader.
+await writeFile(join(bin, 'security'), '#!/bin/sh\nexit 44\n', { mode: 0o700 })
+const policy = join(root, 'isolation.sb')
+// macOS refuses to launch setuid /bin/ps inside an inherited sandbox. Production
+// discovery needs this fixed, read-only program; grant it the same narrow exec
+// exception used by Apple's sandbox profiles for system inspection tools.
+await writeFile(policy, `(version 1)\n(allow default)\n(deny file-write*)\n(allow file-write* (subpath ${JSON.stringify(root)}) (literal "/dev/null") (regex #"^/dev/(ptmx|ttys[0-9]+|tty|fd/[0-9]+)$"))\n(deny network-outbound)\n(allow network-outbound (remote ip "localhost:*") (remote unix-socket (subpath ${JSON.stringify(root)})))\n(allow process-exec (with no-sandbox) (literal "/bin/ps"))\n`, { mode: 0o600 })
+const listener = createServer()
+await new Promise((done, reject) => listener.once('error', reject).listen(0, '127.0.0.1', done))
+const port = listener.address().port
+await new Promise(done => listener.close(done))
+const machineId = randomUUID().replaceAll('-', '')
+const env = {
+ PATH: `${bin}:/usr/bin:/bin:/usr/sbin:/sbin`, LANG: 'en_US.UTF-8', LC_ALL: 'en_US.UTF-8',
+ HOME: childHome, CFFIXED_USER_HOME: childHome, ZDOTDIR: childHome, SHELL: '/bin/zsh',
+ TMPDIR: root, USER: 'harness-benchmark', LOGNAME: 'harness-benchmark', TERM: 'xterm-256color',
+ NODE_ENV: 'production', PORT: String(port), TMUX: `${socket},0,0`,
+ ADAPTER_COMPUTER_ID: machineId, ADAPTER_COMPUTER_ID_FILE: join(root, 'computer-id'),
+ ADAPTER_DATA_DIR: join(root, 'data'), HARNESS_AUTH_DIR: join(root, 'auth'),
+ ADAPTER_CLI_DIR: join(root, 'cli'), ADAPTER_RUNTIME_DIR: join(root, 'runtime'),
+ HARNESS_BIN_DIR: bin, HARNESS_LOGS_DIR: join(root, 'logs'),
+ HARNESS_LESSONS_DIR: join(root, 'lessons'), DSH_DIR: join(root, 'dsh'),
+ XDG_CONFIG_HOME: join(root, 'config'), XDG_DATA_HOME: join(root, 'share'),
+ XDG_CACHE_HOME: join(root, 'cache'),
+ BACKEND_WS_URL: 'ws://127.0.0.1:1', WEB_URL: 'http://127.0.0.1:1',
+ DISABLE_HOOK_INSTALL: 'true', DISABLE_GRID_INSTALL: 'true',
+ ADAPTER_UPDATE_DISABLE: 'true', ANALYTICS_ENABLED: 'false',
+ CABLE_DISABLE: 'true', CABLE_FW_DISABLE: 'true',
+ RECAP_WITHOUT_DEVICE: 'true', SUMMARY_MODE: 'local',
+ TERMINAL_BACKENDS: 'tmux',
+}
+for (const name of ['CLAUDE_PROJECTS_DIR', 'CLAUDE_CONFIG_DIR', 'CODEX_HOME', 'GROK_HOME',
+ 'AGY_HOME', 'AGY_CONFIG_DIR', 'COPILOT_HOME', 'CURSOR_HOME', 'CURSOR_CONFIG_DIR', 'CURSOR_DATA_DIR',
+ 'OPENCODE_DATA_DIR', 'OPENCODE_PLUGIN_DIR', 'KILO_DATA_DIR', 'KILO_PLUGIN_DIR', 'PI_HOME',
+ 'HERMES_HOME', 'COMMANDCODE_HOME', 'DEVIN_HOME', 'DEVIN_CONFIG_PATH', 'MUSE_HOME', 'MUSE_CONFIG_DIR',
+ 'AMP_PLUGIN_DIR', 'AMP_SESSIONS_DIR', 'AMP_STATE_DIR', 'ORI_CREDENTIALS_PATH']) env[name] = join(root, name.toLowerCase())
+await writeFile(join(root, 'environment.json'), JSON.stringify(env, null, 2), { mode: 0o600 })
+let daemon, connection, tmuxStart, stopping, shuttingDown = false
+const pending = new Map()
+const delay = ms => new Promise(done => setTimeout(done, ms))
+function socketListening() {
+ return new Promise((done, reject) => {
+ const probe = createConnection(socket)
+ probe.once('connect', () => { probe.destroy(); done(true) })
+ probe.once('error', error => {
+ if (['ENOENT', 'ECONNREFUSED'].includes(error.code)) done(false)
+ else reject(error)
+ })
+ probe.setTimeout(1000, () => { probe.destroy(); reject(new Error('Private tmux socket probe timed out')) })
+ })
+}
+async function cleanup(code) {
+ if (stopping) return stopping
+ shuttingDown = true
+ stopping = (async () => {
+ const errors = []
+ for (const { reject, timer } of pending.values()) { clearTimeout(timer); reject(new Error('Fixture shutting down')) }
+ pending.clear()
+ connection?.terminate()
+ if (daemon?.pid && daemon.exitCode === null && daemon.signalCode === null) {
+ try { process.kill(-daemon.pid, 'SIGTERM') } catch {}
+ for (let i = 0; i < 50 && daemon.exitCode === null && daemon.signalCode === null; i++) await delay(100)
+ if (daemon.exitCode === null && daemon.signalCode === null) {
+ try { process.kill(-daemon.pid, 'SIGKILL') } catch {}
+ for (let i = 0; i < 50 && daemon.exitCode === null && daemon.signalCode === null; i++) await delay(100)
+ }
+ if (daemon.exitCode === null && daemon.signalCode === null) errors.push('Owned daemon did not exit')
+ }
+ // If EOF arrived during creation, wait for that one owned operation before
+ // checking its socket. Startup checks shuttingDown before any further spawn.
+ await tmuxStart?.catch(() => {})
+ try {
+ if (await socketListening()) {
+ await exec(tmux, ['-S', socket, 'kill-server'], { env, timeout: 5000 })
+ for (let i = 0; i < 50 && await socketListening(); i++) await delay(100)
+ if (await socketListening()) errors.push('Owned tmux server is still listening')
+ }
+ } catch (error) { errors.push(String(error)) }
+ try {
+ await writeFile(join(root, 'cleanup.json'), JSON.stringify({
+ success: errors.length === 0, errors, daemonExit: daemon?.exitCode, daemonSignal: daemon?.signalCode,
+ isolatedSocket: socket, finishedAt: new Date().toISOString(),
+ }, null, 2), { mode: 0o600 })
+ } catch (error) {
+ errors.push(`Could not record cleanup: ${error}`)
+ console.error(errors.at(-1))
+ }
+ process.exit(errors.length ? 1 : code)
+ })()
+ return stopping
+}
+process.stdin.resume()
+process.stdin.on('end', () => { void cleanup(0) })
+for (const signal of ['SIGINT', 'SIGTERM']) process.on(signal, () => { void cleanup(0) })
+process.on('uncaughtException', error => { console.error(error); void cleanup(1) })
+process.on('unhandledRejection', error => { console.error(error); void cleanup(1) })
+const request = (type, payload = {}) => new Promise((done, reject) => {
+ const requestId = randomUUID()
+ const timer = setTimeout(() => { pending.delete(requestId); reject(new Error(`${type} timed out`)) }, 30_000)
+ pending.set(requestId, { done, reject, timer })
+ connection.send(JSON.stringify({ type, payload: { ...payload, requestId } }))
+})
+
+try {
+ tmuxStart = exec('/usr/bin/sandbox-exec', ['-f', policy, tmux, '-S', socket, '-f', '/dev/null',
+ 'new-session', '-d', '-s', 'fixture-keeper', '-x', '120', '-y', '40', '/bin/sh'], { env })
+ await tmuxStart
+ assert(!shuttingDown, 'Fixture stopped during startup')
+ daemon = spawn('/usr/bin/sandbox-exec', ['-f', policy, process.execPath, bundle, '__run'], {
+ env, cwd: join(root, 'workspace'), detached: true, stdio: ['ignore', 'pipe', 'pipe'],
+ })
+ const log = createWriteStream(join(root, 'daemon.log'), { flags: 'wx', mode: 0o600 })
+ daemon.stdout.pipe(log); daemon.stderr.pipe(log)
+ const deadline = Date.now() + 30_000
+ let status
+ while (Date.now() < deadline) {
+ assert(!shuttingDown, 'Fixture stopped during startup')
+ assert(daemon.exitCode === null && daemon.signalCode === null, 'Fixture daemon exited during startup')
+ try {
+ const response = await fetch(`http://127.0.0.1:${port}/api/status`, {
+ headers: { 'x-adapter-local': '1' }, signal: AbortSignal.timeout(1000),
+ })
+ status = await response.json()
+ if (status.discoveryReady === true) break
+ } catch {}
+ await delay(200)
+ }
+ assert(status?.discoveryReady === true && status.machineId === machineId, 'Private daemon did not become ready with its own identity')
+ assert(!shuttingDown, 'Fixture stopped during startup')
+ assert(status.pid === daemon.pid, 'Daemon port belongs to another process')
+ connection = new WebSocket(`ws://127.0.0.1:${port}/api/local-ws`)
+ connection.on('message', (raw, binary) => {
+ if (binary) return
+ const frame = JSON.parse(raw.toString()), reply = pending.get(frame.payload?.requestId)
+ if (!reply) return
+ clearTimeout(reply.timer); pending.delete(frame.payload.requestId)
+ reply.done(frame.payload)
+ })
+ await new Promise((done, reject) => { connection.once('open', done); connection.once('error', reject) })
+ const selected = new Promise((done, reject) => {
+ const timeout = setTimeout(() => reject(new Error('Private machine selection timed out')), 5000)
+ connection.on('message', function selected(raw, binary) {
+ if (!binary && JSON.parse(raw.toString()).type === 'connected') {
+ clearTimeout(timeout); connection.off('message', selected); done()
+ }
+ })
+ })
+ connection.send(JSON.stringify({ type: 'machine_select', payload: { machineId, localProtocolVersion: 1, tool: true } }))
+ await selected
+ const agents = []
+ for (let i = 0; i < count; i++) {
+ assert(!shuttingDown, 'Fixture stopped during terminal creation')
+ const result = await request('agent_create', { engine: 'terminal', cwd: join(root, 'workspace'),
+ creationId: randomUUID(), name: `Resource fixture ${i + 1}`, bypassPermission: false })
+ assert(result.state === 'created' && result.agent?.id, `Private terminal creation failed: ${JSON.stringify(result)}`)
+ agents.push(result.agent)
+ }
+ const observed = await request('agents_list')
+ assert.equal(observed.agents?.length, count, 'The isolated inventory contains unexpected agents')
+ const { stdout } = await exec(tmux, ['-S', socket, 'display-message', '-p', '#{pid}'], { env })
+ const manifest = { schema: 1, ready: true, root, machineId, port, agents,
+ daemonPid: daemon.pid, tmuxPid: Number(stdout.trim()),
+ bundleSha256: createHash('sha256').update(await readFile(bundle)).digest('hex'),
+ sourceRevision: (await exec('git', ['rev-parse', 'HEAD'], { cwd: dirname(bundle) })).stdout.trim(),
+ sourceDiffSha256: createHash('sha256').update((await exec('git',
+ ['diff', '--binary', 'HEAD', '--', '../src', '../package.json', '../package-lock.json', '../build-bundle.mjs'],
+ { cwd: dirname(bundle), maxBuffer: 10 * 1024 * 1024 })).stdout).digest('hex'),
+ startedAt: new Date().toISOString(), boundary: 'Full local daemon and tmux; private terminal shells; no cloud account or model inference.' }
+ await writeFile(join(root, 'stack.json'), JSON.stringify(manifest, null, 2), { mode: 0o600 })
+ connection.close()
+ console.log(JSON.stringify({ ready: true, root, daemonPid: daemon.pid, tmuxPid: manifest.tmuxPid, port, terminals: count }))
+} catch (error) {
+ console.error(error)
+ await cleanup(1)
+}
diff --git a/desktop/tool/native_benchmark/connected_worker.mjs b/desktop/tool/native_benchmark/connected_worker.mjs
new file mode 100644
index 000000000..8137b14a9
--- /dev/null
+++ b/desktop/tool/native_benchmark/connected_worker.mjs
@@ -0,0 +1,50 @@
+// Deterministic terminal workload; launched ONLY in a newly created fixture pane.
+import assert from 'node:assert/strict'
+import { createServer } from 'node:net'
+import { join, dirname } from 'node:path'
+import { performance } from 'node:perf_hooks'
+
+const root = process.env.HARNESS_CONNECTED_ROOT
+const index = Number(process.argv[2])
+assert(root?.startsWith('/private/tmp/harness-connected-') && dirname(root) === '/private/tmp')
+assert(process.env.HOME === join(root, 'home') && process.stdin.isTTY && process.stdout.isTTY)
+assert(Number.isInteger(index) && index >= 0 && index < 48)
+let timer, mode = 'idle-visible', ticks = 0, bytes = 0, skipped = 0, next = 0
+function write(value) { bytes += Buffer.byteLength(value); process.stdout.write(value) }
+function state() { return { pid: process.pid, index, mode, ticks, bytes, skipped, at: performance.now() } }
+function setMode(value) {
+ assert(['idle-visible', 'idle-hidden', 'active'].includes(value))
+ clearInterval(timer)
+ mode = value
+ write(value === 'idle-visible' ? '\x1b[?25h' : '\x1b[?25l')
+ if (value === 'active') {
+ next = performance.now() + 50
+ timer = setInterval(() => {
+ const now = performance.now()
+ skipped += Math.max(0, Math.floor((now - next) / 50))
+ next = now + 50
+ ticks++
+ write('\x1b[H' + Array.from({ length: 8 }, (_, row) =>
+ `\x1b[${row % 2 ? 36 : 32}mRESOURCE ${index} FRAME ${ticks} ROW ${row} deterministic output\x1b[0m\x1b[K\r\n`).join(''))
+ }, 50)
+ }
+}
+process.stdin.setRawMode(true)
+process.stdin.resume()
+process.stdin.on('data', value => write(value.toString()))
+write(Array.from({ length: 1000 }, (_, row) => `${row} resource fixture ${index} retained terminal output\r\n`).join(''))
+write(`RESOURCE ${index} READY\r\n`)
+createServer(socket => {
+ let input = ''
+ socket.on('data', chunk => {
+ input += chunk
+ assert(input.length < 4096, 'Oversized fixture command')
+ const end = input.indexOf('\n')
+ if (end < 0) return
+ try {
+ const command = JSON.parse(input.slice(0, end))
+ if (command.mode) setMode(command.mode)
+ socket.end(JSON.stringify({ success: true, ...state() }) + '\n')
+ } catch (error) { socket.end(JSON.stringify({ success: false, error: String(error) }) + '\n') }
+ })
+}).listen(join(root, `worker-${index}.sock`))
diff --git a/desktop/tool/native_benchmark/prepare.py b/desktop/tool/native_benchmark/prepare.py
index 0834c83c6..f95b9dfa9 100644
--- a/desktop/tool/native_benchmark/prepare.py
+++ b/desktop/tool/native_benchmark/prepare.py
@@ -1,6 +1,7 @@
#!/usr/bin/env python3
"""Build an isolated Release benchmark; never rewrite the user's V2 bundle."""
import argparse
+import hashlib
import json
import os
from pathlib import Path
@@ -12,6 +13,8 @@ from isolation import benchmark_configuration, validate_benchmark_bundle
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('--flutter', required=True, type=Path)
+parser.add_argument('--source', type=Path,
+ help='Desktop source directory for a controlled baseline; tooling always comes from this checkout')
mode = parser.add_mutually_exclusive_group()
mode.add_argument('--interactive', action='store_true',
help='Build a disposable app for manual feature checks through normal input')
@@ -21,6 +24,8 @@ mode.add_argument('--primary-workflows', action='store_true',
help='Benchmark Cmd+N/O/T and tab switching with varied input phase')
mode.add_argument('--core-workflows', action='store_true',
help='Validate and measure typing, navigation, search, and scrolling at idle and under output')
+mode.add_argument('--connected-resource', action='store_true',
+ help='Build the real signed-out workspace for a private connected_stack.mjs run')
parser.add_argument('--terminals', type=int, choices=[1, 16, 48], default=16)
parser.add_argument('--samples', type=int, default=120)
parser.add_argument('--hold', action='store_true', help='Keep core fixture open after measurements for process resource sampling')
@@ -29,16 +34,28 @@ if not 1 <= args.samples <= 500:
parser.error('--samples must be 1–500')
if args.hold and not args.core_workflows:
parser.error('--hold requires --core-workflows')
-source = Path(__file__).resolve().parents[2]
+tool_source = Path(__file__).resolve().parent
+source = (args.source or tool_source.parents[1]).resolve()
+if not (source / 'pubspec.yaml').is_file() or not (source / 'lib/main.dart').is_file():
+ parser.error('--source must be a Harness desktop source directory')
root = Path(tempfile.mkdtemp(prefix='harness-native-benchmark-', dir='/private/tmp'))
desktop = root / 'desktop'
shutil.copytree(source, desktop, ignore=shutil.ignore_patterns('build', '.dart_tool', 'ephemeral', '.DS_Store'))
+if source != tool_source.parents[1]:
+ shutil.copytree(tool_source, desktop / 'tool/native_benchmark', dirs_exist_ok=True,
+ ignore=shutil.ignore_patterns('__pycache__'))
window = desktop / 'macos/Runner/MainFlutterWindow.swift'
code = window.read_text()
marker = ' super.awakeFromNib()'
if code.count(marker) != 1:
raise RuntimeError('Native benchmark insertion point changed')
-code = code.replace(marker, ' NativeBenchmark.install(window: self, messenger: flutterViewController.engine.binaryMessenger)\n' + marker)
+host = 'ConnectedResourceHost' if args.connected_resource else 'NativeBenchmark'
+code = code.replace(marker, f' {host}.install(window: self, messenger: flutterViewController.engine.binaryMessenger)\n' + marker)
+if args.connected_resource:
+ engine = ' let flutterViewController = FlutterViewController()'
+ if code.count(engine) != 1:
+ raise RuntimeError('Connected fixture startup insertion point changed')
+ code = code.replace(engine, ' ConnectedResourceHost.validateEnvironment()\n' + engine)
if args.interactive or args.flutter_dispatch or args.primary_workflows or args.core_workflows:
# Only this copied host gets fixture state. Launching through normal app
# controls needs no shell environment and never opens a real transport.
@@ -59,7 +76,7 @@ if args.interactive or args.flutter_dispatch or args.primary_workflows or args.c
if code.count(engine) != 1:
raise RuntimeError('Native fixture startup insertion point changed')
code = code.replace(engine, setup + '\n' + engine)
-code += '\n' + (source / 'tool/native_benchmark/NativeBenchmark.swift').read_text()
+code += '\n' + (tool_source / f'{host}.swift').read_text()
window.write_text(code)
if args.core_workflows:
(root / 'run-config.json').write_text(json.dumps({
@@ -77,10 +94,26 @@ with log.open('w') as output:
subprocess.run(command, cwd=desktop, env=env, stdout=output, stderr=subprocess.STDOUT, check=True)
run([flutter, '--suppress-analytics', 'config', '--enable-swift-package-manager'])
run([flutter, '--suppress-analytics', 'pub', 'get', '--offline'])
- run([flutter, '--suppress-analytics', 'build', 'macos', '--release', '--config-only', '--no-pub', '--target', 'tool/native_benchmark/main.dart'])
+ entry = 'connected_main.dart' if args.connected_resource else 'main.dart'
+ revision = subprocess.check_output(['git', 'rev-parse', 'HEAD'], cwd=source, text=True).strip()
+ run([flutter, '--suppress-analytics', 'build', 'macos', '--release', '--config-only', '--no-pub',
+ '--dart-define', f'CONNECTED_SOURCE_REVISION={revision}',
+ '--target', f'tool/native_benchmark/{entry}'])
run(['xcodebuild', '-workspace', 'macos/Runner.xcworkspace', '-scheme', 'Runner', '-configuration', 'Release', '-derivedDataPath', 'build/macos', '-destination', 'platform=macOS,arch=arm64', 'CODE_SIGN_IDENTITY=-', 'CODE_SIGN_STYLE=Manual', 'DEVELOPMENT_TEAM=', 'OTHER_CODE_SIGN_FLAGS=', 'ENABLE_HARDENED_RUNTIME=NO', 'build'])
app = desktop / 'build/macos/Build/Products/Release/Harness Benchmark.app'
if not app.exists():
raise RuntimeError('Expected isolated bundle was not built')
validate_benchmark_bundle(app)
+production_diff = subprocess.check_output(
+ ['git', 'diff', '--binary', 'HEAD', '--', 'lib', 'macos', 'packages', 'third_party', 'pubspec.yaml', 'pubspec.lock'], cwd=source)
+(root / 'production-source.patch').write_bytes(production_diff)
+(root / 'build-identity.json').write_text(json.dumps({
+ 'sourceRevision': revision,
+ 'productionDiffSha256': hashlib.sha256(production_diff).hexdigest(),
+ 'source': str(source), 'app': str(app), 'connectedResource': args.connected_resource,
+ 'flutter': str(args.flutter.resolve()),
+ 'developerDirectory': env.get('DEVELOPER_DIR'),
+ 'toolingSha256': {file.name: hashlib.sha256(file.read_bytes()).hexdigest()
+ for file in tool_source.iterdir() if file.is_file()},
+}, indent=2) + '\n')
print(f'BENCHMARK_APP={app}', flush=True)
diff --git a/desktop/tool/native_benchmark/process_forest_usage.swift b/desktop/tool/native_benchmark/process_forest_usage.swift
new file mode 100644
index 000000000..3ab788632
--- /dev/null
+++ b/desktop/tool/native_benchmark/process_forest_usage.swift
@@ -0,0 +1,205 @@
+// Read-only resource accounting for owned app/daemon/tmux roots and descendants.
+// Includes kernel-accounted exited children, so short-lived ps/git helpers count.
+import Foundation
+import Darwin
+
+func fail(_ text: String) -> Never {
+ FileHandle.standardError.write(Data((text + "\n").utf8))
+ exit(1)
+}
+let args = CommandLine.arguments
+guard args.count == 5, let duration = Int(args[2]), (5...1800).contains(duration) else {
+ fail("Usage: process_forest_usage PID[,PID...] SECONDS(5–1800) LABEL NEW_OUTPUT.json")
+}
+let roots = args[1].split(separator: ",").compactMap { Int32($0) }
+guard !roots.isEmpty, roots.count == args[1].split(separator: ",").count,
+ roots.allSatisfy({ $0 > 1 }), Set(roots).count == roots.count else {
+ fail("Expected distinct, valid owned root PIDs")
+}
+guard !FileManager.default.fileExists(atPath: args[4]) else { fail("Output already exists") }
+
+var timebase = mach_timebase_info_data_t()
+guard mach_timebase_info(&timebase) == KERN_SUCCESS, timebase.denom > 0 else { fail("No Mach timebase") }
+let began = ProcessInfo.processInfo.systemUptime
+let startedAt = ISO8601DateFormatter().string(from: Date())
+var rootBirths: [Int32: UInt64] = [:]
+
+struct ProcessRow: Codable {
+ let pid: Int32
+ let ppid: UInt32
+ let root: Int32
+ let birthTicks: UInt64
+ let exitTicks: UInt64
+ let userTicks: UInt64
+ let systemTicks: UInt64
+ let childUserTicks: UInt64
+ let childSystemTicks: UInt64
+ let footprintBytes: UInt64
+ let residentBytes: UInt64
+ let interruptWakeups: UInt64
+ let childInterruptWakeups: UInt64
+ let packageIdleWakeups: UInt64
+ let childPackageIdleWakeups: UInt64
+ let diskReadBytes: UInt64
+ let diskWriteBytes: UInt64
+}
+struct Sample: Codable {
+ let elapsedSeconds: Double
+ let processes: [ProcessRow]
+ var cpuTicks: UInt64 { processes.reduce(0) { $0 + $1.userTicks + $1.systemTicks + $1.childUserTicks + $1.childSystemTicks } }
+ var interrupts: UInt64 { processes.reduce(0) { $0 + $1.interruptWakeups + $1.childInterruptWakeups } }
+ var packageIdle: UInt64 { processes.reduce(0) { $0 + $1.packageIdleWakeups + $1.childPackageIdleWakeups } }
+ var footprint: UInt64 { processes.reduce(0) { $0 + $1.footprintBytes } }
+}
+
+struct ProcessIdentity {
+ let ppid: Int32
+ let startSeconds: Int
+ let startMicros: Int32
+}
+
+func inventory() -> [Int32: ProcessIdentity] {
+ // proc_listallpids omits zombies. Their final CPU still belongs to them
+ // until the parent reaps them and the kernel rolls it into ri_child_*.
+ // KERN_PROC_ALL includes that interval; omitting it makes totals regress.
+ var mib: [Int32] = [CTL_KERN, KERN_PROC, KERN_PROC_ALL, 0]
+ var bytes = 0
+ guard sysctl(&mib, u_int(mib.count), nil, &bytes, nil, 0) == 0 else { fail("Could not size process inventory") }
+ var capacity = max(512, bytes / MemoryLayout<kinfo_proc>.stride + 256)
+ for _ in 0..<3 {
+ var processes = [kinfo_proc](repeating: kinfo_proc(), count: capacity)
+ bytes = capacity * MemoryLayout<kinfo_proc>.stride
+ let status = processes.withUnsafeMutableBufferPointer {
+ sysctl(&mib, u_int(mib.count), $0.baseAddress, &bytes, nil, 0)
+ }
+ if status != 0 && errno == ENOMEM { capacity *= 2; continue }
+ guard status == 0, bytes % MemoryLayout<kinfo_proc>.stride == 0 else { fail("Could not enumerate processes") }
+ var result: [Int32: ProcessIdentity] = [:]
+ for info in processes.prefix(bytes / MemoryLayout<kinfo_proc>.stride) where info.kp_proc.p_pid > 1 {
+ let start = info.kp_proc.p_un.__p_starttime
+ result[info.kp_proc.p_pid] = ProcessIdentity(
+ ppid: info.kp_eproc.e_ppid, startSeconds: start.tv_sec, startMicros: start.tv_usec)
+ }
+ return result
+ }
+ fail("Process inventory would be truncated")
+}
+
+func owned(_ all: [Int32: ProcessIdentity]) -> [Int32: Int32] {
+ guard roots.allSatisfy({ all[$0] != nil }) else { fail("Owned root exited or is unreadable") }
+ var owners = Dictionary(uniqueKeysWithValues: roots.map { ($0, $0) })
+ var changed = true
+ while changed {
+ changed = false
+ for (id, info) in all {
+ if let parentRoot = owners[info.ppid] {
+ if roots.contains(id) { fail("Root trees overlap; refusing to double-count") }
+ if owners[id] == nil { owners[id] = parentRoot; changed = true }
+ }
+ }
+ }
+ return owners
+}
+
+func sample() -> Sample {
+ // Reject a torn snapshot: a child can exit and transfer its counters to its
+ // parent between reads. Stable membership/birth stamps bracket each read.
+ for _ in 0..<10 {
+ let before = inventory()
+ let owners = owned(before)
+ var rows: [ProcessRow] = []
+ var missed = false
+ for id in owners.keys.sorted() {
+ var u = rusage_info_v4()
+ let status = withUnsafeMutablePointer(to: &u) { pointer in
+ pointer.withMemoryRebound(to: rusage_info_t?.self, capacity: 1) {
+ proc_pid_rusage(id, RUSAGE_INFO_V4, $0)
+ }
+ }
+ if status != 0 { missed = true; break }
+ if roots.contains(id) {
+ if u.ri_proc_exit_abstime != 0 { fail("Owned root exited") }
+ if let birth = rootBirths[id], birth != u.ri_proc_start_abstime { fail("Owned root PID was reused") }
+ rootBirths[id] = u.ri_proc_start_abstime
+ }
+ rows.append(ProcessRow(
+ pid: id, ppid: UInt32(before[id]!.ppid), root: owners[id]!, birthTicks: u.ri_proc_start_abstime,
+ exitTicks: u.ri_proc_exit_abstime,
+ userTicks: u.ri_user_time, systemTicks: u.ri_system_time,
+ childUserTicks: u.ri_child_user_time, childSystemTicks: u.ri_child_system_time,
+ footprintBytes: u.ri_proc_exit_abstime == 0 ? u.ri_phys_footprint : 0,
+ residentBytes: u.ri_proc_exit_abstime == 0 ? u.ri_resident_size : 0,
+ interruptWakeups: u.ri_interrupt_wkups, childInterruptWakeups: u.ri_child_interrupt_wkups,
+ packageIdleWakeups: u.ri_pkg_idle_wkups, childPackageIdleWakeups: u.ri_child_pkg_idle_wkups,
+ diskReadBytes: u.ri_diskio_bytesread, diskWriteBytes: u.ri_diskio_byteswritten))
+ }
+ let after = inventory()
+ let same = owners == owned(after) && owners.keys.allSatisfy {
+ before[$0]?.startSeconds == after[$0]?.startSeconds
+ && before[$0]?.startMicros == after[$0]?.startMicros
+ }
+ if !missed && same {
+ return Sample(elapsedSeconds: ProcessInfo.processInfo.systemUptime - began, processes: rows)
+ }
+ Thread.sleep(forTimeInterval: 0.02)
+ }
+ fail("Could not capture stable process membership; preserve this failed run")
+}
+
+var samples = [sample()]
+FileHandle.standardError.write(Data("Sampling owned forest \(roots) for \(duration) seconds\n".utf8))
+for tick in 1...duration {
+ let remaining = began + Double(tick) - ProcessInfo.processInfo.systemUptime
+ if remaining > 0 { Thread.sleep(forTimeInterval: remaining) }
+ let current = sample()
+ let previous = samples.last!
+ guard current.cpuTicks >= previous.cpuTicks,
+ current.interrupts >= previous.interrupts,
+ current.packageIdle >= previous.packageIdle else {
+ let rejected: [String: Any] = [
+ "schema": 1, "success": false, "roots": roots, "label": args[3], "startedAt": startedAt,
+ "error": "Forest counters regressed",
+ "cpuClock": ["timebaseNumer": timebase.numer, "timebaseDenom": timebase.denom],
+ "samples": try JSONSerialization.jsonObject(with: JSONEncoder().encode(samples + [current])),
+ ]
+ let output = try JSONSerialization.data(withJSONObject: rejected, options: [.prettyPrinted, .sortedKeys])
+ let descriptor = open(args[4], O_WRONLY | O_CREAT | O_EXCL, mode_t(0o600))
+ if descriptor >= 0 {
+ let handle = FileHandle(fileDescriptor: descriptor, closeOnDealloc: true)
+ try handle.write(contentsOf: output)
+ try handle.close()
+ }
+ fail("Forest counters regressed (process escape or accounting race); measurement rejected")
+ }
+ samples.append(current)
+}
+let first = samples.first!, last = samples.last!
+let elapsed = last.elapsedSeconds - first.elapsedSeconds
+let cpuSeconds = Double(last.cpuTicks - first.cpuTicks) * Double(timebase.numer) / Double(timebase.denom) / 1e9
+let footprints = samples.map { Double($0.footprint) / 1_048_576 }.sorted()
+let summary: [String: Any] = [
+ "elapsedSeconds": elapsed, "cpuSeconds": cpuSeconds,
+ "cpuPercentOneCore": cpuSeconds / elapsed * 100,
+ "summedPhysicalFootprintMiBMedian": footprints[footprints.count / 2],
+ "summedPhysicalFootprintMiBPeak": footprints.last!,
+ "processCountMin": samples.map { $0.processes.count }.min()!,
+ "processCountMax": samples.map { $0.processes.count }.max()!,
+ "liveProcessCountMin": samples.map { $0.processes.filter { $0.exitTicks == 0 }.count }.min()!,
+ "liveProcessCountMax": samples.map { $0.processes.filter { $0.exitTicks == 0 }.count }.max()!,
+ "interruptWakeupsPerSecond": Double(last.interrupts - first.interrupts) / elapsed,
+ "packageIdleWakeupsPerSecond": Double(last.packageIdle - first.packageIdle) / elapsed,
+]
+let output: [String: Any] = [
+ "schema": 1, "success": true, "roots": roots, "label": args[3], "startedAt": startedAt,
+ "boundary": "Owned live process trees plus kernel-accounted exited children. CPU 100% = one core. No GPU energy, battery discharge or escaped/reparented workers. Summed process footprints can include shared mappings.",
+ "cpuClock": ["unit": "mach_absolute_time", "timebaseNumer": timebase.numer, "timebaseDenom": timebase.denom] as [String: Any],
+ "summary": summary,
+ "samples": try JSONSerialization.jsonObject(with: JSONEncoder().encode(samples)),
+]
+let data = try JSONSerialization.data(withJSONObject: output, options: [.prettyPrinted, .sortedKeys])
+let fd = open(args[4], O_WRONLY | O_CREAT | O_EXCL, mode_t(0o600))
+guard fd >= 0 else { fail("Could not create fresh output; previous evidence is preserved") }
+let handle = FileHandle(fileDescriptor: fd, closeOnDealloc: true)
+try handle.write(contentsOf: data)
+try handle.close()
+print(String(data: try JSONSerialization.data(withJSONObject: summary, options: [.sortedKeys]), encoding: .utf8)!)
diff --git a/desktop/tool/native_benchmark/test_connected_stack.py b/desktop/tool/native_benchmark/test_connected_stack.py
new file mode 100644
index 000000000..d1de3c129
--- /dev/null
+++ b/desktop/tool/native_benchmark/test_connected_stack.py
@@ -0,0 +1,132 @@
+"""Exercise fixture ownership and cleanup without touching installed sessions.
+
+Build cli/dist/cli.js first. Set HARNESS_BENCH_NODE and HARNESS_BENCH_TMUX to
+absolute pinned executables, or let this test resolve node/tmux on PATH.
+Failed and successful run receipts are retained in /private/tmp.
+"""
+import json
+import os
+from pathlib import Path
+import shutil
+import socket
+import subprocess
+import sys
+import time
+from types import SimpleNamespace
+import unittest
+from unittest.mock import patch
+import uuid
+
+import connected_run
+
+
+class ConnectedRunnerPreflightTests(unittest.TestCase):
+ def test_missing_sampler_never_starts_the_stack(self):
+ root = Path('/private/tmp') / ('harness-connected-preflight-' + uuid.uuid4().hex)
+ args = SimpleNamespace(
+ root=root, app=Path('/private/tmp/harness-native-benchmark-not-built/Fixture.app'),
+ node=Path('/usr/bin/false'), tmux=Path('/usr/bin/false'),
+ sampler=root / 'missing-sampler', terminals=1, bundle=None, label='preflight',
+ )
+ with patch.object(connected_run, 'validate_benchmark_bundle'), \
+ patch.object(connected_run.subprocess, 'Popen') as spawn:
+ with self.assertRaises(FileNotFoundError):
+ connected_run.run(args)
+ spawn.assert_not_called()
+ self.assertFalse(root.exists())
+
+
[email protected](sys.platform == 'darwin', 'macOS fixture isolation')
+class ConnectedStackTests(unittest.TestCase):
+ def setUp(self):
+ self.root = Path('/private/tmp') / ('harness-connected-lifecycle-' + uuid.uuid4().hex)
+ self.command = [
+ os.environ.get('HARNESS_BENCH_NODE') or shutil.which('node'),
+ str(Path(__file__).with_name('connected_stack.mjs')),
+ '--root=' + str(self.root),
+ '--tmux=' + str(Path(os.environ.get('HARNESS_BENCH_TMUX') or shutil.which('tmux')).resolve()),
+ '--terminals=1',
+ ]
+
+ def start(self):
+ env = dict(os.environ, HARNESS_FIXTURE_SECRET_SENTINEL='not-a-real-secret',
+ CODEX_HOME='/private/tmp/not-the-fixture-profile')
+ child = subprocess.Popen(self.command, stdin=subprocess.PIPE, stdout=subprocess.PIPE,
+ stderr=subprocess.PIPE, text=True, env=env)
+ self.addCleanup(self.stop, child)
+ return child
+
+ @staticmethod
+ def stop(child):
+ if child.poll() is None:
+ if not child.stdin.closed:
+ child.stdin.close()
+ try:
+ child.wait(timeout=15)
+ except subprocess.TimeoutExpired:
+ child.terminate()
+ child.wait(timeout=15)
+ for pipe in [child.stdin, child.stdout, child.stderr]:
+ if not pipe.closed:
+ pipe.close()
+
+ def wait_for(self, name, child):
+ path = self.root / name
+ deadline = time.monotonic() + 45
+ while not path.exists():
+ self.assertIsNone(child.poll(), f'Fixture exited before {name}')
+ self.assertLess(time.monotonic(), deadline, f'Waiting for {name}')
+ time.sleep(0.05)
+ return path
+
+ def assert_stopped(self, child, had_daemon=False):
+ child.wait(timeout=15)
+ errors = child.stderr.read()
+ self.assertEqual(child.returncode, 0, errors)
+ cleanup = json.loads((self.root / 'cleanup.json').read_text())
+ self.assertTrue(cleanup['success'], cleanup)
+ self.assertEqual(cleanup['errors'], [])
+ if had_daemon:
+ self.assertEqual(cleanup['daemonExit'], 0)
+ with socket.socket(socket.AF_UNIX) as probe:
+ with self.assertRaises((FileNotFoundError, ConnectionRefusedError)):
+ probe.connect(str(self.root / 'tmux.sock'))
+
+ def test_eof_during_startup_cleans_up_pending_tmux_creation(self):
+ child = self.start()
+ child.stdin.close()
+ self.assert_stopped(child)
+
+ def test_eof_after_ready_stops_only_the_private_stack(self):
+ child = self.start()
+ stack = json.loads(self.wait_for('stack.json', child).read_text())
+ self.assertEqual(len(stack['agents']), 1)
+ env = json.loads((self.root / 'environment.json').read_text())
+ self.assertNotIn('HARNESS_FIXTURE_SECRET_SENTINEL', env)
+ self.assertEqual(env['HOME'], str(self.root / 'home'))
+ self.assertEqual(env['CODEX_HOME'], str(self.root / 'codex_home'))
+ self.assertEqual(env['TMUX'].split(',')[0], str(self.root / 'tmux.sock'))
+ child.stdin.close()
+ self.assert_stopped(child, had_daemon=True)
+
+ def test_sigterm_during_daemon_startup_cleans_up(self):
+ child = self.start()
+ self.wait_for('daemon.log', child)
+ child.terminate()
+ self.assert_stopped(child)
+
+ def test_existing_root_is_refused_and_preserved(self):
+ self.root.mkdir(mode=0o700)
+ sentinel = self.root / 'preserve-me'
+ sentinel.write_text('existing evidence')
+ child = self.start()
+ child.stdin.close()
+ child.wait(timeout=5)
+ self.assertNotEqual(child.returncode, 0)
+ self.assertEqual(sentinel.read_text(), 'existing evidence')
+ self.assertFalse((self.root / 'tmux.sock').exists())
+ self.assertFalse((self.root / 'daemon.log').exists())
+
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/desktop/tool/native_benchmark/test_process_forest_usage.py b/desktop/tool/native_benchmark/test_process_forest_usage.py
new file mode 100644
index 000000000..d13a9e3a2
--- /dev/null
+++ b/desktop/tool/native_benchmark/test_process_forest_usage.py
@@ -0,0 +1,131 @@
+"""Calibrate live and exited-child CPU against independent getrusage counters."""
+import json
+import os
+from pathlib import Path
+import select
+import subprocess
+import sys
+import tempfile
+import unittest
+
+
+CHILD = """
+import resource, sys, time
+end = time.monotonic() + 1.2
+while time.monotonic() < end:
+ pass
+"""
+WORKER = r"""
+import json, os, resource, subprocess, sys, time
+sys.stdin.readline()
+before = resource.getrusage(resource.RUSAGE_SELF)
+children_before = resource.getrusage(resource.RUSAGE_CHILDREN)
+if sys.argv[1] == 'descendants':
+ # One live child persists across a sample. Other children live for less
+ # than one sampling interval and must still count after being reaped.
+ for index in range(3):
+ subprocess.run([sys.executable, '-c', sys.argv[2].replace('1.2', '1.2' if index == 0 else '0.35')], check=True)
+elif sys.argv[1] == 'unreaped':
+ child = subprocess.Popen([sys.executable, '-c', sys.argv[2]])
+ # Retain a zombie across two samples. Its CPU has not been transferred to
+ # the parent's child counters yet, but must never disappear from the sum.
+ time.sleep(3.3)
+ child.wait()
+else:
+ time.sleep(2)
+after = resource.getrusage(resource.RUSAGE_SELF)
+children_after = resource.getrusage(resource.RUSAGE_CHILDREN)
+print(json.dumps({'cpuSeconds':
+ after.ru_utime + after.ru_stime - before.ru_utime - before.ru_stime +
+ children_after.ru_utime + children_after.ru_stime - children_before.ru_utime - children_before.ru_stime
+}), flush=True)
+sys.stdin.read()
+"""
+
+
[email protected](sys.platform == 'darwin', 'macOS accounting APIs')
+class ForestUsageTests(unittest.TestCase):
+ @classmethod
+ def setUpClass(cls):
+ cls.temp = tempfile.TemporaryDirectory(prefix='harness-forest-calibration-')
+ cls.root = Path(cls.temp.name)
+ cls.sampler = cls.root / 'sampler'
+ subprocess.run(['xcrun', 'swiftc', str(Path(__file__).with_name('process_forest_usage.swift')),
+ '-o', str(cls.sampler)], check=True, capture_output=True, timeout=60)
+
+ @classmethod
+ def tearDownClass(cls):
+ cls.temp.cleanup()
+
+ def measure(self, mode):
+ output = self.root / (mode + '.json')
+ worker = subprocess.Popen([sys.executable, '-u', '-c', WORKER, mode, CHILD],
+ stdin=subprocess.PIPE, stdout=subprocess.PIPE,
+ stderr=subprocess.PIPE, text=True)
+ sampler = subprocess.Popen([str(self.sampler), str(worker.pid), '5', mode, str(output)],
+ stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+ try:
+ self.assertTrue(select.select([sampler.stderr], [], [], 5)[0])
+ self.assertTrue(sampler.stderr.readline().startswith('Sampling owned forest '))
+ worker.stdin.write('start\n'); worker.stdin.flush()
+ _, error = sampler.communicate(timeout=12)
+ self.assertEqual(sampler.returncode, 0, error)
+ stdout, error = worker.communicate(timeout=5)
+ self.assertEqual(worker.returncode, 0, error)
+ independent = json.loads(stdout)
+ measured = json.loads(output.read_text())
+ print(json.dumps({'mode': mode, 'independent': independent,
+ 'measured': measured['summary'], 'clock': measured['cpuClock']}), flush=True)
+ return independent, measured
+ finally:
+ for process in [sampler, worker]:
+ if process.poll() is None:
+ process.kill(); process.communicate(timeout=5)
+
+ def test_live_and_reaped_children_match_independent_cpu(self):
+ independent, measured = self.measure('descendants')
+ actual = independent['cpuSeconds']
+ self.assertGreater(actual, 0.5)
+ self.assertAlmostEqual(measured['summary']['cpuSeconds'], actual,
+ delta=max(0.06, actual * 0.1))
+ self.assertGreater(measured['summary']['processCountMax'], 1)
+ self.assertEqual(measured['summary']['processCountMin'], 1)
+
+ def test_idle_tree_is_quiet(self):
+ independent, measured = self.measure('idle')
+ self.assertLess(independent['cpuSeconds'], 0.05)
+ self.assertLess(measured['summary']['cpuSeconds'], 0.2)
+
+ def test_unreaped_child_keeps_its_cpu_until_parent_collects_it(self):
+ independent, measured = self.measure('unreaped')
+ actual = independent['cpuSeconds']
+ self.assertGreater(actual, 0.5)
+ self.assertAlmostEqual(measured['summary']['cpuSeconds'], actual,
+ delta=max(0.06, actual * 0.1))
+ zombies = [row for sample in measured['samples'] for row in sample['processes']
+ if row['exitTicks'] != 0]
+ self.assertTrue(zombies, 'Calibration must include the unreaped interval')
+ self.assertTrue(all(row['footprintBytes'] == 0 for row in zombies))
+
+ def test_overlapping_roots_are_rejected(self):
+ child = subprocess.Popen([sys.executable, '-c', 'import time; time.sleep(10)'])
+ try:
+ result = subprocess.run([str(self.sampler), f'{os.getpid()},{child.pid}', '5',
+ 'overlap', str(self.root / 'overlap.json')],
+ capture_output=True, text=True, timeout=5)
+ self.assertNotEqual(result.returncode, 0)
+ self.assertIn('overlap', result.stderr)
+ finally:
+ child.terminate(); child.wait(timeout=5)
+
+ def test_existing_evidence_is_preserved(self):
+ output = self.root / 'existing.json'
+ output.write_text('original evidence')
+ result = subprocess.run([str(self.sampler), str(os.getpid()), '5', 'existing', str(output)],
+ capture_output=True, text=True, timeout=5)
+ self.assertNotEqual(result.returncode, 0)
+ self.assertEqual(output.read_text(), 'original evidence')
+
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/docs/performance/2026-10-02-connected-workspace-resources.json b/docs/performance/2026-10-02-connected-workspace-resources.json
new file mode 100644
index 000000000..43f557511
--- /dev/null
+++ b/docs/performance/2026-10-02-connected-workspace-resources.json
@@ -0,0 +1,10591 @@
+{
+ "schema": 1,
+ "success": true,
+ "measurement": "Connected signed-out local workspace resources",
+ "sourceRevision": "c966e1ac0e10d2741bad53352fcdba9b41d2a6de",
+ "baseline": "Same source with production changes of PRs 628, 631, 633 and 648 reversed",
+ "baselineCombinedPatchSha256": "cdcd1d9488f4713549a386cc67455a1487bb19edd4541681f0182691b09a4688",
+ "boundary": "Release desktop + local daemon + private tmux and deterministic terminal workers; 10 sessions, 4 visible panes; 3 paired trials, 30s per phase",
+ "exclusions": [
+ "Signed-in account, remote machines and cloud model work",
+ "Installer/update acquisition and ownership-triggered daemon restart",
+ "GPU energy, WindowServer/system service costs, battery discharge and macOS energy classification"
+ ],
+ "hardware": {
+ "model": "Mac14,6",
+ "ramBytes": 68719476736,
+ "logicalCPUs": 12,
+ "power": "AC; battery fully charged"
+ },
+ "cpuClock": {
+ "timebaseNumer": 125,
+ "timebaseDenom": 3,
+ "unit": "mach_absolute_time"
+ },
+ "summary": {
+ "foreground-idle-visible": {
+ "cpuPercentOneCore": {
+ "values": {
+ "baseline": [
+ 5.1832550253263365,
+ 5.199710410963612,
+ 5.701732241807247
+ ],
+ "current": [
+ 5.4146227921549315,
+ 5.881817854292955,
+ 5.752423756158272
+ ]
+ },
+ "median": {
+ "baseline": 5.199710410963612,
+ "current": 5.752423756158272
+ },
+ "changePercent": 10.629694762024865,
+ "pairedChangesPercent": [
+ 4.4637542566994926,
+ 13.11818138739258,
+ 0.8890546276329125
+ ]
+ },
+ "interruptWakeupsPerSecond": {
+ "values": {
+ "baseline": [
+ 28.63340022413782,
+ 28.4304566844214,
+ 28.868930431869693
+ ],
+ "current": [
+ 27.494388395329242,
+ 26.6291188314537,
+ 28.398680802383993
+ ]
+ },
+ "median": {
+ "baseline": 28.63340022413782,
+ "current": 27.494388395329242
+ },
+ "changePercent": -3.9779132757289393,
+ "pairedChangesPercent": [
+ -3.9779132757289393,
+ -6.3359441354128965,
+ -1.6289125452551234
+ ]
+ },
+ "summedPhysicalFootprintMiBMedian": {
+ "values": {
+ "baseline": [
+ 514.331184387207,
+ 507.8778305053711,
+ 486.0810012817383
+ ],
+ "current": [
+ 485.00303649902344,
+ 509.29993438720703,
+ 483.8938674926758
+ ]
+ },
+ "median": {
+ "baseline": 507.8778305053711,
+ "current": 485.00303649902344
+ },
+ "changePercent": -4.503995376916881,
+ "pairedChangesPercent": [
+ -5.7021912686718075,
+ 0.2800090487156792,
+ -0.4499525353377942
+ ]
+ }
+ },
+ "foreground-idle-hidden": {
+ "cpuPercentOneCore": {
+ "values": {
+ "baseline": [
+ 4.65025906355759,
+ 4.1723402490880055,
+ 4.751851033981446
+ ],
+ "current": [
+ 3.840327153496184,
+ 3.6928782155403654,
+ 3.905265058679385
+ ]
+ },
+ "median": {
+ "baseline": 4.65025906355759,
+ "current": 3.840327153496184
+ },
+ "changePercent": -17.416920197168174,
+ "pairedChangesPercent": [
+ -17.416920197168174,
+ -11.49144137160054,
+ -17.81591992779139
+ ]
+ },
+ "interruptWakeupsPerSecond": {
+ "values": {
+ "baseline": [
+ 28.167363456797325,
+ 27.93504416079557,
+ 27.997488936317534
+ ],
+ "current": [
+ 15.566008289374722,
+ 15.297426038092624,
+ 15.397946106464424
+ ]
+ },
+ "median": {
+ "baseline": 27.997488936317534,
+ "current": 15.397946106464424
+ },
+ "changePercent": -45.00240310304881,
+ "pairedChangesPercent": [
+ -44.737432336364634,
+ -45.23929888909485,
+ -45.00240310304881
+ ]
+ },
+ "summedPhysicalFootprintMiBMedian": {
+ "values": {
+ "baseline": [
+ 518.5344009399414,
+ 492.2528762817383,
+ 478.00303649902344
+ ],
+ "current": [
+ 447.6905822753906,
+ 472.8312759399414,
+ 447.72212982177734
+ ]
+ },
+ "median": {
+ "baseline": 492.2528762817383,
+ "current": 447.72212982177734
+ },
+ "changePercent": -9.046315137115425,
+ "pairedChangesPercent": [
+ -13.662317974686545,
+ -3.945451875974626,
+ -6.334877472542577
+ ]
+ }
+ },
+ "foreground-active": {
+ "cpuPercentOneCore": {
+ "values": {
+ "baseline": [
+ 29.110023372961148,
+ 31.953996512020023,
+ 31.864468515422956
+ ],
+ "current": [
+ 31.620440932261136,
+ 34.011475830870204,
+ 33.506065870386635
+ ]
+ },
+ "median": {
+ "baseline": 31.864468515422956,
+ "current": 33.506065870386635
+ },
+ "changePercent": 5.151811504934156,
+ "pairedChangesPercent": [
+ 8.623894000826503,
+ 6.43887946246795,
+ 5.151811504934156
+ ]
+ },
+ "interruptWakeupsPerSecond": {
+ "values": {
+ "baseline": [
+ 1059.7122637308598,
+ 1087.1523208211706,
+ 1170.0813992501376
+ ],
+ "current": [
+ 1089.4494957317181,
+ 1072.359041572596,
+ 1041.040681556802
+ ]
+ },
+ "median": {
+ "baseline": 1087.1523208211706,
+ "current": 1072.359041572596
+ },
+ "changePercent": -1.360736574374477,
+ "pairedChangesPercent": [
+ 2.8061609758260664,
+ -1.360736574374477,
+ -11.02835390563709
+ ]
+ },
+ "summedPhysicalFootprintMiBMedian": {
+ "values": {
+ "baseline": [
+ 655.6924133300781,
+ 648.3329238891602,
+ 659.2556457519531
+ ],
+ "current": [
+ 653.8639221191406,
+ 687.2402496337891,
+ 666.0677337646484
+ ]
+ },
+ "median": {
+ "baseline": 655.6924133300781,
+ "current": 666.0677337646484
+ },
+ "changePercent": 1.5823456583670126,
+ "pairedChangesPercent": [
+ -0.2788641707246686,
+ 6.001133724820762,
+ 1.0332999128017217
+ ]
+ }
+ },
+ "background-idle-hidden": {
+ "cpuPercentOneCore": {
+ "values": {
+ "baseline": [
+ 4.230059624930701,
+ 3.5058584025376724,
+ 4.042939709129659
+ ],
+ "current": [
+ 4.185005005191654,
+ 2.980802895269033,
+ 3.8672832996457682
+ ]
+ },
+ "median": {
+ "baseline": 4.042939709129659,
+ "current": 3.8672832996457682
+ },
+ "changePercent": -4.344769452960873,
+ "pairedChangesPercent": [
+ -1.0651060205749463,
+ -14.976517787728804,
+ -4.344769452960873
+ ]
+ },
+ "interruptWakeupsPerSecond": {
+ "values": {
+ "baseline": [
+ 14.632805942606524,
+ 14.131933977465096,
+ 14.367212501017653
+ ],
+ "current": [
+ 14.395606620800061,
+ 14.401358048066125,
+ 14.667032629504153
+ ]
+ },
+ "median": {
+ "baseline": 14.367212501017653,
+ "current": 14.401358048066125
+ },
+ "changePercent": 0.23766299166281257,
+ "pairedChangesPercent": [
+ -1.6210105070539216,
+ 1.9064911499774517,
+ 2.0868357620885902
+ ]
+ },
+ "summedPhysicalFootprintMiBMedian": {
+ "values": {
+ "baseline": [
+ 681.7734909057617,
+ 663.9452972412109,
+ 659.3046951293945
+ ],
+ "current": [
+ 682.7890472412109,
+ 680.539436340332,
+ 682.6802444458008
+ ]
+ },
+ "median": {
+ "baseline": 663.9452972412109,
+ "current": 682.6802444458008
+ },
+ "changePercent": 2.821760660469508,
+ "pairedChangesPercent": [
+ 0.14895802623537957,
+ 2.499323237633,
+ 3.54548503735721
+ ]
+ }
+ },
+ "background-active": {
+ "cpuPercentOneCore": {
+ "values": {
+ "baseline": [
+ 23.520052079850178,
+ 20.551393078865505,
+ 25.96008958389262
+ ],
+ "current": [
+ 23.234900107607952,
+ 20.510776081741913,
+ 24.463135132602822
+ ]
+ },
+ "median": {
+ "baseline": 23.520052079850178,
+ "current": 23.234900107607952
+ },
+ "changePercent": -1.2123781498193043,
+ "pairedChangesPercent": [
+ -1.2123781498193043,
+ -0.19763622333398567,
+ -5.766368588414306
+ ]
+ },
+ "interruptWakeupsPerSecond": {
+ "values": {
+ "baseline": [
+ 915.5482900856168,
+ 862.9277379801514,
+ 921.2637685246706
+ ],
+ "current": [
+ 832.6054039274547,
+ 947.5792311488252,
+ 926.0677087364207
+ ]
+ },
+ "median": {
+ "baseline": 915.5482900856168,
+ "current": 926.0677087364207
+ },
+ "changePercent": 1.1489747471234102,
+ "pairedChangesPercent": [
+ -9.05936770963831,
+ 9.809800918767198,
+ 0.5214511170284375
+ ]
+ },
+ "summedPhysicalFootprintMiBMedian": {
+ "values": {
+ "baseline": [
+ 698.1488800048828,
+ 673.8047409057617,
+ 675.0703659057617
+ ],
+ "current": [
+ 698.4455261230469,
+ 687.1644821166992,
+ 694.1489944458008
+ ]
+ },
+ "median": {
+ "baseline": 675.0703659057617,
+ "current": 694.1489944458008
+ },
+ "changePercent": 2.826168871216961,
+ "pairedChangesPercent": [
+ 0.04249038087147383,
+ 1.9827318509185066,
+ 2.826168871216961
+ ]
+ }
+ }
+ },
+ "cases": [
+ {
+ "variant": "baseline",
+ "run": "harness-connected-v2-1-baseline-20261002",
+ "loadBefore": [
+ 15.912109375,
+ 17.20166015625,
+ 16.783203125
+ ],
+ "loadAfter": [
+ 10.64111328125,
+ 14.576171875,
+ 15.79248046875
+ ],
+ "startEpoch": 1790982793.644437,
+ "endEpoch": 1790982975.694628,
+ "toolingSha256": {
+ "connected_run.py": "f0857e324905b12c47a520cceacd4eff6fe5d8894f78f67e9c4dc10b81c951ed",
+ "connected_stack.mjs": "819ed8941fa33d05bedc732461e9753f69fba9c5796f915909b6c3c1e1f663fe",
+ "connected_worker.mjs": "3456923d6b9f6ff8628c7f84dd2540cb55adf4a83950e6970ace506a1a98295e",
+ "harness-connected-forest-usage-v2-20261002": "48816ec9467b369be056bb03c4b89aa2766a35d07d80f3d0e2a99db987c8c0fb"
+ },
+ "daemonMetadata": {
+ "bundleSha256": "c0f1be69953a507d3abdad60caf95f0641f66221b0c984bc37e81ff84abb61b5",
+ "sourceRevision": "c966e1ac0e10d2741bad53352fcdba9b41d2a6de",
+ "sourceDiffSha256": "b4fd768fe9f620a84bb561384cd613b7103c9f56a81c7ad8191fad2d995e41f5",
+ "boundary": "Full local daemon and tmux; private terminal shells; no cloud account or model inference."
+ },
+ "appSourceRevision": "c966e1ac0e10d2741bad53352fcdba9b41d2a6de",
+ "appProductionDiffSha256": "007836235b4aca69785e4716a83710feccd91853a173e49e5b104925043d477c",
+ "appFixtureSha256": {
+ "connected_main.dart": "8bdf2061c52713ff5dc37939252c5184e90e8da353d3f315e505f270c4e51eed",
+ "ConnectedResourceHost.swift": "f9f58dc6d209119ee4a3440661518785e7ea13f2057c001c666b45ea20e4493e"
+ },
+ "cleanupVerified": true,
+ "phases": [
+ {
+ "label": "foreground-idle-visible",
+ "summary": {
+ "cpuPercentOneCore": 5.1832550253263365,
+ "cpuSeconds": 1.554972875,
+ "elapsedSeconds": 29.999929916666588,
+ "interruptWakeupsPerSecond": 28.63340022413782,
+ "liveProcessCountMax": 24,
+ "liveProcessCountMin": 24,
+ "packageIdleWakeupsPerSecond": 0,
+ "processCountMax": 24,
+ "processCountMin": 24,
+ "summedPhysicalFootprintMiBMedian": 514.331184387207,
+ "summedPhysicalFootprintMiBPeak": 527.4404678344727
+ },
+ "components": {
+ "desktop": {
+ "cpuPercentOneCore": 0.8380789022898821,
+ "interruptWakeupsPerSecond": 15.800036910641824
+ },
+ "daemon": {
+ "cpuPercentOneCore": 4.321248289360598,
+ "interruptWakeupsPerSecond": 12.166695089418283
+ },
+ "tmuxAndWorkers": {
+ "cpuPercentOneCore": 0.023927833675855954,
+ "interruptWakeupsPerSecond": 0.6666682240777141
+ }
+ },
+ "rawSampleSha256": "65515aea01c7da499c4a64517cb99133b548f6beffe06428da071664450830f8",
+ "nativeBefore": {
+ "key": true,
+ "active": true,
+ "focusLosses": 0,
+ "scale": 2.0,
+ "height": 800.0,
+ "visible": true,
+ "hidden": false,
+ "width": 1280.0
+ },
+ "nativeAfter": {
+ "key": true,
+ "active": true,
+ "focusLosses": 0,
+ "scale": 2.0,
+ "height": 800.0,
+ "visible": true,
+ "hidden": false,
+ "width": 1280.0
+ },
+ "outputPerWorker": [
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30508.098667
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30507.440166
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30506.731125
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30506.056792
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30505.350917
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30504.842917
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30504.300541999997
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30504.065958
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30503.835082999998
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30503.757167000003
+ }
+ ],
+ "aggregateSamples": [
+ {
+ "elapsedSeconds": 0.005148750002263114,
+ "cpuTicks": 79439466,
+ "interruptWakeups": 1315,
+ "summedFootprintBytes": 543475672,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 1.007922166667413,
+ "cpuTicks": 79615775,
+ "interruptWakeups": 1330,
+ "summedFootprintBytes": 543541208,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 2.0072464583208784,
+ "cpuTicks": 79960690,
+ "interruptWakeups": 1365,
+ "summedFootprintBytes": 543918040,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 3.0103758333134465,
+ "cpuTicks": 80282677,
+ "interruptWakeups": 1392,
+ "summedFootprintBytes": 544032728,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 4.010956499987515,
+ "cpuTicks": 80453315,
+ "interruptWakeups": 1410,
+ "summedFootprintBytes": 544081880,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 5.006943749991478,
+ "cpuTicks": 91325063,
+ "interruptWakeups": 1487,
+ "summedFootprintBytes": 553061416,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 6.010229166655336,
+ "cpuTicks": 91517410,
+ "interruptWakeups": 1504,
+ "summedFootprintBytes": 520342568,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 7.005733583326219,
+ "cpuTicks": 92034797,
+ "interruptWakeups": 1539,
+ "summedFootprintBytes": 520621096,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 8.007146374991862,
+ "cpuTicks": 92334517,
+ "interruptWakeups": 1573,
+ "summedFootprintBytes": 520703016,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 9.004807916673599,
+ "cpuTicks": 92580826,
+ "interruptWakeups": 1590,
+ "summedFootprintBytes": 520752168,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 10.006271958322031,
+ "cpuTicks": 97987271,
+ "interruptWakeups": 1635,
+ "summedFootprintBytes": 537054224,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 11.006487333332188,
+ "cpuTicks": 98202357,
+ "interruptWakeups": 1650,
+ "summedFootprintBytes": 537103376,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 12.012245833320776,
+ "cpuTicks": 98611653,
+ "interruptWakeups": 1686,
+ "summedFootprintBytes": 537349136,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 13.010565208329353,
+ "cpuTicks": 98932333,
+ "interruptWakeups": 1711,
+ "summedFootprintBytes": 537431056,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 14.00572216665023,
+ "cpuTicks": 99176476,
+ "interruptWakeups": 1728,
+ "summedFootprintBytes": 537496592,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 15.009644250007113,
+ "cpuTicks": 103526301,
+ "interruptWakeups": 1764,
+ "summedFootprintBytes": 538299456,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 16.010005499992985,
+ "cpuTicks": 103723496,
+ "interruptWakeups": 1782,
+ "summedFootprintBytes": 538364992,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 17.011450541671365,
+ "cpuTicks": 104080286,
+ "interruptWakeups": 1813,
+ "summedFootprintBytes": 538594368,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 18.007529750000685,
+ "cpuTicks": 104395531,
+ "interruptWakeups": 1838,
+ "summedFootprintBytes": 538676288,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 19.012426333327312,
+ "cpuTicks": 104614125,
+ "interruptWakeups": 1853,
+ "summedFootprintBytes": 538741824,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 20.00569829167216,
+ "cpuTicks": 108376982,
+ "interruptWakeups": 1903,
+ "summedFootprintBytes": 539692120,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 21.006546874996275,
+ "cpuTicks": 108604708,
+ "interruptWakeups": 1918,
+ "summedFootprintBytes": 539757656,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 22.01058529166039,
+ "cpuTicks": 108861617,
+ "interruptWakeups": 1955,
+ "summedFootprintBytes": 540019800,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 23.00197774998378,
+ "cpuTicks": 109051590,
+ "interruptWakeups": 1984,
+ "summedFootprintBytes": 540101720,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 24.00846349998028,
+ "cpuTicks": 109213881,
+ "interruptWakeups": 2002,
+ "summedFootprintBytes": 540167256,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 25.006776750000427,
+ "cpuTicks": 112798059,
+ "interruptWakeups": 2044,
+ "summedFootprintBytes": 539249800,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 26.003716499981238,
+ "cpuTicks": 112867656,
+ "interruptWakeups": 2061,
+ "summedFootprintBytes": 539315336,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 27.006557249987964,
+ "cpuTicks": 112994731,
+ "interruptWakeups": 2091,
+ "summedFootprintBytes": 539544712,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 28.00269424999715,
+ "cpuTicks": 113101568,
+ "interruptWakeups": 2120,
+ "summedFootprintBytes": 539643016,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 29.006423749990063,
+ "cpuTicks": 113169875,
+ "interruptWakeups": 2135,
+ "summedFootprintBytes": 539692168,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 30.00507866666885,
+ "cpuTicks": 116758815,
+ "interruptWakeups": 2174,
+ "summedFootprintBytes": 540593336,
+ "accountingProcessCount": 24
+ }
+ ]
+ },
+ {
+ "label": "foreground-idle-hidden",
+ "summary": {
+ "cpuPercentOneCore": 4.65025906355759,
+ "cpuSeconds": 1.3950432083333333,
+ "elapsedSeconds": 29.99925787502434,
+ "interruptWakeupsPerSecond": 28.167363456797325,
+ "liveProcessCountMax": 24,
+ "liveProcessCountMin": 24,
+ "packageIdleWakeupsPerSecond": 0,
+ "processCountMax": 24,
+ "processCountMin": 24,
+ "summedPhysicalFootprintMiBMedian": 518.5344009399414,
+ "summedPhysicalFootprintMiBPeak": 521.4251174926758
+ },
+ "components": {
+ "desktop": {
+ "cpuPercentOneCore": 0.9221908682514105,
+ "interruptWakeupsPerSecond": 15.833725020093171
+ },
+ "daemon": {
+ "cpuPercentOneCore": 3.7031099390124442,
+ "interruptWakeupsPerSecond": 11.666955277963389
+ },
+ "tmuxAndWorkers": {
+ "cpuPercentOneCore": 0.024958256293733702,
+ "interruptWakeupsPerSecond": 0.6666831587407651
+ }
+ },
+ "rawSampleSha256": "87e05e8cdc281131681c68f2c27431f9b8c3756fb5d99966cd2ddeeca1da0ac3",
+ "nativeBefore": {
+ "key": true,
+ "active": true,
+ "focusLosses": 0,
+ "scale": 2.0,
+ "height": 800.0,
+ "visible": true,
+ "hidden": false,
+ "width": 1280.0
+ },
+ "nativeAfter": {
+ "key": true,
+ "active": true,
+ "focusLosses": 0,
+ "scale": 2.0,
+ "height": 800.0,
+ "visible": true,
+ "hidden": false,
+ "width": 1280.0
+ },
+ "outputPerWorker": [
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30043.509667
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30043.227332999995
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30043.107459
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30042.98312499999
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30042.865208000003
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30042.677874999994
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30042.535166
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30042.396042
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30042.26108399999
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30042.12745800001
+ }
+ ],
+ "aggregateSamples": [
+ {
+ "elapsedSeconds": 0.0073354583291802555,
+ "cpuTicks": 121962479,
+ "interruptWakeups": 2364,
+ "summedFootprintBytes": 543706344,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 1.004010291682789,
+ "cpuTicks": 122248108,
+ "interruptWakeups": 2383,
+ "summedFootprintBytes": 543722728,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 2.008699958329089,
+ "cpuTicks": 122695600,
+ "interruptWakeups": 2423,
+ "summedFootprintBytes": 543968488,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 3.0114886249939445,
+ "cpuTicks": 122929966,
+ "interruptWakeups": 2451,
+ "summedFootprintBytes": 544050408,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 4.008703583327588,
+ "cpuTicks": 123107985,
+ "interruptWakeups": 2466,
+ "summedFootprintBytes": 544099560,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 5.004395875002956,
+ "cpuTicks": 126828356,
+ "interruptWakeups": 2510,
+ "summedFootprintBytes": 545000728,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 6.010128833353519,
+ "cpuTicks": 126996508,
+ "interruptWakeups": 2525,
+ "summedFootprintBytes": 545049880,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 7.008953375014244,
+ "cpuTicks": 127418346,
+ "interruptWakeups": 2559,
+ "summedFootprintBytes": 545312024,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 8.006365000008373,
+ "cpuTicks": 127643070,
+ "interruptWakeups": 2583,
+ "summedFootprintBytes": 545377560,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 9.00890683333273,
+ "cpuTicks": 127869571,
+ "interruptWakeups": 2601,
+ "summedFootprintBytes": 545426712,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 10.008259708352853,
+ "cpuTicks": 132060953,
+ "interruptWakeups": 2643,
+ "summedFootprintBytes": 546295112,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 11.005673125007888,
+ "cpuTicks": 132262607,
+ "interruptWakeups": 2660,
+ "summedFootprintBytes": 546377032,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 12.003390583326109,
+ "cpuTicks": 132718807,
+ "interruptWakeups": 2692,
+ "summedFootprintBytes": 546622792,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 13.00964870833559,
+ "cpuTicks": 132934612,
+ "interruptWakeups": 2718,
+ "summedFootprintBytes": 546688328,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 14.007372499996563,
+ "cpuTicks": 133209596,
+ "interruptWakeups": 2735,
+ "summedFootprintBytes": 546753864,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 15.007188583345851,
+ "cpuTicks": 138538260,
+ "interruptWakeups": 2789,
+ "summedFootprintBytes": 542428320,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 16.00677570834523,
+ "cpuTicks": 138791236,
+ "interruptWakeups": 2805,
+ "summedFootprintBytes": 542477472,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 17.00856091667083,
+ "cpuTicks": 139621919,
+ "interruptWakeups": 2861,
+ "summedFootprintBytes": 542985376,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 18.007009583350737,
+ "cpuTicks": 139985329,
+ "interruptWakeups": 2888,
+ "summedFootprintBytes": 543067296,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 19.008484791673254,
+ "cpuTicks": 140167832,
+ "interruptWakeups": 2905,
+ "summedFootprintBytes": 543116448,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 20.006952041672776,
+ "cpuTicks": 144382393,
+ "interruptWakeups": 2943,
+ "summedFootprintBytes": 543984848,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 21.009172791673336,
+ "cpuTicks": 144540219,
+ "interruptWakeups": 2961,
+ "summedFootprintBytes": 544034000,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 22.008687374996953,
+ "cpuTicks": 144944201,
+ "interruptWakeups": 2995,
+ "summedFootprintBytes": 527305936,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 23.00852070833207,
+ "cpuTicks": 145288791,
+ "interruptWakeups": 3020,
+ "summedFootprintBytes": 527371472,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 24.007566125015728,
+ "cpuTicks": 145544413,
+ "interruptWakeups": 3035,
+ "summedFootprintBytes": 527420624,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 25.008364125009393,
+ "cpuTicks": 150102237,
+ "interruptWakeups": 3075,
+ "summedFootprintBytes": 528272616,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 26.005006833351217,
+ "cpuTicks": 150308345,
+ "interruptWakeups": 3090,
+ "summedFootprintBytes": 528321768,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 27.007298583339434,
+ "cpuTicks": 150731635,
+ "interruptWakeups": 3125,
+ "summedFootprintBytes": 528567528,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 28.00656350000645,
+ "cpuTicks": 150869975,
+ "interruptWakeups": 3148,
+ "summedFootprintBytes": 528633064,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 29.00924129167106,
+ "cpuTicks": 150970362,
+ "interruptWakeups": 3166,
+ "summedFootprintBytes": 528698600,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 30.00659333335352,
+ "cpuTicks": 155443516,
+ "interruptWakeups": 3209,
+ "summedFootprintBytes": 529534208,
+ "accountingProcessCount": 24
+ }
+ ]
+ },
+ {
+ "label": "foreground-active",
+ "summary": {
+ "cpuPercentOneCore": 29.110023372961148,
+ "cpuSeconds": 8.73263125,
+ "elapsedSeconds": 29.998709166655317,
+ "interruptWakeupsPerSecond": 1059.7122637308598,
+ "liveProcessCountMax": 24,
+ "liveProcessCountMin": 24,
+ "packageIdleWakeupsPerSecond": 0,
+ "processCountMax": 24,
+ "processCountMin": 24,
+ "summedPhysicalFootprintMiBMedian": 655.6924133300781,
+ "summedPhysicalFootprintMiBPeak": 746.8514785766602
+ },
+ "components": {
+ "desktop": {
+ "cpuPercentOneCore": 16.73978597024155,
+ "interruptWakeupsPerSecond": 278.31197514592475
+ },
+ "daemon": {
+ "cpuPercentOneCore": 6.889221566786133,
+ "interruptWakeupsPerSecond": 250.87746136641871
+ },
+ "tmuxAndWorkers": {
+ "cpuPercentOneCore": 5.481015835933458,
+ "interruptWakeupsPerSecond": 530.5228272185163
+ }
+ },
+ "rawSampleSha256": "1a9b71f495d156f182ad176d4937baba9079f6fc084330c10e596ae7c9b7845c",
+ "nativeBefore": {
+ "key": true,
+ "active": true,
+ "focusLosses": 0,
+ "scale": 2.0,
+ "height": 800.0,
+ "visible": true,
+ "hidden": false,
+ "width": 1280.0
+ },
+ "nativeAfter": {
+ "key": true,
+ "active": true,
+ "focusLosses": 0,
+ "scale": 2.0,
+ "height": 800.0,
+ "visible": true,
+ "hidden": false,
+ "width": 1280.0
+ },
+ "outputPerWorker": [
+ {
+ "ticks": 590,
+ "bytes": 294402,
+ "skipped": 0,
+ "elapsedMs": 30034.26849999999
+ },
+ {
+ "ticks": 590,
+ "bytes": 294402,
+ "skipped": 0,
+ "elapsedMs": 30034.367541
+ },
+ {
+ "ticks": 590,
+ "bytes": 294402,
+ "skipped": 0,
+ "elapsedMs": 30034.495542000004
+ },
+ {
+ "ticks": 590,
+ "bytes": 294402,
+ "skipped": 0,
+ "elapsedMs": 30034.53962499999
+ },
+ {
+ "ticks": 590,
+ "bytes": 294402,
+ "skipped": 0,
+ "elapsedMs": 30034.573166000002
+ },
+ {
+ "ticks": 590,
+ "bytes": 294402,
+ "skipped": 0,
+ "elapsedMs": 30034.630707999997
+ },
+ {
+ "ticks": 590,
+ "bytes": 294402,
+ "skipped": 0,
+ "elapsedMs": 30034.679042000003
+ },
+ {
+ "ticks": 590,
+ "bytes": 294402,
+ "skipped": 0,
+ "elapsedMs": 30034.780583
+ },
+ {
+ "ticks": 590,
+ "bytes": 294402,
+ "skipped": 0,
+ "elapsedMs": 30034.82212499999
+ },
+ {
+ "ticks": 590,
+ "bytes": 294402,
+ "skipped": 0,
+ "elapsedMs": 30034.829457999993
+ }
+ ],
+ "aggregateSamples": [
+ {
+ "elapsedSeconds": 0.00456458333064802,
+ "cpuTicks": 193907478,
+ "interruptWakeups": 8222,
+ "summedFootprintBytes": 585666128,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 1.005845749983564,
+ "cpuTicks": 200963966,
+ "interruptWakeups": 9232,
+ "summedFootprintBytes": 606425352,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 2.008080458326731,
+ "cpuTicks": 208039786,
+ "interruptWakeups": 10256,
+ "summedFootprintBytes": 609947912,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 3.009415666660061,
+ "cpuTicks": 215372940,
+ "interruptWakeups": 11401,
+ "summedFootprintBytes": 645894432,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 4.003576124989195,
+ "cpuTicks": 222092351,
+ "interruptWakeups": 12501,
+ "summedFootprintBytes": 630444320,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 5.006725416664267,
+ "cpuTicks": 230991786,
+ "interruptWakeups": 13557,
+ "summedFootprintBytes": 631787856,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 6.011963666649535,
+ "cpuTicks": 236977754,
+ "interruptWakeups": 14536,
+ "summedFootprintBytes": 632427144,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 7.006133666669484,
+ "cpuTicks": 243572948,
+ "interruptWakeups": 15512,
+ "summedFootprintBytes": 650793608,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 8.004998333315598,
+ "cpuTicks": 251598735,
+ "interruptWakeups": 16446,
+ "summedFootprintBytes": 653873704,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 9.009159999986878,
+ "cpuTicks": 261915780,
+ "interruptWakeups": 17519,
+ "summedFootprintBytes": 640881576,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 10.004169499996351,
+ "cpuTicks": 271037109,
+ "interruptWakeups": 18508,
+ "summedFootprintBytes": 660100032,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 11.00412520833197,
+ "cpuTicks": 277477432,
+ "interruptWakeups": 19504,
+ "summedFootprintBytes": 663868376,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 12.010397833335446,
+ "cpuTicks": 282703186,
+ "interruptWakeups": 20596,
+ "summedFootprintBytes": 668488664,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 13.003201208310202,
+ "cpuTicks": 289179577,
+ "interruptWakeups": 21630,
+ "summedFootprintBytes": 686379992,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 14.004943708336214,
+ "cpuTicks": 295356941,
+ "interruptWakeups": 22576,
+ "summedFootprintBytes": 685085656,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 15.009161374997348,
+ "cpuTicks": 305065019,
+ "interruptWakeups": 23546,
+ "summedFootprintBytes": 687543328,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 16.00641283331788,
+ "cpuTicks": 310014373,
+ "interruptWakeups": 24546,
+ "summedFootprintBytes": 699782176,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 17.003163249988575,
+ "cpuTicks": 317106420,
+ "interruptWakeups": 25668,
+ "summedFootprintBytes": 705025056,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 18.005807041656226,
+ "cpuTicks": 323104077,
+ "interruptWakeups": 26756,
+ "summedFootprintBytes": 709350432,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 19.006442083307775,
+ "cpuTicks": 330192188,
+ "interruptWakeups": 27761,
+ "summedFootprintBytes": 726946848,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 20.00625229164143,
+ "cpuTicks": 337689460,
+ "interruptWakeups": 28858,
+ "summedFootprintBytes": 733649800,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 21.00356995832408,
+ "cpuTicks": 344079464,
+ "interruptWakeups": 29899,
+ "summedFootprintBytes": 734322504,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 22.00816450000275,
+ "cpuTicks": 349854339,
+ "interruptWakeups": 30956,
+ "summedFootprintBytes": 752213832,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 23.00639624998439,
+ "cpuTicks": 356614291,
+ "interruptWakeups": 32008,
+ "summedFootprintBytes": 753180488,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 24.003360374976182,
+ "cpuTicks": 363566628,
+ "interruptWakeups": 33083,
+ "summedFootprintBytes": 750100296,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 25.004964541643858,
+ "cpuTicks": 372985700,
+ "interruptWakeups": 34254,
+ "summedFootprintBytes": 763043680,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 26.004007624986116,
+ "cpuTicks": 377453727,
+ "interruptWakeups": 35352,
+ "summedFootprintBytes": 759422816,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 27.004581874993164,
+ "cpuTicks": 382323124,
+ "interruptWakeups": 36496,
+ "summedFootprintBytes": 755982176,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 28.00516949998564,
+ "cpuTicks": 387744941,
+ "interruptWakeups": 37648,
+ "summedFootprintBytes": 773365600,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 29.0081462499802,
+ "cpuTicks": 394639261,
+ "interruptWakeups": 38799,
+ "summedFootprintBytes": 778116960,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 30.003273749985965,
+ "cpuTicks": 403490628,
+ "interruptWakeups": 40012,
+ "summedFootprintBytes": 783130536,
+ "accountingProcessCount": 24
+ }
+ ]
+ },
+ {
+ "label": "background-idle-hidden",
+ "summary": {
+ "cpuPercentOneCore": 4.230059624930701,
+ "cpuSeconds": 1.269063625,
+ "elapsedSeconds": 30.00108125002589,
+ "interruptWakeupsPerSecond": 14.632805942606524,
+ "liveProcessCountMax": 24,
+ "liveProcessCountMin": 24,
+ "packageIdleWakeupsPerSecond": 0,
+ "processCountMax": 24,
+ "processCountMin": 24,
+ "summedPhysicalFootprintMiBMedian": 681.7734909057617,
+ "summedPhysicalFootprintMiBPeak": 684.7267303466797
+ },
+ "components": {
+ "desktop": {
+ "cpuPercentOneCore": 0.1715972875698346,
+ "interruptWakeupsPerSecond": 3.0665561428697043
+ },
+ "daemon": {
+ "cpuPercentOneCore": 4.028011351531839,
+ "interruptWakeupsPerSecond": 10.899607159982535
+ },
+ "tmuxAndWorkers": {
+ "cpuPercentOneCore": 0.03045098582902613,
+ "interruptWakeupsPerSecond": 0.6666426397542835
+ }
+ },
+ "rawSampleSha256": "782dbf842213f4a97f29cbaeb00639f3e5ee3e92cd0d15f7fe1c951ddf3c8e67",
+ "nativeBefore": {
+ "key": false,
+ "active": false,
+ "focusLosses": 1,
+ "scale": 2.0,
+ "height": 800.0,
+ "visible": false,
+ "hidden": true,
+ "width": 1280.0
+ },
+ "nativeAfter": {
+ "key": false,
+ "active": false,
+ "focusLosses": 1,
+ "scale": 2.0,
+ "height": 800.0,
+ "visible": false,
+ "hidden": true,
+ "width": 1280.0
+ },
+ "outputPerWorker": [
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30079.93024999999
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30079.839208999998
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30079.741832999993
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30079.595791
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30079.504625000016
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30079.44379199999
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30079.335999999996
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30079.230500000005
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30079.106582999986
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30078.993375000005
+ }
+ ],
+ "aggregateSamples": [
+ {
+ "elapsedSeconds": 0.008814083324978128,
+ "cpuTicks": 410097271,
+ "interruptWakeups": 40243,
+ "summedFootprintBytes": 711188440,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 1.0076299166830722,
+ "cpuTicks": 410106275,
+ "interruptWakeups": 40248,
+ "summedFootprintBytes": 711139288,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 2.0072674583352637,
+ "cpuTicks": 410359990,
+ "interruptWakeups": 40273,
+ "summedFootprintBytes": 711335896,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 3.0051702083437704,
+ "cpuTicks": 410385141,
+ "interruptWakeups": 40282,
+ "summedFootprintBytes": 711352280,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 4.015422541677253,
+ "cpuTicks": 410390347,
+ "interruptWakeups": 40286,
+ "summedFootprintBytes": 711352280,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 5.00918320834171,
+ "cpuTicks": 415056767,
+ "interruptWakeups": 40319,
+ "summedFootprintBytes": 712171504,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 6.004932416661177,
+ "cpuTicks": 415063060,
+ "interruptWakeups": 40321,
+ "summedFootprintBytes": 712171504,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 7.011986333323875,
+ "cpuTicks": 415451336,
+ "interruptWakeups": 40361,
+ "summedFootprintBytes": 712613872,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 8.013931624998804,
+ "cpuTicks": 415505328,
+ "interruptWakeups": 40370,
+ "summedFootprintBytes": 712630256,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 9.010927833325695,
+ "cpuTicks": 415512402,
+ "interruptWakeups": 40374,
+ "summedFootprintBytes": 712630256,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 10.00813016667962,
+ "cpuTicks": 420242179,
+ "interruptWakeups": 40397,
+ "summedFootprintBytes": 713826336,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 11.00928791667684,
+ "cpuTicks": 420257609,
+ "interruptWakeups": 40403,
+ "summedFootprintBytes": 713826336,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 12.002799916663207,
+ "cpuTicks": 420550306,
+ "interruptWakeups": 40427,
+ "summedFootprintBytes": 714055712,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 13.011031000001822,
+ "cpuTicks": 420564723,
+ "interruptWakeups": 40435,
+ "summedFootprintBytes": 714072096,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 14.009148583339993,
+ "cpuTicks": 420569871,
+ "interruptWakeups": 40438,
+ "summedFootprintBytes": 714072096,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 15.00551954167895,
+ "cpuTicks": 425393675,
+ "interruptWakeups": 40465,
+ "summedFootprintBytes": 714891320,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 16.005402041657362,
+ "cpuTicks": 425397683,
+ "interruptWakeups": 40467,
+ "summedFootprintBytes": 714891320,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 17.00716666667722,
+ "cpuTicks": 425601447,
+ "interruptWakeups": 40495,
+ "summedFootprintBytes": 715087928,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 18.009471625002334,
+ "cpuTicks": 425629296,
+ "interruptWakeups": 40501,
+ "summedFootprintBytes": 715104312,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 19.00705370833748,
+ "cpuTicks": 425638218,
+ "interruptWakeups": 40506,
+ "summedFootprintBytes": 715104312,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 20.00572633332922,
+ "cpuTicks": 430409007,
+ "interruptWakeups": 40537,
+ "summedFootprintBytes": 715907152,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 21.003740166663192,
+ "cpuTicks": 430417882,
+ "interruptWakeups": 40541,
+ "summedFootprintBytes": 715907152,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 22.009686333331047,
+ "cpuTicks": 430615801,
+ "interruptWakeups": 40574,
+ "summedFootprintBytes": 716120144,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 23.01044266668032,
+ "cpuTicks": 430637366,
+ "interruptWakeups": 40585,
+ "summedFootprintBytes": 716136528,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 24.007860250014346,
+ "cpuTicks": 430641123,
+ "interruptWakeups": 40587,
+ "summedFootprintBytes": 716136528,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 25.00815383333247,
+ "cpuTicks": 435400950,
+ "interruptWakeups": 40617,
+ "summedFootprintBytes": 716955776,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 26.006406416679965,
+ "cpuTicks": 435412232,
+ "interruptWakeups": 40620,
+ "summedFootprintBytes": 716955776,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 27.00775900000008,
+ "cpuTicks": 435716417,
+ "interruptWakeups": 40648,
+ "summedFootprintBytes": 717152384,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 28.005917041678913,
+ "cpuTicks": 435745100,
+ "interruptWakeups": 40654,
+ "summedFootprintBytes": 717168768,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 29.002875291684177,
+ "cpuTicks": 435753588,
+ "interruptWakeups": 40659,
+ "summedFootprintBytes": 717168768,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 30.00989533335087,
+ "cpuTicks": 440554798,
+ "interruptWakeups": 40682,
+ "summedFootprintBytes": 717988016,
+ "accountingProcessCount": 24
+ }
+ ]
+ },
+ {
+ "label": "background-active",
+ "summary": {
+ "cpuPercentOneCore": 23.520052079850178,
+ "cpuSeconds": 7.055643458333333,
+ "elapsedSeconds": 29.998417666676687,
+ "interruptWakeupsPerSecond": 915.5482900856168,
+ "liveProcessCountMax": 24,
+ "liveProcessCountMin": 24,
+ "packageIdleWakeupsPerSecond": 0,
+ "processCountMax": 24,
+ "processCountMin": 24,
+ "summedPhysicalFootprintMiBMedian": 698.1488800048828,
+ "summedPhysicalFootprintMiBPeak": 699.7272109985352
+ },
+ "components": {
+ "desktop": {
+ "cpuPercentOneCore": 7.95297197508585,
+ "interruptWakeupsPerSecond": 128.4067727438484
+ },
+ "daemon": {
+ "cpuPercentOneCore": 8.413572519205507,
+ "interruptWakeupsPerSecond": 260.7804213850275
+ },
+ "tmuxAndWorkers": {
+ "cpuPercentOneCore": 7.153507585558816,
+ "interruptWakeupsPerSecond": 526.3610959567409
+ }
+ },
+ "rawSampleSha256": "aa4b6bc884f793644a16261991c22c8fe5045c583b620681772528114f75b5da",
+ "nativeBefore": {
+ "key": false,
+ "active": false,
+ "focusLosses": 1,
+ "scale": 2.0,
+ "height": 800.0,
+ "visible": false,
+ "hidden": true,
+ "width": 1280.0
+ },
+ "nativeAfter": {
+ "key": false,
+ "active": false,
+ "focusLosses": 1,
+ "scale": 2.0,
+ "height": 800.0,
+ "visible": false,
+ "hidden": true,
+ "width": 1280.0
+ },
+ "outputPerWorker": [
+ {
+ "ticks": 590,
+ "bytes": 297426,
+ "skipped": 0,
+ "elapsedMs": 30073.571125000017
+ },
+ {
+ "ticks": 590,
+ "bytes": 297426,
+ "skipped": 0,
+ "elapsedMs": 30073.126542000013
+ },
+ {
+ "ticks": 590,
+ "bytes": 297426,
+ "skipped": 0,
+ "elapsedMs": 30072.606666999985
+ },
+ {
+ "ticks": 590,
+ "bytes": 297426,
+ "skipped": 0,
+ "elapsedMs": 30072.077541000006
+ },
+ {
+ "ticks": 590,
+ "bytes": 297426,
+ "skipped": 0,
+ "elapsedMs": 30071.552417
+ },
+ {
+ "ticks": 590,
+ "bytes": 297426,
+ "skipped": 0,
+ "elapsedMs": 30070.683667000005
+ },
+ {
+ "ticks": 590,
+ "bytes": 297426,
+ "skipped": 0,
+ "elapsedMs": 30070.210290999996
+ },
+ {
+ "ticks": 591,
+ "bytes": 297933,
+ "skipped": 0,
+ "elapsedMs": 30069.744166999997
+ },
+ {
+ "ticks": 590,
+ "bytes": 297426,
+ "skipped": 0,
+ "elapsedMs": 30069.295125000004
+ },
+ {
+ "ticks": 590,
+ "bytes": 297426,
+ "skipped": 0,
+ "elapsedMs": 30068.963875000016
+ }
+ ],
+ "aggregateSamples": [
+ {
+ "elapsedSeconds": 0.010686833324143663,
+ "cpuTicks": 462172134,
+ "interruptWakeups": 44167,
+ "summedFootprintBytes": 732602568,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 1.0071669583267067,
+ "cpuTicks": 465459026,
+ "interruptWakeups": 44883,
+ "summedFootprintBytes": 732946632,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 2.0103990833158605,
+ "cpuTicks": 469673503,
+ "interruptWakeups": 45697,
+ "summedFootprintBytes": 733012168,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 3.016656249994412,
+ "cpuTicks": 474601739,
+ "interruptWakeups": 46474,
+ "summedFootprintBytes": 733044936,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 4.012203791673528,
+ "cpuTicks": 480425644,
+ "interruptWakeups": 47324,
+ "summedFootprintBytes": 733061320,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 5.0107056249980815,
+ "cpuTicks": 489689452,
+ "interruptWakeups": 48155,
+ "summedFootprintBytes": 726753264,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 6.010841374984011,
+ "cpuTicks": 495063722,
+ "interruptWakeups": 48997,
+ "summedFootprintBytes": 727572464,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 7.007111624989193,
+ "cpuTicks": 499812060,
+ "interruptWakeups": 49829,
+ "summedFootprintBytes": 728293360,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 8.01343570832978,
+ "cpuTicks": 504435443,
+ "interruptWakeups": 50677,
+ "summedFootprintBytes": 728375280,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 9.01450970832957,
+ "cpuTicks": 510350393,
+ "interruptWakeups": 51611,
+ "summedFootprintBytes": 727850992,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 10.008563458337449,
+ "cpuTicks": 518963129,
+ "interruptWakeups": 52587,
+ "summedFootprintBytes": 730226696,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 11.007956916670082,
+ "cpuTicks": 524709289,
+ "interruptWakeups": 53540,
+ "summedFootprintBytes": 730816520,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 12.011540083331056,
+ "cpuTicks": 529608119,
+ "interruptWakeups": 54554,
+ "summedFootprintBytes": 730816520,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 13.00679658332956,
+ "cpuTicks": 535131290,
+ "interruptWakeups": 55486,
+ "summedFootprintBytes": 730832904,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 14.00954741667374,
+ "cpuTicks": 540232684,
+ "interruptWakeups": 56387,
+ "summedFootprintBytes": 730832904,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 15.01182241665083,
+ "cpuTicks": 547096680,
+ "interruptWakeups": 57373,
+ "summedFootprintBytes": 732045776,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 16.00570287500159,
+ "cpuTicks": 551389618,
+ "interruptWakeups": 58292,
+ "summedFootprintBytes": 732062160,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 17.013435208325973,
+ "cpuTicks": 555952899,
+ "interruptWakeups": 59248,
+ "summedFootprintBytes": 732062160,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 18.00620666667237,
+ "cpuTicks": 558522569,
+ "interruptWakeups": 60133,
+ "summedFootprintBytes": 732078544,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 19.009547708323225,
+ "cpuTicks": 563313897,
+ "interruptWakeups": 61038,
+ "summedFootprintBytes": 732078544,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 20.01038237498142,
+ "cpuTicks": 571996924,
+ "interruptWakeups": 62029,
+ "summedFootprintBytes": 732750336,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 21.010232875007205,
+ "cpuTicks": 578362366,
+ "interruptWakeups": 63053,
+ "summedFootprintBytes": 730964552,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 22.00941395832342,
+ "cpuTicks": 583437869,
+ "interruptWakeups": 64087,
+ "summedFootprintBytes": 730964552,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 23.01256395832752,
+ "cpuTicks": 588280480,
+ "interruptWakeups": 65077,
+ "summedFootprintBytes": 731685448,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 24.011069666652475,
+ "cpuTicks": 594041011,
+ "interruptWakeups": 65976,
+ "summedFootprintBytes": 731685448,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 25.01295083333389,
+ "cpuTicks": 602307852,
+ "interruptWakeups": 66930,
+ "summedFootprintBytes": 733094520,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 26.00455700000748,
+ "cpuTicks": 607141637,
+ "interruptWakeups": 67845,
+ "summedFootprintBytes": 733094520,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 27.01234012498753,
+ "cpuTicks": 611849755,
+ "interruptWakeups": 68749,
+ "summedFootprintBytes": 733094520,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 28.00307141666417,
+ "cpuTicks": 617211689,
+ "interruptWakeups": 69692,
+ "summedFootprintBytes": 733045368,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 29.011510666663526,
+ "cpuTicks": 623018749,
+ "interruptWakeups": 70658,
+ "summedFootprintBytes": 733045368,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 30.00910450000083,
+ "cpuTicks": 631507577,
+ "interruptWakeups": 71632,
+ "summedFootprintBytes": 733717160,
+ "accountingProcessCount": 24
+ }
+ ]
+ }
+ ]
+ },
+ {
+ "variant": "current",
+ "run": "harness-connected-v2-2-current-20261002",
+ "loadBefore": [
+ 10.64111328125,
+ 14.576171875,
+ 15.79248046875
+ ],
+ "loadAfter": [
+ 7.705078125,
+ 11.3896484375,
+ 14.20947265625
+ ],
+ "startEpoch": 1790982975.6957078,
+ "endEpoch": 1790983157.0423539,
+ "toolingSha256": {
+ "connected_run.py": "f0857e324905b12c47a520cceacd4eff6fe5d8894f78f67e9c4dc10b81c951ed",
+ "connected_stack.mjs": "819ed8941fa33d05bedc732461e9753f69fba9c5796f915909b6c3c1e1f663fe",
+ "connected_worker.mjs": "3456923d6b9f6ff8628c7f84dd2540cb55adf4a83950e6970ace506a1a98295e",
+ "harness-connected-forest-usage-v2-20261002": "48816ec9467b369be056bb03c4b89aa2766a35d07d80f3d0e2a99db987c8c0fb"
+ },
+ "daemonMetadata": {
+ "bundleSha256": "286713aed76a1972419d5d06f6c7069c73bddef81acdeecf9be128de9bd4e369",
+ "sourceRevision": "c966e1ac0e10d2741bad53352fcdba9b41d2a6de",
+ "sourceDiffSha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+ "boundary": "Full local daemon and tmux; private terminal shells; no cloud account or model inference."
+ },
+ "appSourceRevision": "c966e1ac0e10d2741bad53352fcdba9b41d2a6de",
+ "appProductionDiffSha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+ "appFixtureSha256": {
+ "connected_main.dart": "8bdf2061c52713ff5dc37939252c5184e90e8da353d3f315e505f270c4e51eed",
+ "ConnectedResourceHost.swift": "f9f58dc6d209119ee4a3440661518785e7ea13f2057c001c666b45ea20e4493e"
+ },
+ "cleanupVerified": true,
+ "phases": [
+ {
+ "label": "foreground-idle-visible",
+ "summary": {
+ "cpuPercentOneCore": 5.4146227921549315,
+ "cpuSeconds": 1.624718375,
+ "elapsedSeconds": 30.006122999999207,
+ "interruptWakeupsPerSecond": 27.494388395329242,
+ "liveProcessCountMax": 24,
+ "liveProcessCountMin": 24,
+ "packageIdleWakeupsPerSecond": 0,
+ "processCountMax": 24,
+ "processCountMin": 24,
+ "summedPhysicalFootprintMiBMedian": 485.00303649902344,
+ "summedPhysicalFootprintMiBPeak": 548.7205963134766
+ },
+ "components": {
+ "desktop": {
+ "cpuPercentOneCore": 0.9655891732497652,
+ "interruptWakeupsPerSecond": 14.930286061948484
+ },
+ "daemon": {
+ "cpuPercentOneCore": 4.423612418483282,
+ "interruptWakeupsPerSecond": 11.8975717056152
+ },
+ "tmuxAndWorkers": {
+ "cpuPercentOneCore": 0.02542120042188345,
+ "interruptWakeupsPerSecond": 0.6665306277655574
+ }
+ },
+ "rawSampleSha256": "f5cbdf5eda9a61e58e2d75a3a2dbd2b06b4b8649a051114220150aeaea413731",
+ "nativeBefore": {
+ "active": true,
+ "hidden": false,
+ "scale": 2.0,
+ "visible": true,
+ "width": 1280.0,
+ "key": true,
+ "focusLosses": 0,
+ "height": 800.0
+ },
+ "nativeAfter": {
+ "active": true,
+ "hidden": false,
+ "scale": 2.0,
+ "visible": true,
+ "width": 1280.0,
+ "key": true,
+ "focusLosses": 0,
+ "height": 800.0
+ },
+ "outputPerWorker": [
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30047.194917000004
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30046.7485
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30046.08575
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30046.025875
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30045.988834
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30045.56475
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30045.419625
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30045.372957999996
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30045.3485
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30045.311667
+ }
+ ],
+ "aggregateSamples": [
+ {
+ "elapsedSeconds": 0.003779083344852552,
+ "cpuTicks": 69308540,
+ "interruptWakeups": 1355,
+ "summedFootprintBytes": 570377576,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 1.0107922083407175,
+ "cpuTicks": 73562618,
+ "interruptWakeups": 1396,
+ "summedFootprintBytes": 575309712,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 2.0086164166859817,
+ "cpuTicks": 73712869,
+ "interruptWakeups": 1412,
+ "summedFootprintBytes": 575375248,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 3.0101995416916907,
+ "cpuTicks": 74162414,
+ "interruptWakeups": 1455,
+ "summedFootprintBytes": 543082384,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 4.007959625014337,
+ "cpuTicks": 74326860,
+ "interruptWakeups": 1471,
+ "summedFootprintBytes": 543131536,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 5.006551125028636,
+ "cpuTicks": 74553094,
+ "interruptWakeups": 1487,
+ "summedFootprintBytes": 543147920,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 6.006005125003867,
+ "cpuTicks": 84764602,
+ "interruptWakeups": 1558,
+ "summedFootprintBytes": 551799824,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 7.008762041688897,
+ "cpuTicks": 84921642,
+ "interruptWakeups": 1573,
+ "summedFootprintBytes": 519080976,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 8.009654083347414,
+ "cpuTicks": 85392767,
+ "interruptWakeups": 1622,
+ "summedFootprintBytes": 519343120,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 9.003835166688077,
+ "cpuTicks": 85643568,
+ "interruptWakeups": 1640,
+ "summedFootprintBytes": 519408656,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 10.010101000021677,
+ "cpuTicks": 85874385,
+ "interruptWakeups": 1657,
+ "summedFootprintBytes": 519457808,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 11.006897791667143,
+ "cpuTicks": 90274456,
+ "interruptWakeups": 1697,
+ "summedFootprintBytes": 506661952,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 12.011270916671492,
+ "cpuTicks": 90414314,
+ "interruptWakeups": 1711,
+ "summedFootprintBytes": 506711104,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 13.00658958335407,
+ "cpuTicks": 91258633,
+ "interruptWakeups": 1754,
+ "summedFootprintBytes": 507022400,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 14.008825583354337,
+ "cpuTicks": 91459934,
+ "interruptWakeups": 1771,
+ "summedFootprintBytes": 507071552,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 15.010105083347298,
+ "cpuTicks": 91578536,
+ "interruptWakeups": 1787,
+ "summedFootprintBytes": 507120704,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 16.002766541671008,
+ "cpuTicks": 95707100,
+ "interruptWakeups": 1820,
+ "summedFootprintBytes": 508562544,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 17.00832483335398,
+ "cpuTicks": 95820080,
+ "interruptWakeups": 1837,
+ "summedFootprintBytes": 508611696,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 18.008677416684804,
+ "cpuTicks": 96256387,
+ "interruptWakeups": 1876,
+ "summedFootprintBytes": 508890224,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 19.00649929168867,
+ "cpuTicks": 96412778,
+ "interruptWakeups": 1894,
+ "summedFootprintBytes": 508939376,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 20.004677708348026,
+ "cpuTicks": 96667636,
+ "interruptWakeups": 1908,
+ "summedFootprintBytes": 509004912,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 21.005999416694976,
+ "cpuTicks": 101213519,
+ "interruptWakeups": 1955,
+ "summedFootprintBytes": 489311248,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 22.008685250009876,
+ "cpuTicks": 101753271,
+ "interruptWakeups": 1972,
+ "summedFootprintBytes": 506645520,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 23.00990220834501,
+ "cpuTicks": 102423903,
+ "interruptWakeups": 2021,
+ "summedFootprintBytes": 506907664,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 24.00805487501202,
+ "cpuTicks": 102570005,
+ "interruptWakeups": 2036,
+ "summedFootprintBytes": 506956816,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 25.00925250002183,
+ "cpuTicks": 102776896,
+ "interruptWakeups": 2052,
+ "summedFootprintBytes": 507022352,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 26.006402875005733,
+ "cpuTicks": 106974378,
+ "interruptWakeups": 2090,
+ "summedFootprintBytes": 507874368,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 27.005180416686926,
+ "cpuTicks": 107180163,
+ "interruptWakeups": 2107,
+ "summedFootprintBytes": 507939904,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 28.007481041684514,
+ "cpuTicks": 107765933,
+ "interruptWakeups": 2145,
+ "summedFootprintBytes": 508202048,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 29.006779166695196,
+ "cpuTicks": 108069620,
+ "interruptWakeups": 2165,
+ "summedFootprintBytes": 508267584,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 30.00990208334406,
+ "cpuTicks": 108301781,
+ "interruptWakeups": 2180,
+ "summedFootprintBytes": 508267584,
+ "accountingProcessCount": 24
+ }
+ ]
+ },
+ {
+ "label": "foreground-idle-hidden",
+ "summary": {
+ "cpuPercentOneCore": 3.840327153496184,
+ "cpuSeconds": 1.152146875,
+ "elapsedSeconds": 30.00126887499937,
+ "interruptWakeupsPerSecond": 15.566008289374722,
+ "liveProcessCountMax": 24,
+ "liveProcessCountMin": 24,
+ "packageIdleWakeupsPerSecond": 0,
+ "processCountMax": 24,
+ "processCountMin": 24,
+ "summedPhysicalFootprintMiBMedian": 447.6905822753906,
+ "summedPhysicalFootprintMiBPeak": 449.1125259399414
+ },
+ "components": {
+ "desktop": {
+ "cpuPercentOneCore": 0.16472997705279346,
+ "interruptWakeupsPerSecond": 3.066536964930352
+ },
+ "daemon": {
+ "cpuPercentOneCore": 3.65202734001593,
+ "interruptWakeupsPerSecond": 11.832832853807336
+ },
+ "tmuxAndWorkers": {
+ "cpuPercentOneCore": 0.0235698364274606,
+ "interruptWakeupsPerSecond": 0.6666384706370331
+ }
+ },
+ "rawSampleSha256": "1c4f546b7aa9c25b9d8922e65ac0a57185ed6193cdcb4b0c261a8ad8b1c25108",
+ "nativeBefore": {
+ "active": true,
+ "hidden": false,
+ "scale": 2.0,
+ "visible": true,
+ "width": 1280.0,
+ "key": true,
+ "focusLosses": 0,
+ "height": 800.0
+ },
+ "nativeAfter": {
+ "active": true,
+ "hidden": false,
+ "scale": 2.0,
+ "visible": true,
+ "width": 1280.0,
+ "key": true,
+ "focusLosses": 0,
+ "height": 800.0
+ },
+ "outputPerWorker": [
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30058.086333
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30058.332875000007
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30058.514500000005
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30058.503791000003
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30058.644457999995
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30058.746041000006
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30058.825916999995
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30058.884375
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30058.969916000002
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30059.03074999999
+ }
+ ],
+ "aggregateSamples": [
+ {
+ "elapsedSeconds": 0.006979833357036114,
+ "cpuTicks": 113512633,
+ "interruptWakeups": 2310,
+ "summedFootprintBytes": 467881072,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 1.0111944583477452,
+ "cpuTicks": 117061273,
+ "interruptWakeups": 2337,
+ "summedFootprintBytes": 468667528,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 2.010782166675199,
+ "cpuTicks": 117066602,
+ "interruptWakeups": 2342,
+ "summedFootprintBytes": 468667528,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 3.007692750019487,
+ "cpuTicks": 117304334,
+ "interruptWakeups": 2378,
+ "summedFootprintBytes": 468896904,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 4.005732916673878,
+ "cpuTicks": 117313325,
+ "interruptWakeups": 2385,
+ "summedFootprintBytes": 468896904,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 5.010613208345603,
+ "cpuTicks": 117315723,
+ "interruptWakeups": 2387,
+ "summedFootprintBytes": 468896904,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 6.006126250023954,
+ "cpuTicks": 121576821,
+ "interruptWakeups": 2415,
+ "summedFootprintBytes": 469716152,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 7.007938624999952,
+ "cpuTicks": 121579638,
+ "interruptWakeups": 2418,
+ "summedFootprintBytes": 469716152,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 8.008911750017432,
+ "cpuTicks": 121834406,
+ "interruptWakeups": 2444,
+ "summedFootprintBytes": 469929144,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 9.01197245833464,
+ "cpuTicks": 121841654,
+ "interruptWakeups": 2448,
+ "summedFootprintBytes": 469929144,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 10.006834625004558,
+ "cpuTicks": 121858570,
+ "interruptWakeups": 2454,
+ "summedFootprintBytes": 469929144,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 11.010143125022296,
+ "cpuTicks": 126095412,
+ "interruptWakeups": 2479,
+ "summedFootprintBytes": 470715624,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 12.010746708343504,
+ "cpuTicks": 126099960,
+ "interruptWakeups": 2483,
+ "summedFootprintBytes": 470715624,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 13.005633541673888,
+ "cpuTicks": 126411543,
+ "interruptWakeups": 2510,
+ "summedFootprintBytes": 470928616,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 14.00554991667741,
+ "cpuTicks": 126429437,
+ "interruptWakeups": 2517,
+ "summedFootprintBytes": 470928616,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 15.008991583337775,
+ "cpuTicks": 126435424,
+ "interruptWakeups": 2521,
+ "summedFootprintBytes": 470928616,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 16.008585125004174,
+ "cpuTicks": 131349533,
+ "interruptWakeups": 2562,
+ "summedFootprintBytes": 467963016,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 17.008703625004273,
+ "cpuTicks": 131351778,
+ "interruptWakeups": 2564,
+ "summedFootprintBytes": 467963016,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 18.00739975000033,
+ "cpuTicks": 132275146,
+ "interruptWakeups": 2609,
+ "summedFootprintBytes": 468454536,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 19.01018350000959,
+ "cpuTicks": 132291932,
+ "interruptWakeups": 2615,
+ "summedFootprintBytes": 468470920,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 20.010906500014244,
+ "cpuTicks": 132299387,
+ "interruptWakeups": 2619,
+ "summedFootprintBytes": 468470920,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 21.008807958336547,
+ "cpuTicks": 136299615,
+ "interruptWakeups": 2665,
+ "summedFootprintBytes": 469240992,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 22.00734366668621,
+ "cpuTicks": 136314453,
+ "interruptWakeups": 2671,
+ "summedFootprintBytes": 469240992,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 23.00515599999926,
+ "cpuTicks": 136623840,
+ "interruptWakeups": 2698,
+ "summedFootprintBytes": 469437600,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 24.007224500004668,
+ "cpuTicks": 136634250,
+ "interruptWakeups": 2704,
+ "summedFootprintBytes": 469437600,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 25.005013958347263,
+ "cpuTicks": 136639426,
+ "interruptWakeups": 2707,
+ "summedFootprintBytes": 469437600,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 26.0130530000024,
+ "cpuTicks": 140792887,
+ "interruptWakeups": 2736,
+ "summedFootprintBytes": 470224080,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 27.00707608333323,
+ "cpuTicks": 140794792,
+ "interruptWakeups": 2738,
+ "summedFootprintBytes": 470224080,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 28.009379833354615,
+ "cpuTicks": 141146120,
+ "interruptWakeups": 2768,
+ "summedFootprintBytes": 470453456,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 29.007513041666243,
+ "cpuTicks": 141152526,
+ "interruptWakeups": 2772,
+ "summedFootprintBytes": 470453456,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 30.008248708356405,
+ "cpuTicks": 141164158,
+ "interruptWakeups": 2777,
+ "summedFootprintBytes": 470453456,
+ "accountingProcessCount": 24
+ }
+ ]
+ },
+ {
+ "label": "foreground-active",
+ "summary": {
+ "cpuPercentOneCore": 31.620440932261136,
+ "cpuSeconds": 9.486281791666666,
+ "elapsedSeconds": 30.000472833344247,
+ "interruptWakeupsPerSecond": 1089.4494957317181,
+ "liveProcessCountMax": 24,
+ "liveProcessCountMin": 24,
+ "packageIdleWakeupsPerSecond": 0,
+ "processCountMax": 24,
+ "processCountMin": 24,
+ "summedPhysicalFootprintMiBMedian": 653.8639221191406,
+ "summedPhysicalFootprintMiBPeak": 747.0857391357422
+ },
+ "components": {
+ "desktop": {
+ "cpuPercentOneCore": 18.653410862623115,
+ "interruptWakeupsPerSecond": 296.02866759250367
+ },
+ "daemon": {
+ "cpuPercentOneCore": 7.006624567809122,
+ "interruptWakeupsPerSecond": 257.2626119219618
+ },
+ "tmuxAndWorkers": {
+ "cpuPercentOneCore": 5.960405501828895,
+ "interruptWakeupsPerSecond": 536.1582162172526
+ }
+ },
+ "rawSampleSha256": "d869e0c3948da390ca16acc07b9514be801f8abcfdc4d83a3da028f07cfe3a88",
+ "nativeBefore": {
+ "active": true,
+ "hidden": false,
+ "scale": 2.0,
+ "visible": true,
+ "width": 1280.0,
+ "key": true,
+ "focusLosses": 0,
+ "height": 800.0
+ },
+ "nativeAfter": {
+ "active": true,
+ "hidden": false,
+ "scale": 2.0,
+ "visible": true,
+ "width": 1280.0,
+ "key": true,
+ "focusLosses": 0,
+ "height": 800.0
+ },
+ "outputPerWorker": [
+ {
+ "ticks": 590,
+ "bytes": 294402,
+ "skipped": 0,
+ "elapsedMs": 30055.922749999998
+ },
+ {
+ "ticks": 590,
+ "bytes": 294402,
+ "skipped": 0,
+ "elapsedMs": 30055.965207999994
+ },
+ {
+ "ticks": 590,
+ "bytes": 294402,
+ "skipped": 0,
+ "elapsedMs": 30055.895874999987
+ },
+ {
+ "ticks": 590,
+ "bytes": 294402,
+ "skipped": 0,
+ "elapsedMs": 30055.828624999995
+ },
+ {
+ "ticks": 590,
+ "bytes": 294402,
+ "skipped": 0,
+ "elapsedMs": 30055.796375000005
+ },
+ {
+ "ticks": 590,
+ "bytes": 294402,
+ "skipped": 0,
+ "elapsedMs": 30055.663333000004
+ },
+ {
+ "ticks": 591,
+ "bytes": 294901,
+ "skipped": 0,
+ "elapsedMs": 30055.520332999993
+ },
+ {
+ "ticks": 590,
+ "bytes": 294402,
+ "skipped": 0,
+ "elapsedMs": 30055.432042
+ },
+ {
+ "ticks": 590,
+ "bytes": 294402,
+ "skipped": 0,
+ "elapsedMs": 30055.374291
+ },
+ {
+ "ticks": 590,
+ "bytes": 294402,
+ "skipped": 0,
+ "elapsedMs": 30055.326583000002
+ }
+ ],
+ "aggregateSamples": [
+ {
+ "elapsedSeconds": 0.0058437916450202465,
+ "cpuTicks": 179185466,
+ "interruptWakeups": 7438,
+ "summedFootprintBytes": 585879336,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 1.0037234999763314,
+ "cpuTicks": 188255435,
+ "interruptWakeups": 8510,
+ "summedFootprintBytes": 606343408,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 2.0062570000009146,
+ "cpuTicks": 193368790,
+ "interruptWakeups": 9577,
+ "summedFootprintBytes": 609571080,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 3.00783849999425,
+ "cpuTicks": 199696611,
+ "interruptWakeups": 10586,
+ "summedFootprintBytes": 579752200,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 4.004056833306095,
+ "cpuTicks": 206755276,
+ "interruptWakeups": 11584,
+ "summedFootprintBytes": 596840712,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 5.006072624993976,
+ "cpuTicks": 213246993,
+ "interruptWakeups": 12485,
+ "summedFootprintBytes": 596005128,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 6.003757708327612,
+ "cpuTicks": 223460961,
+ "interruptWakeups": 13490,
+ "summedFootprintBytes": 643223936,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 7.006081833329517,
+ "cpuTicks": 228921043,
+ "interruptWakeups": 14466,
+ "summedFootprintBytes": 647303576,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 8.006988958310103,
+ "cpuTicks": 236669151,
+ "interruptWakeups": 15397,
+ "summedFootprintBytes": 650285272,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 9.006328458315693,
+ "cpuTicks": 248390715,
+ "interruptWakeups": 16689,
+ "summedFootprintBytes": 651907672,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 10.001503124978626,
+ "cpuTicks": 255028749,
+ "interruptWakeups": 17770,
+ "summedFootprintBytes": 656347736,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 11.010598291642964,
+ "cpuTicks": 263381675,
+ "interruptWakeups": 18859,
+ "summedFootprintBytes": 662344328,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 12.006131124973763,
+ "cpuTicks": 269741592,
+ "interruptWakeups": 19899,
+ "summedFootprintBytes": 667243144,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 13.008152958325809,
+ "cpuTicks": 277090748,
+ "interruptWakeups": 20992,
+ "summedFootprintBytes": 685626016,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 14.008334999991348,
+ "cpuTicks": 284724093,
+ "interruptWakeups": 22104,
+ "summedFootprintBytes": 685183648,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 15.006753208319424,
+ "cpuTicks": 291797587,
+ "interruptWakeups": 23249,
+ "summedFootprintBytes": 683528864,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 16.00573862498277,
+ "cpuTicks": 301890142,
+ "interruptWakeups": 24466,
+ "summedFootprintBytes": 696423120,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 17.00503291664063,
+ "cpuTicks": 308627425,
+ "interruptWakeups": 25686,
+ "summedFootprintBytes": 701354728,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 18.00683391664643,
+ "cpuTicks": 315689180,
+ "interruptWakeups": 26864,
+ "summedFootprintBytes": 706630400,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 19.005455541657284,
+ "cpuTicks": 322232419,
+ "interruptWakeups": 27981,
+ "summedFootprintBytes": 724931520,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 20.006648333306657,
+ "cpuTicks": 328649263,
+ "interruptWakeups": 29084,
+ "summedFootprintBytes": 730700392,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 21.009197416657116,
+ "cpuTicks": 339773163,
+ "interruptWakeups": 30186,
+ "summedFootprintBytes": 732061344,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 22.00564608332934,
+ "cpuTicks": 346144007,
+ "interruptWakeups": 31269,
+ "summedFootprintBytes": 750263968,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 23.009523958317004,
+ "cpuTicks": 353721189,
+ "interruptWakeups": 32359,
+ "summedFootprintBytes": 751525536,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 24.00400958332466,
+ "cpuTicks": 360851385,
+ "interruptWakeups": 33441,
+ "summedFootprintBytes": 749444768,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 25.009081333322683,
+ "cpuTicks": 366665310,
+ "interruptWakeups": 34555,
+ "summedFootprintBytes": 759226016,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 26.010952416661894,
+ "cpuTicks": 376647218,
+ "interruptWakeups": 35711,
+ "summedFootprintBytes": 759340752,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 27.006885583308758,
+ "cpuTicks": 384193296,
+ "interruptWakeups": 36831,
+ "summedFootprintBytes": 756702928,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 28.00651787497918,
+ "cpuTicks": 391997140,
+ "interruptWakeups": 37931,
+ "summedFootprintBytes": 774676176,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 29.00702937497408,
+ "cpuTicks": 399521667,
+ "interruptWakeups": 39045,
+ "summedFootprintBytes": 778985168,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 30.006316624989267,
+ "cpuTicks": 406856229,
+ "interruptWakeups": 40122,
+ "summedFootprintBytes": 783376176,
+ "accountingProcessCount": 24
+ }
+ ]
+ },
+ {
+ "label": "background-idle-hidden",
+ "summary": {
+ "cpuPercentOneCore": 4.185005005191654,
+ "cpuSeconds": 1.2558846666666668,
+ "elapsedSeconds": 30.009155666688457,
+ "interruptWakeupsPerSecond": 14.395606620800061,
+ "liveProcessCountMax": 24,
+ "liveProcessCountMin": 24,
+ "packageIdleWakeupsPerSecond": 0,
+ "processCountMax": 24,
+ "processCountMin": 24,
+ "summedPhysicalFootprintMiBMedian": 682.7890472412109,
+ "summedPhysicalFootprintMiBPeak": 685.6329345703125
+ },
+ "components": {
+ "desktop": {
+ "cpuPercentOneCore": 0.17525012671953263,
+ "interruptWakeupsPerSecond": 3.132377366562976
+ },
+ "daemon": {
+ "cpuPercentOneCore": 3.9744360740454927,
+ "interruptWakeupsPerSecond": 10.5967659847556
+ },
+ "tmuxAndWorkers": {
+ "cpuPercentOneCore": 0.03531880442662783,
+ "interruptWakeupsPerSecond": 0.6664632694814843
+ }
+ },
+ "rawSampleSha256": "705e8ff53f8711d20a6a65c1b29d85c62d0818988da777c7718404a95e250532",
+ "nativeBefore": {
+ "active": false,
+ "hidden": true,
+ "scale": 2.0,
+ "visible": false,
+ "width": 1280.0,
+ "key": false,
+ "focusLosses": 1,
+ "height": 800.0
+ },
+ "nativeAfter": {
+ "active": false,
+ "hidden": true,
+ "scale": 2.0,
+ "visible": false,
+ "width": 1280.0,
+ "key": false,
+ "focusLosses": 1,
+ "height": 800.0
+ },
+ "outputPerWorker": [
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30089.978833000016
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30089.95279200001
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30089.536332999996
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30089.439458000008
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30089.30287500001
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30089.163916999998
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30087.898625000016
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30085.065457999997
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30083.838292
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30077.506208000006
+ }
+ ],
+ "aggregateSamples": [
+ {
+ "elapsedSeconds": 0.008871166646713391,
+ "cpuTicks": 412307232,
+ "interruptWakeups": 40359,
+ "summedFootprintBytes": 711483256,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 1.0123196666536387,
+ "cpuTicks": 416762377,
+ "interruptWakeups": 40383,
+ "summedFootprintBytes": 712236968,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 2.0088079999841284,
+ "cpuTicks": 416793921,
+ "interruptWakeups": 40390,
+ "summedFootprintBytes": 712384424,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 3.0165399583347607,
+ "cpuTicks": 416942397,
+ "interruptWakeups": 40416,
+ "summedFootprintBytes": 712449960,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 4.0148327499919105,
+ "cpuTicks": 416958277,
+ "interruptWakeups": 40421,
+ "summedFootprintBytes": 712449960,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 5.035727999988012,
+ "cpuTicks": 416963542,
+ "interruptWakeups": 40426,
+ "summedFootprintBytes": 712449960,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 6.014784749975661,
+ "cpuTicks": 421522674,
+ "interruptWakeups": 40454,
+ "summedFootprintBytes": 714432472,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 7.014210791647201,
+ "cpuTicks": 421720759,
+ "interruptWakeups": 40462,
+ "summedFootprintBytes": 714792920,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 8.016038291651057,
+ "cpuTicks": 421959471,
+ "interruptWakeups": 40504,
+ "summedFootprintBytes": 714907608,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 9.015376916649984,
+ "cpuTicks": 421967711,
+ "interruptWakeups": 40506,
+ "summedFootprintBytes": 714907608,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 10.009000166668557,
+ "cpuTicks": 421975529,
+ "interruptWakeups": 40510,
+ "summedFootprintBytes": 714907608,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 11.008002916641999,
+ "cpuTicks": 426938946,
+ "interruptWakeups": 40535,
+ "summedFootprintBytes": 715694064,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 12.018262124998728,
+ "cpuTicks": 427073308,
+ "interruptWakeups": 40542,
+ "summedFootprintBytes": 715890672,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 13.020152999990387,
+ "cpuTicks": 427256520,
+ "interruptWakeups": 40568,
+ "summedFootprintBytes": 715956208,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 14.011989416641882,
+ "cpuTicks": 427263723,
+ "interruptWakeups": 40573,
+ "summedFootprintBytes": 715956208,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 15.012376958329696,
+ "cpuTicks": 427267804,
+ "interruptWakeups": 40575,
+ "summedFootprintBytes": 715956208,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 16.017128124978626,
+ "cpuTicks": 432013247,
+ "interruptWakeups": 40600,
+ "summedFootprintBytes": 716759072,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 17.01471604165272,
+ "cpuTicks": 432071759,
+ "interruptWakeups": 40606,
+ "summedFootprintBytes": 716890144,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 18.01456716665416,
+ "cpuTicks": 432235115,
+ "interruptWakeups": 40635,
+ "summedFootprintBytes": 716939296,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 19.016974083322566,
+ "cpuTicks": 432238974,
+ "interruptWakeups": 40637,
+ "summedFootprintBytes": 716939296,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 20.015077333315276,
+ "cpuTicks": 432255564,
+ "interruptWakeups": 40643,
+ "summedFootprintBytes": 716939296,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 21.012809958308935,
+ "cpuTicks": 436969195,
+ "interruptWakeups": 40671,
+ "summedFootprintBytes": 717725776,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 22.016796749987407,
+ "cpuTicks": 437087603,
+ "interruptWakeups": 40677,
+ "summedFootprintBytes": 717873232,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 23.015583499975037,
+ "cpuTicks": 437251715,
+ "interruptWakeups": 40714,
+ "summedFootprintBytes": 717938768,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 24.017554791644216,
+ "cpuTicks": 437265144,
+ "interruptWakeups": 40719,
+ "summedFootprintBytes": 717938768,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 25.013557166646933,
+ "cpuTicks": 437269815,
+ "interruptWakeups": 40721,
+ "summedFootprintBytes": 717938768,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 26.009327374980785,
+ "cpuTicks": 442097264,
+ "interruptWakeups": 40747,
+ "summedFootprintBytes": 718725248,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 27.015325541666243,
+ "cpuTicks": 442208633,
+ "interruptWakeups": 40751,
+ "summedFootprintBytes": 718872704,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 28.009884083323414,
+ "cpuTicks": 442436026,
+ "interruptWakeups": 40782,
+ "summedFootprintBytes": 718938240,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 29.010986249981215,
+ "cpuTicks": 442441634,
+ "interruptWakeups": 40787,
+ "summedFootprintBytes": 718938240,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 30.01802683333517,
+ "cpuTicks": 442448464,
+ "interruptWakeups": 40791,
+ "summedFootprintBytes": 718938240,
+ "accountingProcessCount": 24
+ }
+ ]
+ },
+ {
+ "label": "background-active",
+ "summary": {
+ "cpuPercentOneCore": 23.234900107607952,
+ "cpuSeconds": 6.972099166666667,
+ "elapsedSeconds": 30.007011583336862,
+ "interruptWakeupsPerSecond": 832.6054039274547,
+ "liveProcessCountMax": 26,
+ "liveProcessCountMin": 24,
+ "packageIdleWakeupsPerSecond": 0,
+ "processCountMax": 26,
+ "processCountMin": 24,
+ "summedPhysicalFootprintMiBMedian": 698.4455261230469,
+ "summedPhysicalFootprintMiBPeak": 700.8832778930664
+ },
+ "components": {
+ "desktop": {
+ "cpuPercentOneCore": 7.590106183487516,
+ "interruptWakeupsPerSecond": 110.20757567995888
+ },
+ "daemon": {
+ "cpuPercentOneCore": 8.414238290011555,
+ "interruptWakeupsPerSecond": 223.94765907750943
+ },
+ "tmuxAndWorkers": {
+ "cpuPercentOneCore": 7.230555634108875,
+ "interruptWakeupsPerSecond": 498.4501691699864
+ }
+ },
+ "rawSampleSha256": "a6d48c4f4f7dc094da9129cc01e9d745762e5cab40ca7173555c1a9787f53955",
+ "nativeBefore": {
+ "active": false,
+ "hidden": true,
+ "scale": 2.0,
+ "visible": false,
+ "width": 1280.0,
+ "key": false,
+ "focusLosses": 1,
+ "height": 800.0
+ },
+ "nativeAfter": {
+ "active": false,
+ "hidden": true,
+ "scale": 2.0,
+ "visible": false,
+ "width": 1280.0,
+ "key": false,
+ "focusLosses": 1,
+ "height": 800.0
+ },
+ "outputPerWorker": [
+ {
+ "ticks": 585,
+ "bytes": 294891,
+ "skipped": 0,
+ "elapsedMs": 30142.986125000025
+ },
+ {
+ "ticks": 584,
+ "bytes": 294384,
+ "skipped": 0,
+ "elapsedMs": 30142.835458000016
+ },
+ {
+ "ticks": 584,
+ "bytes": 294376,
+ "skipped": 0,
+ "elapsedMs": 30142.690250000014
+ },
+ {
+ "ticks": 585,
+ "bytes": 294891,
+ "skipped": 0,
+ "elapsedMs": 30142.484708000004
+ },
+ {
+ "ticks": 585,
+ "bytes": 294891,
+ "skipped": 0,
+ "elapsedMs": 30142.210457999987
+ },
+ {
+ "ticks": 584,
+ "bytes": 294376,
+ "skipped": 0,
+ "elapsedMs": 30141.986375000008
+ },
+ {
+ "ticks": 584,
+ "bytes": 294384,
+ "skipped": 0,
+ "elapsedMs": 30141.76874999999
+ },
+ {
+ "ticks": 584,
+ "bytes": 294384,
+ "skipped": 0,
+ "elapsedMs": 30141.571083000017
+ },
+ {
+ "ticks": 584,
+ "bytes": 294384,
+ "skipped": 0,
+ "elapsedMs": 30141.387749999994
+ },
+ {
+ "ticks": 584,
+ "bytes": 294384,
+ "skipped": 0,
+ "elapsedMs": 30141.258375000005
+ }
+ ],
+ "aggregateSamples": [
+ {
+ "elapsedSeconds": 0.09275062501546927,
+ "cpuTicks": 471543422,
+ "interruptWakeups": 44669,
+ "summedFootprintBytes": 734126472,
+ "accountingProcessCount": 25
+ },
+ {
+ "elapsedSeconds": 1.008274916675873,
+ "cpuTicks": 476618924,
+ "interruptWakeups": 45381,
+ "summedFootprintBytes": 733684008,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 2.014929375000065,
+ "cpuTicks": 482947313,
+ "interruptWakeups": 46130,
+ "summedFootprintBytes": 727457848,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 3.013197708351072,
+ "cpuTicks": 487165678,
+ "interruptWakeups": 46958,
+ "summedFootprintBytes": 727490616,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 4.0156994166609365,
+ "cpuTicks": 492909779,
+ "interruptWakeups": 47797,
+ "summedFootprintBytes": 727523384,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 5.106591041665524,
+ "cpuTicks": 502410271,
+ "interruptWakeups": 48760,
+ "summedFootprintBytes": 729456936,
+ "accountingProcessCount": 25
+ },
+ {
+ "elapsedSeconds": 6.00457487499807,
+ "cpuTicks": 506711131,
+ "interruptWakeups": 49465,
+ "summedFootprintBytes": 729342056,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 7.0112369999988005,
+ "cpuTicks": 511932420,
+ "interruptWakeups": 50244,
+ "summedFootprintBytes": 729981032,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 8.019489375001285,
+ "cpuTicks": 516840102,
+ "interruptWakeups": 51101,
+ "summedFootprintBytes": 730046568,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 9.015964375023032,
+ "cpuTicks": 521858745,
+ "interruptWakeups": 51882,
+ "summedFootprintBytes": 730046568,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 10.115923666686285,
+ "cpuTicks": 531802054,
+ "interruptWakeups": 52853,
+ "summedFootprintBytes": 733045056,
+ "accountingProcessCount": 25
+ },
+ {
+ "elapsedSeconds": 11.013479833345627,
+ "cpuTicks": 536851912,
+ "interruptWakeups": 53636,
+ "summedFootprintBytes": 731619456,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 12.003803708328633,
+ "cpuTicks": 542359860,
+ "interruptWakeups": 54462,
+ "summedFootprintBytes": 731619456,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 13.010292749997461,
+ "cpuTicks": 546285312,
+ "interruptWakeups": 55405,
+ "summedFootprintBytes": 731619456,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 14.014897375018336,
+ "cpuTicks": 552172571,
+ "interruptWakeups": 56301,
+ "summedFootprintBytes": 732160128,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 15.062748208350968,
+ "cpuTicks": 559268815,
+ "interruptWakeups": 57258,
+ "summedFootprintBytes": 733962680,
+ "accountingProcessCount": 25
+ },
+ {
+ "elapsedSeconds": 16.009064416663023,
+ "cpuTicks": 563903499,
+ "interruptWakeups": 58065,
+ "summedFootprintBytes": 733028600,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 17.010913125006482,
+ "cpuTicks": 569949563,
+ "interruptWakeups": 58888,
+ "summedFootprintBytes": 731160752,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 18.008929125004215,
+ "cpuTicks": 574487621,
+ "interruptWakeups": 59793,
+ "summedFootprintBytes": 731160752,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 19.0171569166705,
+ "cpuTicks": 578742781,
+ "interruptWakeups": 60553,
+ "summedFootprintBytes": 731422896,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 20.123188249999657,
+ "cpuTicks": 587299515,
+ "interruptWakeups": 61428,
+ "summedFootprintBytes": 733962848,
+ "accountingProcessCount": 26
+ },
+ {
+ "elapsedSeconds": 21.01066475000698,
+ "cpuTicks": 591734062,
+ "interruptWakeups": 62170,
+ "summedFootprintBytes": 732373216,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 22.01441258334671,
+ "cpuTicks": 597162039,
+ "interruptWakeups": 63021,
+ "summedFootprintBytes": 732373216,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 23.007883875019616,
+ "cpuTicks": 601607080,
+ "interruptWakeups": 63866,
+ "summedFootprintBytes": 732373216,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 24.016040791670093,
+ "cpuTicks": 606110199,
+ "interruptWakeups": 64716,
+ "summedFootprintBytes": 732373216,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 25.115881333331345,
+ "cpuTicks": 613989463,
+ "interruptWakeups": 65598,
+ "summedFootprintBytes": 733979088,
+ "accountingProcessCount": 25
+ },
+ {
+ "elapsedSeconds": 26.020718875020975,
+ "cpuTicks": 618459268,
+ "interruptWakeups": 66363,
+ "summedFootprintBytes": 733094160,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 27.016892541665584,
+ "cpuTicks": 623211841,
+ "interruptWakeups": 67134,
+ "summedFootprintBytes": 733110544,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 28.010232541681034,
+ "cpuTicks": 627647397,
+ "interruptWakeups": 67952,
+ "summedFootprintBytes": 733110544,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 29.016042166680563,
+ "cpuTicks": 631052985,
+ "interruptWakeups": 68730,
+ "summedFootprintBytes": 733126928,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 30.09976220835233,
+ "cpuTicks": 638873802,
+ "interruptWakeups": 69653,
+ "summedFootprintBytes": 734929384,
+ "accountingProcessCount": 25
+ }
+ ]
+ }
+ ]
+ },
+ {
+ "variant": "current",
+ "run": "harness-connected-v2-3-current-20261002",
+ "loadBefore": [
+ 7.705078125,
+ 11.3896484375,
+ 14.20947265625
+ ],
+ "loadAfter": [
+ 8.87841796875,
+ 10.83984375,
+ 13.4833984375
+ ],
+ "startEpoch": 1790983157.043078,
+ "endEpoch": 1790983338.127649,
+ "toolingSha256": {
+ "connected_run.py": "f0857e324905b12c47a520cceacd4eff6fe5d8894f78f67e9c4dc10b81c951ed",
+ "connected_stack.mjs": "819ed8941fa33d05bedc732461e9753f69fba9c5796f915909b6c3c1e1f663fe",
+ "connected_worker.mjs": "3456923d6b9f6ff8628c7f84dd2540cb55adf4a83950e6970ace506a1a98295e",
+ "harness-connected-forest-usage-v2-20261002": "48816ec9467b369be056bb03c4b89aa2766a35d07d80f3d0e2a99db987c8c0fb"
+ },
+ "daemonMetadata": {
+ "bundleSha256": "286713aed76a1972419d5d06f6c7069c73bddef81acdeecf9be128de9bd4e369",
+ "sourceRevision": "c966e1ac0e10d2741bad53352fcdba9b41d2a6de",
+ "sourceDiffSha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+ "boundary": "Full local daemon and tmux; private terminal shells; no cloud account or model inference."
+ },
+ "appSourceRevision": "c966e1ac0e10d2741bad53352fcdba9b41d2a6de",
+ "appProductionDiffSha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+ "appFixtureSha256": {
+ "connected_main.dart": "8bdf2061c52713ff5dc37939252c5184e90e8da353d3f315e505f270c4e51eed",
+ "ConnectedResourceHost.swift": "f9f58dc6d209119ee4a3440661518785e7ea13f2057c001c666b45ea20e4493e"
+ },
+ "cleanupVerified": true,
+ "phases": [
+ {
+ "label": "foreground-idle-visible",
+ "summary": {
+ "cpuPercentOneCore": 5.881817854292955,
+ "cpuSeconds": 1.764824625,
+ "elapsedSeconds": 30.004748000006657,
+ "interruptWakeupsPerSecond": 26.6291188314537,
+ "liveProcessCountMax": 24,
+ "liveProcessCountMin": 24,
+ "packageIdleWakeupsPerSecond": 0,
+ "processCountMax": 24,
+ "processCountMin": 24,
+ "summedPhysicalFootprintMiBMedian": 509.29993438720703,
+ "summedPhysicalFootprintMiBPeak": 555.7051086425781
+ },
+ "components": {
+ "desktop": {
+ "cpuPercentOneCore": 1.1795926153640355,
+ "interruptWakeupsPerSecond": 13.831144324221883
+ },
+ "daemon": {
+ "cpuPercentOneCore": 4.673712112717478,
+ "interruptWakeupsPerSecond": 12.131413334980158
+ },
+ "tmuxAndWorkers": {
+ "cpuPercentOneCore": 0.02851312621144083,
+ "interruptWakeupsPerSecond": 0.666561172251657
+ }
+ },
+ "rawSampleSha256": "35994af1433f14ef2493120c3cdd7fe498f1959628d8a6bd824dbeb2050f444a",
+ "nativeBefore": {
+ "height": 800.0,
+ "key": true,
+ "hidden": false,
+ "width": 1280.0,
+ "scale": 2.0,
+ "visible": true,
+ "focusLosses": 0,
+ "active": true
+ },
+ "nativeAfter": {
+ "height": 800.0,
+ "key": true,
+ "hidden": false,
+ "width": 1280.0,
+ "scale": 2.0,
+ "visible": true,
+ "focusLosses": 0,
+ "active": true
+ },
+ "outputPerWorker": [
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30068.803750000003
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30068.126707999996
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30067.803458
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30067.448417000003
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30067.284874999998
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30067.223042000005
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30067.149041999997
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30067.16775
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30067.245375000002
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30067.166
+ }
+ ],
+ "aggregateSamples": [
+ {
+ "elapsedSeconds": 0.007287749991519377,
+ "cpuTicks": 69711735,
+ "interruptWakeups": 1316,
+ "summedFootprintBytes": 577766856,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 1.0074164583347738,
+ "cpuTicks": 74321217,
+ "interruptWakeups": 1352,
+ "summedFootprintBytes": 582699040,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 2.0087462500086986,
+ "cpuTicks": 74519061,
+ "interruptWakeups": 1366,
+ "summedFootprintBytes": 549963808,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 3.009406041674083,
+ "cpuTicks": 74917256,
+ "interruptWakeups": 1409,
+ "summedFootprintBytes": 550406176,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 4.011137416673591,
+ "cpuTicks": 75106119,
+ "interruptWakeups": 1424,
+ "summedFootprintBytes": 550471712,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 5.015074291673955,
+ "cpuTicks": 75286255,
+ "interruptWakeups": 1440,
+ "summedFootprintBytes": 550520864,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 6.01182825001888,
+ "cpuTicks": 86060253,
+ "interruptWakeups": 1513,
+ "summedFootprintBytes": 559058008,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 7.0138048749940936,
+ "cpuTicks": 86295104,
+ "interruptWakeups": 1528,
+ "summedFootprintBytes": 526339160,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 8.013583291671239,
+ "cpuTicks": 86743338,
+ "interruptWakeups": 1575,
+ "summedFootprintBytes": 526699608,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 9.009665791672887,
+ "cpuTicks": 86927883,
+ "interruptWakeups": 1593,
+ "summedFootprintBytes": 526765144,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 10.009764250018634,
+ "cpuTicks": 87207613,
+ "interruptWakeups": 1608,
+ "summedFootprintBytes": 526830680,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 11.012780833349098,
+ "cpuTicks": 91597184,
+ "interruptWakeups": 1645,
+ "summedFootprintBytes": 527731824,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 12.010471624991624,
+ "cpuTicks": 91746669,
+ "interruptWakeups": 1658,
+ "summedFootprintBytes": 527780976,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 13.008770833344897,
+ "cpuTicks": 92365092,
+ "interruptWakeups": 1701,
+ "summedFootprintBytes": 528075888,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 14.02037795833894,
+ "cpuTicks": 92555788,
+ "interruptWakeups": 1716,
+ "summedFootprintBytes": 528141424,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 15.006646541674854,
+ "cpuTicks": 92766818,
+ "interruptWakeups": 1731,
+ "summedFootprintBytes": 528206984,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 16.015462916664546,
+ "cpuTicks": 97085995,
+ "interruptWakeups": 1768,
+ "summedFootprintBytes": 528764040,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 17.008269833342638,
+ "cpuTicks": 97351412,
+ "interruptWakeups": 1783,
+ "summedFootprintBytes": 528829576,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 18.009005791682284,
+ "cpuTicks": 97838840,
+ "interruptWakeups": 1820,
+ "summedFootprintBytes": 529091720,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 19.002738916664384,
+ "cpuTicks": 98074041,
+ "interruptWakeups": 1837,
+ "summedFootprintBytes": 529140872,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 20.01249408334843,
+ "cpuTicks": 98289806,
+ "interruptWakeups": 1850,
+ "summedFootprintBytes": 529206408,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 21.0173939166707,
+ "cpuTicks": 103724913,
+ "interruptWakeups": 1898,
+ "summedFootprintBytes": 526928984,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 22.002844916685717,
+ "cpuTicks": 104487689,
+ "interruptWakeups": 1913,
+ "summedFootprintBytes": 544230488,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 23.01248062500963,
+ "cpuTicks": 105078050,
+ "interruptWakeups": 1962,
+ "summedFootprintBytes": 544509016,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 24.006675999989966,
+ "cpuTicks": 105252560,
+ "interruptWakeups": 1977,
+ "summedFootprintBytes": 544574552,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 25.007055541675072,
+ "cpuTicks": 105465563,
+ "interruptWakeups": 1993,
+ "summedFootprintBytes": 544623704,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 26.012005333352135,
+ "cpuTicks": 110994844,
+ "interruptWakeups": 2031,
+ "summedFootprintBytes": 534039688,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 27.010979583341395,
+ "cpuTicks": 111192447,
+ "interruptWakeups": 2047,
+ "summedFootprintBytes": 534056072,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 28.012688624992734,
+ "cpuTicks": 111640940,
+ "interruptWakeups": 2084,
+ "summedFootprintBytes": 534318216,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 29.01197108332417,
+ "cpuTicks": 111815217,
+ "interruptWakeups": 2102,
+ "summedFootprintBytes": 534383752,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 30.012035749998176,
+ "cpuTicks": 112067526,
+ "interruptWakeups": 2115,
+ "summedFootprintBytes": 534432904,
+ "accountingProcessCount": 24
+ }
+ ]
+ },
+ {
+ "label": "foreground-idle-hidden",
+ "summary": {
+ "cpuPercentOneCore": 3.6928782155403654,
+ "cpuSeconds": 1.108049875,
+ "elapsedSeconds": 30.00504783334327,
+ "interruptWakeupsPerSecond": 15.297426038092624,
+ "liveProcessCountMax": 24,
+ "liveProcessCountMin": 24,
+ "packageIdleWakeupsPerSecond": 0,
+ "processCountMax": 24,
+ "processCountMin": 24,
+ "summedPhysicalFootprintMiBMedian": 472.8312759399414,
+ "summedPhysicalFootprintMiBPeak": 475.0969924926758
+ },
+ "components": {
+ "desktop": {
+ "cpuPercentOneCore": 0.13001298498175615,
+ "interruptWakeupsPerSecond": 3.0994784783063487
+ },
+ "daemon": {
+ "cpuPercentOneCore": 3.538089260501979,
+ "interruptWakeupsPerSecond": 11.531393048322544
+ },
+ "tmuxAndWorkers": {
+ "cpuPercentOneCore": 0.024775970056630094,
+ "interruptWakeupsPerSecond": 0.6665545114637309
+ }
+ },
+ "rawSampleSha256": "69ade623fea4240d3d2188462dec5e8485c274705031feed0fd1f531da60249a",
+ "nativeBefore": {
+ "height": 800.0,
+ "key": true,
+ "hidden": false,
+ "width": 1280.0,
+ "scale": 2.0,
+ "visible": true,
+ "focusLosses": 0,
+ "active": true
+ },
+ "nativeAfter": {
+ "height": 800.0,
+ "key": true,
+ "hidden": false,
+ "width": 1280.0,
+ "scale": 2.0,
+ "visible": true,
+ "focusLosses": 0,
+ "active": true
+ },
+ "outputPerWorker": [
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30045.982167000002
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30045.861917000002
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30045.802000000003
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30045.749333
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30045.726875000008
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30045.709333000006
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30045.653540999992
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30045.621250000004
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30045.549916999997
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30045.494958000003
+ }
+ ],
+ "aggregateSamples": [
+ {
+ "elapsedSeconds": 0.005260000005364418,
+ "cpuTicks": 117582683,
+ "interruptWakeups": 2243,
+ "summedFootprintBytes": 493948088,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 1.0142079583602026,
+ "cpuTicks": 121781908,
+ "interruptWakeups": 2273,
+ "summedFootprintBytes": 494701800,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 2.013294541684445,
+ "cpuTicks": 121793512,
+ "interruptWakeups": 2278,
+ "summedFootprintBytes": 494701800,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 3.012518458359409,
+ "cpuTicks": 122303216,
+ "interruptWakeups": 2314,
+ "summedFootprintBytes": 494914792,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 4.012964916677447,
+ "cpuTicks": 122315409,
+ "interruptWakeups": 2321,
+ "summedFootprintBytes": 494914792,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 5.012814416666515,
+ "cpuTicks": 122317820,
+ "interruptWakeups": 2323,
+ "summedFootprintBytes": 494914792,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 6.012946833332535,
+ "cpuTicks": 126523173,
+ "interruptWakeups": 2355,
+ "summedFootprintBytes": 495701272,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 7.01195695833303,
+ "cpuTicks": 126529108,
+ "interruptWakeups": 2358,
+ "summedFootprintBytes": 495701272,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 8.002235041669337,
+ "cpuTicks": 126848256,
+ "interruptWakeups": 2386,
+ "summedFootprintBytes": 495914264,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 9.015658000018448,
+ "cpuTicks": 126853250,
+ "interruptWakeups": 2390,
+ "summedFootprintBytes": 495914264,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 10.00386066667852,
+ "cpuTicks": 126869425,
+ "interruptWakeups": 2396,
+ "summedFootprintBytes": 495914264,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 11.014158208359731,
+ "cpuTicks": 131145666,
+ "interruptWakeups": 2421,
+ "summedFootprintBytes": 496684336,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 12.008460208337056,
+ "cpuTicks": 131150857,
+ "interruptWakeups": 2425,
+ "summedFootprintBytes": 496700720,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 13.009454083337914,
+ "cpuTicks": 131261281,
+ "interruptWakeups": 2452,
+ "summedFootprintBytes": 496913712,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 14.011642500001471,
+ "cpuTicks": 131268064,
+ "interruptWakeups": 2459,
+ "summedFootprintBytes": 496913712,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 15.003809708345216,
+ "cpuTicks": 131269857,
+ "interruptWakeups": 2463,
+ "summedFootprintBytes": 496913712,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 16.00434958335245,
+ "cpuTicks": 134571038,
+ "interruptWakeups": 2500,
+ "summedFootprintBytes": 497683784,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 17.011634083348326,
+ "cpuTicks": 134572206,
+ "interruptWakeups": 2502,
+ "summedFootprintBytes": 497683784,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 18.00597870835918,
+ "cpuTicks": 135077091,
+ "interruptWakeups": 2550,
+ "summedFootprintBytes": 498158920,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 19.007338583352976,
+ "cpuTicks": 135085431,
+ "interruptWakeups": 2556,
+ "summedFootprintBytes": 498175304,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 20.011430500017013,
+ "cpuTicks": 135087150,
+ "interruptWakeups": 2560,
+ "summedFootprintBytes": 498175304,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 21.009978041693103,
+ "cpuTicks": 139187755,
+ "interruptWakeups": 2589,
+ "summedFootprintBytes": 494570680,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 22.001660000008997,
+ "cpuTicks": 139192727,
+ "interruptWakeups": 2595,
+ "summedFootprintBytes": 494570680,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 23.011565833352506,
+ "cpuTicks": 139270835,
+ "interruptWakeups": 2621,
+ "summedFootprintBytes": 494816440,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 24.016065416682977,
+ "cpuTicks": 139274827,
+ "interruptWakeups": 2627,
+ "summedFootprintBytes": 494816440,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 25.014443666674197,
+ "cpuTicks": 139280485,
+ "interruptWakeups": 2630,
+ "summedFootprintBytes": 494816440,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 26.01557833334664,
+ "cpuTicks": 143827461,
+ "interruptWakeups": 2661,
+ "summedFootprintBytes": 495602920,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 27.012682708358625,
+ "cpuTicks": 143831779,
+ "interruptWakeups": 2663,
+ "summedFootprintBytes": 495602920,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 28.011850750015583,
+ "cpuTicks": 144160896,
+ "interruptWakeups": 2693,
+ "summedFootprintBytes": 495799528,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 29.011394291679608,
+ "cpuTicks": 144162592,
+ "interruptWakeups": 2697,
+ "summedFootprintBytes": 495799528,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 30.010307833348634,
+ "cpuTicks": 144175880,
+ "interruptWakeups": 2702,
+ "summedFootprintBytes": 495799528,
+ "accountingProcessCount": 24
+ }
+ ]
+ },
+ {
+ "label": "foreground-active",
+ "summary": {
+ "cpuPercentOneCore": 34.011475830870204,
+ "cpuSeconds": 10.205418291666666,
+ "elapsedSeconds": 30.00580845834338,
+ "interruptWakeupsPerSecond": 1072.359041572596,
+ "liveProcessCountMax": 24,
+ "liveProcessCountMin": 24,
+ "packageIdleWakeupsPerSecond": 0,
+ "processCountMax": 24,
+ "processCountMin": 24,
+ "summedPhysicalFootprintMiBMedian": 687.2402496337891,
+ "summedPhysicalFootprintMiBPeak": 749.6484680175781
+ },
+ "components": {
+ "desktop": {
+ "cpuPercentOneCore": 20.518000734914725,
+ "interruptWakeupsPerSecond": 301.70825133967463
+ },
+ "daemon": {
+ "cpuPercentOneCore": 7.157972023922531,
+ "interruptWakeupsPerSecond": 257.31684619392774
+ },
+ "tmuxAndWorkers": {
+ "cpuPercentOneCore": 6.335503072032946,
+ "interruptWakeupsPerSecond": 513.3339440389935
+ }
+ },
+ "rawSampleSha256": "335a2cab1984b9674d7ac916c2a6355e062a1f575eedcc13550e01a063832598",
+ "nativeBefore": {
+ "focusLosses": 0,
+ "height": 800.0,
+ "width": 1280.0,
+ "visible": true,
+ "hidden": false,
+ "scale": 2.0,
+ "active": true,
+ "key": true
+ },
+ "nativeAfter": {
+ "focusLosses": 0,
+ "visible": true,
+ "active": true,
+ "scale": 2.0,
+ "key": true,
+ "height": 800.0,
+ "width": 1280.0,
+ "hidden": false
+ },
+ "outputPerWorker": [
+ {
+ "ticks": 582,
+ "bytes": 290402,
+ "skipped": 0,
+ "elapsedMs": 30053.246958000003
+ },
+ {
+ "ticks": 583,
+ "bytes": 290901,
+ "skipped": 0,
+ "elapsedMs": 30053.209791999994
+ },
+ {
+ "ticks": 582,
+ "bytes": 290402,
+ "skipped": 0,
+ "elapsedMs": 30053.316124999998
+ },
+ {
+ "ticks": 582,
+ "bytes": 290402,
+ "skipped": 0,
+ "elapsedMs": 30053.363708000004
+ },
+ {
+ "ticks": 583,
+ "bytes": 290901,
+ "skipped": 0,
+ "elapsedMs": 30053.346250000002
+ },
+ {
+ "ticks": 582,
+ "bytes": 290402,
+ "skipped": 0,
+ "elapsedMs": 30053.271957999998
+ },
+ {
+ "ticks": 582,
+ "bytes": 290402,
+ "skipped": 0,
+ "elapsedMs": 30053.036708
+ },
+ {
+ "ticks": 583,
+ "bytes": 290901,
+ "skipped": 0,
+ "elapsedMs": 30052.949833000006
+ },
+ {
+ "ticks": 583,
+ "bytes": 290901,
+ "skipped": 0,
+ "elapsedMs": 30052.997875
+ },
+ {
+ "ticks": 582,
+ "bytes": 290402,
+ "skipped": 0,
+ "elapsedMs": 30053.14845899999
+ }
+ ],
+ "aggregateSamples": [
+ {
+ "elapsedSeconds": 0.005182416673051193,
+ "cpuTicks": 181259194,
+ "interruptWakeups": 6973,
+ "summedFootprintBytes": 625872920,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 1.01535916668945,
+ "cpuTicks": 191456810,
+ "interruptWakeups": 7947,
+ "summedFootprintBytes": 632640232,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 2.0108558750071097,
+ "cpuTicks": 200201779,
+ "interruptWakeups": 9083,
+ "summedFootprintBytes": 649040520,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 3.0138541666674428,
+ "cpuTicks": 208118358,
+ "interruptWakeups": 10131,
+ "summedFootprintBytes": 652284552,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 4.01316412500455,
+ "cpuTicks": 214250246,
+ "interruptWakeups": 11168,
+ "summedFootprintBytes": 655479432,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 5.009980083355913,
+ "cpuTicks": 222444255,
+ "interruptWakeups": 12253,
+ "summedFootprintBytes": 672715448,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 6.0040588333504274,
+ "cpuTicks": 232561511,
+ "interruptWakeups": 13331,
+ "summedFootprintBytes": 677122768,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 7.0133238333510235,
+ "cpuTicks": 239149671,
+ "interruptWakeups": 14215,
+ "summedFootprintBytes": 678793936,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 8.011687791673467,
+ "cpuTicks": 245668081,
+ "interruptWakeups": 15152,
+ "summedFootprintBytes": 686904016,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 9.010729375004303,
+ "cpuTicks": 255817526,
+ "interruptWakeups": 16304,
+ "summedFootprintBytes": 674927576,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 10.006462000019383,
+ "cpuTicks": 263384657,
+ "interruptWakeups": 17442,
+ "summedFootprintBytes": 679154672,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 11.007914333342342,
+ "cpuTicks": 273389826,
+ "interruptWakeups": 18608,
+ "summedFootprintBytes": 697422880,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 12.003747916663997,
+ "cpuTicks": 281803269,
+ "interruptWakeups": 19744,
+ "summedFootprintBytes": 701535264,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 13.0122954583494,
+ "cpuTicks": 290396622,
+ "interruptWakeups": 20861,
+ "summedFootprintBytes": 706221088,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 14.004639583348762,
+ "cpuTicks": 295224717,
+ "interruptWakeups": 21925,
+ "summedFootprintBytes": 720623632,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 15.014764208346605,
+ "cpuTicks": 303089421,
+ "interruptWakeups": 23011,
+ "summedFootprintBytes": 727849000,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 16.003688416676596,
+ "cpuTicks": 313672115,
+ "interruptWakeups": 24094,
+ "summedFootprintBytes": 732878936,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 17.008991583337775,
+ "cpuTicks": 321698419,
+ "interruptWakeups": 25140,
+ "summedFootprintBytes": 742709336,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 18.006157416675705,
+ "cpuTicks": 330088954,
+ "interruptWakeups": 26217,
+ "summedFootprintBytes": 722180184,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 19.01136000000406,
+ "cpuTicks": 337294127,
+ "interruptWakeups": 27258,
+ "summedFootprintBytes": 719984728,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 20.015065833344124,
+ "cpuTicks": 345231070,
+ "interruptWakeups": 28320,
+ "summedFootprintBytes": 739598272,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 21.008811250008876,
+ "cpuTicks": 355766827,
+ "interruptWakeups": 29336,
+ "summedFootprintBytes": 744382424,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 22.0105573333567,
+ "cpuTicks": 361674663,
+ "interruptWakeups": 30347,
+ "summedFootprintBytes": 749363160,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 23.0063597499975,
+ "cpuTicks": 369632438,
+ "interruptWakeups": 31391,
+ "summedFootprintBytes": 766926808,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 24.004315416677855,
+ "cpuTicks": 376727551,
+ "interruptWakeups": 32482,
+ "summedFootprintBytes": 771514352,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 25.001660416688537,
+ "cpuTicks": 385607962,
+ "interruptWakeups": 33588,
+ "summedFootprintBytes": 773136368,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 26.014557875023456,
+ "cpuTicks": 395210089,
+ "interruptWakeups": 34790,
+ "summedFootprintBytes": 783704096,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 27.007210416690214,
+ "cpuTicks": 403541000,
+ "interruptWakeups": 35868,
+ "summedFootprintBytes": 780034080,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 28.011651500011794,
+ "cpuTicks": 411924376,
+ "interruptWakeups": 36980,
+ "summedFootprintBytes": 776298528,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 29.010011375008617,
+ "cpuTicks": 418617850,
+ "interruptWakeups": 38077,
+ "summedFootprintBytes": 786063392,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 30.010990875016432,
+ "cpuTicks": 426189233,
+ "interruptWakeups": 39150,
+ "summedFootprintBytes": 781918336,
+ "accountingProcessCount": 24
+ }
+ ]
+ },
+ {
+ "label": "background-idle-hidden",
+ "summary": {
+ "cpuPercentOneCore": 2.980802895269033,
+ "cpuSeconds": 0.8941565416666666,
+ "elapsedSeconds": 29.997170999995433,
+ "interruptWakeupsPerSecond": 14.401358048066125,
+ "liveProcessCountMax": 24,
+ "liveProcessCountMin": 24,
+ "packageIdleWakeupsPerSecond": 0,
+ "processCountMax": 24,
+ "processCountMin": 24,
+ "summedPhysicalFootprintMiBMedian": 680.539436340332,
+ "summedPhysicalFootprintMiBPeak": 683.46142578125
+ },
+ "components": {
+ "desktop": {
+ "cpuPercentOneCore": 0.07261795898465441,
+ "interruptWakeupsPerSecond": 3.1002923575697907
+ },
+ "daemon": {
+ "cpuPercentOneCore": 2.8909145576876742,
+ "interruptWakeupsPerSecond": 10.634336151234013
+ },
+ "tmuxAndWorkers": {
+ "cpuPercentOneCore": 0.017270378596704297,
+ "interruptWakeupsPerSecond": 0.6667295392623206
+ }
+ },
+ "rawSampleSha256": "4c46b8a195b86b15afab57b66b7ee1d866f3c6de271a2da9d531031618a423e9",
+ "nativeBefore": {
+ "focusLosses": 1,
+ "visible": false,
+ "active": false,
+ "scale": 2.0,
+ "key": false,
+ "height": 800.0,
+ "width": 1280.0,
+ "hidden": true
+ },
+ "nativeAfter": {
+ "focusLosses": 1,
+ "visible": false,
+ "active": false,
+ "scale": 2.0,
+ "key": false,
+ "height": 800.0,
+ "width": 1280.0,
+ "hidden": true
+ },
+ "outputPerWorker": [
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30041.689290999988
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30041.32775000001
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30040.852750000005
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30040.499125000002
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30040.166375
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30039.865749999997
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30039.54241600001
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30038.72470800001
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30038.296291000006
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30037.90462500001
+ }
+ ],
+ "aggregateSamples": [
+ {
+ "elapsedSeconds": 0.004294583341106772,
+ "cpuTicks": 432874674,
+ "interruptWakeups": 39367,
+ "summedFootprintBytes": 709632200,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 1.0066716250148602,
+ "cpuTicks": 436302745,
+ "interruptWakeups": 39391,
+ "summedFootprintBytes": 710582496,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 2.0030142916657496,
+ "cpuTicks": 436305902,
+ "interruptWakeups": 39396,
+ "summedFootprintBytes": 710582496,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 3.0065944583329838,
+ "cpuTicks": 436415795,
+ "interruptWakeups": 39422,
+ "summedFootprintBytes": 710795488,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 4.006789625011152,
+ "cpuTicks": 436425747,
+ "interruptWakeups": 39429,
+ "summedFootprintBytes": 710795488,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 5.006016375002218,
+ "cpuTicks": 436427872,
+ "interruptWakeups": 39434,
+ "summedFootprintBytes": 710795488,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 6.003057458350668,
+ "cpuTicks": 439808832,
+ "interruptWakeups": 39463,
+ "summedFootprintBytes": 711598352,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 7.002222166687716,
+ "cpuTicks": 439830555,
+ "interruptWakeups": 39467,
+ "summedFootprintBytes": 711598352,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 8.003765083354665,
+ "cpuTicks": 439992304,
+ "interruptWakeups": 39510,
+ "summedFootprintBytes": 712040720,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 9.006562041671714,
+ "cpuTicks": 440001839,
+ "interruptWakeups": 39515,
+ "summedFootprintBytes": 712057104,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 10.006620958331041,
+ "cpuTicks": 440003983,
+ "interruptWakeups": 39519,
+ "summedFootprintBytes": 712057104,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 11.006594750011573,
+ "cpuTicks": 443413127,
+ "interruptWakeups": 39543,
+ "summedFootprintBytes": 713384328,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 12.006363708351273,
+ "cpuTicks": 443417754,
+ "interruptWakeups": 39548,
+ "summedFootprintBytes": 713384328,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 13.006519333343022,
+ "cpuTicks": 443522151,
+ "interruptWakeups": 39574,
+ "summedFootprintBytes": 713597320,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 14.004401958343806,
+ "cpuTicks": 443525375,
+ "interruptWakeups": 39581,
+ "summedFootprintBytes": 713597320,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 15.004500250011915,
+ "cpuTicks": 443526613,
+ "interruptWakeups": 39583,
+ "summedFootprintBytes": 713597320,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 16.00667666667141,
+ "cpuTicks": 446961453,
+ "interruptWakeups": 39609,
+ "summedFootprintBytes": 714383776,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 17.006585916678887,
+ "cpuTicks": 446963044,
+ "interruptWakeups": 39612,
+ "summedFootprintBytes": 714383776,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 18.006310041673714,
+ "cpuTicks": 447075945,
+ "interruptWakeups": 39640,
+ "summedFootprintBytes": 714645920,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 19.0065682916902,
+ "cpuTicks": 447078010,
+ "interruptWakeups": 39644,
+ "summedFootprintBytes": 714645920,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 20.00650841667084,
+ "cpuTicks": 447082786,
+ "interruptWakeups": 39650,
+ "summedFootprintBytes": 714645920,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 21.00342225001077,
+ "cpuTicks": 450538159,
+ "interruptWakeups": 39677,
+ "summedFootprintBytes": 715416016,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 22.006588583346456,
+ "cpuTicks": 450540522,
+ "interruptWakeups": 39681,
+ "summedFootprintBytes": 715416016,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 23.006575750012416,
+ "cpuTicks": 450659377,
+ "interruptWakeups": 39719,
+ "summedFootprintBytes": 715612624,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 24.006611000018893,
+ "cpuTicks": 450664312,
+ "interruptWakeups": 39726,
+ "summedFootprintBytes": 715612624,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 25.00673045834992,
+ "cpuTicks": 450665572,
+ "interruptWakeups": 39728,
+ "summedFootprintBytes": 715612624,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 26.0065794166876,
+ "cpuTicks": 454215819,
+ "interruptWakeups": 39756,
+ "summedFootprintBytes": 716448256,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 27.006571791687747,
+ "cpuTicks": 454219025,
+ "interruptWakeups": 39758,
+ "summedFootprintBytes": 716448256,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 28.006621500011533,
+ "cpuTicks": 454329371,
+ "interruptWakeups": 39790,
+ "summedFootprintBytes": 716661248,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 29.00658104167087,
+ "cpuTicks": 454332048,
+ "interruptWakeups": 39795,
+ "summedFootprintBytes": 716661248,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 30.00146558333654,
+ "cpuTicks": 454334431,
+ "interruptWakeups": 39799,
+ "summedFootprintBytes": 716661248,
+ "accountingProcessCount": 24
+ }
+ ]
+ },
+ {
+ "label": "background-active",
+ "summary": {
+ "cpuPercentOneCore": 20.510776081741913,
+ "cpuSeconds": 6.154666416666667,
+ "elapsedSeconds": 30.00698945831391,
+ "interruptWakeupsPerSecond": 947.5792311488252,
+ "liveProcessCountMax": 24,
+ "liveProcessCountMin": 24,
+ "packageIdleWakeupsPerSecond": 0,
+ "processCountMax": 24,
+ "processCountMin": 24,
+ "summedPhysicalFootprintMiBMedian": 687.1644821166992,
+ "summedPhysicalFootprintMiBPeak": 689.2586441040039
+ },
+ "components": {
+ "desktop": {
+ "cpuPercentOneCore": 6.964455879753868,
+ "interruptWakeupsPerSecond": 136.20160081962612
+ },
+ "daemon": {
+ "cpuPercentOneCore": 7.233965033431818,
+ "interruptWakeupsPerSecond": 274.6693403365203
+ },
+ "tmuxAndWorkers": {
+ "cpuPercentOneCore": 6.312355168556226,
+ "interruptWakeupsPerSecond": 536.7082899926788
+ }
+ },
+ "rawSampleSha256": "25295a84fffdc07a9f12b3a1316d5859b6eee94499204749aa17cddd3f73338a",
+ "nativeBefore": {
+ "focusLosses": 1,
+ "visible": false,
+ "active": false,
+ "scale": 2.0,
+ "key": false,
+ "height": 800.0,
+ "width": 1280.0,
+ "hidden": true
+ },
+ "nativeAfter": {
+ "focusLosses": 1,
+ "visible": false,
+ "active": false,
+ "scale": 2.0,
+ "key": false,
+ "height": 800.0,
+ "width": 1280.0,
+ "hidden": true
+ },
+ "outputPerWorker": [
+ {
+ "ticks": 590,
+ "bytes": 297362,
+ "skipped": 0,
+ "elapsedMs": 30064.916874999995
+ },
+ {
+ "ticks": 590,
+ "bytes": 297362,
+ "skipped": 0,
+ "elapsedMs": 30065.109708000004
+ },
+ {
+ "ticks": 590,
+ "bytes": 297354,
+ "skipped": 0,
+ "elapsedMs": 30065.273917000013
+ },
+ {
+ "ticks": 591,
+ "bytes": 297861,
+ "skipped": 0,
+ "elapsedMs": 30065.352583
+ },
+ {
+ "ticks": 591,
+ "bytes": 297869,
+ "skipped": 0,
+ "elapsedMs": 30065.488166000025
+ },
+ {
+ "ticks": 590,
+ "bytes": 297354,
+ "skipped": 0,
+ "elapsedMs": 30065.632167000003
+ },
+ {
+ "ticks": 590,
+ "bytes": 297354,
+ "skipped": 0,
+ "elapsedMs": 30065.762749999994
+ },
+ {
+ "ticks": 591,
+ "bytes": 297869,
+ "skipped": 0,
+ "elapsedMs": 30065.763624999992
+ },
+ {
+ "ticks": 590,
+ "bytes": 297362,
+ "skipped": 0,
+ "elapsedMs": 30065.82370899999
+ },
+ {
+ "ticks": 591,
+ "bytes": 297869,
+ "skipped": 0,
+ "elapsedMs": 30065.87054199999
+ }
+ ],
+ "aggregateSamples": [
+ {
+ "elapsedSeconds": 0.0037907916703261435,
+ "cpuTicks": 466457875,
+ "interruptWakeups": 43664,
+ "summedFootprintBytes": 716955944,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 1.0068317916593514,
+ "cpuTicks": 471496396,
+ "interruptWakeups": 44480,
+ "summedFootprintBytes": 717660504,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 2.004801374976523,
+ "cpuTicks": 473135002,
+ "interruptWakeups": 45267,
+ "summedFootprintBytes": 717955416,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 3.003979041648563,
+ "cpuTicks": 474776897,
+ "interruptWakeups": 46184,
+ "summedFootprintBytes": 717955416,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 4.005507624999154,
+ "cpuTicks": 476407775,
+ "interruptWakeups": 47025,
+ "summedFootprintBytes": 718020952,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 5.0040693749906495,
+ "cpuTicks": 478184787,
+ "interruptWakeups": 47970,
+ "summedFootprintBytes": 718348704,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 6.006750708329491,
+ "cpuTicks": 483270233,
+ "interruptWakeups": 48847,
+ "summedFootprintBytes": 719757752,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 7.001794083334971,
+ "cpuTicks": 485050453,
+ "interruptWakeups": 49814,
+ "summedFootprintBytes": 720495032,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 8.006082499981858,
+ "cpuTicks": 486825532,
+ "interruptWakeups": 50797,
+ "summedFootprintBytes": 720544184,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 9.006568499986315,
+ "cpuTicks": 488523069,
+ "interruptWakeups": 51738,
+ "summedFootprintBytes": 720544184,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 10.002147083316231,
+ "cpuTicks": 490684852,
+ "interruptWakeups": 52752,
+ "summedFootprintBytes": 720593336,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 11.012548666651128,
+ "cpuTicks": 497745344,
+ "interruptWakeups": 53745,
+ "summedFootprintBytes": 721265104,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 12.002109791646944,
+ "cpuTicks": 502616709,
+ "interruptWakeups": 54748,
+ "summedFootprintBytes": 721265104,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 13.006210041668965,
+ "cpuTicks": 507369068,
+ "interruptWakeups": 55821,
+ "summedFootprintBytes": 720495056,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 14.01023487499333,
+ "cpuTicks": 512493270,
+ "interruptWakeups": 56851,
+ "summedFootprintBytes": 720527824,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 15.010416416655062,
+ "cpuTicks": 516755670,
+ "interruptWakeups": 57854,
+ "summedFootprintBytes": 720757344,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 16.015213166654576,
+ "cpuTicks": 526291414,
+ "interruptWakeups": 58707,
+ "summedFootprintBytes": 719643400,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 17.01266883331118,
+ "cpuTicks": 531922206,
+ "interruptWakeups": 59546,
+ "summedFootprintBytes": 719643400,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 18.012899291643407,
+ "cpuTicks": 536527640,
+ "interruptWakeups": 60380,
+ "summedFootprintBytes": 720347912,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 19.01288154165377,
+ "cpuTicks": 542739547,
+ "interruptWakeups": 61264,
+ "summedFootprintBytes": 720347912,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 20.002784374984913,
+ "cpuTicks": 547598267,
+ "interruptWakeups": 62235,
+ "summedFootprintBytes": 721134344,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 21.013119291659677,
+ "cpuTicks": 557571715,
+ "interruptWakeups": 63269,
+ "summedFootprintBytes": 721855288,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 22.006655833334662,
+ "cpuTicks": 564053446,
+ "interruptWakeups": 64258,
+ "summedFootprintBytes": 722019128,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 23.00589149998268,
+ "cpuTicks": 570478517,
+ "interruptWakeups": 65181,
+ "summedFootprintBytes": 722019128,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 24.008620999986306,
+ "cpuTicks": 576687579,
+ "interruptWakeups": 66144,
+ "summedFootprintBytes": 722051896,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 25.007191458309535,
+ "cpuTicks": 582104016,
+ "interruptWakeups": 67174,
+ "summedFootprintBytes": 722068280,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 26.011517208331497,
+ "cpuTicks": 591760411,
+ "interruptWakeups": 68247,
+ "summedFootprintBytes": 722707304,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 27.00557091666269,
+ "cpuTicks": 596784476,
+ "interruptWakeups": 69172,
+ "summedFootprintBytes": 722740072,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 28.013357916643145,
+ "cpuTicks": 602568290,
+ "interruptWakeups": 70102,
+ "summedFootprintBytes": 722740072,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 29.014694291661726,
+ "cpuTicks": 608688399,
+ "interruptWakeups": 71086,
+ "summedFootprintBytes": 722740072,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 30.010780249984236,
+ "cpuTicks": 614169869,
+ "interruptWakeups": 72098,
+ "summedFootprintBytes": 722740072,
+ "accountingProcessCount": 24
+ }
+ ]
+ }
+ ]
+ },
+ {
+ "variant": "baseline",
+ "run": "harness-connected-v2-4-baseline-20261002",
+ "loadBefore": [
+ 8.87841796875,
+ 10.83984375,
+ 13.4833984375
+ ],
+ "loadAfter": [
+ 8.34228515625,
+ 9.7060546875,
+ 12.4755859375
+ ],
+ "startEpoch": 1790983338.128426,
+ "endEpoch": 1790983519.720495,
+ "toolingSha256": {
+ "connected_run.py": "f0857e324905b12c47a520cceacd4eff6fe5d8894f78f67e9c4dc10b81c951ed",
+ "connected_stack.mjs": "819ed8941fa33d05bedc732461e9753f69fba9c5796f915909b6c3c1e1f663fe",
+ "connected_worker.mjs": "3456923d6b9f6ff8628c7f84dd2540cb55adf4a83950e6970ace506a1a98295e",
+ "harness-connected-forest-usage-v2-20261002": "48816ec9467b369be056bb03c4b89aa2766a35d07d80f3d0e2a99db987c8c0fb"
+ },
+ "daemonMetadata": {
+ "bundleSha256": "c0f1be69953a507d3abdad60caf95f0641f66221b0c984bc37e81ff84abb61b5",
+ "sourceRevision": "c966e1ac0e10d2741bad53352fcdba9b41d2a6de",
+ "sourceDiffSha256": "b4fd768fe9f620a84bb561384cd613b7103c9f56a81c7ad8191fad2d995e41f5",
+ "boundary": "Full local daemon and tmux; private terminal shells; no cloud account or model inference."
+ },
+ "appSourceRevision": "c966e1ac0e10d2741bad53352fcdba9b41d2a6de",
+ "appProductionDiffSha256": "007836235b4aca69785e4716a83710feccd91853a173e49e5b104925043d477c",
+ "appFixtureSha256": {
+ "connected_main.dart": "8bdf2061c52713ff5dc37939252c5184e90e8da353d3f315e505f270c4e51eed",
+ "ConnectedResourceHost.swift": "f9f58dc6d209119ee4a3440661518785e7ea13f2057c001c666b45ea20e4493e"
+ },
+ "cleanupVerified": true,
+ "phases": [
+ {
+ "label": "foreground-idle-visible",
+ "summary": {
+ "cpuPercentOneCore": 5.199710410963612,
+ "cpuSeconds": 1.5600709583333332,
+ "elapsedSeconds": 30.003035458357772,
+ "interruptWakeupsPerSecond": 28.4304566844214,
+ "liveProcessCountMax": 24,
+ "liveProcessCountMin": 24,
+ "packageIdleWakeupsPerSecond": 0,
+ "processCountMax": 24,
+ "processCountMin": 24,
+ "summedPhysicalFootprintMiBMedian": 507.8778305053711,
+ "summedPhysicalFootprintMiBPeak": 530.3619995117188
+ },
+ "components": {
+ "desktop": {
+ "cpuPercentOneCore": 0.8199648121430412,
+ "interruptWakeupsPerSecond": 15.765071526062512
+ },
+ "daemon": {
+ "cpuPercentOneCore": 4.355242522533939,
+ "interruptWakeupsPerSecond": 11.998785939497894
+ },
+ "tmuxAndWorkers": {
+ "cpuPercentOneCore": 0.02450307628663204,
+ "interruptWakeupsPerSecond": 0.6665992188609942
+ }
+ },
+ "rawSampleSha256": "45839c33a85bed83d4eea9d23383a8b3e1a1ac563d7e73fb1ac9b43c53ecbabe",
+ "nativeBefore": {
+ "height": 800.0,
+ "focusLosses": 0,
+ "width": 1280.0,
+ "scale": 2.0,
+ "key": true,
+ "visible": true,
+ "hidden": false,
+ "active": true
+ },
+ "nativeAfter": {
+ "height": 800.0,
+ "focusLosses": 0,
+ "width": 1280.0,
+ "scale": 2.0,
+ "key": true,
+ "visible": true,
+ "hidden": false,
+ "active": true
+ },
+ "outputPerWorker": [
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30037.9125
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30037.472708
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30036.906375000002
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30036.479542
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30036.220499999996
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30036.013208
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30035.960292000003
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30035.888666
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30035.8135
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30035.732208
+ }
+ ],
+ "aggregateSamples": [
+ {
+ "elapsedSeconds": 0.0035543333215173334,
+ "cpuTicks": 73256198,
+ "interruptWakeups": 1377,
+ "summedFootprintBytes": 544933320,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 1.0023175416572485,
+ "cpuTicks": 76961120,
+ "interruptWakeups": 1419,
+ "summedFootprintBytes": 549619816,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 2.0064532500109635,
+ "cpuTicks": 77236921,
+ "interruptWakeups": 1435,
+ "summedFootprintBytes": 549685352,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 3.008009333338123,
+ "cpuTicks": 77754886,
+ "interruptWakeups": 1479,
+ "summedFootprintBytes": 550111336,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 4.003632666659541,
+ "cpuTicks": 77864120,
+ "interruptWakeups": 1496,
+ "summedFootprintBytes": 550176872,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 5.011439124995377,
+ "cpuTicks": 78125758,
+ "interruptWakeups": 1514,
+ "summedFootprintBytes": 550226024,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 6.008516666654032,
+ "cpuTicks": 88939239,
+ "interruptWakeups": 1580,
+ "summedFootprintBytes": 555715264,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 7.007521083345637,
+ "cpuTicks": 89166400,
+ "interruptWakeups": 1597,
+ "summedFootprintBytes": 555780800,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 8.009133249986917,
+ "cpuTicks": 89759952,
+ "interruptWakeups": 1646,
+ "summedFootprintBytes": 556059328,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 9.00469816668192,
+ "cpuTicks": 89962051,
+ "interruptWakeups": 1666,
+ "summedFootprintBytes": 556124864,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 10.005939458322246,
+ "cpuTicks": 90523210,
+ "interruptWakeups": 1684,
+ "summedFootprintBytes": 536890048,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 11.007491083320929,
+ "cpuTicks": 94845066,
+ "interruptWakeups": 1722,
+ "summedFootprintBytes": 530172704,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 12.008648541668663,
+ "cpuTicks": 95056212,
+ "interruptWakeups": 1737,
+ "summedFootprintBytes": 530238240,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 13.007840083329938,
+ "cpuTicks": 95717510,
+ "interruptWakeups": 1782,
+ "summedFootprintBytes": 530516768,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 14.008850083337165,
+ "cpuTicks": 95889618,
+ "interruptWakeups": 1799,
+ "summedFootprintBytes": 530582304,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 15.006987458327785,
+ "cpuTicks": 96116119,
+ "interruptWakeups": 1817,
+ "summedFootprintBytes": 530631456,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 16.007065624988172,
+ "cpuTicks": 100429000,
+ "interruptWakeups": 1852,
+ "summedFootprintBytes": 532548504,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 17.00718945832341,
+ "cpuTicks": 100707789,
+ "interruptWakeups": 1870,
+ "summedFootprintBytes": 532614040,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 18.008811458334094,
+ "cpuTicks": 101205049,
+ "interruptWakeups": 1909,
+ "summedFootprintBytes": 532892568,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 19.008224666671595,
+ "cpuTicks": 101394282,
+ "interruptWakeups": 1928,
+ "summedFootprintBytes": 532958104,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 20.005714916682336,
+ "cpuTicks": 101561502,
+ "interruptWakeups": 1943,
+ "summedFootprintBytes": 533007256,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 21.005097041663248,
+ "cpuTicks": 106437075,
+ "interruptWakeups": 1995,
+ "summedFootprintBytes": 509201208,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 22.005901124997763,
+ "cpuTicks": 106509926,
+ "interruptWakeups": 2010,
+ "summedFootprintBytes": 509266744,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 23.005021666671382,
+ "cpuTicks": 106725476,
+ "interruptWakeups": 2063,
+ "summedFootprintBytes": 509578040,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 24.006580499990378,
+ "cpuTicks": 106793145,
+ "interruptWakeups": 2080,
+ "summedFootprintBytes": 509643576,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 25.00662095833104,
+ "cpuTicks": 106887333,
+ "interruptWakeups": 2099,
+ "summedFootprintBytes": 509709112,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 26.004323791654315,
+ "cpuTicks": 110314757,
+ "interruptWakeups": 2140,
+ "summedFootprintBytes": 510561104,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 27.00587937500677,
+ "cpuTicks": 110385183,
+ "interruptWakeups": 2157,
+ "summedFootprintBytes": 510626640,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 28.006557166663697,
+ "cpuTicks": 110557937,
+ "interruptWakeups": 2197,
+ "summedFootprintBytes": 510888784,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 29.00661495834356,
+ "cpuTicks": 110630036,
+ "interruptWakeups": 2215,
+ "summedFootprintBytes": 510954320,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 30.00658979167929,
+ "cpuTicks": 110697901,
+ "interruptWakeups": 2230,
+ "summedFootprintBytes": 511003472,
+ "accountingProcessCount": 24
+ }
+ ]
+ },
+ {
+ "label": "foreground-idle-hidden",
+ "summary": {
+ "cpuPercentOneCore": 4.1723402490880055,
+ "cpuSeconds": 1.2516254166666667,
+ "elapsedSeconds": 29.99816270833253,
+ "interruptWakeupsPerSecond": 27.93504416079557,
+ "liveProcessCountMax": 25,
+ "liveProcessCountMin": 24,
+ "packageIdleWakeupsPerSecond": 0,
+ "processCountMax": 25,
+ "processCountMin": 24,
+ "summedPhysicalFootprintMiBMedian": 492.2528762817383,
+ "summedPhysicalFootprintMiBPeak": 495.5187530517578
+ },
+ "components": {
+ "desktop": {
+ "cpuPercentOneCore": 0.8073995865066423,
+ "interruptWakeupsPerSecond": 15.83430307443663
+ },
+ "daemon": {
+ "cpuPercentOneCore": 3.3428695886591338,
+ "interruptWakeupsPerSecond": 11.434033588487925
+ },
+ "tmuxAndWorkers": {
+ "cpuPercentOneCore": 0.022071073922229203,
+ "interruptWakeupsPerSecond": 0.6667074978710159
+ }
+ },
+ "rawSampleSha256": "62449dc98de6008bba558902fc417a52abc654c4ef676e95928e6f908e65b28b",
+ "nativeBefore": {
+ "height": 800.0,
+ "focusLosses": 0,
+ "width": 1280.0,
+ "scale": 2.0,
+ "key": true,
+ "visible": true,
+ "hidden": false,
+ "active": true
+ },
+ "nativeAfter": {
+ "height": 800.0,
+ "focusLosses": 0,
+ "width": 1280.0,
+ "scale": 2.0,
+ "key": true,
+ "visible": true,
+ "hidden": false,
+ "active": true
+ },
+ "outputPerWorker": [
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30117.550417000006
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30117.08070900001
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30116.777958999992
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30116.443374999995
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30116.152499999997
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30115.907917000004
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30115.727332999995
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30115.546459000005
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30115.407291999996
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30115.257625
+ }
+ ],
+ "aggregateSamples": [
+ {
+ "elapsedSeconds": 0.08612299998640083,
+ "cpuTicks": 118868197,
+ "interruptWakeups": 2438,
+ "summedFootprintBytes": 515722352,
+ "accountingProcessCount": 25
+ },
+ {
+ "elapsedSeconds": 1.0134892083297018,
+ "cpuTicks": 120063202,
+ "interruptWakeups": 2456,
+ "summedFootprintBytes": 514870192,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 2.0078754583373666,
+ "cpuTicks": 120286934,
+ "interruptWakeups": 2474,
+ "summedFootprintBytes": 514935728,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 3.00785637498484,
+ "cpuTicks": 120762801,
+ "interruptWakeups": 2523,
+ "summedFootprintBytes": 515214256,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 4.006597291649086,
+ "cpuTicks": 120920641,
+ "interruptWakeups": 2542,
+ "summedFootprintBytes": 515279792,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 5.081611208326649,
+ "cpuTicks": 123828436,
+ "interruptWakeups": 2580,
+ "summedFootprintBytes": 517016712,
+ "accountingProcessCount": 25
+ },
+ {
+ "elapsedSeconds": 6.011720666661859,
+ "cpuTicks": 125366667,
+ "interruptWakeups": 2600,
+ "summedFootprintBytes": 516164552,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 7.010643749992596,
+ "cpuTicks": 125628987,
+ "interruptWakeups": 2615,
+ "summedFootprintBytes": 516180936,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 8.011802541674115,
+ "cpuTicks": 126273551,
+ "interruptWakeups": 2654,
+ "summedFootprintBytes": 516459464,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 9.006070999981603,
+ "cpuTicks": 126398581,
+ "interruptWakeups": 2671,
+ "summedFootprintBytes": 516525000,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 10.079532208328601,
+ "cpuTicks": 128942069,
+ "interruptWakeups": 2711,
+ "summedFootprintBytes": 518278328,
+ "accountingProcessCount": 25
+ },
+ {
+ "elapsedSeconds": 11.006630458316067,
+ "cpuTicks": 130122831,
+ "interruptWakeups": 2728,
+ "summedFootprintBytes": 517442552,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 12.002928041649284,
+ "cpuTicks": 130194564,
+ "interruptWakeups": 2745,
+ "summedFootprintBytes": 517508088,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 13.003557749994798,
+ "cpuTicks": 130413212,
+ "interruptWakeups": 2784,
+ "summedFootprintBytes": 517770232,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 14.002728624996962,
+ "cpuTicks": 130492066,
+ "interruptWakeups": 2804,
+ "summedFootprintBytes": 517835768,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 15.07997779166908,
+ "cpuTicks": 133071193,
+ "interruptWakeups": 2851,
+ "summedFootprintBytes": 519589072,
+ "accountingProcessCount": 25
+ },
+ {
+ "elapsedSeconds": 16.006555125000887,
+ "cpuTicks": 134030761,
+ "interruptWakeups": 2870,
+ "summedFootprintBytes": 518736912,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 17.006616958329687,
+ "cpuTicks": 134098305,
+ "interruptWakeups": 2885,
+ "summedFootprintBytes": 518786064,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 18.005938708316535,
+ "cpuTicks": 134672404,
+ "interruptWakeups": 2946,
+ "summedFootprintBytes": 519359504,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 19.00274604166043,
+ "cpuTicks": 134746662,
+ "interruptWakeups": 2964,
+ "summedFootprintBytes": 519408656,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 20.07804020831827,
+ "cpuTicks": 138023612,
+ "interruptWakeups": 3009,
+ "summedFootprintBytes": 516983944,
+ "accountingProcessCount": 25
+ },
+ {
+ "elapsedSeconds": 21.01319924998097,
+ "cpuTicks": 139447704,
+ "interruptWakeups": 3025,
+ "summedFootprintBytes": 501763016,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 22.011013916664524,
+ "cpuTicks": 139746502,
+ "interruptWakeups": 3043,
+ "summedFootprintBytes": 501828552,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 23.008078166662017,
+ "cpuTicks": 140312803,
+ "interruptWakeups": 3085,
+ "summedFootprintBytes": 502074312,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 24.012647791649215,
+ "cpuTicks": 140530246,
+ "interruptWakeups": 3104,
+ "summedFootprintBytes": 502139848,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 25.085718708316563,
+ "cpuTicks": 143475018,
+ "interruptWakeups": 3140,
+ "summedFootprintBytes": 503008248,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 26.005931874999078,
+ "cpuTicks": 145103183,
+ "interruptWakeups": 3163,
+ "summedFootprintBytes": 503024632,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 27.011658708332106,
+ "cpuTicks": 145315841,
+ "interruptWakeups": 3177,
+ "summedFootprintBytes": 503090168,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 28.012662416673265,
+ "cpuTicks": 145767484,
+ "interruptWakeups": 3218,
+ "summedFootprintBytes": 503352312,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 29.00715191665222,
+ "cpuTicks": 146002566,
+ "interruptWakeups": 3235,
+ "summedFootprintBytes": 503417848,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 30.08428570831893,
+ "cpuTicks": 148907207,
+ "interruptWakeups": 3276,
+ "summedFootprintBytes": 504253480,
+ "accountingProcessCount": 24
+ }
+ ]
+ },
+ {
+ "label": "foreground-active",
+ "summary": {
+ "cpuPercentOneCore": 31.953996512020023,
+ "cpuSeconds": 9.586619375,
+ "elapsedSeconds": 30.001315708330367,
+ "interruptWakeupsPerSecond": 1087.1523208211706,
+ "liveProcessCountMax": 26,
+ "liveProcessCountMin": 24,
+ "packageIdleWakeupsPerSecond": 0,
+ "processCountMax": 26,
+ "processCountMin": 24,
+ "summedPhysicalFootprintMiBMedian": 648.3329238891602,
+ "summedPhysicalFootprintMiBPeak": 731.8830032348633
+ },
+ "components": {
+ "desktop": {
+ "cpuPercentOneCore": 18.902131843589054,
+ "interruptWakeupsPerSecond": 298.65356863372847
+ },
+ "daemon": {
+ "cpuPercentOneCore": 7.018390389287744,
+ "interruptWakeupsPerSecond": 256.3220918296174
+ },
+ "tmuxAndWorkers": {
+ "cpuPercentOneCore": 6.033474279143217,
+ "interruptWakeupsPerSecond": 532.1766603578246
+ }
+ },
+ "rawSampleSha256": "8e4019993992fe055e28ff7352a3e0eb48d95e686cbe09a4d8666ca819a2dff8",
+ "nativeBefore": {
+ "width": 1280.0,
+ "visible": true,
+ "scale": 2.0,
+ "focusLosses": 0,
+ "active": true,
+ "height": 800.0,
+ "key": true,
+ "hidden": false
+ },
+ "nativeAfter": {
+ "active": true,
+ "key": true,
+ "height": 800.0,
+ "width": 1280.0,
+ "visible": true,
+ "hidden": false,
+ "focusLosses": 0,
+ "scale": 2.0
+ },
+ "outputPerWorker": [
+ {
+ "ticks": 590,
+ "bytes": 294402,
+ "skipped": 0,
+ "elapsedMs": 30039.064041000005
+ },
+ {
+ "ticks": 590,
+ "bytes": 294402,
+ "skipped": 0,
+ "elapsedMs": 30039.208499999993
+ },
+ {
+ "ticks": 590,
+ "bytes": 294402,
+ "skipped": 0,
+ "elapsedMs": 30039.312000000005
+ },
+ {
+ "ticks": 590,
+ "bytes": 294402,
+ "skipped": 0,
+ "elapsedMs": 30039.413208000013
+ },
+ {
+ "ticks": 590,
+ "bytes": 294402,
+ "skipped": 0,
+ "elapsedMs": 30039.519250000012
+ },
+ {
+ "ticks": 590,
+ "bytes": 294402,
+ "skipped": 0,
+ "elapsedMs": 30039.610583
+ },
+ {
+ "ticks": 590,
+ "bytes": 294402,
+ "skipped": 0,
+ "elapsedMs": 30039.725583000007
+ },
+ {
+ "ticks": 590,
+ "bytes": 294402,
+ "skipped": 0,
+ "elapsedMs": 30039.790999999997
+ },
+ {
+ "ticks": 590,
+ "bytes": 294402,
+ "skipped": 0,
+ "elapsedMs": 30039.916207999995
+ },
+ {
+ "ticks": 590,
+ "bytes": 294402,
+ "skipped": 0,
+ "elapsedMs": 30040.015583
+ }
+ ],
+ "aggregateSamples": [
+ {
+ "elapsedSeconds": 0.003948750003473833,
+ "cpuTicks": 187304101,
+ "interruptWakeups": 7717,
+ "summedFootprintBytes": 568905584,
+ "accountingProcessCount": 26
+ },
+ {
+ "elapsedSeconds": 1.0049737916560844,
+ "cpuTicks": 193864547,
+ "interruptWakeups": 8721,
+ "summedFootprintBytes": 573558808,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 2.0043901666649617,
+ "cpuTicks": 200612864,
+ "interruptWakeups": 9702,
+ "summedFootprintBytes": 590270488,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 3.0092745416623075,
+ "cpuTicks": 208136839,
+ "interruptWakeups": 10792,
+ "summedFootprintBytes": 593186840,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 4.006956124998396,
+ "cpuTicks": 215170484,
+ "interruptWakeups": 11869,
+ "summedFootprintBytes": 597102640,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 5.006632833334152,
+ "cpuTicks": 224173569,
+ "interruptWakeups": 13025,
+ "summedFootprintBytes": 615141448,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 6.004231333325151,
+ "cpuTicks": 230891558,
+ "interruptWakeups": 14183,
+ "summedFootprintBytes": 616960624,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 7.007248833338963,
+ "cpuTicks": 238618626,
+ "interruptWakeups": 15327,
+ "summedFootprintBytes": 622695024,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 8.005256458331132,
+ "cpuTicks": 246430860,
+ "interruptWakeups": 16464,
+ "summedFootprintBytes": 640651888,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 9.005110083322506,
+ "cpuTicks": 258669559,
+ "interruptWakeups": 17814,
+ "summedFootprintBytes": 627839840,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 10.001564375008456,
+ "cpuTicks": 268023209,
+ "interruptWakeups": 18981,
+ "summedFootprintBytes": 635376936,
+ "accountingProcessCount": 26
+ },
+ {
+ "elapsedSeconds": 11.011460375011666,
+ "cpuTicks": 274349192,
+ "interruptWakeups": 20122,
+ "summedFootprintBytes": 651875240,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 12.008104916661978,
+ "cpuTicks": 281530835,
+ "interruptWakeups": 21283,
+ "summedFootprintBytes": 656610216,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 13.004938500002027,
+ "cpuTicks": 289096685,
+ "interruptWakeups": 22382,
+ "summedFootprintBytes": 661558184,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 14.006629958341364,
+ "cpuTicks": 296562468,
+ "interruptWakeups": 23513,
+ "summedFootprintBytes": 679826344,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 15.005940166680375,
+ "cpuTicks": 306733651,
+ "interruptWakeups": 24734,
+ "summedFootprintBytes": 682267992,
+ "accountingProcessCount": 26
+ },
+ {
+ "elapsedSeconds": 16.005820499995025,
+ "cpuTicks": 312987855,
+ "interruptWakeups": 25819,
+ "summedFootprintBytes": 676959192,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 17.007595500006573,
+ "cpuTicks": 319266051,
+ "interruptWakeups": 26874,
+ "summedFootprintBytes": 690148312,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 18.006178291660035,
+ "cpuTicks": 325604526,
+ "interruptWakeups": 27891,
+ "summedFootprintBytes": 694506480,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 19.00728312501451,
+ "cpuTicks": 332416071,
+ "interruptWakeups": 28885,
+ "summedFootprintBytes": 698455024,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 20.002230999991298,
+ "cpuTicks": 341236684,
+ "interruptWakeups": 29875,
+ "summedFootprintBytes": 720510192,
+ "accountingProcessCount": 26
+ },
+ {
+ "elapsedSeconds": 21.00822741666343,
+ "cpuTicks": 347789578,
+ "interruptWakeups": 30800,
+ "summedFootprintBytes": 722901872,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 22.004879416665062,
+ "cpuTicks": 356074558,
+ "interruptWakeups": 31799,
+ "summedFootprintBytes": 723623608,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 23.005430916673504,
+ "cpuTicks": 362603313,
+ "interruptWakeups": 32737,
+ "summedFootprintBytes": 742579920,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 24.00672658334952,
+ "cpuTicks": 369631916,
+ "interruptWakeups": 33610,
+ "summedFootprintBytes": 708386512,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 25.00645204167813,
+ "cpuTicks": 379166763,
+ "interruptWakeups": 34596,
+ "summedFootprintBytes": 740892800,
+ "accountingProcessCount": 26
+ },
+ {
+ "elapsedSeconds": 26.007045333331916,
+ "cpuTicks": 385365278,
+ "interruptWakeups": 35699,
+ "summedFootprintBytes": 750591744,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 27.0061483750178,
+ "cpuTicks": 392242654,
+ "interruptWakeups": 36760,
+ "summedFootprintBytes": 746610432,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 28.005495041667018,
+ "cpuTicks": 399868579,
+ "interruptWakeups": 37955,
+ "summedFootprintBytes": 743300864,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 29.00330758333439,
+ "cpuTicks": 407244925,
+ "interruptWakeups": 39085,
+ "summedFootprintBytes": 759996160,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 30.00526445833384,
+ "cpuTicks": 417382966,
+ "interruptWakeups": 40333,
+ "summedFootprintBytes": 767434952,
+ "accountingProcessCount": 26
+ }
+ ]
+ },
+ {
+ "label": "background-idle-hidden",
+ "summary": {
+ "cpuPercentOneCore": 3.5058584025376724,
+ "cpuSeconds": 1.0518616666666667,
+ "elapsedSeconds": 30.002970624977024,
+ "interruptWakeupsPerSecond": 14.131933977465096,
+ "liveProcessCountMax": 24,
+ "liveProcessCountMin": 24,
+ "packageIdleWakeupsPerSecond": 0,
+ "processCountMax": 24,
+ "processCountMin": 24,
+ "summedPhysicalFootprintMiBMedian": 663.9452972412109,
+ "summedPhysicalFootprintMiBPeak": 666.8673095703125
+ },
+ "components": {
+ "desktop": {
+ "cpuPercentOneCore": 0.1653307121485674,
+ "interruptWakeupsPerSecond": 3.0663630328462
+ },
+ "daemon": {
+ "cpuPercentOneCore": 3.315626822760416,
+ "interruptWakeupsPerSecond": 10.398970285304504
+ },
+ "tmuxAndWorkers": {
+ "cpuPercentOneCore": 0.024900867628689087,
+ "interruptWakeupsPerSecond": 0.6666006593143913
+ }
+ },
+ "rawSampleSha256": "b6b643e3a3c7d3fb07d279bc79ac41614610407bf4164e3abb3ded6993fa0435",
+ "nativeBefore": {
+ "active": false,
+ "key": false,
+ "height": 800.0,
+ "width": 1280.0,
+ "visible": false,
+ "hidden": true,
+ "focusLosses": 1,
+ "scale": 2.0
+ },
+ "nativeAfter": {
+ "active": false,
+ "key": false,
+ "height": 800.0,
+ "width": 1280.0,
+ "visible": false,
+ "hidden": true,
+ "focusLosses": 1,
+ "scale": 2.0
+ },
+ "outputPerWorker": [
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30033.709415999998
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30033.758916999985
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30033.773707999993
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30033.819500000012
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30033.817958000014
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30033.817916999993
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30033.81495900001
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30033.837125000005
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30033.829708000005
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30033.874459000013
+ }
+ ],
+ "aggregateSamples": [
+ {
+ "elapsedSeconds": 0.0036128750070929527,
+ "cpuTicks": 423155058,
+ "interruptWakeups": 40560,
+ "summedFootprintBytes": 692871032,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 1.0210689583327621,
+ "cpuTicks": 423171569,
+ "interruptWakeups": 40565,
+ "summedFootprintBytes": 692805496,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 2.0210090833425056,
+ "cpuTicks": 423333599,
+ "interruptWakeups": 40575,
+ "summedFootprintBytes": 692969336,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 3.0137055833183695,
+ "cpuTicks": 423510056,
+ "interruptWakeups": 40599,
+ "summedFootprintBytes": 693018488,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 4.009169791650493,
+ "cpuTicks": 423513972,
+ "interruptWakeups": 40601,
+ "summedFootprintBytes": 693018488,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 5.00354912498733,
+ "cpuTicks": 427003743,
+ "interruptWakeups": 40638,
+ "summedFootprintBytes": 693968784,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 6.012965250003617,
+ "cpuTicks": 427016031,
+ "interruptWakeups": 40640,
+ "summedFootprintBytes": 693985168,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 7.013895083335228,
+ "cpuTicks": 427255658,
+ "interruptWakeups": 40656,
+ "summedFootprintBytes": 694427536,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 8.009452875005081,
+ "cpuTicks": 427440229,
+ "interruptWakeups": 40687,
+ "summedFootprintBytes": 694476688,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 9.008057166676736,
+ "cpuTicks": 427449152,
+ "interruptWakeups": 40691,
+ "summedFootprintBytes": 694476688,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 10.002520708338125,
+ "cpuTicks": 431105765,
+ "interruptWakeups": 40712,
+ "summedFootprintBytes": 695214016,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 11.012335000006715,
+ "cpuTicks": 431126876,
+ "interruptWakeups": 40718,
+ "summedFootprintBytes": 695214016,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 12.01156675000675,
+ "cpuTicks": 431180580,
+ "interruptWakeups": 40727,
+ "summedFootprintBytes": 695361472,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 13.010561916657025,
+ "cpuTicks": 431344621,
+ "interruptWakeups": 40751,
+ "summedFootprintBytes": 695410624,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 14.009388208331075,
+ "cpuTicks": 431347821,
+ "interruptWakeups": 40754,
+ "summedFootprintBytes": 695410624,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 15.006081916653784,
+ "cpuTicks": 435235248,
+ "interruptWakeups": 40780,
+ "summedFootprintBytes": 696197104,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 16.006278291664785,
+ "cpuTicks": 435237920,
+ "interruptWakeups": 40782,
+ "summedFootprintBytes": 696197104,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 17.009196291677654,
+ "cpuTicks": 435335198,
+ "interruptWakeups": 40793,
+ "summedFootprintBytes": 696360944,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 18.011127375008073,
+ "cpuTicks": 435507991,
+ "interruptWakeups": 40815,
+ "summedFootprintBytes": 696410096,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 19.00411429165979,
+ "cpuTicks": 435521781,
+ "interruptWakeups": 40820,
+ "summedFootprintBytes": 696410096,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 20.006523083342472,
+ "cpuTicks": 439677495,
+ "interruptWakeups": 40846,
+ "summedFootprintBytes": 697212960,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 21.012398666673107,
+ "cpuTicks": 439686528,
+ "interruptWakeups": 40850,
+ "summedFootprintBytes": 697212960,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 22.011907624982996,
+ "cpuTicks": 439800070,
+ "interruptWakeups": 40859,
+ "summedFootprintBytes": 697376800,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 23.0115234166733,
+ "cpuTicks": 440002067,
+ "interruptWakeups": 40894,
+ "summedFootprintBytes": 697425952,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 24.005683374998625,
+ "cpuTicks": 440004078,
+ "interruptWakeups": 40896,
+ "summedFootprintBytes": 697425952,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 25.00510487498832,
+ "cpuTicks": 444409795,
+ "interruptWakeups": 40920,
+ "summedFootprintBytes": 698245200,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 26.011984124983428,
+ "cpuTicks": 444422186,
+ "interruptWakeups": 40923,
+ "summedFootprintBytes": 698261584,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 27.01118691667216,
+ "cpuTicks": 444552831,
+ "interruptWakeups": 40937,
+ "summedFootprintBytes": 698409040,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 28.007914374989923,
+ "cpuTicks": 444700309,
+ "interruptWakeups": 40959,
+ "summedFootprintBytes": 698474576,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 29.00882970832754,
+ "cpuTicks": 444706814,
+ "interruptWakeups": 40964,
+ "summedFootprintBytes": 698474576,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 30.006583499984117,
+ "cpuTicks": 448399738,
+ "interruptWakeups": 40984,
+ "summedFootprintBytes": 699261056,
+ "accountingProcessCount": 24
+ }
+ ]
+ },
+ {
+ "label": "background-active",
+ "summary": {
+ "cpuPercentOneCore": 20.551393078865505,
+ "cpuSeconds": 6.164981583333333,
+ "elapsedSeconds": 29.997876833338523,
+ "interruptWakeupsPerSecond": 862.9277379801514,
+ "liveProcessCountMax": 24,
+ "liveProcessCountMin": 24,
+ "packageIdleWakeupsPerSecond": 0,
+ "processCountMax": 24,
+ "processCountMin": 24,
+ "summedPhysicalFootprintMiBMedian": 673.8047409057617,
+ "summedPhysicalFootprintMiBPeak": 675.4768447875977
+ },
+ "components": {
+ "desktop": {
+ "cpuPercentOneCore": 6.659581035570025,
+ "interruptWakeupsPerSecond": 115.90820308108579
+ },
+ "daemon": {
+ "cpuPercentOneCore": 7.525236744392512,
+ "interruptWakeupsPerSecond": 232.94981970970017
+ },
+ "tmuxAndWorkers": {
+ "cpuPercentOneCore": 6.366575298902968,
+ "interruptWakeupsPerSecond": 514.0697151893655
+ }
+ },
+ "rawSampleSha256": "f05e2e31b378ca70349523ae1224c9312960845a4dc89ce1eaf6e5abb0876386",
+ "nativeBefore": {
+ "active": false,
+ "key": false,
+ "height": 800.0,
+ "width": 1280.0,
+ "visible": false,
+ "hidden": true,
+ "focusLosses": 1,
+ "scale": 2.0
+ },
+ "nativeAfter": {
+ "active": false,
+ "key": false,
+ "height": 800.0,
+ "width": 1280.0,
+ "visible": false,
+ "hidden": true,
+ "focusLosses": 1,
+ "scale": 2.0
+ },
+ "outputPerWorker": [
+ {
+ "ticks": 590,
+ "bytes": 297426,
+ "skipped": 0,
+ "elapsedMs": 30036.332082999987
+ },
+ {
+ "ticks": 589,
+ "bytes": 296919,
+ "skipped": 0,
+ "elapsedMs": 30036.376791000017
+ },
+ {
+ "ticks": 589,
+ "bytes": 296919,
+ "skipped": 0,
+ "elapsedMs": 30036.38412500001
+ },
+ {
+ "ticks": 590,
+ "bytes": 297426,
+ "skipped": 0,
+ "elapsedMs": 30036.365625000006
+ },
+ {
+ "ticks": 589,
+ "bytes": 296919,
+ "skipped": 0,
+ "elapsedMs": 30036.362666
+ },
+ {
+ "ticks": 589,
+ "bytes": 296919,
+ "skipped": 0,
+ "elapsedMs": 30036.36166600001
+ },
+ {
+ "ticks": 589,
+ "bytes": 296919,
+ "skipped": 0,
+ "elapsedMs": 30036.337790999998
+ },
+ {
+ "ticks": 589,
+ "bytes": 296919,
+ "skipped": 0,
+ "elapsedMs": 30036.323000000004
+ },
+ {
+ "ticks": 589,
+ "bytes": 296919,
+ "skipped": 0,
+ "elapsedMs": 30036.318874999997
+ },
+ {
+ "ticks": 589,
+ "bytes": 296919,
+ "skipped": 0,
+ "elapsedMs": 30036.313291000028
+ }
+ ],
+ "aggregateSamples": [
+ {
+ "elapsedSeconds": 0.0037177083431743085,
+ "cpuTicks": 475017101,
+ "interruptWakeups": 44906,
+ "summedFootprintBytes": 700932032,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 1.0113832916831598,
+ "cpuTicks": 480102668,
+ "interruptWakeups": 45829,
+ "summedFootprintBytes": 701325296,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 2.006605208327528,
+ "cpuTicks": 485758182,
+ "interruptWakeups": 46749,
+ "summedFootprintBytes": 701341680,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 3.0033811250177678,
+ "cpuTicks": 487262455,
+ "interruptWakeups": 47676,
+ "summedFootprintBytes": 701341680,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 4.006667458335869,
+ "cpuTicks": 488560614,
+ "interruptWakeups": 48519,
+ "summedFootprintBytes": 701423600,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 5.002802666684147,
+ "cpuTicks": 493084490,
+ "interruptWakeups": 49294,
+ "summedFootprintBytes": 702341152,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 6.003872250003042,
+ "cpuTicks": 494323901,
+ "interruptWakeups": 50085,
+ "summedFootprintBytes": 703176736,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 7.006956833327422,
+ "cpuTicks": 495485883,
+ "interruptWakeups": 50887,
+ "summedFootprintBytes": 703881248,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 8.007263625011547,
+ "cpuTicks": 496846842,
+ "interruptWakeups": 51688,
+ "summedFootprintBytes": 703881248,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 9.007012499991106,
+ "cpuTicks": 501566674,
+ "interruptWakeups": 52516,
+ "summedFootprintBytes": 703881248,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 10.001615749992197,
+ "cpuTicks": 509484202,
+ "interruptWakeups": 53401,
+ "summedFootprintBytes": 706240568,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 11.009512749995338,
+ "cpuTicks": 512883336,
+ "interruptWakeups": 54320,
+ "summedFootprintBytes": 706355256,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 12.009134374995483,
+ "cpuTicks": 517329555,
+ "interruptWakeups": 55244,
+ "summedFootprintBytes": 706535480,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 13.014218333322788,
+ "cpuTicks": 521945073,
+ "interruptWakeups": 56094,
+ "summedFootprintBytes": 706535480,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 14.008841708331602,
+ "cpuTicks": 527290286,
+ "interruptWakeups": 56897,
+ "summedFootprintBytes": 706617400,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 15.005848333326867,
+ "cpuTicks": 536955865,
+ "interruptWakeups": 57752,
+ "summedFootprintBytes": 707469560,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 16.004168166662566,
+ "cpuTicks": 539963415,
+ "interruptWakeups": 58556,
+ "summedFootprintBytes": 707617016,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 17.004569250013446,
+ "cpuTicks": 544668840,
+ "interruptWakeups": 59379,
+ "summedFootprintBytes": 707600632,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 18.009213125013048,
+ "cpuTicks": 550187984,
+ "interruptWakeups": 60272,
+ "summedFootprintBytes": 707600632,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 19.00883516666363,
+ "cpuTicks": 555893720,
+ "interruptWakeups": 61171,
+ "summedFootprintBytes": 707600632,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 20.005184500012547,
+ "cpuTicks": 564125665,
+ "interruptWakeups": 62078,
+ "summedFootprintBytes": 708288808,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 21.00601983332308,
+ "cpuTicks": 567541641,
+ "interruptWakeups": 62938,
+ "summedFootprintBytes": 708272424,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 22.002521583344787,
+ "cpuTicks": 572496703,
+ "interruptWakeups": 63708,
+ "summedFootprintBytes": 705781960,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 23.01029166666558,
+ "cpuTicks": 576334622,
+ "interruptWakeups": 64512,
+ "summedFootprintBytes": 705781960,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 24.00569208333036,
+ "cpuTicks": 580893450,
+ "interruptWakeups": 65317,
+ "summedFootprintBytes": 705781960,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 25.005176250007935,
+ "cpuTicks": 590186153,
+ "interruptWakeups": 66177,
+ "summedFootprintBytes": 706765048,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 26.00898041666369,
+ "cpuTicks": 593924764,
+ "interruptWakeups": 67029,
+ "summedFootprintBytes": 706781432,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 27.00484075001441,
+ "cpuTicks": 599994808,
+ "interruptWakeups": 67961,
+ "summedFootprintBytes": 707059960,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 28.005623041681247,
+ "cpuTicks": 607272015,
+ "interruptWakeups": 68860,
+ "summedFootprintBytes": 706568464,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 29.00486770833959,
+ "cpuTicks": 612782276,
+ "interruptWakeups": 69780,
+ "summedFootprintBytes": 706568464,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 30.001594541681698,
+ "cpuTicks": 622976659,
+ "interruptWakeups": 70792,
+ "summedFootprintBytes": 708223296,
+ "accountingProcessCount": 24
+ }
+ ]
+ }
+ ]
+ },
+ {
+ "variant": "baseline",
+ "run": "harness-connected-v2-5-baseline-20261002",
+ "loadBefore": [
+ 8.34228515625,
+ 9.7060546875,
+ 12.4755859375
+ ],
+ "loadAfter": [
+ 6.1103515625,
+ 7.97900390625,
+ 11.212890625
+ ],
+ "startEpoch": 1790983519.72224,
+ "endEpoch": 1790983701.272863,
+ "toolingSha256": {
+ "connected_run.py": "f0857e324905b12c47a520cceacd4eff6fe5d8894f78f67e9c4dc10b81c951ed",
+ "connected_stack.mjs": "819ed8941fa33d05bedc732461e9753f69fba9c5796f915909b6c3c1e1f663fe",
+ "connected_worker.mjs": "3456923d6b9f6ff8628c7f84dd2540cb55adf4a83950e6970ace506a1a98295e",
+ "harness-connected-forest-usage-v2-20261002": "48816ec9467b369be056bb03c4b89aa2766a35d07d80f3d0e2a99db987c8c0fb"
+ },
+ "daemonMetadata": {
+ "bundleSha256": "c0f1be69953a507d3abdad60caf95f0641f66221b0c984bc37e81ff84abb61b5",
+ "sourceRevision": "c966e1ac0e10d2741bad53352fcdba9b41d2a6de",
+ "sourceDiffSha256": "b4fd768fe9f620a84bb561384cd613b7103c9f56a81c7ad8191fad2d995e41f5",
+ "boundary": "Full local daemon and tmux; private terminal shells; no cloud account or model inference."
+ },
+ "appSourceRevision": "c966e1ac0e10d2741bad53352fcdba9b41d2a6de",
+ "appProductionDiffSha256": "007836235b4aca69785e4716a83710feccd91853a173e49e5b104925043d477c",
+ "appFixtureSha256": {
+ "connected_main.dart": "8bdf2061c52713ff5dc37939252c5184e90e8da353d3f315e505f270c4e51eed",
+ "ConnectedResourceHost.swift": "f9f58dc6d209119ee4a3440661518785e7ea13f2057c001c666b45ea20e4493e"
+ },
+ "cleanupVerified": true,
+ "phases": [
+ {
+ "label": "foreground-idle-visible",
+ "summary": {
+ "cpuPercentOneCore": 5.701732241807247,
+ "cpuSeconds": 1.7103855416666667,
+ "elapsedSeconds": 29.997647541662445,
+ "interruptWakeupsPerSecond": 28.868930431869693,
+ "liveProcessCountMax": 24,
+ "liveProcessCountMin": 24,
+ "packageIdleWakeupsPerSecond": 0,
+ "processCountMax": 24,
+ "processCountMin": 24,
+ "summedPhysicalFootprintMiBMedian": 486.0810012817383,
+ "summedPhysicalFootprintMiBPeak": 518.0801086425781
+ },
+ "components": {
+ "desktop": {
+ "cpuPercentOneCore": 1.0190442141908225,
+ "interruptWakeupsPerSecond": 15.834575005933145
+ },
+ "daemon": {
+ "cpuPercentOneCore": 4.655395470796329,
+ "interruptWakeupsPerSecond": 12.367636478318309
+ },
+ "tmuxAndWorkers": {
+ "cpuPercentOneCore": 0.027292556820094818,
+ "interruptWakeupsPerSecond": 0.6667189476182377
+ }
+ },
+ "rawSampleSha256": "318035a949c25398351c15bfd022b9a90f88d36c85e49c51d57eef0473bf05fa",
+ "nativeBefore": {
+ "height": 800.0,
+ "scale": 2.0,
+ "key": true,
+ "width": 1280.0,
+ "visible": true,
+ "hidden": false,
+ "focusLosses": 0,
+ "active": true
+ },
+ "nativeAfter": {
+ "height": 800.0,
+ "scale": 2.0,
+ "key": true,
+ "width": 1280.0,
+ "visible": true,
+ "hidden": false,
+ "focusLosses": 0,
+ "active": true
+ },
+ "outputPerWorker": [
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30047.453999999998
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30047.123250000004
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30046.8115
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30046.515667
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30046.122958000004
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30045.771500000003
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30045.558374999997
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30045.201584000002
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30044.863958
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30044.556416000003
+ }
+ ],
+ "aggregateSamples": [
+ {
+ "elapsedSeconds": 0.006986208347370848,
+ "cpuTicks": 71156795,
+ "interruptWakeups": 1359,
+ "summedFootprintBytes": 537593216,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 1.0081509166629985,
+ "cpuTicks": 75614096,
+ "interruptWakeups": 1399,
+ "summedFootprintBytes": 542591008,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 2.0122098750143778,
+ "cpuTicks": 75930071,
+ "interruptWakeups": 1415,
+ "summedFootprintBytes": 542656544,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 3.0083998333429918,
+ "cpuTicks": 76503884,
+ "interruptWakeups": 1455,
+ "summedFootprintBytes": 543115296,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 4.008983166684629,
+ "cpuTicks": 76683504,
+ "interruptWakeups": 1472,
+ "summedFootprintBytes": 543180832,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 5.0096029583364725,
+ "cpuTicks": 76886246,
+ "interruptWakeups": 1490,
+ "summedFootprintBytes": 543246368,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 6.007058666669764,
+ "cpuTicks": 87901133,
+ "interruptWakeups": 1566,
+ "summedFootprintBytes": 519113648,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 7.008750875014812,
+ "cpuTicks": 88166834,
+ "interruptWakeups": 1583,
+ "summedFootprintBytes": 519179184,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 8.009136666660197,
+ "cpuTicks": 88699445,
+ "interruptWakeups": 1630,
+ "summedFootprintBytes": 519523248,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 9.004619750019629,
+ "cpuTicks": 88964390,
+ "interruptWakeups": 1650,
+ "summedFootprintBytes": 519588784,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 10.010802083328599,
+ "cpuTicks": 89166942,
+ "interruptWakeups": 1667,
+ "summedFootprintBytes": 519605168,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 11.008845541684423,
+ "cpuTicks": 94397839,
+ "interruptWakeups": 1713,
+ "summedFootprintBytes": 508300184,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 12.00532391667366,
+ "cpuTicks": 94636088,
+ "interruptWakeups": 1727,
+ "summedFootprintBytes": 508365720,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 13.010515583329834,
+ "cpuTicks": 95378630,
+ "interruptWakeups": 1766,
+ "summedFootprintBytes": 508726168,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 14.007400583330309,
+ "cpuTicks": 95601226,
+ "interruptWakeups": 1783,
+ "summedFootprintBytes": 508791704,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 15.008613583340775,
+ "cpuTicks": 95816905,
+ "interruptWakeups": 1800,
+ "summedFootprintBytes": 508840856,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 16.007741625013296,
+ "cpuTicks": 99641940,
+ "interruptWakeups": 1839,
+ "summedFootprintBytes": 509692872,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 17.00777337499312,
+ "cpuTicks": 99771222,
+ "interruptWakeups": 1857,
+ "summedFootprintBytes": 509758408,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 18.010061000008136,
+ "cpuTicks": 100091907,
+ "interruptWakeups": 1896,
+ "summedFootprintBytes": 510020552,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 19.008789750019787,
+ "cpuTicks": 100260821,
+ "interruptWakeups": 1915,
+ "summedFootprintBytes": 510086088,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 20.005159249994904,
+ "cpuTicks": 100473057,
+ "interruptWakeups": 1930,
+ "summedFootprintBytes": 510135240,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 21.017953625007067,
+ "cpuTicks": 104933625,
+ "interruptWakeups": 1978,
+ "summedFootprintBytes": 490605536,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 22.00469250002061,
+ "cpuTicks": 105619488,
+ "interruptWakeups": 1995,
+ "summedFootprintBytes": 507907040,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 23.00757845834596,
+ "cpuTicks": 106101447,
+ "interruptWakeups": 2046,
+ "summedFootprintBytes": 508234720,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 24.00917541666422,
+ "cpuTicks": 106274031,
+ "interruptWakeups": 2063,
+ "summedFootprintBytes": 508283872,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 25.004333833348937,
+ "cpuTicks": 106535262,
+ "interruptWakeups": 2082,
+ "summedFootprintBytes": 508349408,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 26.01024299999699,
+ "cpuTicks": 110990862,
+ "interruptWakeups": 2130,
+ "summedFootprintBytes": 509217808,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 27.01076529166312,
+ "cpuTicks": 111233643,
+ "interruptWakeups": 2149,
+ "summedFootprintBytes": 509217808,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 28.00798712502001,
+ "cpuTicks": 111712413,
+ "interruptWakeups": 2190,
+ "summedFootprintBytes": 509496336,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 29.009071500011487,
+ "cpuTicks": 111965410,
+ "interruptWakeups": 2210,
+ "summedFootprintBytes": 509545488,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 30.004633750009816,
+ "cpuTicks": 112206048,
+ "interruptWakeups": 2225,
+ "summedFootprintBytes": 509611024,
+ "accountingProcessCount": 24
+ }
+ ]
+ },
+ {
+ "label": "foreground-idle-hidden",
+ "summary": {
+ "cpuPercentOneCore": 4.751851033981446,
+ "cpuSeconds": 1.4256831666666667,
+ "elapsedSeconds": 30.002690666675335,
+ "interruptWakeupsPerSecond": 27.997488936317534,
+ "liveProcessCountMax": 24,
+ "liveProcessCountMin": 24,
+ "packageIdleWakeupsPerSecond": 0,
+ "processCountMax": 24,
+ "processCountMin": 24,
+ "summedPhysicalFootprintMiBMedian": 478.00303649902344,
+ "summedPhysicalFootprintMiBPeak": 491.03430938720703
+ },
+ "components": {
+ "desktop": {
+ "cpuPercentOneCore": 1.101074162548125,
+ "interruptWakeupsPerSecond": 15.93190441852355
+ },
+ "daemon": {
+ "cpuPercentOneCore": 3.6254512261956426,
+ "interruptWakeupsPerSecond": 11.398977638357852
+ },
+ "tmuxAndWorkers": {
+ "cpuPercentOneCore": 0.025325645237677583,
+ "interruptWakeupsPerSecond": 0.6666068794361317
+ }
+ },
+ "rawSampleSha256": "7012ea53c8c59f58c523614293ee5222fb83847dd80ba3327909c0cb9f86104e",
+ "nativeBefore": {
+ "height": 800.0,
+ "scale": 2.0,
+ "key": true,
+ "width": 1280.0,
+ "visible": true,
+ "hidden": false,
+ "focusLosses": 0,
+ "active": true
+ },
+ "nativeAfter": {
+ "height": 800.0,
+ "scale": 2.0,
+ "key": true,
+ "width": 1280.0,
+ "visible": true,
+ "hidden": false,
+ "focusLosses": 0,
+ "active": true
+ },
+ "outputPerWorker": [
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30049.947708
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30050.314041999998
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30050.60475
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30050.910333
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30051.214459000003
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30051.541916000002
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30051.858042000007
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30052.147958999994
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30052.447667
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30052.757374999994
+ }
+ ],
+ "aggregateSamples": [
+ {
+ "elapsedSeconds": 0.0038009166601113975,
+ "cpuTicks": 117393000,
+ "interruptWakeups": 2422,
+ "summedFootprintBytes": 512674880,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 1.0104462500021327,
+ "cpuTicks": 121309996,
+ "interruptWakeups": 2464,
+ "summedFootprintBytes": 513510488,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 2.0131820416718256,
+ "cpuTicks": 121547219,
+ "interruptWakeups": 2482,
+ "summedFootprintBytes": 513576024,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 3.011796125007095,
+ "cpuTicks": 122068244,
+ "interruptWakeups": 2530,
+ "summedFootprintBytes": 513838168,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 4.003778499987675,
+ "cpuTicks": 122340799,
+ "interruptWakeups": 2549,
+ "summedFootprintBytes": 513903704,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 5.005276999989292,
+ "cpuTicks": 122524504,
+ "interruptWakeups": 2564,
+ "summedFootprintBytes": 513952856,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 6.010239916678984,
+ "cpuTicks": 126087426,
+ "interruptWakeups": 2609,
+ "summedFootprintBytes": 514821256,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 7.004679750010837,
+ "cpuTicks": 126316886,
+ "interruptWakeups": 2624,
+ "summedFootprintBytes": 514886792,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 8.011700333328918,
+ "cpuTicks": 127500047,
+ "interruptWakeups": 2663,
+ "summedFootprintBytes": 500780168,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 9.006782583339373,
+ "cpuTicks": 127719279,
+ "interruptWakeups": 2680,
+ "summedFootprintBytes": 500845704,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 10.013235291669844,
+ "cpuTicks": 127947462,
+ "interruptWakeups": 2698,
+ "summedFootprintBytes": 500911240,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 11.01219879166456,
+ "cpuTicks": 132036854,
+ "interruptWakeups": 2739,
+ "summedFootprintBytes": 501763256,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 12.009095791669097,
+ "cpuTicks": 132215652,
+ "interruptWakeups": 2756,
+ "summedFootprintBytes": 501845176,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 13.008185624988982,
+ "cpuTicks": 132581430,
+ "interruptWakeups": 2795,
+ "summedFootprintBytes": 502074552,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 14.003073583327932,
+ "cpuTicks": 132710538,
+ "interruptWakeups": 2815,
+ "summedFootprintBytes": 502140088,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 15.010518249997403,
+ "cpuTicks": 133003113,
+ "interruptWakeups": 2832,
+ "summedFootprintBytes": 502189240,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 16.00959545833757,
+ "cpuTicks": 138441899,
+ "interruptWakeups": 2886,
+ "summedFootprintBytes": 498027560,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 17.013835249992553,
+ "cpuTicks": 138732012,
+ "interruptWakeups": 2901,
+ "summedFootprintBytes": 498093096,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 18.005266458319966,
+ "cpuTicks": 139630880,
+ "interruptWakeups": 2962,
+ "summedFootprintBytes": 498650152,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 19.0104486666678,
+ "cpuTicks": 139845399,
+ "interruptWakeups": 2980,
+ "summedFootprintBytes": 498699304,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 20.011865041655255,
+ "cpuTicks": 140128643,
+ "interruptWakeups": 2997,
+ "summedFootprintBytes": 498764840,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 21.00380433333339,
+ "cpuTicks": 144702270,
+ "interruptWakeups": 3037,
+ "summedFootprintBytes": 499616832,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 22.01483008332434,
+ "cpuTicks": 144931238,
+ "interruptWakeups": 3055,
+ "summedFootprintBytes": 499665984,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 23.012528374994872,
+ "cpuTicks": 145342124,
+ "interruptWakeups": 3094,
+ "summedFootprintBytes": 499928128,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 24.006685500004096,
+ "cpuTicks": 145572448,
+ "interruptWakeups": 3114,
+ "summedFootprintBytes": 499977280,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 25.00880370833329,
+ "cpuTicks": 145819898,
+ "interruptWakeups": 3130,
+ "summedFootprintBytes": 500042816,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 26.00649245834211,
+ "cpuTicks": 150274460,
+ "interruptWakeups": 3171,
+ "summedFootprintBytes": 500894832,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 27.009859041660093,
+ "cpuTicks": 150564017,
+ "interruptWakeups": 3186,
+ "summedFootprintBytes": 500960368,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 28.007982749986695,
+ "cpuTicks": 151067888,
+ "interruptWakeups": 3227,
+ "summedFootprintBytes": 501222512,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 29.007959708338603,
+ "cpuTicks": 151332223,
+ "interruptWakeups": 3244,
+ "summedFootprintBytes": 501288048,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 30.006491583335446,
+ "cpuTicks": 151609396,
+ "interruptWakeups": 3262,
+ "summedFootprintBytes": 501337200,
+ "accountingProcessCount": 24
+ }
+ ]
+ },
+ {
+ "label": "foreground-active",
+ "summary": {
+ "cpuPercentOneCore": 31.864468515422956,
+ "cpuSeconds": 9.5603095,
+ "elapsedSeconds": 30.00304083331139,
+ "interruptWakeupsPerSecond": 1170.0813992501376,
+ "liveProcessCountMax": 24,
+ "liveProcessCountMin": 24,
+ "packageIdleWakeupsPerSecond": 0,
+ "processCountMax": 24,
+ "processCountMin": 24,
+ "summedPhysicalFootprintMiBMedian": 659.2556457519531,
+ "summedPhysicalFootprintMiBPeak": 736.2418975830078
+ },
+ "components": {
+ "desktop": {
+ "cpuPercentOneCore": 18.91414659109964,
+ "interruptWakeupsPerSecond": 324.033822238644
+ },
+ "daemon": {
+ "cpuPercentOneCore": 6.992743013359122,
+ "interruptWakeupsPerSecond": 299.6362951990753
+ },
+ "tmuxAndWorkers": {
+ "cpuPercentOneCore": 5.9575789109641875,
+ "interruptWakeupsPerSecond": 546.4112818124182
+ }
+ },
+ "rawSampleSha256": "a5e170b22dc8cd6f2459a02517ace1e0f06854989aaabf0ac73cd18ceb165d20",
+ "nativeBefore": {
+ "height": 800.0,
+ "scale": 2.0,
+ "key": true,
+ "width": 1280.0,
+ "visible": true,
+ "hidden": false,
+ "focusLosses": 0,
+ "active": true
+ },
+ "nativeAfter": {
+ "height": 800.0,
+ "active": true,
+ "hidden": false,
+ "width": 1280.0,
+ "visible": true,
+ "scale": 2.0,
+ "focusLosses": 0,
+ "key": true
+ },
+ "outputPerWorker": [
+ {
+ "ticks": 591,
+ "bytes": 294901,
+ "skipped": 0,
+ "elapsedMs": 30053.579291999995
+ },
+ {
+ "ticks": 590,
+ "bytes": 294402,
+ "skipped": 0,
+ "elapsedMs": 30053.123708
+ },
+ {
+ "ticks": 590,
+ "bytes": 294402,
+ "skipped": 0,
+ "elapsedMs": 30053.061875
+ },
+ {
+ "ticks": 590,
+ "bytes": 294402,
+ "skipped": 0,
+ "elapsedMs": 30053.152334
+ },
+ {
+ "ticks": 590,
+ "bytes": 294402,
+ "skipped": 0,
+ "elapsedMs": 30053.059708
+ },
+ {
+ "ticks": 590,
+ "bytes": 294402,
+ "skipped": 0,
+ "elapsedMs": 30053.136375000002
+ },
+ {
+ "ticks": 591,
+ "bytes": 294901,
+ "skipped": 0,
+ "elapsedMs": 30053.28154200001
+ },
+ {
+ "ticks": 590,
+ "bytes": 294402,
+ "skipped": 0,
+ "elapsedMs": 30053.13004199999
+ },
+ {
+ "ticks": 591,
+ "bytes": 294901,
+ "skipped": 0,
+ "elapsedMs": 30053.252999999997
+ },
+ {
+ "ticks": 591,
+ "bytes": 294901,
+ "skipped": 0,
+ "elapsedMs": 30053.37333300001
+ }
+ ],
+ "aggregateSamples": [
+ {
+ "elapsedSeconds": 0.004776541667524725,
+ "cpuTicks": 188679286,
+ "interruptWakeups": 8013,
+ "summedFootprintBytes": 570199848,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 1.0050952083256561,
+ "cpuTicks": 198152740,
+ "interruptWakeups": 9155,
+ "summedFootprintBytes": 577474728,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 2.005638041649945,
+ "cpuTicks": 206540952,
+ "interruptWakeups": 10260,
+ "summedFootprintBytes": 591892984,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 3.0056416250008624,
+ "cpuTicks": 214213380,
+ "interruptWakeups": 11388,
+ "summedFootprintBytes": 595988984,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 4.010491666645976,
+ "cpuTicks": 221617838,
+ "interruptWakeups": 12510,
+ "summedFootprintBytes": 601117200,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 5.008812791638775,
+ "cpuTicks": 228532116,
+ "interruptWakeups": 13669,
+ "summedFootprintBytes": 605606416,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 6.007037749979645,
+ "cpuTicks": 236989333,
+ "interruptWakeups": 14849,
+ "summedFootprintBytes": 624497216,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 7.006595041661058,
+ "cpuTicks": 245062695,
+ "interruptWakeups": 16020,
+ "summedFootprintBytes": 628888128,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 8.003999999986263,
+ "cpuTicks": 254238028,
+ "interruptWakeups": 17214,
+ "summedFootprintBytes": 631148784,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 9.01039370833314,
+ "cpuTicks": 264978541,
+ "interruptWakeups": 18581,
+ "summedFootprintBytes": 633934640,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 10.007263208332006,
+ "cpuTicks": 272656539,
+ "interruptWakeups": 19838,
+ "summedFootprintBytes": 638784328,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 11.002492874977179,
+ "cpuTicks": 280514863,
+ "interruptWakeups": 21118,
+ "summedFootprintBytes": 644764536,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 12.004002041649073,
+ "cpuTicks": 286828073,
+ "interruptWakeups": 22192,
+ "summedFootprintBytes": 663098232,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 13.00463499999023,
+ "cpuTicks": 294322552,
+ "interruptWakeups": 23298,
+ "summedFootprintBytes": 667685752,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 14.006248499994399,
+ "cpuTicks": 301873133,
+ "interruptWakeups": 24444,
+ "summedFootprintBytes": 672158584,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 15.005717916646972,
+ "cpuTicks": 309044374,
+ "interruptWakeups": 25637,
+ "summedFootprintBytes": 691524472,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 16.007448166667018,
+ "cpuTicks": 316572966,
+ "interruptWakeups": 26731,
+ "summedFootprintBytes": 695948176,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 17.008058249979513,
+ "cpuTicks": 325258599,
+ "interruptWakeups": 27931,
+ "summedFootprintBytes": 693966624,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 18.011784583330154,
+ "cpuTicks": 332916555,
+ "interruptWakeups": 29089,
+ "summedFootprintBytes": 691279648,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 19.009558083314914,
+ "cpuTicks": 340515455,
+ "interruptWakeups": 30239,
+ "summedFootprintBytes": 702306080,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 20.00603962497553,
+ "cpuTicks": 348166949,
+ "interruptWakeups": 31425,
+ "summedFootprintBytes": 700653144,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 21.00944154165336,
+ "cpuTicks": 355871488,
+ "interruptWakeups": 32641,
+ "summedFootprintBytes": 707845744,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 22.00884258330916,
+ "cpuTicks": 361958278,
+ "interruptWakeups": 33871,
+ "summedFootprintBytes": 726244976,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 23.00950070831459,
+ "cpuTicks": 370025962,
+ "interruptWakeups": 35150,
+ "summedFootprintBytes": 731405936,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 24.00605641666334,
+ "cpuTicks": 377380637,
+ "interruptWakeups": 36320,
+ "summedFootprintBytes": 735960688,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 25.005481999978656,
+ "cpuTicks": 382976834,
+ "interruptWakeups": 37373,
+ "summedFootprintBytes": 754196104,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 26.009464791655773,
+ "cpuTicks": 390829977,
+ "interruptWakeups": 38498,
+ "summedFootprintBytes": 758619856,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 27.00461604166776,
+ "cpuTicks": 396615601,
+ "interruptWakeups": 39554,
+ "summedFootprintBytes": 762011344,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 28.006322916655336,
+ "cpuTicks": 402946829,
+ "interruptWakeups": 40751,
+ "summedFootprintBytes": 772005584,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 29.006180958327604,
+ "cpuTicks": 410086803,
+ "interruptWakeups": 41939,
+ "summedFootprintBytes": 768581328,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 30.007817374978913,
+ "cpuTicks": 418126714,
+ "interruptWakeups": 43119,
+ "summedFootprintBytes": 762847024,
+ "accountingProcessCount": 24
+ }
+ ]
+ },
+ {
+ "label": "background-idle-hidden",
+ "summary": {
+ "cpuPercentOneCore": 4.042939709129659,
+ "cpuSeconds": 1.2128358333333333,
+ "elapsedSeconds": 29.998860249994323,
+ "interruptWakeupsPerSecond": 14.367212501017653,
+ "liveProcessCountMax": 25,
+ "liveProcessCountMin": 24,
+ "packageIdleWakeupsPerSecond": 0,
+ "processCountMax": 25,
+ "processCountMin": 24,
+ "summedPhysicalFootprintMiBMedian": 659.3046951293945,
+ "summedPhysicalFootprintMiBPeak": 663.5862197875977
+ },
+ "components": {
+ "desktop": {
+ "cpuPercentOneCore": 0.21110788145141385,
+ "interruptWakeupsPerSecond": 3.1001177786418603
+ },
+ "daemon": {
+ "cpuPercentOneCore": 3.7985182009269245,
+ "interruptWakeupsPerSecond": 10.600402726968941
+ },
+ "tmuxAndWorkers": {
+ "cpuPercentOneCore": 0.03331362675132041,
+ "interruptWakeupsPerSecond": 0.6666919954068516
+ }
+ },
+ "rawSampleSha256": "0d50b4f67fbd35ebc146ecab36a46e6a1ce34c39642cde21b163621f8335ac0f",
+ "nativeBefore": {
+ "height": 800.0,
+ "active": false,
+ "hidden": true,
+ "width": 1280.0,
+ "visible": false,
+ "scale": 2.0,
+ "focusLosses": 1,
+ "key": false
+ },
+ "nativeAfter": {
+ "height": 800.0,
+ "active": false,
+ "hidden": true,
+ "width": 1280.0,
+ "visible": false,
+ "scale": 2.0,
+ "focusLosses": 1,
+ "key": false
+ },
+ "outputPerWorker": [
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30109.419458999982
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30109.19249999999
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30108.992499999993
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30108.853917000015
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30108.711250000008
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30108.568459000016
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30108.402874999985
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30108.229124999998
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30108.05595800001
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30107.88841700001
+ }
+ ],
+ "aggregateSamples": [
+ {
+ "elapsedSeconds": 0.0787574999849312,
+ "cpuTicks": 427884191,
+ "interruptWakeups": 43378,
+ "summedFootprintBytes": 691757136,
+ "accountingProcessCount": 25
+ },
+ {
+ "elapsedSeconds": 1.0126697916421108,
+ "cpuTicks": 428802282,
+ "interruptWakeups": 43384,
+ "summedFootprintBytes": 690790288,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 2.009918416646542,
+ "cpuTicks": 428958191,
+ "interruptWakeups": 43395,
+ "summedFootprintBytes": 690954128,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 3.008531541650882,
+ "cpuTicks": 429145941,
+ "interruptWakeups": 43417,
+ "summedFootprintBytes": 691019664,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 4.012818541668821,
+ "cpuTicks": 429153775,
+ "interruptWakeups": 43421,
+ "summedFootprintBytes": 691019664,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 5.081296166667016,
+ "cpuTicks": 433192577,
+ "interruptWakeups": 43454,
+ "summedFootprintBytes": 689332328,
+ "accountingProcessCount": 25
+ },
+ {
+ "elapsedSeconds": 6.012991625000723,
+ "cpuTicks": 433944938,
+ "interruptWakeups": 43458,
+ "summedFootprintBytes": 688431016,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 7.011829583323561,
+ "cpuTicks": 434215719,
+ "interruptWakeups": 43474,
+ "summedFootprintBytes": 688807848,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 8.009228583308868,
+ "cpuTicks": 434486752,
+ "interruptWakeups": 43508,
+ "summedFootprintBytes": 688873384,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 9.009294958319515,
+ "cpuTicks": 434494742,
+ "interruptWakeups": 43510,
+ "summedFootprintBytes": 688873384,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 10.072777833323926,
+ "cpuTicks": 438360151,
+ "interruptWakeups": 43533,
+ "summedFootprintBytes": 691036312,
+ "accountingProcessCount": 25
+ },
+ {
+ "elapsedSeconds": 11.008113791642245,
+ "cpuTicks": 439468058,
+ "interruptWakeups": 43539,
+ "summedFootprintBytes": 690135000,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 12.009932374989148,
+ "cpuTicks": 439632418,
+ "interruptWakeups": 43549,
+ "summedFootprintBytes": 690315224,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 13.012001374998363,
+ "cpuTicks": 439820389,
+ "interruptWakeups": 43569,
+ "summedFootprintBytes": 690380760,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 14.009952749998774,
+ "cpuTicks": 439825369,
+ "interruptWakeups": 43574,
+ "summedFootprintBytes": 690380760,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 15.06145541666774,
+ "cpuTicks": 443047547,
+ "interruptWakeups": 43597,
+ "summedFootprintBytes": 692084936,
+ "accountingProcessCount": 25
+ },
+ {
+ "elapsedSeconds": 16.011581375001697,
+ "cpuTicks": 443937499,
+ "interruptWakeups": 43603,
+ "summedFootprintBytes": 691183624,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 17.015362333331723,
+ "cpuTicks": 444080882,
+ "interruptWakeups": 43613,
+ "summedFootprintBytes": 691331080,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 18.012050624995027,
+ "cpuTicks": 444230328,
+ "interruptWakeups": 43636,
+ "summedFootprintBytes": 691380232,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 19.00792491665925,
+ "cpuTicks": 444234916,
+ "interruptWakeups": 43639,
+ "summedFootprintBytes": 691380232,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 20.063182916666847,
+ "cpuTicks": 447575287,
+ "interruptWakeups": 43663,
+ "summedFootprintBytes": 693543160,
+ "accountingProcessCount": 25
+ },
+ {
+ "elapsedSeconds": 21.00703949999297,
+ "cpuTicks": 448386728,
+ "interruptWakeups": 43669,
+ "summedFootprintBytes": 692658232,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 22.015600541664753,
+ "cpuTicks": 448524117,
+ "interruptWakeups": 43681,
+ "summedFootprintBytes": 692822072,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 23.012752833310515,
+ "cpuTicks": 448766780,
+ "interruptWakeups": 43713,
+ "summedFootprintBytes": 692871224,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 24.009881833335385,
+ "cpuTicks": 448774751,
+ "interruptWakeups": 43717,
+ "summedFootprintBytes": 692871224,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 25.07168449999881,
+ "cpuTicks": 451653627,
+ "interruptWakeups": 43740,
+ "summedFootprintBytes": 694558992,
+ "accountingProcessCount": 25
+ },
+ {
+ "elapsedSeconds": 26.01553066665656,
+ "cpuTicks": 452866754,
+ "interruptWakeups": 43748,
+ "summedFootprintBytes": 693919824,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 27.01402487498126,
+ "cpuTicks": 452991067,
+ "interruptWakeups": 43760,
+ "summedFootprintBytes": 694083664,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 28.015186083328445,
+ "cpuTicks": 453175369,
+ "interruptWakeups": 43782,
+ "summedFootprintBytes": 694132816,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 29.017794124985812,
+ "cpuTicks": 453179073,
+ "interruptWakeups": 43785,
+ "summedFootprintBytes": 694132816,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 30.077617749979254,
+ "cpuTicks": 456992251,
+ "interruptWakeups": 43809,
+ "summedFootprintBytes": 695820584,
+ "accountingProcessCount": 25
+ }
+ ]
+ },
+ {
+ "label": "background-active",
+ "summary": {
+ "cpuPercentOneCore": 25.96008958389262,
+ "cpuSeconds": 7.788051375,
+ "elapsedSeconds": 30.000094374991022,
+ "interruptWakeupsPerSecond": 921.2637685246706,
+ "liveProcessCountMax": 24,
+ "liveProcessCountMin": 24,
+ "packageIdleWakeupsPerSecond": 0.6999977979238036,
+ "processCountMax": 24,
+ "processCountMin": 24,
+ "summedPhysicalFootprintMiBMedian": 675.0703659057617,
+ "summedPhysicalFootprintMiBPeak": 676.5862655639648
+ },
+ "components": {
+ "desktop": {
+ "cpuPercentOneCore": 9.022083840252842,
+ "interruptWakeupsPerSecond": 126.49960205337307
+ },
+ "daemon": {
+ "cpuPercentOneCore": 8.862655869564396,
+ "interruptWakeupsPerSecond": 275.2991339548902
+ },
+ "tmuxAndWorkers": {
+ "cpuPercentOneCore": 8.075349874075382,
+ "interruptWakeupsPerSecond": 519.4650325164073
+ }
+ },
+ "rawSampleSha256": "df3337e046d35444082d34645c1b4ad2b997af736c453639b05c76fb0848a06e",
+ "nativeBefore": {
+ "height": 800.0,
+ "active": false,
+ "hidden": true,
+ "width": 1280.0,
+ "visible": false,
+ "scale": 2.0,
+ "focusLosses": 1,
+ "key": false
+ },
+ "nativeAfter": {
+ "height": 800.0,
+ "active": false,
+ "hidden": true,
+ "width": 1280.0,
+ "visible": false,
+ "scale": 2.0,
+ "focusLosses": 1,
+ "key": false
+ },
+ "outputPerWorker": [
+ {
+ "ticks": 584,
+ "bytes": 294384,
+ "skipped": 0,
+ "elapsedMs": 30028.679999999993
+ },
+ {
+ "ticks": 583,
+ "bytes": 293869,
+ "skipped": 0,
+ "elapsedMs": 30028.666958999995
+ },
+ {
+ "ticks": 583,
+ "bytes": 293877,
+ "skipped": 0,
+ "elapsedMs": 30028.724792000023
+ },
+ {
+ "ticks": 583,
+ "bytes": 293869,
+ "skipped": 0,
+ "elapsedMs": 30028.694665999996
+ },
+ {
+ "ticks": 583,
+ "bytes": 293877,
+ "skipped": 0,
+ "elapsedMs": 30028.708584000007
+ },
+ {
+ "ticks": 582,
+ "bytes": 293370,
+ "skipped": 0,
+ "elapsedMs": 30028.712834000005
+ },
+ {
+ "ticks": 582,
+ "bytes": 293370,
+ "skipped": 0,
+ "elapsedMs": 30028.730541000026
+ },
+ {
+ "ticks": 583,
+ "bytes": 293869,
+ "skipped": 0,
+ "elapsedMs": 30028.775374999997
+ },
+ {
+ "ticks": 583,
+ "bytes": 293877,
+ "skipped": 0,
+ "elapsedMs": 30028.795790999982
+ },
+ {
+ "ticks": 582,
+ "bytes": 293370,
+ "skipped": 0,
+ "elapsedMs": 30028.81370900001
+ }
+ ],
+ "aggregateSamples": [
+ {
+ "elapsedSeconds": 0.003620083356508985,
+ "cpuTicks": 485396350,
+ "interruptWakeups": 47893,
+ "summedFootprintBytes": 702701456,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 1.0184971250128,
+ "cpuTicks": 489902692,
+ "interruptWakeups": 48702,
+ "summedFootprintBytes": 703111104,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 2.0160880833573174,
+ "cpuTicks": 494470999,
+ "interruptWakeups": 49500,
+ "summedFootprintBytes": 703078336,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 3.0170292916882318,
+ "cpuTicks": 500350832,
+ "interruptWakeups": 50362,
+ "summedFootprintBytes": 703078336,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 4.017273458332056,
+ "cpuTicks": 506931578,
+ "interruptWakeups": 51290,
+ "summedFootprintBytes": 703160280,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 5.009098833339522,
+ "cpuTicks": 516799437,
+ "interruptWakeups": 52187,
+ "summedFootprintBytes": 704012296,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 6.016343958355719,
+ "cpuTicks": 522117398,
+ "interruptWakeups": 53149,
+ "summedFootprintBytes": 704765960,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 7.014323375013191,
+ "cpuTicks": 526262867,
+ "interruptWakeups": 54086,
+ "summedFootprintBytes": 705503240,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 8.01700008334592,
+ "cpuTicks": 531343286,
+ "interruptWakeups": 54887,
+ "summedFootprintBytes": 705634312,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 9.018086958356434,
+ "cpuTicks": 536641071,
+ "interruptWakeups": 55771,
+ "summedFootprintBytes": 705634312,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 10.00935179166845,
+ "cpuTicks": 546912725,
+ "interruptWakeups": 56695,
+ "summedFootprintBytes": 707862584,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 11.005472291668411,
+ "cpuTicks": 551435557,
+ "interruptWakeups": 57573,
+ "summedFootprintBytes": 707862584,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 12.005684958334314,
+ "cpuTicks": 555697615,
+ "interruptWakeups": 58461,
+ "summedFootprintBytes": 707862584,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 13.015562750020763,
+ "cpuTicks": 560675180,
+ "interruptWakeups": 59416,
+ "summedFootprintBytes": 707862584,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 14.008306083356729,
+ "cpuTicks": 565902599,
+ "interruptWakeups": 60260,
+ "summedFootprintBytes": 708370488,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 15.009504041663604,
+ "cpuTicks": 575671348,
+ "interruptWakeups": 61146,
+ "summedFootprintBytes": 709370200,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 16.01097900001332,
+ "cpuTicks": 580251394,
+ "interruptWakeups": 62081,
+ "summedFootprintBytes": 709353816,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 17.016350000019884,
+ "cpuTicks": 586516377,
+ "interruptWakeups": 63066,
+ "summedFootprintBytes": 707485968,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 18.014629250013968,
+ "cpuTicks": 592847493,
+ "interruptWakeups": 64094,
+ "summedFootprintBytes": 707485968,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 19.01563041668851,
+ "cpuTicks": 599280252,
+ "interruptWakeups": 65089,
+ "summedFootprintBytes": 707485968,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 20.006390458351234,
+ "cpuTicks": 610036435,
+ "interruptWakeups": 66075,
+ "summedFootprintBytes": 708108584,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 21.008125250024023,
+ "cpuTicks": 614784296,
+ "interruptWakeups": 67005,
+ "summedFootprintBytes": 708108584,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 22.014611000020523,
+ "cpuTicks": 619583817,
+ "interruptWakeups": 67973,
+ "summedFootprintBytes": 708108584,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 23.015873291675234,
+ "cpuTicks": 626665436,
+ "interruptWakeups": 68985,
+ "summedFootprintBytes": 708108584,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 24.00684287500917,
+ "cpuTicks": 631126703,
+ "interruptWakeups": 69900,
+ "summedFootprintBytes": 708108584,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 25.009735916682985,
+ "cpuTicks": 639408257,
+ "interruptWakeups": 70856,
+ "summedFootprintBytes": 708780352,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 26.016061375004938,
+ "cpuTicks": 644341328,
+ "interruptWakeups": 71823,
+ "summedFootprintBytes": 708796736,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 27.015047458349727,
+ "cpuTicks": 649478716,
+ "interruptWakeups": 72773,
+ "summedFootprintBytes": 708796736,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 28.007492500008084,
+ "cpuTicks": 655989407,
+ "interruptWakeups": 73650,
+ "summedFootprintBytes": 708829504,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 29.015575833356706,
+ "cpuTicks": 662426891,
+ "interruptWakeups": 74585,
+ "summedFootprintBytes": 708829504,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 30.00371445834753,
+ "cpuTicks": 672309583,
+ "interruptWakeups": 75531,
+ "summedFootprintBytes": 709452120,
+ "accountingProcessCount": 24
+ }
+ ]
+ }
+ ]
+ },
+ {
+ "variant": "current",
+ "run": "harness-connected-v2-6-current-20261002",
+ "loadBefore": [
+ 6.1103515625,
+ 7.97900390625,
+ 11.212890625
+ ],
+ "loadAfter": [
+ 8.99951171875,
+ 8.86279296875,
+ 10.96826171875
+ ],
+ "startEpoch": 1790983701.2743738,
+ "endEpoch": 1790983882.656082,
+ "toolingSha256": {
+ "connected_run.py": "f0857e324905b12c47a520cceacd4eff6fe5d8894f78f67e9c4dc10b81c951ed",
+ "connected_stack.mjs": "819ed8941fa33d05bedc732461e9753f69fba9c5796f915909b6c3c1e1f663fe",
+ "connected_worker.mjs": "3456923d6b9f6ff8628c7f84dd2540cb55adf4a83950e6970ace506a1a98295e",
+ "harness-connected-forest-usage-v2-20261002": "48816ec9467b369be056bb03c4b89aa2766a35d07d80f3d0e2a99db987c8c0fb"
+ },
+ "daemonMetadata": {
+ "bundleSha256": "286713aed76a1972419d5d06f6c7069c73bddef81acdeecf9be128de9bd4e369",
+ "sourceRevision": "c966e1ac0e10d2741bad53352fcdba9b41d2a6de",
+ "sourceDiffSha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+ "boundary": "Full local daemon and tmux; private terminal shells; no cloud account or model inference."
+ },
+ "appSourceRevision": "c966e1ac0e10d2741bad53352fcdba9b41d2a6de",
+ "appProductionDiffSha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+ "appFixtureSha256": {
+ "connected_main.dart": "8bdf2061c52713ff5dc37939252c5184e90e8da353d3f315e505f270c4e51eed",
+ "ConnectedResourceHost.swift": "f9f58dc6d209119ee4a3440661518785e7ea13f2057c001c666b45ea20e4493e"
+ },
+ "cleanupVerified": true,
+ "phases": [
+ {
+ "label": "foreground-idle-visible",
+ "summary": {
+ "cpuPercentOneCore": 5.752423756158272,
+ "cpuSeconds": 1.7258072916666667,
+ "elapsedSeconds": 30.00139358334127,
+ "interruptWakeupsPerSecond": 28.398680802383993,
+ "liveProcessCountMax": 24,
+ "liveProcessCountMin": 24,
+ "packageIdleWakeupsPerSecond": 0,
+ "processCountMax": 24,
+ "processCountMin": 24,
+ "summedPhysicalFootprintMiBMedian": 483.8938674926758,
+ "summedPhysicalFootprintMiBPeak": 522.2057952880859
+ },
+ "components": {
+ "desktop": {
+ "cpuPercentOneCore": 1.0991386641778174,
+ "interruptWakeupsPerSecond": 15.465948230406307
+ },
+ "daemon": {
+ "cpuPercentOneCore": 4.626581749091581,
+ "interruptWakeupsPerSecond": 12.266096872391207
+ },
+ "tmuxAndWorkers": {
+ "cpuPercentOneCore": 0.02670334288887313,
+ "interruptWakeupsPerSecond": 0.6666356995864787
+ }
+ },
+ "rawSampleSha256": "ac756c5004c0e3c9209b626bda74030b3effb2e3f900f864345e5500cca95c61",
+ "nativeBefore": {
+ "hidden": false,
+ "visible": true,
+ "width": 1280.0,
+ "height": 800.0,
+ "active": true,
+ "focusLosses": 0,
+ "key": true,
+ "scale": 2.0
+ },
+ "nativeAfter": {
+ "hidden": false,
+ "visible": true,
+ "width": 1280.0,
+ "height": 800.0,
+ "active": true,
+ "focusLosses": 0,
+ "key": true,
+ "scale": 2.0
+ },
+ "outputPerWorker": [
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30055.811125
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30055.139875
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30054.582
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30053.938917
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30053.016416
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30052.679875
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30052.540041999997
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30052.500791000006
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30052.173124999998
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30051.697916
+ }
+ ],
+ "aggregateSamples": [
+ {
+ "elapsedSeconds": 0.004914374992949888,
+ "cpuTicks": 69617548,
+ "interruptWakeups": 1344,
+ "summedFootprintBytes": 537872152,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 1.015316958335461,
+ "cpuTicks": 74128822,
+ "interruptWakeups": 1384,
+ "summedFootprintBytes": 542755160,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 2.016811958339531,
+ "cpuTicks": 74433965,
+ "interruptWakeups": 1400,
+ "summedFootprintBytes": 542820696,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 3.0046575416636188,
+ "cpuTicks": 75050864,
+ "interruptWakeups": 1442,
+ "summedFootprintBytes": 543246680,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 4.005437749990961,
+ "cpuTicks": 75353323,
+ "interruptWakeups": 1460,
+ "summedFootprintBytes": 543295832,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 5.011208749987418,
+ "cpuTicks": 75657641,
+ "interruptWakeups": 1478,
+ "summedFootprintBytes": 543377752,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 6.011577666649828,
+ "cpuTicks": 86616344,
+ "interruptWakeups": 1553,
+ "summedFootprintBytes": 547572464,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 7.014107541675912,
+ "cpuTicks": 86864735,
+ "interruptWakeups": 1569,
+ "summedFootprintBytes": 514804464,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 8.013732166669797,
+ "cpuTicks": 87255256,
+ "interruptWakeups": 1614,
+ "summedFootprintBytes": 515148528,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 9.012403083324898,
+ "cpuTicks": 87454556,
+ "interruptWakeups": 1637,
+ "summedFootprintBytes": 515197680,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 10.011971708328929,
+ "cpuTicks": 87743807,
+ "interruptWakeups": 1654,
+ "summedFootprintBytes": 515263216,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 11.007704333314905,
+ "cpuTicks": 92218043,
+ "interruptWakeups": 1694,
+ "summedFootprintBytes": 497371984,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 12.006906624999829,
+ "cpuTicks": 92447156,
+ "interruptWakeups": 1709,
+ "summedFootprintBytes": 497437520,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 13.008360416657524,
+ "cpuTicks": 93215240,
+ "interruptWakeups": 1752,
+ "summedFootprintBytes": 497732432,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 14.005712833342841,
+ "cpuTicks": 93445764,
+ "interruptWakeups": 1770,
+ "summedFootprintBytes": 497781584,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 15.00593841666705,
+ "cpuTicks": 93683440,
+ "interruptWakeups": 1787,
+ "summedFootprintBytes": 497847120,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 16.003434583341004,
+ "cpuTicks": 97467879,
+ "interruptWakeups": 1827,
+ "summedFootprintBytes": 499321800,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 17.006974749994697,
+ "cpuTicks": 97641132,
+ "interruptWakeups": 1844,
+ "summedFootprintBytes": 499370952,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 18.011134791653603,
+ "cpuTicks": 98029745,
+ "interruptWakeups": 1880,
+ "summedFootprintBytes": 499665864,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 19.00715424999362,
+ "cpuTicks": 98258100,
+ "interruptWakeups": 1900,
+ "summedFootprintBytes": 499715016,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 20.01557270833291,
+ "cpuTicks": 98462290,
+ "interruptWakeups": 1914,
+ "summedFootprintBytes": 499780552,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 21.011054999980843,
+ "cpuTicks": 103761867,
+ "interruptWakeups": 1964,
+ "summedFootprintBytes": 487312640,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 22.02859445833019,
+ "cpuTicks": 104264020,
+ "interruptWakeups": 1982,
+ "summedFootprintBytes": 504646936,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 23.015723708318546,
+ "cpuTicks": 104865864,
+ "interruptWakeups": 2030,
+ "summedFootprintBytes": 505089304,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 24.00859708333155,
+ "cpuTicks": 105021667,
+ "interruptWakeups": 2048,
+ "summedFootprintBytes": 505154840,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 25.01108266666415,
+ "cpuTicks": 105192682,
+ "interruptWakeups": 2065,
+ "summedFootprintBytes": 505220376,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 26.009692333318526,
+ "cpuTicks": 109824203,
+ "interruptWakeups": 2105,
+ "summedFootprintBytes": 507399496,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 27.011347749998095,
+ "cpuTicks": 110049000,
+ "interruptWakeups": 2123,
+ "summedFootprintBytes": 507448648,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 28.015688791667344,
+ "cpuTicks": 110560655,
+ "interruptWakeups": 2159,
+ "summedFootprintBytes": 507727176,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 29.013266916648718,
+ "cpuTicks": 110822333,
+ "interruptWakeups": 2181,
+ "summedFootprintBytes": 507792712,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 30.00630795833422,
+ "cpuTicks": 111036923,
+ "interruptWakeups": 2196,
+ "summedFootprintBytes": 507841864,
+ "accountingProcessCount": 24
+ }
+ ]
+ },
+ {
+ "label": "foreground-idle-hidden",
+ "summary": {
+ "cpuPercentOneCore": 3.905265058679385,
+ "cpuSeconds": 1.1717357916666666,
+ "elapsedSeconds": 30.004001624998637,
+ "interruptWakeupsPerSecond": 15.397946106464424,
+ "liveProcessCountMax": 24,
+ "liveProcessCountMin": 24,
+ "packageIdleWakeupsPerSecond": 0,
+ "processCountMax": 24,
+ "processCountMin": 24,
+ "summedPhysicalFootprintMiBMedian": 447.72212982177734,
+ "summedPhysicalFootprintMiBPeak": 450.8940963745117
+ },
+ "components": {
+ "desktop": {
+ "cpuPercentOneCore": 0.14501551785372996,
+ "interruptWakeupsPerSecond": 3.099586553898683
+ },
+ "daemon": {
+ "cpuPercentOneCore": 3.7352692617715144,
+ "interruptWakeupsPerSecond": 11.631781799039143
+ },
+ "tmuxAndWorkers": {
+ "cpuPercentOneCore": 0.02498027905413991,
+ "interruptWakeupsPerSecond": 0.6665777535265984
+ }
+ },
+ "rawSampleSha256": "16c172edb97e17bbcb1d581aac0c8fcd573d41f0d21cba896ddf921aff989bf8",
+ "nativeBefore": {
+ "hidden": false,
+ "visible": true,
+ "width": 1280.0,
+ "height": 800.0,
+ "active": true,
+ "focusLosses": 0,
+ "key": true,
+ "scale": 2.0
+ },
+ "nativeAfter": {
+ "hidden": false,
+ "visible": true,
+ "width": 1280.0,
+ "height": 800.0,
+ "active": true,
+ "focusLosses": 0,
+ "key": true,
+ "scale": 2.0
+ },
+ "outputPerWorker": [
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30062.077416
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30061.530250000003
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30061.077917000002
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30060.745334
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30060.530333000002
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30060.572959000005
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30060.472458999997
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30060.277500000004
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30060.06674999999
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30059.891374999992
+ }
+ ],
+ "aggregateSamples": [
+ {
+ "elapsedSeconds": 0.006807083322200924,
+ "cpuTicks": 116310768,
+ "interruptWakeups": 2323,
+ "summedFootprintBytes": 467537296,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 1.0127878749917727,
+ "cpuTicks": 120758018,
+ "interruptWakeups": 2353,
+ "summedFootprintBytes": 468274624,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 2.0041049166757148,
+ "cpuTicks": 120768078,
+ "interruptWakeups": 2358,
+ "summedFootprintBytes": 468274624,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 3.0138112916611135,
+ "cpuTicks": 120983959,
+ "interruptWakeups": 2392,
+ "summedFootprintBytes": 468487616,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 4.0153971666586585,
+ "cpuTicks": 120993643,
+ "interruptWakeups": 2401,
+ "summedFootprintBytes": 468487616,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 5.012165458349045,
+ "cpuTicks": 120994975,
+ "interruptWakeups": 2403,
+ "summedFootprintBytes": 468487616,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 6.01394516666187,
+ "cpuTicks": 125264702,
+ "interruptWakeups": 2432,
+ "summedFootprintBytes": 469257688,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 7.006821749993833,
+ "cpuTicks": 125268454,
+ "interruptWakeups": 2435,
+ "summedFootprintBytes": 469257688,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 8.010829750011908,
+ "cpuTicks": 125545296,
+ "interruptWakeups": 2461,
+ "summedFootprintBytes": 469470680,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 9.01091195832123,
+ "cpuTicks": 125551086,
+ "interruptWakeups": 2467,
+ "summedFootprintBytes": 469470680,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 10.00321879168041,
+ "cpuTicks": 125563467,
+ "interruptWakeups": 2473,
+ "summedFootprintBytes": 469470680,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 11.018644875002792,
+ "cpuTicks": 129803273,
+ "interruptWakeups": 2501,
+ "summedFootprintBytes": 470224368,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 12.011235458339797,
+ "cpuTicks": 129807111,
+ "interruptWakeups": 2505,
+ "summedFootprintBytes": 470257136,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 13.012288916681428,
+ "cpuTicks": 130047387,
+ "interruptWakeups": 2530,
+ "summedFootprintBytes": 470486512,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 14.010817500005942,
+ "cpuTicks": 130063455,
+ "interruptWakeups": 2539,
+ "summedFootprintBytes": 470486512,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 15.014880875009112,
+ "cpuTicks": 130067744,
+ "interruptWakeups": 2543,
+ "summedFootprintBytes": 470486512,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 16.016125333320815,
+ "cpuTicks": 133966185,
+ "interruptWakeups": 2577,
+ "summedFootprintBytes": 471289352,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 17.013800416665617,
+ "cpuTicks": 133969183,
+ "interruptWakeups": 2579,
+ "summedFootprintBytes": 471289352,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 18.014716333331307,
+ "cpuTicks": 134657774,
+ "interruptWakeups": 2627,
+ "summedFootprintBytes": 471748104,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 19.01702770832344,
+ "cpuTicks": 134678856,
+ "interruptWakeups": 2635,
+ "summedFootprintBytes": 471748104,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 20.01416529167909,
+ "cpuTicks": 134684204,
+ "interruptWakeups": 2639,
+ "summedFootprintBytes": 471748104,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 21.016720166662708,
+ "cpuTicks": 138887036,
+ "interruptWakeups": 2666,
+ "summedFootprintBytes": 472534584,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 22.008883875008905,
+ "cpuTicks": 138900798,
+ "interruptWakeups": 2672,
+ "summedFootprintBytes": 472534584,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 23.011001041682903,
+ "cpuTicks": 139160940,
+ "interruptWakeups": 2696,
+ "summedFootprintBytes": 472796728,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 24.008209666673793,
+ "cpuTicks": 139172060,
+ "interruptWakeups": 2704,
+ "summedFootprintBytes": 472796728,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 25.01123637499404,
+ "cpuTicks": 139177385,
+ "interruptWakeups": 2707,
+ "summedFootprintBytes": 472796728,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 26.011447416676674,
+ "cpuTicks": 144120647,
+ "interruptWakeups": 2744,
+ "summedFootprintBytes": 468635048,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 27.009838958329055,
+ "cpuTicks": 144124948,
+ "interruptWakeups": 2746,
+ "summedFootprintBytes": 468635048,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 28.00861554167932,
+ "cpuTicks": 144408798,
+ "interruptWakeups": 2774,
+ "summedFootprintBytes": 468815272,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 29.015791166661074,
+ "cpuTicks": 144417433,
+ "interruptWakeups": 2780,
+ "summedFootprintBytes": 468815272,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 30.010808708320837,
+ "cpuTicks": 144432427,
+ "interruptWakeups": 2785,
+ "summedFootprintBytes": 468831656,
+ "accountingProcessCount": 24
+ }
+ ]
+ },
+ {
+ "label": "foreground-active",
+ "summary": {
+ "cpuPercentOneCore": 33.506065870386635,
+ "cpuSeconds": 10.051426958333334,
+ "elapsedSeconds": 29.998827666655416,
+ "interruptWakeupsPerSecond": 1041.040681556802,
+ "liveProcessCountMax": 24,
+ "liveProcessCountMin": 24,
+ "packageIdleWakeupsPerSecond": 0,
+ "processCountMax": 24,
+ "processCountMin": 24,
+ "summedPhysicalFootprintMiBMedian": 666.0677337646484,
+ "summedPhysicalFootprintMiBPeak": 752.0861282348633
+ },
+ "components": {
+ "desktop": {
+ "cpuPercentOneCore": 20.33704347647326,
+ "interruptWakeupsPerSecond": 292.4447614248422
+ },
+ "daemon": {
+ "cpuPercentOneCore": 7.156298124452723,
+ "interruptWakeupsPerSecond": 242.04279182785586
+ },
+ "tmuxAndWorkers": {
+ "cpuPercentOneCore": 6.012724269460651,
+ "interruptWakeupsPerSecond": 506.55312830410384
+ }
+ },
+ "rawSampleSha256": "a6402fe91d725f614b7282321d2a382cdeb1c7b04382147946f7f7c5162e6efa",
+ "nativeBefore": {
+ "hidden": false,
+ "visible": true,
+ "width": 1280.0,
+ "height": 800.0,
+ "active": true,
+ "focusLosses": 0,
+ "key": true,
+ "scale": 2.0
+ },
+ "nativeAfter": {
+ "hidden": false,
+ "visible": true,
+ "width": 1280.0,
+ "height": 800.0,
+ "active": true,
+ "focusLosses": 0,
+ "key": true,
+ "scale": 2.0
+ },
+ "outputPerWorker": [
+ {
+ "ticks": 582,
+ "bytes": 290394,
+ "skipped": 0,
+ "elapsedMs": 30052.36591699999
+ },
+ {
+ "ticks": 582,
+ "bytes": 290394,
+ "skipped": 0,
+ "elapsedMs": 30052.285791999995
+ },
+ {
+ "ticks": 583,
+ "bytes": 290893,
+ "skipped": 0,
+ "elapsedMs": 30052.038958999998
+ },
+ {
+ "ticks": 581,
+ "bytes": 289903,
+ "skipped": 0,
+ "elapsedMs": 30052.061125000007
+ },
+ {
+ "ticks": 582,
+ "bytes": 290402,
+ "skipped": 0,
+ "elapsedMs": 30052.03770799999
+ },
+ {
+ "ticks": 582,
+ "bytes": 290402,
+ "skipped": 0,
+ "elapsedMs": 30051.221458
+ },
+ {
+ "ticks": 581,
+ "bytes": 289903,
+ "skipped": 0,
+ "elapsedMs": 30050.550292
+ },
+ {
+ "ticks": 582,
+ "bytes": 290402,
+ "skipped": 0,
+ "elapsedMs": 30049.739791999993
+ },
+ {
+ "ticks": 582,
+ "bytes": 290402,
+ "skipped": 0,
+ "elapsedMs": 30049.173375
+ },
+ {
+ "ticks": 582,
+ "bytes": 290402,
+ "skipped": 0,
+ "elapsedMs": 30048.678541
+ }
+ ],
+ "aggregateSamples": [
+ {
+ "elapsedSeconds": 0.0058991666592191905,
+ "cpuTicks": 180971289,
+ "interruptWakeups": 7037,
+ "summedFootprintBytes": 581062752,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 1.0048927500029095,
+ "cpuTicks": 189613913,
+ "interruptWakeups": 7957,
+ "summedFootprintBytes": 600707552,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 2.007598374999361,
+ "cpuTicks": 195147292,
+ "interruptWakeups": 8987,
+ "summedFootprintBytes": 604377568,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 3.0070039166603237,
+ "cpuTicks": 202481309,
+ "interruptWakeups": 10050,
+ "summedFootprintBytes": 639799776,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 4.008892749989172,
+ "cpuTicks": 210817837,
+ "interruptWakeups": 11093,
+ "summedFootprintBytes": 624185824,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 5.008533749991329,
+ "cpuTicks": 218601904,
+ "interruptWakeups": 12140,
+ "summedFootprintBytes": 628298208,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 6.011916499992367,
+ "cpuTicks": 228076971,
+ "interruptWakeups": 13120,
+ "summedFootprintBytes": 632771688,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 7.008606291667093,
+ "cpuTicks": 236616441,
+ "interruptWakeups": 14189,
+ "summedFootprintBytes": 647304248,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 8.004861624998739,
+ "cpuTicks": 244227837,
+ "interruptWakeups": 15251,
+ "summedFootprintBytes": 652678200,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 9.013623583334265,
+ "cpuTicks": 256523043,
+ "interruptWakeups": 16447,
+ "summedFootprintBytes": 639866128,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 10.010384041670477,
+ "cpuTicks": 263607102,
+ "interruptWakeups": 17332,
+ "summedFootprintBytes": 658085136,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 11.00842399999965,
+ "cpuTicks": 272953127,
+ "interruptWakeups": 18301,
+ "summedFootprintBytes": 663999784,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 12.009360750002088,
+ "cpuTicks": 279445421,
+ "interruptWakeups": 19232,
+ "summedFootprintBytes": 667604264,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 13.00808174998383,
+ "cpuTicks": 285958505,
+ "interruptWakeups": 20167,
+ "summedFootprintBytes": 685430080,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 14.011263458320173,
+ "cpuTicks": 292957700,
+ "interruptWakeups": 21154,
+ "summedFootprintBytes": 689739072,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 15.00751816664706,
+ "cpuTicks": 301023474,
+ "interruptWakeups": 22208,
+ "summedFootprintBytes": 698422640,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 16.01687366666738,
+ "cpuTicks": 310165560,
+ "interruptWakeups": 23273,
+ "summedFootprintBytes": 717116856,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 17.00827191665303,
+ "cpuTicks": 317230865,
+ "interruptWakeups": 24306,
+ "summedFootprintBytes": 715052472,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 18.00826229166705,
+ "cpuTicks": 324900972,
+ "interruptWakeups": 25452,
+ "summedFootprintBytes": 711923128,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 19.0080458750017,
+ "cpuTicks": 332668774,
+ "interruptWakeups": 26472,
+ "summedFootprintBytes": 721671608,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 20.010928375006188,
+ "cpuTicks": 341017068,
+ "interruptWakeups": 27560,
+ "summedFootprintBytes": 724524320,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 21.012224000005517,
+ "cpuTicks": 351256810,
+ "interruptWakeups": 28650,
+ "summedFootprintBytes": 729816376,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 22.008313791651744,
+ "cpuTicks": 358831847,
+ "interruptWakeups": 29710,
+ "summedFootprintBytes": 747445560,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 23.01137604165706,
+ "cpuTicks": 367315630,
+ "interruptWakeups": 30760,
+ "summedFootprintBytes": 748806296,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 24.01054966665106,
+ "cpuTicks": 374844550,
+ "interruptWakeups": 31817,
+ "summedFootprintBytes": 754147480,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 25.011305083316984,
+ "cpuTicks": 381670043,
+ "interruptWakeups": 32931,
+ "summedFootprintBytes": 726376600,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 26.01165137498174,
+ "cpuTicks": 392118906,
+ "interruptWakeups": 34094,
+ "summedFootprintBytes": 779526344,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 27.00859554167255,
+ "cpuTicks": 400691332,
+ "interruptWakeups": 35181,
+ "summedFootprintBytes": 781803720,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 28.011006458313204,
+ "cpuTicks": 407964342,
+ "interruptWakeups": 36244,
+ "summedFootprintBytes": 778821832,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 29.005485833331477,
+ "cpuTicks": 415687506,
+ "interruptWakeups": 37251,
+ "summedFootprintBytes": 788619464,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 30.004726833314635,
+ "cpuTicks": 422205536,
+ "interruptWakeups": 38267,
+ "summedFootprintBytes": 785195352,
+ "accountingProcessCount": 24
+ }
+ ]
+ },
+ {
+ "label": "background-idle-hidden",
+ "summary": {
+ "cpuPercentOneCore": 3.8672832996457682,
+ "cpuSeconds": 1.1601560416666667,
+ "elapsedSeconds": 29.999251458328217,
+ "interruptWakeupsPerSecond": 14.667032629504153,
+ "liveProcessCountMax": 24,
+ "liveProcessCountMin": 24,
+ "packageIdleWakeupsPerSecond": 0,
+ "processCountMax": 24,
+ "processCountMin": 24,
+ "summedPhysicalFootprintMiBMedian": 682.6802444458008,
+ "summedPhysicalFootprintMiBPeak": 685.5084609985352
+ },
+ "components": {
+ "desktop": {
+ "cpuPercentOneCore": 0.15129488612867759,
+ "interruptWakeupsPerSecond": 3.06674318616905
+ },
+ "daemon": {
+ "cpuPercentOneCore": 3.687161999813582,
+ "interruptWakeupsPerSecond": 10.933606141994005
+ },
+ "tmuxAndWorkers": {
+ "cpuPercentOneCore": 0.028826413703507945,
+ "interruptWakeupsPerSecond": 0.6666833013410979
+ }
+ },
+ "rawSampleSha256": "54d59e3df6c577869bb998f4b7e389135c6c308229bfbd96cef58d2df49ddb2c",
+ "nativeBefore": {
+ "hidden": true,
+ "visible": false,
+ "width": 1280.0,
+ "height": 800.0,
+ "active": false,
+ "focusLosses": 1,
+ "key": false,
+ "scale": 2.0
+ },
+ "nativeAfter": {
+ "hidden": true,
+ "visible": false,
+ "width": 1280.0,
+ "height": 800.0,
+ "active": false,
+ "focusLosses": 1,
+ "key": false,
+ "scale": 2.0
+ },
+ "outputPerWorker": [
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30065.521500000003
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30065.026625000013
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30064.32154199999
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30062.674542000008
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30061.995792
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30061.192916000015
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30060.540209
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30059.99650000001
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30059.683417000007
+ },
+ {
+ "ticks": 0,
+ "bytes": 0,
+ "skipped": 0,
+ "elapsedMs": 30059.208041000005
+ }
+ ],
+ "aggregateSamples": [
+ {
+ "elapsedSeconds": 0.006528833328047767,
+ "cpuTicks": 427815785,
+ "interruptWakeups": 38494,
+ "summedFootprintBytes": 711500264,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 1.0206947083352134,
+ "cpuTicks": 432462155,
+ "interruptWakeups": 38518,
+ "summedFootprintBytes": 712712704,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 2.014167291665217,
+ "cpuTicks": 432530013,
+ "interruptWakeups": 38525,
+ "summedFootprintBytes": 712843776,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 3.0158730416733306,
+ "cpuTicks": 432651708,
+ "interruptWakeups": 38550,
+ "summedFootprintBytes": 712909312,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 4.017063166684238,
+ "cpuTicks": 432657664,
+ "interruptWakeups": 38554,
+ "summedFootprintBytes": 712909312,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 5.014772124995943,
+ "cpuTicks": 432666046,
+ "interruptWakeups": 38559,
+ "summedFootprintBytes": 712909312,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 6.016749666683609,
+ "cpuTicks": 437393533,
+ "interruptWakeups": 38592,
+ "summedFootprintBytes": 713728560,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 7.011442458344391,
+ "cpuTicks": 437533923,
+ "interruptWakeups": 38600,
+ "summedFootprintBytes": 713892400,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 8.018603583332151,
+ "cpuTicks": 437793116,
+ "interruptWakeups": 38643,
+ "summedFootprintBytes": 714170928,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 9.009904041682603,
+ "cpuTicks": 437827695,
+ "interruptWakeups": 38646,
+ "summedFootprintBytes": 714170928,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 10.004154708323767,
+ "cpuTicks": 437831529,
+ "interruptWakeups": 38650,
+ "summedFootprintBytes": 714170928,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 11.01725145833916,
+ "cpuTicks": 441999733,
+ "interruptWakeups": 38676,
+ "summedFootprintBytes": 715612744,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 12.008342333341716,
+ "cpuTicks": 442054513,
+ "interruptWakeups": 38682,
+ "summedFootprintBytes": 715760200,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 13.014551458327333,
+ "cpuTicks": 442221759,
+ "interruptWakeups": 38709,
+ "summedFootprintBytes": 715842120,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 14.013648749998538,
+ "cpuTicks": 442227952,
+ "interruptWakeups": 38714,
+ "summedFootprintBytes": 715842120,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 15.0094530833303,
+ "cpuTicks": 442232308,
+ "interruptWakeups": 38717,
+ "summedFootprintBytes": 715842120,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 16.01772541666287,
+ "cpuTicks": 446634820,
+ "interruptWakeups": 38744,
+ "summedFootprintBytes": 716612216,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 17.01586083334405,
+ "cpuTicks": 446768628,
+ "interruptWakeups": 38749,
+ "summedFootprintBytes": 716792440,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 18.015030875016237,
+ "cpuTicks": 446964654,
+ "interruptWakeups": 38777,
+ "summedFootprintBytes": 716857976,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 19.017038041667547,
+ "cpuTicks": 446977003,
+ "interruptWakeups": 38780,
+ "summedFootprintBytes": 716857976,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 20.017244999995455,
+ "cpuTicks": 446984905,
+ "interruptWakeups": 38785,
+ "summedFootprintBytes": 716857976,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 21.01405391667504,
+ "cpuTicks": 451573526,
+ "interruptWakeups": 38809,
+ "summedFootprintBytes": 717628048,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 22.00402687501628,
+ "cpuTicks": 451608526,
+ "interruptWakeups": 38815,
+ "summedFootprintBytes": 717775504,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 23.007730416662525,
+ "cpuTicks": 451734724,
+ "interruptWakeups": 38855,
+ "summedFootprintBytes": 717824656,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 24.00471562499297,
+ "cpuTicks": 451741186,
+ "interruptWakeups": 38859,
+ "summedFootprintBytes": 717824656,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 25.011814333323855,
+ "cpuTicks": 451743660,
+ "interruptWakeups": 38861,
+ "summedFootprintBytes": 717824656,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 26.01734491667594,
+ "cpuTicks": 455383156,
+ "interruptWakeups": 38891,
+ "summedFootprintBytes": 718594728,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 27.008108083333354,
+ "cpuTicks": 455488477,
+ "interruptWakeups": 38899,
+ "summedFootprintBytes": 718742184,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 28.014378583349753,
+ "cpuTicks": 455651214,
+ "interruptWakeups": 38927,
+ "summedFootprintBytes": 718807720,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 29.01027645834256,
+ "cpuTicks": 455655296,
+ "interruptWakeups": 38930,
+ "summedFootprintBytes": 718807720,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 30.005780291656265,
+ "cpuTicks": 455659530,
+ "interruptWakeups": 38934,
+ "summedFootprintBytes": 718807720,
+ "accountingProcessCount": 24
+ }
+ ]
+ },
+ {
+ "label": "background-active",
+ "summary": {
+ "cpuPercentOneCore": 24.463135132602822,
+ "cpuSeconds": 7.34051725,
+ "elapsedSeconds": 30.006445250008255,
+ "interruptWakeupsPerSecond": 926.0677087364207,
+ "liveProcessCountMax": 24,
+ "liveProcessCountMin": 24,
+ "packageIdleWakeupsPerSecond": 0,
+ "processCountMax": 24,
+ "processCountMin": 24,
+ "summedPhysicalFootprintMiBMedian": 694.1489944458008,
+ "summedPhysicalFootprintMiBPeak": 697.4307479858398
+ },
+ "components": {
+ "desktop": {
+ "cpuPercentOneCore": 8.263016981879865,
+ "interruptWakeupsPerSecond": 129.07226989837906
+ },
+ "daemon": {
+ "cpuPercentOneCore": 8.755597960516866,
+ "interruptWakeupsPerSecond": 276.84052312053575
+ },
+ "tmuxAndWorkers": {
+ "cpuPercentOneCore": 7.444520190206086,
+ "interruptWakeupsPerSecond": 520.1549157175059
+ }
+ },
+ "rawSampleSha256": "3f0a7f6e1bb4cb6ea3a31dc7d35d94bffac6a62b3373afc69c9df0baf51f7e4b",
+ "nativeBefore": {
+ "hidden": true,
+ "visible": false,
+ "width": 1280.0,
+ "height": 800.0,
+ "active": false,
+ "focusLosses": 1,
+ "key": false,
+ "scale": 2.0
+ },
+ "nativeAfter": {
+ "hidden": true,
+ "visible": false,
+ "width": 1280.0,
+ "height": 800.0,
+ "active": false,
+ "focusLosses": 1,
+ "key": false,
+ "scale": 2.0
+ },
+ "outputPerWorker": [
+ {
+ "ticks": 584,
+ "bytes": 294296,
+ "skipped": 0,
+ "elapsedMs": 30093.2935
+ },
+ {
+ "ticks": 585,
+ "bytes": 294811,
+ "skipped": 0,
+ "elapsedMs": 30092.407791999984
+ },
+ {
+ "ticks": 585,
+ "bytes": 294811,
+ "skipped": 0,
+ "elapsedMs": 30091.211458000005
+ },
+ {
+ "ticks": 583,
+ "bytes": 293797,
+ "skipped": 0,
+ "elapsedMs": 30090.39962500002
+ },
+ {
+ "ticks": 584,
+ "bytes": 294304,
+ "skipped": 0,
+ "elapsedMs": 30089.999916
+ },
+ {
+ "ticks": 584,
+ "bytes": 294304,
+ "skipped": 0,
+ "elapsedMs": 30089.623208000005
+ },
+ {
+ "ticks": 584,
+ "bytes": 294304,
+ "skipped": 0,
+ "elapsedMs": 30089.184665999986
+ },
+ {
+ "ticks": 584,
+ "bytes": 294304,
+ "skipped": 0,
+ "elapsedMs": 30088.809959000006
+ },
+ {
+ "ticks": 584,
+ "bytes": 294304,
+ "skipped": 0,
+ "elapsedMs": 30088.393374999985
+ },
+ {
+ "ticks": 584,
+ "bytes": 294304,
+ "skipped": 0,
+ "elapsedMs": 30087.204291000002
+ }
+ ],
+ "aggregateSamples": [
+ {
+ "elapsedSeconds": 0.006236166664166376,
+ "cpuTicks": 482668550,
+ "interruptWakeups": 42597,
+ "summedFootprintBytes": 728376024,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 1.007849833345972,
+ "cpuTicks": 491339566,
+ "interruptWakeups": 43543,
+ "summedFootprintBytes": 729031432,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 2.009650791675085,
+ "cpuTicks": 499028569,
+ "interruptWakeups": 44401,
+ "summedFootprintBytes": 722723304,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 3.014693666686071,
+ "cpuTicks": 501633289,
+ "interruptWakeups": 45364,
+ "summedFootprintBytes": 722723304,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 4.00881395835313,
+ "cpuTicks": 505835227,
+ "interruptWakeups": 46271,
+ "summedFootprintBytes": 723427816,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 5.01225054168026,
+ "cpuTicks": 511032866,
+ "interruptWakeups": 47238,
+ "summedFootprintBytes": 723689960,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 6.012200666678837,
+ "cpuTicks": 518517539,
+ "interruptWakeups": 48183,
+ "summedFootprintBytes": 725033496,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 7.01135591667844,
+ "cpuTicks": 522020896,
+ "interruptWakeups": 49024,
+ "summedFootprintBytes": 725754392,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 8.013481750007486,
+ "cpuTicks": 525666855,
+ "interruptWakeups": 49887,
+ "summedFootprintBytes": 725869080,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 9.014073416678002,
+ "cpuTicks": 529612305,
+ "interruptWakeups": 50679,
+ "summedFootprintBytes": 725869080,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 10.014278166665463,
+ "cpuTicks": 535123044,
+ "interruptWakeups": 51625,
+ "summedFootprintBytes": 727245336,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 11.018506791675463,
+ "cpuTicks": 543305681,
+ "interruptWakeups": 52544,
+ "summedFootprintBytes": 727867976,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 12.015424416662427,
+ "cpuTicks": 549169284,
+ "interruptWakeups": 53407,
+ "summedFootprintBytes": 727867976,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 13.012174041679827,
+ "cpuTicks": 553637898,
+ "interruptWakeups": 54284,
+ "summedFootprintBytes": 727343688,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 14.007141000009142,
+ "cpuTicks": 559333712,
+ "interruptWakeups": 55122,
+ "summedFootprintBytes": 727376456,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 15.015870000002906,
+ "cpuTicks": 565175946,
+ "interruptWakeups": 56025,
+ "summedFootprintBytes": 728064704,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 16.0131306250114,
+ "cpuTicks": 574424534,
+ "interruptWakeups": 57035,
+ "summedFootprintBytes": 728736472,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 17.010668833332602,
+ "cpuTicks": 583111056,
+ "interruptWakeups": 58019,
+ "summedFootprintBytes": 727278608,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 18.003110583347734,
+ "cpuTicks": 587947860,
+ "interruptWakeups": 58959,
+ "summedFootprintBytes": 726770704,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 19.016388416668633,
+ "cpuTicks": 593789296,
+ "interruptWakeups": 59885,
+ "summedFootprintBytes": 726787088,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 20.016691875003744,
+ "cpuTicks": 598683222,
+ "interruptWakeups": 60776,
+ "summedFootprintBytes": 727311376,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 21.012709583330434,
+ "cpuTicks": 607796758,
+ "interruptWakeups": 61772,
+ "summedFootprintBytes": 729506856,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 22.0132010000234,
+ "cpuTicks": 612040313,
+ "interruptWakeups": 62713,
+ "summedFootprintBytes": 729506856,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 23.009907041676342,
+ "cpuTicks": 616257220,
+ "interruptWakeups": 63682,
+ "summedFootprintBytes": 729506856,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 24.015560666681267,
+ "cpuTicks": 620189170,
+ "interruptWakeups": 64627,
+ "summedFootprintBytes": 729506856,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 25.016534958354896,
+ "cpuTicks": 625729347,
+ "interruptWakeups": 65556,
+ "summedFootprintBytes": 729556008,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 26.016605625016382,
+ "cpuTicks": 634817440,
+ "interruptWakeups": 66461,
+ "summedFootprintBytes": 731292760,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 27.013100500014843,
+ "cpuTicks": 641630798,
+ "interruptWakeups": 67437,
+ "summedFootprintBytes": 731292760,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 28.017203916679136,
+ "cpuTicks": 647384236,
+ "interruptWakeups": 68382,
+ "summedFootprintBytes": 731292760,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 29.016576249996433,
+ "cpuTicks": 652802163,
+ "interruptWakeups": 69389,
+ "summedFootprintBytes": 731292760,
+ "accountingProcessCount": 24
+ },
+ {
+ "elapsedSeconds": 30.01268141667242,
+ "cpuTicks": 658840964,
+ "interruptWakeups": 70385,
+ "summedFootprintBytes": 731309144,
+ "accountingProcessCount": 24
+ }
+ ]
+ }
+ ]
+ }
+ ],
+ "rejectedExperiments": [
+ {
+ "comparison": "v1 pair 2",
+ "reason": "Counter regression: proc_listallpids omitted unreaped children; no v1 runs used here"
+ },
+ {
+ "calibration": "unreaped child with old sampler",
+ "result": "Reproduced CPU disappearance; fixed KERN_PROC_ALL inventory passes independent accounting test"
+ }
+ ]
+}
diff --git a/docs/performance/2026-10-02-connected-workspace-resources.md b/docs/performance/2026-10-02-connected-workspace-resources.md
new file mode 100644
index 000000000..f6ce63ee6
--- /dev/null
+++ b/docs/performance/2026-10-02-connected-workspace-resources.md
@@ -0,0 +1,119 @@
+# Connected local workspace resource comparison
+
+The controlled local workspace used less CPU and fewer interrupt wakeups while
+idle with hidden terminal cursors. It did **not** establish an overall energy
+improvement: foreground output used more CPU in all three pairs, and background
+memory footprints increased. These results must accompany the much larger
+component-level transcript improvements; those improvements are not whole-app
+energy measurements.
+
+## Results
+
+Values are the median of three runs per variant. CPU is percent of **one core**,
+summed across the desktop, daemon, tmux and terminal workers. “Hidden cursor”
+means the terminal sent DECTCEM hide; “background” means the native app was hidden.
+
+| Workload | CPU before → after | Relative CPU change | Interrupt wakeups/s before → after | Summed footprint MiB before → after |
+| --- | ---: | ---: | ---: | ---: |
+| Foreground idle, visible cursor | 5.20 → 5.75 | +10.6% | 28.63 → 27.49 | 507.9 → 485.0 |
+| Foreground idle, hidden cursor | 4.65 → 3.84 | **−17.4%** | **28.00 → 15.40 (−45.0%)** | 492.3 → 447.7 |
+| Foreground active output | 31.86 → 33.51 | **+5.2%** | 1087.15 → 1072.36 | 655.7 → 666.1 |
+| Background idle, hidden cursor | 4.04 → 3.87 | −4.3% | 14.37 → 14.40 | 663.9 → 682.7 |
+| Background active output | 23.52 → 23.23 | −1.2% | 915.55 → 926.07 | 675.1 → 694.1 |
+
+The hidden-cursor wakeup reduction was 44.7–45.2% in the individual pairs;
+CPU reductions were 11.5–17.8%. Foreground active CPU was **5.2–8.6% higher in
+every pair**. That observed regression needs investigation. The unchanged
+terminal workers also varied in CPU cost, so host scheduling/frequency may
+contribute, but its cause has not been isolated. Three short pairs on a shared
+machine cannot settle that attribution or establish a universal improvement.
+
+Footprints are sums of per-process physical footprints, which can count shared
+mappings more than once. Phases run in a fixed sequence after startup; allocation
+and garbage-collection history affect them. These are not estimates of total
+machine RAM saved.
+
+The [data](2026-10-02-connected-workspace-resources.json) retain all six runs,
+individual paired changes, component CPU, output counts, native states, source
+and tooling hashes, 1 Hz aggregate samples, and hashes of the full private raw
+samples. No failed run is silently included as passing.
+
+## Source and workload
+
+- Current source: `c966e1ac0e10d2741bad53352fcdba9b41d2a6de`.
+- Baseline: that same source with only production patches from
+ [#628](https://github.com/autonomous-ai/openharness/pull/628),
+ [#631](https://github.com/autonomous-ai/openharness/pull/631),
+ [#633](https://github.com/autonomous-ai/openharness/pull/633) and
+ [#648](https://github.com/autonomous-ai/openharness/pull/648) reversed in a
+ temporary checkout. Combined patch SHA-256:
+ `cdcd1d9488f4713549a386cc67455a1487bb19edd4541681f0182691b09a4688`.
+- Identical connected fixture source for both native Release builds. Flutter
+ 3.47.2/Dart 3.13.2, full Xcode selected per command, native arm64, unique
+ `ai.autonomous.harness.benchmark` bundle. Exact app-source patches and CLI
+ bundle hashes are in the data. The current build's identity record was added
+ after building: all 563 tracked production Dart inputs were then checked
+ byte-for-byte against the copied sources. This is a scoped identity check,
+ not a complete reproducible-build attestation.
+- Mac14,6, 64 GiB RAM, 12 logical CPUs, macOS 26.6.2; AC power, charged battery.
+ Other real work remained running. Per-run host load averages are retained.
+- Ten real private tmux terminals, four visible in the selected tab. Each worker
+ seeds 1,000 terminal lines. Active workers redraw eight ANSI rows at 20 Hz
+ through the actual tmux → daemon → native desktop transport and renderer.
+- Five phases per fresh process, five-second settling periods, 30 seconds of
+ sampling per phase. Three pairs ordered baseline/current, current/baseline,
+ baseline/current. All builds finished before the comparison.
+- Every active worker achieved at least 18 Hz, with skipped ticks at most 2%.
+ Output reached every retained terminal; all connections remained controlling.
+ Native focus, hidden state and window geometry remained unchanged within each
+ phase. All six apps and private stacks exited successfully and their tmux
+ sockets stopped listening.
+
+The workload covers steady local terminal activity. It does **not** trigger
+large Codex transcript recaps, so it cannot reproduce the component gains in
+[the recap comparison](2026-10-02-codex-recap-tail.md).
+
+## Measurement validity and limits
+
+The older native fixtures suppress connections and production background
+services. This fixture instead uses the real signed-out app bootstrap, local
+daemon, discovery, supervision and terminal transports, without `FLUTTER_TEST`.
+It substitutes installer/sign-in/update acquisition and disables ownership-driven
+daemon replacement because the launcher owns a private daemon. No installed app,
+daemon, tmux server, real session or credentials were changed.
+
+The forest sampler converts Mach ticks using the recorded 125/3 timebase and
+includes live processes, exited-but-unreaped children, and kernel child counters.
+The initial experiment used `proc_listallpids`, which omitted unreaped children
+before their CPU moved to parent counters. A deterministic reproduction exposed
+the temporary loss; that comparison was rejected in full. The corrected
+`KERN_PROC_ALL` inventory includes that interval and treats exited-process memory
+as zero. Independent CPU calibrations measured 1.9843 s versus 1.9594 s for
+live/reaped workers and 1.2481 s versus 1.2221 s for a delayed-reap worker. Both
+passed the stated 0.06 s or 10% tolerance. Root overlap, PID reuse, unstable
+membership and regressing counters reject a sample.
+
+The sampler excludes processes reparented outside the selected trees, shared
+system services such as WindowServer, GPU energy and battery discharge. There
+are no signed-in accounts, remote machines or real Codex/Claude engines in this
+workload. CPU and interrupt wakeups are resource indicators, **not joules or a
+measurement of macOS's “Using Significant Energy” classification**. That claim
+requires a separate matched energy measurement on representative user workloads.
+
+The runner's missing-input cleanup was tightened after recording the comparison:
+it now hashes required inputs before launching the private stack. This does not
+change the measured workload; recorded tooling hashes identify the measured
+revision rather than silently claiming that later tooling ran retroactively.
+
+## Reproduction and next work
+
+Use the [connected fixture instructions](../../desktop/tool/native_benchmark/README.md#connected-local-workspace-resources)
+to build both variants and run them with the same tooling. Preserve failed runs
+and inspect output-rate and focus checks before comparing medians. All local
+results from this comparison remain under
+`/private/tmp/harness-connected-v2-{1..6}-{baseline|current}-20261002`.
+
+The next performance investigation is the daemon's remaining idle CPU and the
+foreground-output regression, followed by representative signed-in and physical
+energy measurements. This change adds measurement tooling and records evidence;
+it does not change production behavior or publish a release.