@githolon/dsl 0.108.7 → 0.110.1

package/dart/test/model_adoption_test.dart

@@ -0,0 +1,198 @@
+// THE DART SIDE OF THE MODEL-ADOPTION DESK.
+//
+// The office decides whether a workspace is current, needs the approved
+// package, or must defer; Dart supplies the approved model once, answers the
+// runtime's law-package effect with exactly the package for that identity, and
+// projects the desk's typed observations. Nothing here stages or promotes.
+import 'dart:typed_data';
+
+import 'package:fixnum/fixnum.dart';
+import 'package:nomos_client/src/application_model_adoption.dart';
+import 'package:nomos_client/src/runtime_v2_transport.dart';
+import 'package:nomos_client/src/sync_status_projection.dart';
+import 'package:nomos_types/nomos_kernel_protocol.dart' as p;
+import 'package:test/test.dart';
+
+const lawSha = '5efef545fdadae764e29ba678833073e0245b1b76e315d3a5fe71c6a65240a45';
+const otherSha =
+    '48f3b1810000000000000000000000000000000000000000000000000000abcd';
+
+class _Platform
+    with NmsPlatformCredentialProviderHost
+    implements NomosRuntimeV2Transport {
+  int sequence = 40;
+  @override
+  int nextRuntimeRequestId() => ++sequence;
+  @override
+  Future<p.RuntimeResponse> invokeRuntime(p.RuntimeRequest request) async =>
+      p.RuntimeResponse(protocolVersion: 2, requestId: request.requestId);
+}
+
+NomosApprovedModel model({List<String> keys = const ['home']}) =>
+    NomosApprovedModel(
+      lawSha256: lawSha,
+      reason: '2026-09-11: retire the value fields; decided by Jack',
+      domainKeys: keys,
+      loadPackage: () async => Uint8List.fromList([80, 75, 3, 4, 7]),
+    );
+
+p.PeerLawPackageEffect effect([String sha = lawSha]) =>
+    p.PeerLawPackageEffect(effectId: 'law:1', lawSha256: sha);
+
+void main() {
+  group('NomosApprovedModel is the contract', () {
+    test('every field is required and checked at construction', () {
+      expect(model().domainKeys, ['home']);
+      expect(
+          () => NomosApprovedModel(
+              lawSha256: 'not-a-hash',
+              reason: 'r',
+              domainKeys: const ['home'],
+              loadPackage: () async => Uint8List(0)),
+          throwsArgumentError);
+      expect(
+          () => NomosApprovedModel(
+              lawSha256: lawSha,
+              reason: '   ',
+              domainKeys: const ['home'],
+              loadPackage: () async => Uint8List(0)),
+          throwsArgumentError);
+      expect(
+          () => NomosApprovedModel(
+              lawSha256: lawSha,
+              reason: 'r',
+              domainKeys: const [],
+              loadPackage: () async => Uint8List(0)),
+          throwsArgumentError);
+      expect(
+          () => NomosApprovedModel(
+              lawSha256: lawSha,
+              reason: 'r',
+              domainKeys: const ['home', ' '],
+              loadPackage: () async => Uint8List(0)),
+          throwsArgumentError);
+    });
+
+    test('its package source answers only the identity it was released with',
+        () async {
+      final source = NmsApprovedModelLawPackageSource(model());
+      expect(await source.load(lawSha), [80, 75, 3, 4, 7]);
+      expect(await source.load(otherSha), isNull);
+    });
+  });
+
+  group('the shell answers the law-package effect', () {
+    test('with the bytes for the named identity', () async {
+      final platform = _Platform()
+        ..registerLawPackageSource(NmsApprovedModelLawPackageSource(model()));
+      final receipt = await platform.performLawPackageEffect(effect());
+      expect(receipt.effectId, 'law:1');
+      expect(receipt.hasLawPackage(), isTrue);
+      expect(receipt.lawPackage.lawUsdz, [80, 75, 3, 4, 7]);
+    });
+
+    test('typed refusals: no source, another identity, an unreadable package',
+        () async {
+      final none = await _Platform().performLawPackageEffect(effect());
+      expect(none.hasFailure(), isTrue);
+      expect(none.failure.message, contains('supplies no application law packages'));
+
+      final platform = _Platform()
+        ..registerLawPackageSource(NmsApprovedModelLawPackageSource(model()));
+      final other = await platform.performLawPackageEffect(effect(otherSha));
+      expect(other.hasFailure(), isTrue);
+      expect(other.failure.message, contains('holds no law package with identity $otherSha'));
+
+      final malformed = await platform.performLawPackageEffect(effect('nope'));
+      expect(malformed.failure.message, contains('names no package identity'));
+
+      final broken = _Platform()
+        ..registerLawPackageSource(NmsApprovedModelLawPackageSource(
+            NomosApprovedModel(
+                lawSha256: lawSha,
+                reason: 'r',
+                domainKeys: const ['home'],
+                loadPackage: () async => throw StateError('asset missing'))));
+      final unreadable = await broken.performLawPackageEffect(effect());
+      expect(unreadable.hasFailure(), isTrue);
+      expect(unreadable.failure.message, contains('could not be read'));
+    });
+
+    test('the effect loop carries the receipt back on the same request',
+        () async {
+      final platform = _Platform()
+        ..registerLawPackageSource(NmsApprovedModelLawPackageSource(model()));
+      var frames = 0;
+      final response = await platform.driveCredentialEffects(
+          p.RuntimeRequest(
+              protocolVersion: 2,
+              requestId: Int64(9),
+              adoptApplicationModel: p.AdoptApplicationModelRequest(
+                  session: 'home', lawSha256: lawSha)), (request) async {
+        frames++;
+        if (frames == 1) {
+          return p.RuntimeResponse(
+              protocolVersion: 2,
+              requestId: request.requestId,
+              correspondencePending: p.CorrespondencePending(
+                  workId: 'model-adoption-1', lawPackage: effect()));
+        }
+        expect(request.hasContinueCorrespondence(), isTrue);
+        expect(request.continueCorrespondence.workId, 'model-adoption-1');
+        expect(request.continueCorrespondence.receipt.lawPackage.lawUsdz,
+            [80, 75, 3, 4, 7]);
+        return p.RuntimeResponse(
+            protocolVersion: 2,
+            requestId: request.requestId,
+            applicationModelAdopted: p.ApplicationModelAdopted(
+                workspace: 'nomos-rg-ada',
+                outcome: p.ModelAdoptionOutcome.MODEL_ADOPTION_OUTCOME_ADOPTED,
+                currentLawSha256: lawSha));
+      });
+      expect(frames, 2);
+      expect(response.hasApplicationModelAdopted(), isTrue);
+      final adoption =
+          NomosModelAdoption.fromRuntime(response.applicationModelAdopted);
+      expect(adoption.outcome, NomosModelAdoptionOutcome.adopted);
+      expect(adoption.currentLawSha256, lawSha);
+      expect(adoption.deferred, isNull);
+    });
+  });
+
+  group('the desk\'s observations project onto the sync-status surface', () {
+    test('a deferred progress is the typed condition the app renders', () {
+      final progress = NomosModelAdoptionProgress.fromRuntime(
+          p.ModelAdoptionProgress(
+              workspace: 'nomos-rg-ada',
+              phase: p.ModelAdoptionPhase.MODEL_ADOPTION_PHASE_PROMOTE,
+              outcome: p.ModelAdoptionOutcome.MODEL_ADOPTION_OUTCOME_DEFERRED,
+              detail: 'remote offer preparation key is not an active signer',
+              currentLawSha256: otherSha));
+      expect(progress.isTerminal, isTrue);
+      final deferred = progress.deferred;
+      expect(deferred, isNotNull);
+      expect(deferred!.workspace, 'nomos-rg-ada');
+      expect(deferred.phase, NomosModelAdoptionPhase.promote);
+      expect(deferred.detail, contains('not an active signer'));
+      expect(deferred.currentLawSha256, otherSha);
+      final status = const SyncStatus().copyWith(modelAdoption: progress);
+      expect(status.modelAdoption, same(progress));
+      expect(status.copyWith(phase: SyncPhase.idle).modelAdoption, same(progress));
+    });
+
+    test('progress and the non-deferred outcomes map one to one', () {
+      NomosModelAdoptionProgress of(p.ModelAdoptionOutcome outcome) =>
+          NomosModelAdoptionProgress.fromRuntime(p.ModelAdoptionProgress(
+              workspace: 'w',
+              phase: p.ModelAdoptionPhase.MODEL_ADOPTION_PHASE_STAGE,
+              outcome: outcome));
+      expect(of(p.ModelAdoptionOutcome.MODEL_ADOPTION_OUTCOME_IN_PROGRESS).isTerminal, isFalse);
+      expect(of(p.ModelAdoptionOutcome.MODEL_ADOPTION_OUTCOME_CURRENT).outcome, NomosModelAdoptionOutcome.current);
+      expect(of(p.ModelAdoptionOutcome.MODEL_ADOPTION_OUTCOME_ADOPTED).outcome, NomosModelAdoptionOutcome.adopted);
+      expect(of(p.ModelAdoptionOutcome.MODEL_ADOPTION_OUTCOME_PREVIEWED).outcome, NomosModelAdoptionOutcome.previewed);
+      expect(of(p.ModelAdoptionOutcome.MODEL_ADOPTION_OUTCOME_UNSPECIFIED).outcome, NomosModelAdoptionOutcome.inProgress);
+      expect(of(p.ModelAdoptionOutcome.MODEL_ADOPTION_OUTCOME_CURRENT).phase, NomosModelAdoptionPhase.stage);
+      expect(of(p.ModelAdoptionOutcome.MODEL_ADOPTION_OUTCOME_CURRENT).deferred, isNull);
+    });
+  });
+}

package/dart/test/node_peer_local_custody_test.dart

@@ -0,0 +1,153 @@
+// LOCAL-FIRST RESTART on the node peer: a workspace this peer ACQUIRED from a custodian is sealed into
+// the peer's own Git custody after every frame, so a fresh process over the same custody reopens it
+// with no custodian at all. This is the restart lane every device has; the reinstall lane
+// (`reinstall()`) is the other one — empty custody, everything re-acquired from the custodian.
+@TestOn('vm')
+library;
+
+import 'dart:io';
+
+import 'package:nomos_client/src/nms_conformance_runtime.dart';
+import 'package:test/test.dart';
+
+import '../../../examples/co2-birth/build/application/co2_application/lib/src/generated/application.framework_calls.dart'
+    show nomosInternalApplicationFrameworkCalls;
+
+String get _repoRoot => Directory.current.parent.parent.path;
+String get _serverEntry =>
+    '$_repoRoot/platform-shells/node/local-development/server.ts';
+String get _peerEntry => '$_repoRoot/platform-shells/node/stdio/entry.ts';
+String get _co2LawUsdz => '$_repoRoot/examples/co2-birth/build/co2.law.usdz';
+String get _runtimeDir =>
+    Platform.environment['NOMOS_CANDIDATE_RUNTIME'] ??
+    Platform.environment['NOMOS_DART_RUNTIME'] ??
+    Platform.environment['NOMOS_OFFLINE_RUNTIME'] ??
+    '${Platform.environment['HOME'] ?? ''}/.holon/runtime';
+
+String? _missingPrereq() {
+  if (!File(_serverEntry).existsSync() || !File(_peerEntry).existsSync()) {
+    return 'the node shells are not in this checkout';
+  }
+  if (!File(_co2LawUsdz).existsSync()) {
+    return 'compile the fixture first: cd examples/co2-birth && npx nomos-compile';
+  }
+  for (final artifact in const [
+    'holon.wasm',
+    'kernel.repository.xml',
+    'bootstrap.law.usdz',
+    'nomos.law.usdz',
+  ]) {
+    if (!File('$_runtimeDir/$artifact').existsSync()) {
+      return 'point NOMOS_CANDIDATE_RUNTIME at a complete runtime bundle (missing $artifact)';
+    }
+  }
+  return null;
+}
+
+void main() {
+  test(
+    'LOCAL-FIRST: an acquired Home survives the node peer restarting on its own custody, offline',
+    () async {
+      final skip = _missingPrereq();
+      if (skip != null) {
+        markTestSkipped(skip);
+        return;
+      }
+      final diagnostics = <String>[];
+      void log(String line) {
+        diagnostics.add(line);
+        printOnFailure(line);
+      }
+
+      final custody =
+          await Directory.systemTemp.createTemp('nomos-node-peer-custody-');
+      addTearDown(() => custody.delete(recursive: true));
+
+      final cloud = await NomosTestCloud.start(
+        serverEntry: _serverEntry,
+        platform: 'restart-platform',
+        lawUsdzPaths: [_co2LawUsdz],
+        applicationMaxChildWorkspacesPerUser: 5,
+        runtimeDirectory: _runtimeDir,
+        mintTrustRoot: true,
+        testIdentityProvider: true,
+        readyTimeout: const Duration(minutes: 4),
+        onDiagnostic: log,
+      );
+      addTearDown(cloud.stop);
+
+      final harness = await NomosTestHarness.cloudBound(
+        cloud: cloud,
+        lawUsdzPaths: [_co2LawUsdz],
+        platformWorkspace: 'restart-platform',
+        subject: 'user:restart-owner',
+        applicationFrameworkCalls: nomosInternalApplicationFrameworkCalls,
+        nodeEntry: _peerEntry,
+        nodePeerCustody: custody.path,
+        registerTearDown: addTearDown,
+        phaseTimeout: const Duration(minutes: 4),
+        onDiagnostic: log,
+      );
+      final home = harness.homeWorkspace!;
+      final headBeforeRestart = await harness.reception.head();
+      expect(headBeforeRestart, hasLength(40));
+      // Mounting proves readable residency. Retention is an asynchronous runtime
+      // effect: observe its durable Git frontier before simulating process loss.
+      // A repository directory alone can exist before any objects were saved.
+      final repository = '${custody.path}/custody/holon-$home.git';
+      final deadline = DateTime.now().add(const Duration(seconds: 30));
+      String retainedHead = '';
+      do {
+        final retained = await Process.run(
+          'git',
+          ['--git-dir=$repository', 'rev-parse', '--verify', 'refs/heads/main'],
+        );
+        retainedHead =
+            retained.exitCode == 0 ? '${retained.stdout}'.trim() : '';
+        if (retainedHead == headBeforeRestart) break;
+        await Future<void>.delayed(const Duration(milliseconds: 50));
+      } while (DateTime.now().isBefore(deadline));
+      expect(retainedHead, headBeforeRestart,
+          reason:
+              'the runtime must retain the acquired Home without a client save or sync call');
+
+      // The process ends; the custodian is not consulted again.
+      await harness.dispose();
+      await cloud.stop();
+
+      final restarted = await NodeRunnerTransport.start(
+        entry: _peerEntry,
+        arguments: [
+          '--runtime-bundle=$_runtimeDir',
+          if (cloud.testKRootPublic case final root?)
+            '--trust-root-public-key=$root',
+          '--custody=${custody.path}',
+        ],
+        onDiagnostic: log,
+      );
+      addTearDown(restarted.dispose);
+      final peer = DartReception(restarted);
+      await peer.ready.timeout(const Duration(seconds: 30));
+      await peer.bindSession(
+        workspace: home,
+        session: home,
+      );
+      // Binding names the interaction; its first local operation attaches retained
+      // custody. With the cloud stopped, verification cannot borrow remote state.
+      // A head-only (lazy history) Home verifies what is present and says its
+      // history is still materialising; it is never called broken.
+      final verdict = await peer.session(home).verifyChain();
+      expect(
+        verdict.valid ||
+            (verdict.hasHistory() && verdict.history.state == 'materialising'),
+        isTrue,
+        reason: 'verifyChain: valid=${verdict.valid} error=${verdict.error} '
+            'history=${verdict.hasHistory() ? verdict.history.state : 'none'}',
+      );
+      expect(await peer.session(home).head(), equals(headBeforeRestart),
+          reason:
+              'the Home reopens from local custody at the exact head it was sealed at');
+    },
+    timeout: const Timeout(Duration(minutes: 10)),
+  );
+}