@githolon/dsl 0.108.7 → 0.110.0

package/dart/test/sync_status_reducer_test.dart

@@ -0,0 +1,419 @@
+import 'package:nomos_client/src/sync_status_projection.dart';
+import 'package:nomos_client/src/sync_status_reducer.dart';
+import 'package:nomos_types/nomos_kernel_protocol.dart' as protocol;
+import 'package:fixnum/fixnum.dart' as fixnum;
+import 'package:test/test.dart';
+
+void main() {
+  final at = DateTime.utc(2026, 9, 7);
+  SyncStatus reduce(protocol.SyncWorkspaceResponse result,
+          [SyncStatus current = const SyncStatus()]) =>
+      reduceSyncCompletion(current, protocol.SyncCompleted(result: result), at);
+
+  test('cold-start status is unknown, not current with zero debt', () {
+    const status = SyncStatus();
+    expect(status.phase, SyncPhase.checking);
+    expect(status.ahead, isNull);
+    expect(status.lastSyncedAt, isNull);
+  });
+
+  test('read-only transfer completion never invents unsaved work or currency',
+      () {
+    for (final kind in ['full', 'delta', 'push']) {
+      final settled =
+          reduce(protocol.SyncWorkspaceResponse(currentHead: 'head'));
+      final started = reduceTransferProgress(
+          settled, TransferProgress(received: 4, total: 10, kind: kind));
+      expect(started.phase, SyncPhase.checking);
+      expect(started.presentationPhase, SyncPhase.transferring);
+      final done = reduceTransferProgress(
+          started, TransferProgress(received: 10, total: 10, kind: kind));
+      expect(done.phase, SyncPhase.checking);
+      expect(done.presentationPhase, SyncPhase.checking);
+      expect(done.transfer, isNull);
+      expect(done.ahead, isNull);
+      expect(done.lastSyncedAt, at);
+    }
+  });
+
+  test(
+      'transfer overlay preserves actual local work, failure and offline state',
+      () {
+    for (final phase in [
+      SyncPhase.syncing,
+      SyncPhase.error,
+      SyncPhase.offline
+    ]) {
+      final initial =
+          SyncStatus(phase: phase, lastError: 'retained explanation');
+      final started = reduceTransferProgress(
+          initial, const TransferProgress(received: 4, total: 10));
+      final done = reduceTransferProgress(
+          started, const TransferProgress(received: 10, total: 10));
+      expect(done.phase, phase);
+      expect(done.lastError, 'retained explanation');
+    }
+    final admittedDuringTransfer = locallyAdmitted(reduceTransferProgress(
+        const SyncStatus(), const TransferProgress(received: 1, total: 10)));
+    expect(
+        reduceTransferProgress(admittedDuringTransfer,
+                const TransferProgress(received: 10, total: 10))
+            .phase,
+        SyncPhase.syncing);
+  });
+
+  test('aggregate progress clears to unknown rather than manufactured saving',
+      () async {
+    final projection = NmsSyncStatusProjection();
+    addTearDown(projection.close);
+    projection.pushSession(
+        'catalogue',
+        reduceTransferProgress(
+            const SyncStatus(), const TransferProgress(received: 1, total: 2)));
+    projection.foldApplication(['catalogue']);
+    expect(projection.applicationStatus.phase, SyncPhase.transferring);
+    final completed = reduceTransferProgress(projection.applicationStatus,
+        const TransferProgress(received: 2, total: 2));
+    expect(completed.phase, SyncPhase.checking);
+    expect(completed.transfer, isNull);
+  });
+
+  test('unsettled runtime result reconstructs pending without callback counts',
+      () {
+    final status = reduce(protocol.SyncWorkspaceResponse(stillAhead: true));
+    expect(status.phase, SyncPhase.syncing);
+    expect(status.ahead, isNull);
+    expect(status.lastSyncedAt, isNull);
+  });
+
+  test('only a settled result establishes zero and the successful-sync time',
+      () {
+    final status = reduce(protocol.SyncWorkspaceResponse(currentHead: 'head'));
+    expect(status.phase, SyncPhase.idle);
+    expect(status.ahead, 0);
+    expect(status.behind, 0);
+    expect(status.saved, isNull);
+    expect(status.onMain, isNull);
+    expect(status.lastSyncedAt, at);
+  });
+
+  test('unsealed remote admission is not unsent local work or confirmed sync',
+      () async {
+    final pending = protocol.SyncWorkspaceResponse(
+      currentHead: 'shared-head',
+      stillAhead: true,
+      offerReceipt: protocol.CustodyOfferReceipt(
+          admission: protocol.CustodyOfferAdmissionReceipt(
+              main: 'shared-head', sealedMain: 'older-head')),
+    );
+    final status = reduce(pending);
+    expect(status.phase, SyncPhase.awaitingRemoteDurability);
+    expect(status.ahead, isNull);
+    expect(status.lastSyncedAt, isNull);
+    final projection = NmsSyncStatusProjection();
+    addTearDown(projection.close);
+    projection.pushSession('catalogue', status);
+    projection.foldApplication(['catalogue']);
+    expect(
+        projection.applicationStatus.phase, SyncPhase.awaitingRemoteDurability);
+    pending.currentHead = 'newer-local-head';
+    expect(reduce(pending).phase, SyncPhase.syncing);
+    pending.currentHead = 'shared-head';
+    pending.stillAhead = false;
+    pending.offerReceipt.admission.sealedMain = 'shared-head';
+    expect(reduce(pending).phase, SyncPhase.idle);
+  });
+
+  test(
+      'local admission invalidates settled counts without maintaining a mirror',
+      () {
+    final current = reduce(protocol.SyncWorkspaceResponse(currentHead: 'head'));
+    final status = locallyAdmitted(locallyAdmitted(current));
+    expect(status.phase, SyncPhase.syncing);
+    expect(status.ahead, isNull);
+  });
+
+  test(
+      'offline preserves the last successful time and exposes discovery failure',
+      () {
+    final earlier = DateTime.utc(2026, 9, 6);
+    final status = reduce(
+        protocol.SyncWorkspaceResponse(
+          offline: true,
+          stillAhead: true,
+          discoveryError:
+              protocol.RuntimeTransportFailure(message: 'DNS unavailable'),
+        ),
+        SyncStatus(lastSyncedAt: earlier));
+    expect(status.phase, SyncPhase.offline);
+    expect(status.lastSyncedAt, earlier);
+    expect(status.lastError, 'DNS unavailable');
+  });
+
+  test('push refusal remains attention even with no local callback counter',
+      () {
+    final status = reduce(protocol.SyncWorkspaceResponse(
+      pushFailed: true,
+      stillAhead: true,
+      pushError: protocol.RuntimeTransportFailure(message: 'Offer refused'),
+    ));
+    expect(status.phase, SyncPhase.error);
+    expect(status.lastError, 'Offer refused');
+  });
+
+  test(
+      'terminal reconciliation failure preserves prior receipt and observation age',
+      () {
+    final earlier = DateTime.utc(2026, 9, 16, 16);
+    final receipt =
+        protocol.SyncWorkspaceResponse(currentHead: 'confirmed-head');
+    final current = SyncStatus(
+        phase: SyncPhase.syncing, lastSyncedAt: earlier, lastResult: receipt);
+    final failed = reduceSyncCompletion(
+        current,
+        protocol.SyncCompleted(
+          failure: protocol.RuntimeFailure(
+              code: 'nomos.runtime.sync_failed',
+              message: 'workspace-sync-1: reconciliation failed'),
+        ),
+        DateTime.utc(2026, 9, 16, 17));
+    expect(failed.phase, SyncPhase.error);
+    expect(failed.lastSyncedAt, earlier);
+    expect(identical(failed.lastResult, receipt), isTrue);
+    expect(failed.lastError, contains('workspace-sync-1'));
+    expect(failed.transfer, isNull);
+  });
+
+  test('local-only and reconnect outcomes are not cloud convergence', () {
+    for (final result in [
+      protocol.SyncWorkspaceResponse(localOnly: true),
+      protocol.SyncWorkspaceResponse(reconnectRequired: true),
+    ]) {
+      expect(reduce(result).phase, SyncPhase.checking);
+      expect(reduce(result).lastSyncedAt, isNull);
+    }
+    expect(
+        reduce(protocol.SyncWorkspaceResponse(directOfferDeferred: true)).phase,
+        SyncPhase.syncing);
+  });
+
+  test('deferred admission preserves the remote explanation', () {
+    final status = reduce(protocol.SyncWorkspaceResponse(
+      stillAhead: true,
+      offerReceipt: protocol.CustodyOfferReceipt(
+        admission: protocol.CustodyOfferAdmissionReceipt(sessions: [
+          protocol.CustodySessionAdmission(intents: [
+            protocol.CustodyIntentAdmission(
+              deadLettered: protocol.CustodyIntentDeadLettered(
+                message: 'Required source workspace is unavailable',
+              ),
+            ),
+          ]),
+        ]),
+      ),
+    ));
+    expect(status.phase, SyncPhase.error);
+    expect(status.lastError, 'Required source workspace is unavailable');
+    expect(status.ahead, isNull);
+  });
+
+  test('blocked custody offer names the remote dependency', () {
+    final status = reduce(protocol.SyncWorkspaceResponse(
+      stillAhead: true,
+      directOfferDeferred: true,
+      offerReceipt: protocol.CustodyOfferReceipt(
+        blocked: protocol.RuntimeBlocked(
+          siblings: protocol.SiblingResidenciesRequired(residencies: [
+            protocol.SiblingResidencyRequired(workspace: 'catalogue-source'),
+          ]),
+        ),
+      ),
+    ));
+    expect(status.phase, SyncPhase.error);
+    expect(status.lastError, contains('catalogue-source'));
+  });
+
+  test('typed offer failure cannot be presented as ordinary pending', () {
+    final status = reduce(protocol.SyncWorkspaceResponse(
+      stillAhead: true,
+      offerReceipt: protocol.CustodyOfferReceipt(
+        failure: protocol.CustodyOfferFailure(message: 'Admission unavailable'),
+      ),
+    ));
+    expect(status.phase, SyncPhase.error);
+    expect(status.lastError, 'Admission unavailable');
+  });
+
+  test('remote refusal retains code, reason, intent and immutable receipt', () {
+    final result = protocol.SyncWorkspaceResponse(
+      currentHead: 'local-head',
+      remoteRefusal: protocol.SyncRefusal(
+        code: 'REFERENCE_TYPE_MISMATCH',
+        reason: 'catalogueWorkspace must be a reference',
+        intentId: 'offer-17',
+      ),
+    );
+    final status = reduce(result);
+    expect(status.phase, SyncPhase.error);
+    expect(status.lastError, contains('REFERENCE_TYPE_MISMATCH'));
+    expect(
+        status.lastError, contains('catalogueWorkspace must be a reference'));
+    expect(status.lastError, contains('offer-17'));
+    result.currentHead = 'mutated';
+    expect(status.lastResult!.currentHead, 'local-head');
+    expect(status.lastResult!.isFrozen, isTrue);
+  });
+
+  test('custody disagreement retains both heads and does not invent counts',
+      () {
+    final status = reduce(protocol.SyncWorkspaceResponse(
+      custodyDisagreement: protocol.CustodyDisagreement(
+        localHead: 'local',
+        candidateHead: 'remote',
+        reason: 'Not a fast forward',
+      ),
+    ));
+    expect(status.lastError, contains('Not a fast forward'));
+    expect(status.lastError, contains('Local: local'));
+    expect(status.lastError, contains('Remote: remote'));
+    expect(status.ahead, isNull);
+    expect(status.lastResult!.custodyReplaced, isFalse);
+  });
+
+  test('per-session changes notify even when application summary is unchanged',
+      () async {
+    final projection = NmsSyncStatusProjection();
+    addTearDown(projection.close);
+    projection.ensureSession('home', const SyncStatus(phase: SyncPhase.error));
+    projection.ensureSession('estate', const SyncStatus());
+    projection.foldApplication(['home', 'estate']);
+    final application = projection.applicationStatus;
+    final changed = projection.changes.first;
+    projection.pushSession(
+        'estate', const SyncStatus(lastError: 'Exact issue'));
+    await changed;
+    expect(projection.statusFor('estate').lastError, 'Exact issue');
+    expect(identical(application, projection.applicationStatus), isTrue);
+  });
+
+  test('missing result is a protocol failure, not a default success', () {
+    expect(
+        reduceSyncCompletion(const SyncStatus(), protocol.SyncCompleted(), at)
+            .phase,
+        SyncPhase.error);
+  });
+
+  test('an empty result does not establish a confirmed frontier', () {
+    final status = reduce(protocol.SyncWorkspaceResponse());
+    expect(status.phase, SyncPhase.checking);
+    expect(status.ahead, isNull);
+    expect(status.lastSyncedAt, isNull);
+  });
+
+  test('aggregation retains unknown sessions and never fabricates totals',
+      () async {
+    final projection = NmsSyncStatusProjection();
+    addTearDown(projection.close);
+    projection.pushSession(
+        'estate', reduce(protocol.SyncWorkspaceResponse(currentHead: 'head')));
+    projection.foldApplication(['estate', 'home']);
+    expect(projection.applicationStatus.phase, SyncPhase.checking);
+    expect(projection.applicationStatus.ahead, isNull);
+    expect(projection.applicationStatus.lastSyncedAt, isNull);
+    projection.pushSession(
+        'home', reduce(protocol.SyncWorkspaceResponse(stillAhead: true)));
+    projection.foldApplication(['estate', 'home']);
+    expect(projection.applicationStatus.phase, SyncPhase.syncing);
+    projection.foldApplication([]);
+    expect(projection.applicationStatus.phase, SyncPhase.checking);
+  });
+
+  test(
+      'a settled workspace with an open live link is current now, not as of its last round',
+      () async {
+    final projection = NmsSyncStatusProjection();
+    addTearDown(projection.close);
+    final settled = reduce(protocol.SyncWorkspaceResponse(
+        previousHead: 'head', currentHead: 'head'));
+    expect(settled.phase, SyncPhase.idle, reason: 'fixture must be settled');
+    expect(settled.lastSyncedAt, at);
+    projection.pushSession('estate', settled);
+    projection.pushSession('home', settled.copyWith(live: true));
+    projection.foldApplication(['estate', 'home']);
+    expect(projection.applicationStatus.live, isFalse);
+    expect(projection.applicationStatus.lastSyncedAt, at,
+        reason: 'the quiet, link-less workspace is the oldest confirmation');
+    projection.pushSession('estate', settled.copyWith(live: true));
+    projection.foldApplication(['estate', 'home']);
+    expect(projection.applicationStatus.live, isTrue);
+    expect(projection.applicationStatus.lastSyncedAt!.isAfter(at), isTrue,
+        reason: 'every workspace is live: confirmed as of now');
+    expect(
+        reduce(
+                protocol.SyncWorkspaceResponse(
+                    previousHead: 'head', currentHead: 'next'),
+                settled.copyWith(live: true))
+            .live,
+        isTrue,
+        reason: 'a completed round never forgets the link state');
+  });
+
+  test(
+      'the runtime follow inventory survives every re-fold of the application status',
+      () async {
+    final projection = NmsSyncStatusProjection();
+    addTearDown(projection.close);
+    const follow = WorkspaceFollowStatus(
+      workspace: 'estate-example',
+      phase: WorkspaceFollowPhase.running,
+      live: false,
+    );
+    projection.updateFollows(9, 7, live: 6, statuses: [follow]);
+    expect(projection.applicationStatus.followed, 9);
+    expect(projection.applicationStatus.followsInSync, 7);
+    expect(projection.applicationStatus.followsLive, 6);
+    expect(projection.applicationStatus.followStatuses.single.workspace,
+        'estate-example');
+    projection.pushSession(
+        'estate',
+        reduce(protocol.SyncWorkspaceResponse(
+            previousHead: 'head', currentHead: 'head')));
+    projection.foldApplication(['estate']);
+    expect(projection.applicationStatus.followed, 9);
+    expect(projection.applicationStatus.followsInSync, 7);
+    expect(projection.applicationStatus.followStatuses.single.phase,
+        WorkspaceFollowPhase.running);
+    projection.foldApplication([]);
+    expect(projection.applicationStatus.followsInSync, 7);
+    expect(projection.applicationStatus.followsLive, 6);
+    expect(projection.applicationStatus.followStatuses.single.live, isFalse);
+  });
+
+  test('follow report keeps the peer operation, schedule and source time',
+      () async {
+    final projection = NmsSyncStatusProjection();
+    addTearDown(projection.close);
+    final observedAt = DateTime.fromMillisecondsSinceEpoch(1800000000000);
+    final due = WorkspaceFollowStatus.fromRuntime(protocol.FollowObservation(
+      workspace: 'catalogue',
+      phase: protocol.FollowObservationPhase.FOLLOW_OBSERVATION_PHASE_DUE,
+      dueAtUnixMillis: fixnum.Int64(1800000060000),
+    ));
+    final running =
+        WorkspaceFollowStatus.fromRuntime(protocol.FollowObservation(
+      workspace: 'estate',
+      phase: protocol.FollowObservationPhase.FOLLOW_OBSERVATION_PHASE_RUNNING,
+      attempt: 2,
+      activeEffect: 'gitFetch',
+    ));
+    projection.updateFollows(2, 0,
+        statuses: [due, running], observedAt: observedAt);
+    projection.foldApplication(const []);
+    final status = projection.applicationStatus;
+    expect(status.followReportAt, observedAt);
+    expect(status.followStatuses.first.dueAt,
+        DateTime.fromMillisecondsSinceEpoch(1800000060000));
+    expect(status.followStatuses.last.attempt, 2);
+    expect(status.followStatuses.last.activeEffect, 'gitFetch');
+  });
+}

package/dart/test/test_harness_test.dart

@@ -1,10 +1,10 @@
 // NomosTestHarness — the EPHEMERAL, FULLY-OFFLINE fixture loop: install real tenant law into a fresh local
 // workspace (no cloud), drive one directive + one read through the REAL githolon over the node runner, and
-// tear down deterministically. This is the headless app-test lane: the same bridge + generated-client surface
+// tear down deterministically. This is the UI-less app-test lane: the same bridge + generated-client surface
 // the app UI uses, under `dart test` / `flutter test`, with no network.
 //
 // Prerequisites (skipped-with-reason when absent, so CI stays green either way): `node` on PATH; the
-// in-repo runner; a warm `~/.holon/runtime` cache (holon-testmint.wasm + bootstrap.law.usdz + nomos.law.usdz — one `githolon` run fills it);
+// in-repo runner; a warm `~/.holon/runtime` cache (holon.wasm + bootstrap.law.usdz + nomos.law.usdz — one `githolon` run fills it);
 // and the compiled `examples/guestbook/build/guestbook.law.usdz` (`cd examples/guestbook && npx nomos-compile`).
 @TestOn('vm')
 library;
@@ -18,15 +18,15 @@ import 'package:nomos_types/nomos_kernel_protocol.dart'
 import 'package:test/test.dart';
 
 String get _repoEntry =>
-    '${Directory.current.path}/../../cloud/web-client/runner/node-entry.ts';
+    '${Directory.current.path}/../../peer-office/package/runner/node-entry.mjs';
 String get _guestbookLawUsdz =>
     '${Directory.current.path}/../../examples/guestbook/build/guestbook.law.usdz';
 String get _runtimeDir =>
+    // Same precedence as the harness itself: an explicit candidate runtime first.
+    Platform.environment['NOMOS_CANDIDATE_RUNTIME'] ??
     Platform.environment['NOMOS_DART_RUNTIME'] ??
     Platform.environment['NOMOS_OFFLINE_RUNTIME'] ??
     '${Platform.environment['HOME'] ?? ''}/.holon/runtime';
-// The built CLI bin — drives the `githolon harness-install` SUBCOMMAND lane (the published-harness path).
-String get _cliDist => '${Directory.current.path}/../../cli/dist/cli.mjs';
 
 /// The prerequisite that isn't installable in-test (a warm runtime cache + the compiled fixture). Returns a
 /// skip reason, or null when everything the harness needs is present.
@@ -36,7 +36,7 @@ String? _missingPrereq() {
   if (!File(_guestbookLawUsdz).existsSync()) {
     return 'compile the fixture first: cd examples/guestbook && npx nomos-compile';
   }
-  if (!File('$_runtimeDir/holon-testmint.wasm').existsSync() ||
+  if (!File('$_runtimeDir/holon.wasm').existsSync() ||
       !File('$_runtimeDir/bootstrap.law.usdz').existsSync() ||
       !File('$_runtimeDir/nomos.law.usdz').existsSync()) {
     return 'provide the coordinated candidate with NOMOS_DART_RUNTIME, or warm ~/.holon/runtime once';
@@ -45,6 +45,23 @@ String? _missingPrereq() {
 }
 
 void main() {
+  test('remote convergence requires an actual settled frontier', () {
+    expect(nmsRemoteConvergenceSettled(SyncWorkspaceResponse()), isFalse);
+    expect(nmsRemoteConvergenceSettled(SyncWorkspaceResponse(
+      currentHead: 'settled-head',
+    )), isTrue);
+    for (final pending in <SyncWorkspaceResponse>[
+      SyncWorkspaceResponse(currentHead: 'head', reconnectRequired: true),
+      SyncWorkspaceResponse(currentHead: 'head', directOfferDeferred: true),
+      SyncWorkspaceResponse(currentHead: 'head', localOnly: true),
+      SyncWorkspaceResponse(currentHead: 'head', discoveryError: RuntimeTransportFailure(status: 503)),
+      SyncWorkspaceResponse(currentHead: 'head', deferred: Int64.ONE),
+      SyncWorkspaceResponse(currentHead: 'head', refused: Int64.ONE),
+    ]) {
+      expect(nmsRemoteConvergenceSettled(pending), isFalse, reason: pending.toString());
+    }
+  });
+
   test(
       'convergence never reports rejected or dead-lettered business work as success',
       () {
@@ -71,7 +88,7 @@ void main() {
     );
   });
 
-  test('OFFLINE: install real law, write one directive, read it back, dispose',
+  test('OFFLINE: install real law into Git custody and cold-remount it',
       () async {
     final skip = _missingPrereq();
     if (skip != null) {
@@ -86,27 +103,15 @@ void main() {
           addTearDown, // deterministic auto-dispose even if an expect() throws
     );
 
-    // Drive the REAL law: a create directive + a declared query — the same ops a generated client emits.
-    final outcome = await harness.bridge.offerCreates(
+    await harness.assertDomainInstalled(
+      workspace: harness.workspace,
+      domain: 'guestbook',
+    );
+    await harness.reopenWorkspaceCustody(harness.workspace);
+    await harness.assertDomainInstalled(
+      workspace: harness.workspace,
       domain: 'guestbook',
-      directiveId: 'signGuestbook',
-      payload: {
-        'author': 'harness',
-        'message': 'offline fixture green',
-        'mood': 'happy',
-        'signedAt': DateTime.now().toUtc().toIso8601String(),
-      },
     );
-    expect(outcome.created, hasLength(1));
-    expect(outcome.created.single.type, 'guestbook.GuestbookEntry');
-
-    final rows =
-        await harness.bridge.query('entriesByAuthor', {'author': 'harness'});
-    expect(rows, hasLength(1));
-    expect(rows.first['id'], outcome.created.single.id);
-    expect((rows.first['data'] as Map)['message'], 'offline fixture green');
-    expect((rows.first['data'] as Map)['moodEmoji'],
-        '😊'); // proves the law's plan ran, not a stub
 
     stdout.writeln('offline harness green: ws=${harness.workspace}');
   }, timeout: const Timeout(Duration(minutes: 2)));
@@ -125,114 +130,85 @@ void main() {
       runtimeDir: _runtimeDir,
       registerTearDown: addTearDown,
     );
-    // harness.bridge is a SESSION HANDLE — pinned ops work as before…
-    expect(harness.bridge, isA<NomosSession>());
-    expect(await harness.bridge.query('entriesByAuthor', {'author': 'x'}),
-        isEmpty);
-    // …but the RAW PLANE holds the decoy too, so an op that forgot its session refuses HERE —
-    // exactly the refusal a real multi-workspace app would hit (never a silent sole-session guess).
-    final plane = (harness.bridge as NomosSession).parent;
-    await expectLater(
-      plane.query('entriesByAuthor', {'author': 'x'}),
-      throwsA(predicate((e) => '$e'.contains('multiple sessions'))),
-    );
+    // harness.reception is a SESSION HANDLE and the raw plane also holds the decoy.
+    expect(harness.reception, isA<NomosSession>());
+    final plane = (harness.reception as NomosSession).parent;
+    expect(plane.boundSessions, containsAll(['test-ws', '__nomos-decoy']));
   }, timeout: const Timeout(Duration(minutes: 2)));
 
   test(
-      'DX: ephemeral emits phase-progress diagnostics (install → runner → ready → connect)',
+      'CLUSTER: many workspaces share one Peer Office and keep separate Git custody',
       () async {
     final skip = _missingPrereq();
     if (skip != null) {
       markTestSkipped(skip);
       return;
     }
-    final lines = <String>[];
-    final harness = await NomosTestHarness.ephemeral(
-      lawUsdzPaths: [_guestbookLawUsdz],
+    final harness = await NomosTestHarness.cluster(
+      workspaces: {
+        'guestbook-a': [_guestbookLawUsdz],
+        'guestbook-b': [_guestbookLawUsdz],
+      },
       nodeEntry: _repoEntry,
       runtimeDir: _runtimeDir,
       registerTearDown: addTearDown,
-      onDiagnostic: lines.add,
     );
-    final joined = lines.join('\n');
-    // the four named phases are surfaced so an AppSim can tell install vs runner-wait vs connect-block.
-    expect(joined, contains('phase 1/4: offline law install'));
-    expect(joined, contains('phase 2/4: spawn the node runner'));
-    expect(joined, contains('phase 2/4: spawn the node runner done'));
-    expect(joined, contains('phase 3/4: runner ready'));
-    expect(joined, contains('phase 4/4: connect session'));
-    expect(joined, contains('phase 4/4: connect session "test-ws" done'));
-    expect(joined, contains('ready — session "test-ws" connected'));
-    expect(harness.bridge, isNotNull);
+    expect(harness.sessions, ['guestbook-a', 'guestbook-b']);
+    await harness.assertDomainInstalled(
+      workspace: 'guestbook-a',
+      domain: 'guestbook',
+    );
+    await harness.assertDomainInstalled(
+      workspace: 'guestbook-b',
+      domain: 'guestbook',
+    );
+    expect(
+        harness.session('guestbook-a'), isNot(harness.session('guestbook-b')));
   }, timeout: const Timeout(Duration(minutes: 2)));
 
-  test('OFFLINE: dispose is idempotent and removes the temp dir', () async {
+  test('DX: ephemeral emits canonical Peer Office and install progress',
+      () async {
     final skip = _missingPrereq();
     if (skip != null) {
       markTestSkipped(skip);
       return;
     }
+    final lines = <String>[];
     final harness = await NomosTestHarness.ephemeral(
       lawUsdzPaths: [_guestbookLawUsdz],
       nodeEntry: _repoEntry,
       runtimeDir: _runtimeDir,
-      autoTearDown: false, // drive dispose explicitly to assert its determinism
+      registerTearDown: addTearDown,
+      onDiagnostic: lines.add,
     );
-    // A read proves the holon is live before teardown.
-    expect(await harness.bridge.query('entriesByAuthor', {'author': 'nobody'}),
-        isEmpty);
-
-    await harness.dispose();
-    await harness
-        .dispose(); // idempotent: the second call is a no-op, never throws
-    // The bridge is dead after dispose — a call fails rather than silently reaching a leaked runner.
-    await expectLater(harness.bridge.query('entriesByAuthor', {'author': 'x'}),
-        throwsA(anything));
+    final joined = lines.join('\n');
+    expect(joined, contains('phase 1/2: open canonical test peer'));
+    expect(joined, contains('phase 2/2: create Git custody and install law'));
+    expect(joined, contains('ready — session "test-ws" connected'));
+    expect(harness.reception, isNotNull);
   }, timeout: const Timeout(Duration(minutes: 2)));
 
-  test(
-      'OFFLINE: the `githolon harness-install` SUBCOMMAND lane installs law and drives a read',
-      () async {
+  test('OFFLINE: dispose is idempotent and removes the temp dir', () async {
     final skip = _missingPrereq();
     if (skip != null) {
       markTestSkipped(skip);
       return;
     }
-    if (!File(_cliDist).existsSync()) {
-      markTestSkipped(
-          'build the CLI first: cd cli && npm run build (needs dist/cli.mjs)');
-      return;
-    }
-    // FORCE the published subcommand lane via the installHelper seam: a githolon command line (here the
-    // in-repo built bin) whose `harness-install` subcommand does the offline install a published tenant gets.
     final harness = await NomosTestHarness.ephemeral(
       lawUsdzPaths: [_guestbookLawUsdz],
       nodeEntry: _repoEntry,
       runtimeDir: _runtimeDir,
-      installHelper:
-          'node $_cliDist', // NOT an existing .mjs file ⇒ the subcommand lane
-      registerTearDown: addTearDown,
+      autoTearDown: false, // drive dispose explicitly to assert its determinism
     );
-
-    final outcome = await harness.bridge.offerCreates(
+    await harness.assertDomainInstalled(
+      workspace: harness.workspace,
       domain: 'guestbook',
-      directiveId: 'signGuestbook',
-      payload: {
-        'author': 'subcommand',
-        'message': 'installed via githolon harness-install',
-        'mood': 'happy',
-        'signedAt': DateTime.now().toUtc().toIso8601String(),
-      },
     );
-    expect(outcome.created, hasLength(1));
-    final rows =
-        await harness.bridge.query('entriesByAuthor', {'author': 'subcommand'});
-    expect(rows, hasLength(1));
-    expect((rows.first['data'] as Map)['message'],
-        'installed via githolon harness-install');
-    expect((rows.first['data'] as Map)['moodEmoji'],
-        '😊'); // the law's plan ran through the subcommand-built snapshot
 
-    stdout.writeln('subcommand harness green: ws=${harness.workspace}');
+    await harness.dispose();
+    await harness
+        .dispose(); // idempotent: the second call is a no-op, never throws
+    // The bridge is dead after dispose — a call fails rather than silently reaching a leaked runner.
+    await expectLater(harness.reception.authorKeygen(), throwsA(anything));
   }, timeout: const Timeout(Duration(minutes: 2)));
 }