The ultimate harness for coding agents and beyond. All your agents. All your machines. One command center. Start with code, then follow your curiosity and build across disciplines: CAD, circuits, robots, games and music.
TypeScript 3d-modelingagent-frameworkagent-harnessai-agentscadclaude-codecodexcoding-agentsdeveloper-toolsesp32game-developmentmcp-servermulti-agentopen-hardwareopencodeopenharnesspcbroboticsterminaltmux
import 'dart:convert';
import 'dart:io';
import 'dart:math';
import 'package:fake_async/fake_async.dart';
import 'package:flutter/services.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:harness_mobile/core/agent_output_stats.dart';
import 'package:harness_mobile/core/agent_preference.dart';
import 'package:harness_mobile/core/device_name.dart';
import 'package:harness_mobile/core/fuzzy_match.dart';
import 'package:harness_mobile/core/git_project.dart';
import 'package:harness_mobile/core/harness_file_store.dart';
import 'package:harness_mobile/core/local_key_value_store.dart';
import 'package:harness_mobile/core/models.dart';
import 'package:harness_mobile/core/phone_search_history.dart';
import 'package:harness_mobile/core/project_folder.dart';
import 'package:harness_mobile/core/project_history.dart';
import 'package:harness_mobile/state/external_session.dart';
import 'package:harness_mobile/state/search_when.dart';
import 'package:harness_mobile/state/session_content_search.dart';
import 'voice_fakes.dart' show MemoryKeyValueStore;
/// The parts of `core/` the phone's screens stand on: what a machine's answers
/// are read into, what a new agent's Git choices become, how the search ranks,
/// and what is kept on disk between launches.
void main() {
group('Git choices', () {
GitProjectInfo repo({
String? branch = 'main',
String? defaultRef = 'refs/remotes/origin/main',
List<GitBranch> branches = const [
GitBranch('refs/heads/main', 'main'),
GitBranch('refs/heads/feature', 'feature'),
GitBranch('refs/heads/busy', 'busy', worktree: '/w/busy'),
GitBranch('refs/remotes/origin/main', 'origin/main', remote: true),
GitBranch('refs/remotes/origin/only-remote', 'x', remote: true),
],
}) => GitProjectInfo(
isGit: true,
branch: branch,
defaultRef: defaultRef,
branches: branches,
);
test('a machine\'s answer is read, and what it cannot mean is dropped', () {
final info = GitProjectInfo.fromJson({
'isGit': true,
'branch': 'main',
'mainFolder': 'relative/path',
'mainBranch': 'main',
'defaultRef': 'refs/tags/v1',
'root': '/w/app',
'branches': [
{'ref': 'refs/heads/main', 'name': 'main', 'harness': true},
{'ref': 'refs/heads/x', 'name': 'x', 'worktree': '/w/x'},
{'ref': 3},
'junk',
],
});
expect(info.isGit, isTrue);
expect(info.mainFolder, isNull, reason: 'not an absolute path');
expect(info.defaultRef, isNull, reason: 'not a branch ref');
expect(info.root, '/w/app');
expect(info.branches.map((b) => b.name), ['main', 'x']);
expect(info.branches.first.harness, isTrue);
expect(info.branches.last.worktree, '/w/x');
expect(info.unavailable, isFalse);
expect(
GitProjectInfo.fromJson({'error': 'UNAVAILABLE'}).unavailable,
isTrue,
);
});
test('where Start begins with nothing chosen', () {
final info = repo();
expect(currentBranchRef(info), 'refs/heads/main');
expect(currentBranchRef(repo(branch: 'gone')), isNull);
expect(worktreeByDefault(info), isTrue);
expect(worktreeByDefault(const GitProjectInfo(isGit: true)), isFalse);
expect(defaultBranchRef(info, worktree: false), 'refs/heads/main');
expect(defaultBranchRef(info, worktree: true), 'refs/heads/main');
expect(
defaultBranchRef(
repo(defaultRef: 'refs/remotes/origin/dev'),
worktree: true,
),
'refs/remotes/origin/dev',
reason: 'no local branch of that name: the remote itself',
);
expect(
defaultBranchRef(repo(defaultRef: null), worktree: true),
'refs/heads/main',
);
});
test('a worktree plan for every kind of base and name', () {
final info = repo();
WorktreePlan plan({String? base, String? name}) =>
planWorktree(info, base: base, name: name, placeholder: 'calm-otter');
// Typed names.
expect(plan(name: 'new-thing').kind, WorktreeStart.newBranch);
expect(plan(name: 'new-thing').branch, 'new-thing');
expect(plan(name: 'main').kind, WorktreeStart.unavailable);
expect(plan(name: 'feature').kind, WorktreeStart.existingBranch);
expect(plan(name: 'busy').kind, WorktreeStart.openWorktree);
expect(plan(name: 'busy').worktree, '/w/busy');
// Nothing typed.
expect(plan().branch, 'calm-otter');
expect(plan(base: 'refs/remotes/origin/main').branch, 'calm-otter');
expect(plan(base: 'refs/heads/main').branch, 'calm-otter');
expect(
plan(base: 'refs/heads/feature').kind,
WorktreeStart.existingBranch,
);
expect(plan(base: 'refs/heads/missing').branch, 'calm-otter');
expect(
plan(base: 'refs/remotes/origin/feature').kind,
WorktreeStart.existingBranch,
);
final tracking = plan(base: 'refs/remotes/origin/only-remote');
expect(tracking.kind, WorktreeStart.newBranch);
expect(tracking.branch, 'only-remote');
expect(tracking.tracks, isTrue);
expect(plan(name: 'x', base: 'refs/heads/main').tracks, isFalse);
// The folder's own branch, picked from the list, starts a new branch.
final own = planWorktree(
repo(defaultRef: null),
base: 'refs/heads/main',
name: null,
placeholder: 'calm-otter',
);
expect(own.kind, WorktreeStart.newBranch);
expect(own.branch, 'calm-otter');
});
test('what the machine is asked to do with the folder', () {
final info = repo();
ProjectFolderRequest? request({
bool worktree = true,
String? ref,
String? name,
}) => gitFolderRequest(
'/w/app',
info,
worktree: worktree,
branchRef: ref,
branchName: name,
placeholder: 'calm-otter',
);
expect(request(worktree: false)!.payload, {
'projectSource': 'branch',
'gitSource': '/w/app',
'branchRef': 'refs/heads/main',
});
expect(request(worktree: false, name: 'fresh')!.payload, {
'projectSource': 'branch',
'gitSource': '/w/app',
'branchRef': 'refs/heads/fresh',
'branchName': 'fresh',
});
expect(
gitFolderRequest(
'/w/app',
repo(branch: null),
worktree: false,
branchRef: null,
branchName: null,
placeholder: 'p',
),
isNull,
);
expect(request()!.payload, {
'projectSource': 'worktree',
'gitSource': '/w/app',
'branchRef': 'refs/heads/main',
'branchName': 'calm-otter',
'branchMode': 'placeholder',
});
expect(request(name: 'feature')!.payload['branchMode'], 'existing');
expect(request(name: 'busy')!.payload, {
'projectSource': 'branch',
'gitSource': '/w/app',
'branchRef': 'refs/heads/busy',
});
expect(
request(name: 'typed')!.payload.containsKey('branchMode'),
isFalse,
);
});
test('with Worktree off, only a name no branch has is a new one', () {
final info = repo();
expect(newBranchHere(info, null), isNull);
expect(newBranchHere(info, ' '), isNull);
expect(newBranchHere(info, 'feature'), isNull);
expect(newBranchHere(info, ' fresh '), 'fresh');
});
test('with Worktree off, which choices move the folder onto another '
'branch', () {
final info = repo();
bool switches(
GitProjectInfo info, {
bool worktree = false,
String? ref,
String? name,
}) => switchesFolderBranch(
info,
worktree: worktree,
branchRef: ref,
branchName: name,
);
// Moved: another local branch with no worktree, or a new branch made here.
expect(switches(info, ref: 'refs/heads/feature'), isTrue);
expect(switches(info, name: 'fresh'), isTrue);
expect(
switches(info, ref: 'refs/heads/main', name: ' fresh '),
isTrue,
reason: 'a typed new name wins over the picked branch',
);
// A folder on no branch is moved by any local branch.
expect(switches(repo(branch: null), ref: 'refs/heads/main'), isTrue);
// Left where it is.
expect(switches(info), isFalse, reason: 'nothing picked: where it is');
expect(switches(info, ref: 'refs/heads/main'), isFalse);
expect(
switches(info, ref: 'refs/heads/main', name: 'feature'),
isFalse,
reason: 'a typed name an existing branch has is not a new one',
);
expect(
switches(info, ref: 'refs/heads/busy'),
isFalse,
reason: 'opened in its own worktree instead',
);
expect(
switches(info, ref: 'refs/remotes/origin/main'),
isFalse,
reason: 'the machine refuses a remote branch with Worktree off',
);
expect(switches(repo(branch: null)), isFalse);
expect(
switches(info, worktree: true, ref: 'refs/heads/feature'),
isFalse,
);
expect(switches(info, worktree: true, name: 'fresh'), isFalse);
});
test('a checkout holds itself and every folder inside it, nothing '
'else', () {
expect(withinCheckout('/w/app', '/w/app'), isTrue);
expect(withinCheckout('/w/app', '/w/app/'), isTrue);
expect(withinCheckout('/w/app/', '/w/app'), isTrue);
expect(withinCheckout('/w/app', '/w/app/cli'), isTrue);
expect(withinCheckout('/w/app', '/w/app/cli/src/lib'), isTrue);
expect(withinCheckout('/w/app', '/w/app/cli/../desktop'), isTrue);
expect(withinCheckout('/w/app', '/w/application'), isFalse);
expect(withinCheckout('/w/app', '/w/app-2'), isFalse);
expect(withinCheckout('/w/app', '/w'), isFalse);
expect(withinCheckout('/w/app', '/w/other'), isFalse);
expect(withinCheckout('/w/app', '/w/app/../other'), isFalse);
});
test('a placeholder branch is two words none of the taken ones use', () {
final taken = <String>{};
final random = Random(1);
for (var i = 0; i < 50; i++) {
final name = placeholderBranch(taken, random: random);
expect(taken, isNot(contains(name)));
expect(name, matches(RegExp(r'^[a-z]+-[a-z]+(-\d+)?$')));
taken.add(name);
}
// Every name taken: a suffix.
final all = {
for (final a in kPlaceholderAdjectives)
for (final n in kPlaceholderNouns) 'refs/heads/$a-$n',
};
expect(placeholderBranch(all), matches(RegExp(r'-\d+$')));
});
test('a typed name becomes a branch git accepts', () {
expect(branchNameFrom(' fix the login '), 'fix-the-login');
expect(branchNameFrom('a..b~c^d:e?f*g[h\\i'), 'a.bcdefghi');
expect(branchNameFrom('-/.lead'), 'lead');
expect(branchNameFrom('x//y/.z'), 'x/y/z');
expect(branchNameFrom('name.lock'), 'name');
expect(branchNameFrom('ends/.'), 'ends');
expect(branchNameFrom('a@{b'), 'a@b');
expect(branchNameFrom('@'), '');
expect(branchNameFrom('a---b'), 'a-b');
expect(plausibleBranchName('ok/name'), isTrue);
expect(plausibleBranchName(''), isFalse);
expect(plausibleBranchName('-x'), isFalse);
expect(plausibleBranchName('has space'), isFalse);
expect(plausibleBranchName('x' * 256), isFalse);
expect(validGitPath('/abs'), isTrue);
expect(validGitPath('rel'), isFalse);
expect(validGitPath('/a\u0001b'), isFalse);
expect(validGitRef('refs/heads/x'), isTrue);
expect(validGitRef('refs/tags/x'), isFalse);
});
});
group('fuzzy matching', () {
test('a subsequence, its spread, and where each letter landed', () {
final at = <(int, int)>[];
expect(subsequenceSpread('harness', ''), 0);
expect(
subsequenceSpread('harness', 'hns', onMatch: (s, e) => at.add((s, e))),
5,
);
expect(at, [(0, 1), (3, 4), (5, 6)]);
expect(subsequenceSpread('harness', 'z'), isNull);
expect(subsequenceSpread('harness', 'h', from: 1), isNull);
});
test('a word starts after anything that is not a letter or digit', () {
expect(startsWord('fix-auth', 0), isTrue);
expect(startsWord('fix-auth', 4), isTrue);
expect(startsWord('fix-auth', 5), isFalse);
expect(startsWord('a9', 1), isFalse);
expect(startsWord('a\u00a0b', 2), isTrue);
expect(startsWord('a·b', 2), isTrue);
expect(startsWord('a—b', 2), isTrue);
expect(startsWord('é b', 1), isFalse);
expect(startsWord('éb', 1), isFalse);
expect(startsWord('中b', 1), isFalse);
expect(startsWord('🙂b', 2), isTrue);
});
test('a term found only where it begins a word', () {
expect(wordStartIndexOf('windows port', 'port'), 8);
expect(wordStartIndexOf('support', 'port'), -1);
expect(wordStartIndexOf('abc', '', 5), 3);
});
test('scattered letters stay close and start on a word', () {
final at = <(int, int)>[];
expect(
wordSubsequenceSpread(
'fix authentication',
'ath',
onMatch: (s, e) => at.add((s, e)),
),
isNotNull,
);
expect(at.first.$1, 4);
expect(wordSubsequenceSpread('command', 'cmd'), isNotNull);
expect(wordSubsequenceSpread('x', ''), 0);
expect(wordSubsequenceSpread('autonomous-harness', 'auth'), isNull);
expect(wordSubsequenceSpread('abc', 'xyz'), isNull);
// Two letters count only as initials.
expect(wordSubsequenceSpread('new split', 'ns'), isNotNull);
expect(wordSubsequenceSpread('harness', 'hn'), isNull);
final initials = <(int, int)>[];
wordSubsequenceSpread(
'new split',
'ns',
onMatch: (s, e) => initials.add((s, e)),
);
expect(initials, [(0, 1), (4, 5)]);
// Too far apart to count.
expect(wordSubsequenceSpread('a${' ' * 40}bc', 'abc'), isNull);
// A later start that finds the tightest spread wins.
expect(wordSubsequenceSpread('dxxxxxial dial', 'dial'), 3);
});
});
group('models off the wire', () {
test('the account\'s profile, and what it cannot be', () {
expect(
() => CurrentUserProfile.fromMe({'user': 'x'}),
throwsFormatException,
);
expect(
() => CurrentUserProfile.fromMe({
'user': {'email': ' '},
}),
throwsFormatException,
);
final pat = CurrentUserProfile.fromMe({
'user': {'id': 'u', 'email': ' [email protected] ', 'name': ' Pat Lee '},
'avatarUrl': ' https://a/b.png ',
});
expect(pat.email, '[email protected]');
expect(pat.displayName, 'Pat Lee');
expect(pat.initials, 'PL');
expect(pat.avatarUrl, 'https://a/b.png');
final bare = CurrentUserProfile.fromMe({
'user': {'email': '[email protected]', 'name': ''},
});
expect(bare.displayName, '[email protected]');
expect(bare.initials, 'Q');
expect(const CurrentUserProfile(email: ' ').initials, '?');
});
test('when the account was made, if the backend says readably', () {
CurrentUserProfile made(Object? createdAt) => CurrentUserProfile.fromMe({
'user': {'email': '[email protected]', 'createdAt': createdAt},
});
expect(
made('2026-10-19T08:30:00.000Z').createdAt,
DateTime.utc(2026, 10, 19, 8, 30),
);
expect(made(null).createdAt, isNull);
expect(made('yesterday').createdAt, isNull);
expect(made(1760862600000).createdAt, isNull);
expect(
CurrentUserProfile.fromMe({
'user': {'email': '[email protected]'},
}).createdAt,
isNull,
);
});
test('a machine with no name is called by its id', () {
const long = Machine(
machineId: 'abcdef0123456789',
authMode: MachineAuthMode.remote,
);
const short = Machine(machineId: 'abc', authMode: MachineAuthMode.remote);
expect(long.displayName, 'machine-abcdef01');
expect(short.displayName, 'machine-abc');
expect(long.copyWith(name: 'Mac').displayName, 'Mac');
expect(
Machine.fromJson({'machineId': 'm', 'authMode': 'weird'}).authMode,
MachineAuthMode.managed,
);
});
test('an agent reads only what it can trust', () {
final agent = Agent.fromJson({
'id': 'a',
'engine': 'codex',
'codexHome': 'relative',
'launch': {'state': 'failed', 'error': 'E', 'detail': 'bad\u0000thing'},
'terminal': {
'runtimes': [
{'backend': 'tmux'},
],
},
'tokenUsage': {'totalTokens': -1},
'resumeMode': 'nonsense',
});
expect(agent.name, 'harness');
expect(agent.codexHome, isNull);
expect(agent.launchDetail, 'bad thing');
expect(agent.terminalAvailable, isTrue, reason: 'a tmux runtime');
expect(agent.tokensUsed, isNull);
expect(agent.resumeMode, isNull);
expect(
Agent.fromJson({'id': 'a', 'engine': 'bad engine!'}).engine,
isNull,
);
expect(
Agent.fromJson({
'id': 'a',
'launch': {'state': 'failed', 'detail': ' '},
}).launchDetail,
isNull,
);
expect(
Agent.fromJson({
'id': 'a',
'launch': {'state': 'failed', 'detail': 'x' * 600},
}).launchDetail!.length,
500,
);
});
test(
'a name somebody chose is kept; a made-up one gives way to the title',
() {
const chosen = Agent(id: 'a', name: 'api work');
const made = Agent(id: 'a', name: 'harness-3', title: 'Fix the dial');
const untitled = Agent(id: 'a', name: 'harness-3');
expect(chosen.displayName, 'api work');
expect(made.displayName, 'Fix the dial');
expect(untitled.displayName, kUntitledPane);
expect(isAutomaticHarnessName('Claude harness 9-23 13:52'), isTrue);
},
);
test('the last use is the later of activity and opening', () {
final early = DateTime(2026, 9, 1);
final late = DateTime(2026, 9, 2);
expect(Agent(id: 'a', name: 'a', updatedAt: early).lastUsedAt, early);
expect(Agent(id: 'a', name: 'a', lastOpenedAt: late).lastUsedAt, late);
expect(
Agent(
id: 'a',
name: 'a',
updatedAt: late,
lastOpenedAt: early,
).lastUsedAt,
late,
);
expect(
Agent(
id: 'a',
name: 'a',
updatedAt: early,
lastOpenedAt: late,
).lastUsedAt,
late,
);
});
test('a project is labelled as the person chose it', () {
const plain = AgentProject(name: 'work', cwd: '/work');
const sub = AgentProject(
name: 'repo',
cwd: '/w/repo/packages/app/',
root: '/w/repo',
branch: ' Detached 6528156 ',
);
const same = AgentProject(name: 'repo', cwd: '/w/repo/', root: '/w/repo');
const pending = AgentProject(
name: 'r',
cwd: '/r',
branch: 'main',
branchPending: true,
);
expect(plain.label, 'work');
expect(sub.label, 'app');
expect(same.label, 'repo');
expect(sub.detached, isTrue);
expect(sub.shownBranch, isNull);
expect(sub.branchDetail, 'No branch: on commit 6528156');
expect(pending.shownBranch, isNull);
expect(pending.branchDetail, 'Branch: main');
expect(plain.branchDetail, isNull);
expect(
const AgentProject(name: 'r', cwd: '/r', branch: ' ').branchLabel,
isNull,
);
expect(plain.identity('m'), 'folder:m:/work');
expect(
const AgentProject(name: 'r', cwd: '/r', remote: 'git@x').identity('m'),
'repo:git@x',
);
expect(plain, const AgentProject(name: 'work', cwd: '/work'));
expect(
plain.hashCode,
const AgentProject(name: 'work', cwd: '/work').hashCode,
);
expect(AgentProject.fromJson({'name': 'n', 'cwd': 'a\u0001'}), isNull);
});
test('grid answers: web search, sections and who may run locally', () {
expect(GridWebSearch.on.sentence, isNull);
expect(GridWebSearch.unsupported.sentence, contains('not supported'));
expect(GridWebSearch.fromWire('new-word'), isNull);
expect(GridCli.parse('path'), GridCli.path);
expect(GridCli.parse('missing'), GridCli.missing);
const own = GridModels(
gridName: 'mine',
models: [GridModel(id: 'q', node: 'mac')],
);
expect(own.sections.single.own, isTrue);
expect(const GridModels(gridName: null, models: []).sections, isEmpty);
expect(own.canRunLocally('anything'), isTrue);
const limited = GridModels(
gridName: 'mine',
models: [],
localModelEngines: {'codex'},
);
expect(limited.canRunLocally(' Codex '), isTrue);
expect(limited.canRunLocally('claude'), isFalse);
expect(limited.canRunLocally(null), isFalse);
expect(const GridModels.unreachable().reachable, isFalse);
});
test('output stats keep an edit pair whole, or not at all', () {
expect(AgentOutputStats.fromJson('x'), isNull);
expect(AgentOutputStats.fromJson({'linesAdded': 3}), isNull);
final stats = AgentOutputStats.fromJson({
'linesAdded': 3,
'linesRemoved': 1,
'pullRequestsCreated': 2,
'updatedAt': '2026-09-27T10:00:00Z',
})!;
expect(stats.hasEdits, isTrue);
expect(
stats,
AgentOutputStats.fromJson({
'linesAdded': 3,
'linesRemoved': 1,
'pullRequestsCreated': 2,
'updatedAt': '2026-09-27T10:00:00Z',
}),
);
expect(stats.hashCode, isA<int>());
expect(wireCount(-1), isNull);
expect(wireCount(1.5), isNull);
});
test('a project folder request says what the machine should make', () {
expect(const ProjectFolderRequest.newProject().payload, {
'projectSource': 'new',
});
expect(
const ProjectFolderRequest.branch(
'/w',
'refs/heads/x',
newBranch: 'x',
).payload,
{
'projectSource': 'branch',
'gitSource': '/w',
'branchRef': 'refs/heads/x',
'branchName': 'x',
},
);
});
});
group('what search reads', () {
test('a conversation Harness did not start, as a person says it', () {
const ext = ExternalSessionRef(
sessionId: 's',
engine: 'codex',
cwd: '/w/app/',
origin: 'codex-app',
);
expect(ext.originLabel, 'Codex app');
expect(ext.engineLabel, 'Codex');
expect(ext.folderName, 'app');
expect(
const ExternalSessionRef(
sessionId: 's',
engine: 'gemini',
cwd: '/',
origin: 'editor',
).engineLabel,
'gemini',
);
expect(
const ExternalSessionRef(
sessionId: 's',
engine: 'claude',
cwd: '/',
origin: 'claude-app',
).originLabel,
'Claude app',
);
expect(
const ExternalSessionRef(
sessionId: 's',
engine: 'claude',
cwd: '/',
origin: 'editor',
).originLabel,
'editor',
);
expect(externalDestinationId('m', 's'), 'external:m:s');
});
test(
'a hit on a conversation Harness did not start, and a long snippet',
() {
final hits = SessionContentHit.listFromReply('m', {
'hits': [
{
'agentId': '',
'sessionId': 's-ext',
'engine': 'claude',
'snippet': 'x' * 700,
'lastAt': 1790000000000,
'external': {'cwd': '/w/app', 'title': 'Fix', 'open': true},
},
{
'agentId': '',
'sessionId': 's-bad',
'engine': 'claude',
'external': {'cwd': 'relative'},
},
],
});
final hit = hits.single;
expect(hit.snippet.length, 600);
expect(hit.lastAt, DateTime.fromMillisecondsSinceEpoch(1790000000000));
expect(hit.external!.origin, 'terminal');
expect(hit.external!.open, isTrue);
expect(hit.destinationId, 'external:m:s-ext');
expect(SessionContentHit.listFromReply('m', {'error': 'OLD'}), isEmpty);
},
);
test('an earlier answer vouches only where a word begins', () async {
final search = SessionContentSearch(
machines: () => ['m'],
debounce: Duration.zero,
ask: (_, query, _) async => query == 'po'
? [
SessionContentHit(
machineId: 'm',
agentId: 'a',
sessionId: 's',
field: 'ask',
snippet: 'support the port',
together: true,
score: 1,
),
]
: null,
);
addTearDown(search.dispose);
search.search('po');
await Future<void>.delayed(const Duration(milliseconds: 20));
search.search('port');
expect(search.hitsFor('port'), hasLength(1));
});
test('a later, closer conversation of one harness wins its row', () async {
SessionContentHit hit(int position, {bool together = false}) =>
SessionContentHit(
machineId: 'm',
agentId: 'a',
sessionId: 's$position',
field: 'ask',
snippet: 'dial',
together: together,
score: 1,
position: position,
);
final search = SessionContentSearch(
machines: () => ['m', 'n'],
debounce: Duration.zero,
ask: (machine, _, _) async =>
machine == 'm' ? [hit(3), hit(1)] : [hit(5, together: true)],
);
addTearDown(search.dispose);
search.search('dial');
await Future<void>.delayed(const Duration(milliseconds: 20));
expect(search.hits.values.single.together, isTrue);
});
test('"this month" runs from the first to now', () {
final now = DateTime(2026, 9, 27, 12);
final read = parseSearchWhen('dial this month', now);
expect(read.words, 'dial');
expect(read.when!.from, DateTime(2026, 9));
expect(read.when!.to, now);
});
});
group('kept between launches', () {
test(
'agent recency migrates the old preference and survives reopening',
() async {
final storage = MemoryKeyValueStore()
..values['new_agent_engine'] = 'claude';
final preference = AgentPreference(storage);
await preference.load();
expect(preference.recent, ['claude']);
await preference.select('codex');
await preference.select('opencode');
await preference.select('codex');
final reopened = AgentPreference(storage);
await reopened.load();
expect(reopened.value, 'codex');
expect(reopened.recent, ['codex', 'opencode', 'claude']);
},
);
test('bad agent history keeps the saved default usable', () async {
final storage = MemoryKeyValueStore()
..values['new_agent_engine'] = 'codex'
..values['new_agent_engine_history_v1'] = '{broken';
final preference = AgentPreference(storage);
await preference.load();
expect(preference.recent, ['codex']);
await preference.select('claude');
expect(preference.recent, ['claude', 'codex']);
});
test(
'failed persistence keeps agent recency for the current run',
() async {
final preference = AgentPreference(_Broken());
await preference.select('claude');
await preference.select('codex');
expect(preference.value, 'codex');
expect(preference.recent, ['codex', 'claude']);
},
);
test('recent folders, per machine, newest first and valid only', () async {
final storage = MemoryKeyValueStore()
..values['new_agent_projects_v1'] = jsonEncode({
'm': {
'selected': '/w/b',
'recent': ['/w/b', '/w/a', 'relative', 3, '/w/a'],
},
'n': {'selected': 'relative', 'recent': 'nope'},
'': 7,
});
final history = ProjectHistory(storage);
await history.load();
expect(history.recent('m'), ['/w/b', '/w/a']);
expect(history.selected('m'), '/w/b');
expect(history.hasSelection('n'), isFalse);
await history.select('m', '/w/c');
await history.select('m', 'relative');
expect(history.recent('m'), ['/w/c', '/w/b', '/w/a']);
final again = ProjectHistory(storage);
await again.load();
expect(again.recent('m'), ['/w/c', '/w/b', '/w/a']);
await again.select('m', null);
expect(again.selected('m'), isNull);
expect(again.hasSelection('m'), isTrue);
});
test(
'recent folders survive a store that cannot be read or written',
() async {
final history = ProjectHistory(_Broken());
await history.select('m', '/w/a');
expect(history.recent('m'), ['/w/a']);
expect(ProjectHistory(null).recent('m'), isEmpty);
final garbled = ProjectHistory(
MemoryKeyValueStore()..values['new_agent_projects_v1'] = '[1]',
);
await garbled.load();
expect(garbled.recent('m'), isEmpty);
},
);
test('search visits, most recent first, written once they settle', () {
fakeAsync((async) {
final storage = MemoryKeyValueStore()
..values['phone_recent_agents_v1'] = jsonEncode([
'agent:m:a',
'not-an-agent',
'agent:m:a',
7,
])
..values['phone_recent_commands_v1'] = '{broken';
final history = PhoneSearchHistory(storage);
history.load();
async.flushMicrotasks();
expect(history.recent, ['agent:m:a']);
expect(history.recentCommands, isEmpty);
history.remember('agent:m:b');
history.remember('agent:m:b');
history.rememberCommand('cmd:new');
async.elapse(const Duration(milliseconds: 300));
expect(storage.values['phone_recent_agents_v1'], contains('agent:m:a'));
expect(jsonDecode(storage.values['phone_recent_agents_v1']!), [
'agent:m:a',
'not-an-agent',
'agent:m:a',
7,
], reason: 'not yet: visits come in bursts');
async.elapse(const Duration(milliseconds: 400));
expect(jsonDecode(storage.values['phone_recent_agents_v1']!), [
'agent:m:b',
'agent:m:a',
]);
expect(jsonDecode(storage.values['phone_recent_commands_v1']!), [
'cmd:new',
]);
for (var i = 0; i < 40; i++) {
history.remember('agent:m:$i');
}
expect(history.recent, hasLength(32));
history.dispose();
async.elapse(const Duration(seconds: 1));
});
});
test('search visits with nowhere to keep them, or a store that fails', () {
fakeAsync((async) {
final memory = PhoneSearchHistory(null)..remember('agent:m:a');
expect(memory.recent, ['agent:m:a']);
final broken = PhoneSearchHistory(_Broken());
broken.load();
broken.remember('agent:m:a');
async.elapse(const Duration(seconds: 1));
expect(broken.recent, ['agent:m:a']);
});
});
});
group('the state file', () {
late Directory dir;
setUp(() => dir = Directory.systemTemp.createTempSync('harness_store'));
tearDown(() => dir.deleteSync(recursive: true));
test('keys round-trip, alone and together, and deletes stick', () async {
final store = HarnessFileStore(directory: dir);
await store.write('a', '1');
await store.write('b', '2');
expect(await store.read('a'), '1');
expect(await store.readMany(['a', 'b', 'c']), {
'a': '1',
'b': '2',
'c': null,
});
expect(await store.readMany(const []), isEmpty);
await store.delete('a');
await store.delete('never-there');
expect(await HarnessFileStore(directory: dir).read('a'), isNull);
expect(await HarnessFileStore(directory: dir).read('b'), '2');
});
test('a corrupt file is moved aside and read as empty', () async {
final store = HarnessFileStore(directory: dir);
store.stateFile.writeAsStringSync('{not json');
expect(await store.read('a'), isNull);
expect(
dir.listSync().map((f) => f.path.split('/').last),
contains(startsWith('state.corrupt-')),
);
});
test('every wrong shape is corruption', () async {
final store = HarnessFileStore(directory: dir);
for (final document in [
'[]',
'{"version": 1}',
'{"version": 0, "values": {}}',
'{"version": 1, "values": {"a": 3}}',
]) {
store.stateFile.writeAsStringSync(document);
expect(await store.read('a'), isNull, reason: document);
}
expect(
dir.listSync().where((f) => f.path.contains('state.corrupt-')),
hasLength(4),
);
});
test(
'a newer build\'s file is refused, and left exactly as it was',
() async {
final store = HarnessFileStore(directory: dir);
const newer = '{"version": 99, "values": {"a": "1"}}';
store.stateFile.writeAsStringSync(newer);
await expectLater(
store.read('a'),
throwsA(isA<UnsupportedStateVersionException>()),
);
await expectLater(store.write('a', '2'), throwsA(anything));
expect(store.stateFile.readAsStringSync(), newer);
expect(
const UnsupportedStateVersionException(99).toString(),
contains('refusing to overwrite'),
);
},
);
test(
'on a phone the document is held, and a failed write drops it',
() async {
final store = HarnessFileStore(directory: dir, cacheableForTest: true);
final outside = HarnessFileStore(directory: dir);
await store.write('a', '1');
// Changed behind its back: the held copy answers, as it may where it is
// the only writer.
await outside.write('a', 'outside');
expect(await store.read('a'), '1');
expect(await store.readMany(['a']), {'a': '1'});
// A write that cannot land: its rename meets a directory.
store.stateFile.deleteSync();
Directory('${store.stateFile.path}/blocker')
.createSync(recursive: true);
await expectLater(store.write('b', '2'), throwsA(anything));
Directory(store.stateFile.path).deleteSync(recursive: true);
await outside.write('a', 'on disk');
// Forgotten, so the next read goes and looks.
expect(await store.read('a'), 'on disk');
},
);
test('a home is required, and the sibling is named', () {
expect(
HarnessFileStore.defaultDirectoryPath(
environment: {'HOME': '/Users/pat'},
name: 'machines',
),
'/Users/pat/.harness/machines',
);
expect(
() => HarnessFileStore.defaultDirectoryPath(environment: const {}),
throwsStateError,
);
});
});
group('the phone\'s own name', () {
const channel = MethodChannel('harness/device_name');
TestWidgetsFlutterBinding.ensureInitialized();
tearDown(() {
TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger
.setMockMethodCallHandler(channel, null);
NativeDeviceInfo.setForTest(null);
});
test('is asked of the OS once, and kept', () async {
var asked = 0;
TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger
.setMockMethodCallHandler(channel, (call) async {
asked++;
return {'name': "Pat's iPhone", 'modelCode': 'iPhone16,1'};
});
final first = NativeDeviceInfo.describe();
final second = NativeDeviceInfo.describe();
expect((await first)?.name, "Pat's iPhone");
await second;
await NativeDeviceInfo.describe();
expect(asked, 1);
expect(NativeDeviceInfo.cached?.modelCode, 'iPhone16,1');
});
test('a platform with no answer, or a failing one, has no name', () async {
TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger
.setMockMethodCallHandler(
channel,
(call) async => throw PlatformException(code: 'nope'),
);
expect(await NativeDeviceInfo.describe(), isNull);
NativeDeviceInfo.setForTest(null);
TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger
.setMockMethodCallHandler(channel, null);
expect(await NativeDeviceInfo.describe(), isNull);
expect(DeviceInfo.fromMap('junk'), isNull);
});
});
}
class _Broken implements LocalKeyValueStore {
@override
Future<String?> read(String key) async => throw StateError('locked');
@override
Future<void> write(String key, String value) async =>
throw StateError('locked');
@override
Future<void> delete(String key) async => throw StateError('locked');
}