@githolon/dsl 0.114.0 → 0.116.2

package/dart/lib/src/runtime_v2_transport.dart

@@ -280,6 +280,9 @@ mixin NmsPlatformCredentialProviderHost
     } on NomosConsoleEnrolmentRefused catch (refusal) {
       return refused(refusal.status, refusal.message,
           code: refusal.code, retryable: refusal.retryable);
+    } on TimeoutException {
+      return failed('the console did not answer within '
+          '${nomosConsoleEnrolmentTimeout.inSeconds} s; asking again');
     } catch (error) {
       // Never echo the request: it carries the token.
       return failed('the console could not be reached (${error.runtimeType})');

package/dart/lib/src/sync_status_projection.dart

@@ -126,6 +126,14 @@ enum WorkspaceFollowPhase {
   rebornRemotely,
   replacingLocal,
   localCopyUnreadable,
+
+  /// This peer's kernel deterministically refused the last round at the same
+  /// local head and remote frontier: sync is blocked, not retrying. No timer
+  /// re-runs it; it runs again on new local work, an upstream head change, a
+  /// socket reopen or a changed kernel/runtime. [WorkspaceFollowStatus.retryAt]
+  /// is set only once such an event made it due, and
+  /// [WorkspaceFollowStatus.detail] carries the kernel's refusal.
+  kernelRefused,
   unknown,
 }
 
@@ -182,6 +190,9 @@ final class WorkspaceFollowStatus {
           nomos_protocol.FollowObservationPhase
                 .FOLLOW_OBSERVATION_PHASE_LOCAL_COPY_UNREADABLE =>
             WorkspaceFollowPhase.localCopyUnreadable,
+          nomos_protocol.FollowObservationPhase
+                .FOLLOW_OBSERVATION_PHASE_KERNEL_REFUSED =>
+            WorkspaceFollowPhase.kernelRefused,
           _ => WorkspaceFollowPhase.unknown,
         },
         live: report.live,

package/dart/pubspec.lock

@@ -222,7 +222,7 @@ packages:
       path: "../dart_types"
       relative: true
     source: path
-    version: "0.13.0"
+    version: "0.15.0"
   package_config:
     dependency: "direct main"
     description:

package/dart/pubspec.yaml

@@ -7,7 +7,7 @@ repository: https://github.com/Captain-App/nomos2
 description: >-
   Nomos 2 Dart client — generated domain values, intent payloads and application
   lifecycle types over the typed Nomos kernel protocol and USDA custody model.
-version: 0.68.0
+version: 0.70.1
 
 environment:
   sdk: ^3.5.0
@@ -18,7 +18,7 @@ dependencies:
   # The pure-data core (wire types, offer codec, NomosReads, schema validation, error
   # info). nomos_client depends on and re-exports it, so existing imports are unchanged.
   # For local monorepo dev, pubspec_overrides.yaml points this at ../dart_types.
-  nomos_types: ^0.13.0
+  nomos_types: ^0.15.0
   fixnum: ^1.1.1
   json_schema: ^5.2.2
   crypto: ^3.0.0

package/dart/test/console_enrolment_test.dart

@@ -1,9 +1,11 @@
+import 'dart:async';
 import 'dart:convert';
 import 'dart:io';
 import 'dart:typed_data';
 
 import 'package:fixnum/fixnum.dart';
 import 'package:nomos_client/src/console_enrolment.dart';
+import 'package:nomos_client/src/console_http_io.dart';
 import 'package:nomos_client/src/runtime_v2_transport.dart';
 import 'package:nomos_peer_host/nomos_peer_host.dart'
     show NomosDeviceIdentityStore, NomosProviderCredentialStore;
@@ -224,4 +226,49 @@ void main() {
     final receipt = await noKey.performConsoleEnrolment(effect);
     expect(receipt.failure.message, contains('no usable identity'));
   });
+
+  test(
+      'a console that does not answer is a bounded, retryable transport failure (CAP-807)',
+      () async {
+    // The default transport gives up on its own deadline instead of holding the write.
+    final silent = await ServerSocket.bind(InternetAddress.loopbackIPv4, 0);
+    final held = <Socket>[];
+    silent.listen(held.add);
+    try {
+      final started = DateTime.now();
+      await expectLater(
+          nomosDefaultConsolePost(
+              Uri.parse('http://127.0.0.1:${silent.port}/v1/enrol'), '{}',
+              timeout: const Duration(milliseconds: 300)),
+          throwsA(isA<TimeoutException>()));
+      expect(DateTime.now().difference(started).inSeconds, lessThan(5));
+    } finally {
+      for (final socket in held) {
+        socket.destroy();
+      }
+      await silent.close();
+    }
+    // The shell reports it typed, as a failure Peer Office asks again after.
+    final seed = Uint8List(32)..[0] = 7;
+    final platform = _Platform([])
+      ..registerDeviceIdentityStore(_Store({'device': seed}))
+      ..registerCredentialProvider(
+          capability: 'home',
+          cloud: 'x',
+          signIn: ({String? deviceChallenge}) async => 'token')
+      ..registerConsolePost(
+          (url, text) async => throw TimeoutException('slow'));
+    final receipt = await platform.performConsoleEnrolment(
+        p.PeerConsoleEnrolmentEffect(
+            effectId: 'e',
+            deviceIdentity: 'device',
+            capability: 'home',
+            console: 'http://console.test',
+            tenant: 't',
+            scope: 'user',
+            workspaces: ['estate-a']));
+    expect(receipt.hasFailure(), isTrue);
+    expect(receipt.failure.message,
+        'the console did not answer within 20 s; asking again');
+  });
 }

package/dart/test/kernel_refused_follow_test.dart

@@ -0,0 +1,36 @@
+import 'package:fixnum/fixnum.dart' as fixnum;
+import 'package:nomos_client/src/sync_status_projection.dart';
+import 'package:nomos_types/nomos_kernel_protocol.dart' as protocol;
+import 'package:test/test.dart';
+
+void main() {
+  test('a follow the kernel refused is blocked, not retrying', () {
+    final blocked =
+        WorkspaceFollowStatus.fromRuntime(protocol.FollowObservation(
+      workspace: 'estate',
+      phase: protocol
+          .FollowObservationPhase.FOLLOW_OBSERVATION_PHASE_KERNEL_REFUSED,
+      detail: 'NMS-KERNEL-CALL: refused',
+      attempt: 2,
+    ));
+    expect(blocked.phase, WorkspaceFollowPhase.kernelRefused);
+    expect(blocked.retryAt, isNull,
+        reason: 'no timer re-runs a blocked refusal');
+  });
+
+  test('an event made a refused follow due again at its re-run time', () {
+    final retryAt = DateTime.utc(2026, 10, 8, 9, 0, 10);
+    final status = WorkspaceFollowStatus.fromRuntime(protocol.FollowObservation(
+      workspace: 'estate',
+      phase: protocol
+          .FollowObservationPhase.FOLLOW_OBSERVATION_PHASE_KERNEL_REFUSED,
+      detail:
+          'NMS-KERNEL-CALL: invalid or repeated command frontier commit marker',
+      retryAtUnixMillis: fixnum.Int64(retryAt.millisecondsSinceEpoch),
+      attempt: 2,
+    ));
+    expect(status.phase, WorkspaceFollowPhase.kernelRefused);
+    expect(status.detail, startsWith('NMS-KERNEL-CALL:'));
+    expect(status.retryAt, retryAt.toLocal());
+  });
+}

package/dart/test/model_adoption_test.dart

@@ -11,6 +11,7 @@ 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:nomos_types/nomos_types.dart' show NomosDomainRequirement;
 import 'package:test/test.dart';
 
 const lawSha = '5efef545fdadae764e29ba678833073e0245b1b76e315d3a5fe71c6a65240a45';
@@ -89,6 +90,54 @@ void main() {
           throwsArgumentError);
     });
 
+    test('per-domain requirements (CAP-666) are optional, keyed and checked',
+        () {
+      expect(model().domainRequirements, isEmpty);
+      final pinned = NomosApprovedModel(
+          unitSet: unitSet,
+          lawSha256: lawSha,
+          reason: 'r',
+          domainKeys: const ['home'],
+          loadPackage: () async => Uint8List(0),
+          domainRequirements: {
+            'home': NomosDomainRequirement(
+                domainKey: 'home',
+                unitSha256: '3' * 64,
+                requirementSha256: '4' * 64),
+          });
+      expect(pinned.domainRequirements['home']!.unitSha256, '3' * 64);
+      expect(() => pinned.domainRequirements['x'] = pinned.domainRequirements['home']!,
+          throwsUnsupportedError);
+      expect(
+          () => NomosApprovedModel(
+              unitSet: unitSet,
+              lawSha256: lawSha,
+              reason: 'r',
+              domainKeys: const ['home'],
+              loadPackage: () async => Uint8List(0),
+              domainRequirements: {
+                'estate': NomosDomainRequirement(
+                    domainKey: 'home',
+                    unitSha256: '3' * 64,
+                    requirementSha256: '4' * 64),
+              }),
+          throwsArgumentError);
+      expect(
+          () => NomosApprovedModel(
+              unitSet: unitSet,
+              lawSha256: lawSha,
+              reason: 'r',
+              domainKeys: const ['home'],
+              loadPackage: () async => Uint8List(0),
+              domainRequirements: {
+                'home': NomosDomainRequirement(
+                    domainKey: 'home',
+                    unitSha256: 'nope',
+                    requirementSha256: '4' * 64),
+              }),
+          throwsArgumentError);
+    });
+
     test('its package source answers only the identity it was released with',
         () async {
       final source = NmsApprovedModelLawPackageSource(model());

package/dart/test/result_usda_test.dart

@@ -1,4 +1,5 @@
 import 'dart:convert';
+import 'dart:io';
 import 'dart:typed_data';
 
 import 'package:nomos_client/src/nms_generated_runtime.dart';
@@ -46,4 +47,70 @@ def NomosReadResult "Result"
       'Ship',
     );
   });
+
+  // CAP-862: the shared conformance vectors. Every canonical literal, and every legacy `\uXXXX`
+  // spelling an older kernel wrote, reads back as the value it names.
+  test('decodes the canonical and legacy USDA string vectors', () {
+    final vectors = jsonDecode(
+            File('../conformance/usda_string.v1.json').readAsStringSync())
+        as Map<String, dynamic>;
+    final cases = [
+      ...(vectors['encode'] as List).cast<Map<String, dynamic>>(),
+      ...(vectors['legacyDecode'] as List).cast<Map<String, dynamic>>(),
+    ];
+    expect(cases.length, greaterThan(60));
+    for (final vector in cases) {
+      final result = NmsUsdaResult.parse(
+        Uint8List.fromList(
+          utf8.encode('''#usda 1.0
+(
+    defaultPrim = "Result"
+)
+
+def NomosReadResult "Result"
+{
+    custom uniform bool nomos:done = true
+
+    def NomosListValue "Rows"
+    {
+        def NomosRecordValue "i_00000000"
+        {
+            custom uniform string nomos:id = "note:1"
+            custom rel nomos:type = </Nomos/Domains/d_1/Aggregates/a_note>
+
+            def NomosStringValue "f_title"
+            {
+                custom rel nomos:field = </Nomos/Domains/d_1/Aggregates/a_note/Fields/f_title>
+                custom uniform string nomos:value = ${vector['usda']}
+            }
+        }
+    }
+}
+'''),
+        ),
+      );
+      expect(
+        result.rows.single
+            .requiredField('/Nomos/Domains/d_1/Aggregates/a_note/Fields/f_title')
+            .stringValue(),
+        vector['value'],
+        reason: vector['name'] as String,
+      );
+    }
+  });
+
+  test('framework-call quoting writes every vector canonically', () {
+    final vectors = jsonDecode(
+            File('../conformance/usda_string.v1.json').readAsStringSync())
+        as Map<String, dynamic>;
+    for (final vector
+        in (vectors['encode'] as List).cast<Map<String, dynamic>>()) {
+      expect(NmsUsdaLayer.quote(vector['value'] as String), vector['usda'],
+          reason: vector['name'] as String);
+    }
+    for (final point in (vectors['refusedCodePoints'] as List).cast<int>()) {
+      expect(() => NmsUsdaLayer.quote('a${String.fromCharCode(point)}b'),
+          throwsArgumentError);
+    }
+  });
 }

package/dart/test/runtime_projections_test.dart

@@ -61,6 +61,47 @@ void main() {
     expect(receipt.current.phase, NomosOperationPhase.converged);
   });
 
+  test(
+      'a birth custody refused as already parented fails its creation receipt, '
+      'typed and terminal (CAP-804)', () async {
+    final projection = NmsOperationReceiptProjection();
+    final birth = projection.register('home-bob', 'intent-birth');
+    projection.rememberBirth('notebook-1', birth);
+    final other = projection.register('home-bob', 'intent-other');
+    projection.advance(
+      'home-bob',
+      protocol.SyncWorkspaceResponse(
+        pushFailed: true,
+        admittedIntentIds: const ['intent-other'],
+        birthOutcomes: [
+          protocol.BirthOutcome(
+            workspace: 'notebook-1',
+            childWorkspace: 'notebook-1',
+            parentWorkspace: 'home-bob',
+            status: protocol.BirthOutcomeStatus.BIRTH_OUTCOME_STATUS_REFUSED,
+            code: 'birth-child-already-parented',
+            refusal: protocol.KernelRefusal(
+              terminal: true,
+              message: "[birth-child-already-parented] workspace 'notebook-1' "
+                  'already has a parent',
+            ),
+          ),
+        ],
+      ),
+    );
+    await expectLater(
+      birth.admitted,
+      throwsA(isA<NomosOperationRefused>()
+          .having((r) => r.code, 'code', 'birth-child-already-parented')
+          .having((r) => r.childWorkspace, 'child', 'notebook-1')),
+    );
+    await expectLater(birth.converged, throwsA(isA<NomosOperationRefused>()));
+    expect(birth.current.isRefused, isTrue);
+    expect(birth.current.phase, NomosOperationPhase.locallyAccepted);
+    // The parent's other write in the same round is unaffected.
+    await other.admitted;
+  });
+
   test('typed watch registry only correlates runtime events and cancellation',
       () async {
     final registry = NmsTypedWatchRegistry();

package/dart_types/CHANGELOG.md

@@ -1,3 +1,33 @@
+## 0.15.0
+
+- `FollowObservationPhase.FOLLOW_OBSERVATION_PHASE_KERNEL_REFUSED`: this peer's kernel deterministically refused a replica follow's round, so the follow's sync is blocked and is not retrying.
+
+- Generated value objects compare by the law's canonical value encoding, `nomos.vo-canonical.v1` (RFC 8785 over the value's `toJson()`): `NmsInternalValueIdentity.equals` / `hash` / `canonical` (CAP-853). Member order never matters, `2` and `2.0` are one number, `-0` is `0`, and an omitted optional member differs from `null`.
+
+## 0.14.0
+
+- Live stream frames for peer catch-up (CAP-826): `LiveOfferFrame` gains checkpoint, history, ref, pack and
+  refusal frames; `PeerStreamEffect`/`PeerStreamReceipt`; the runtime command `serveLiveStream`; and the kernel's
+  shallow pack request (`PackDeltaRequest.depth`, `below_head`, `also_heads`).
+
+- `NomosDomainRequirement` and `NomosApprovedModel.domainRequirements` (CAP-666): per application domain key,
+  the exact law unit (`domain:<key>` of the unit set) and the generated consumer requirement identity a client
+  was compiled against. A workspace serving that unit for the key is current for the release whatever else its
+  unit set carries. `AdoptApplicationModelRequest` carries them as `domain_requirements` (field 7,
+  `DomainUnitRequirement`). Empty on clients generated before they existed: `unitSet` alone then decides.
+- `KeyedBirthName.parent` (field 3) is reserved and unused (CAP-803): a business child is named by namespace and
+  key, fixed at birth. CAP-788's parent-scoped naming is withdrawn before release; one parent per node is the
+  kernel's `[birth-child-already-parented]` refusal.
+- Carry the current generated kernel Protobuf contract: `FrontierTransitionRequest.candidateUnits`,
+  `InterfaceCompatibilityQuery.candidateUnits` and `InterfaceCompatibilityResponse.candidateHash` qualify a law
+  release without installing it (CAP-789).
+  `ApplyPackRequest.work_budget_bytes` / `continue_pending` and `ApplyPackResponse.import_pending` /
+  `work_done_bytes` import a pack in bounded steps (CAP-806). `LawIdentity`, `LawVersion`, `LawVersionClaim` and
+  `OfferAdmitted.law_version_warnings` (`LawVersionWarning`, `LawVersionOrder`) report an install that does not
+  move its law's claimed version forward (CAP-811). `PeerGitFetchEffect.alongside_refs` (`PeerGitRefsAlongside`)
+  and `PeerGitFetchResponse.alongside_refs` (`PeerGitRefsFetched`) carry a head-only mount's settled-letter outcome
+  refs beside main.
+
 ## 0.13.0
 
 - `NomosApprovedModel` requires `unitSet`: the law a release approves is its unit set identity (the generated

package/dart_types/lib/src/approved_model.dart

@@ -12,6 +12,55 @@ import 'dart:typed_data';
 
 final RegExp _lowerHex64 = RegExp(r'^[0-9a-f]{64}$');
 
+/// ONE APPLICATION DOMAIN'S REQUIREMENT (CAP-666), as the compiler generated it
+/// beside the unit set: the exact law unit the client was compiled against
+/// (`domain:<key>` in `build/<name>.units`) and the identity of the generated
+/// consumer requirement for that domain (the domain's slice of
+/// `<name>.compatibility.usda`, which the kernel's Compatibility Desk judges).
+///
+/// A workspace serving exactly [unitSha256] for [domainKey] satisfies this
+/// release for that domain even when its unit set carries other domains the
+/// application never touches. Identities only; the bytes stay in the generated
+/// client. Const-constructible so generated code can bake it; the approved
+/// model validates it.
+final class NomosDomainRequirement {
+  const NomosDomainRequirement({
+    required this.domainKey,
+    required this.unitSha256,
+    required this.requirementSha256,
+  });
+
+  /// The application domain key this requirement is about.
+  final String domainKey;
+
+  /// The hash of the domain's law unit (`domain:<key>`), 64 lowercase hex.
+  final String unitSha256;
+
+  /// The sha256 of the domain's generated compatibility requirement, 64
+  /// lowercase hex. Observation and qualification name the contract by it.
+  final String requirementSha256;
+
+  /// The wire shape the inventory carries (identities only).
+  Map<String, String> toJson() => {
+        'unit': unitSha256,
+        'requirement': requirementSha256,
+      };
+
+  @override
+  bool operator ==(Object other) =>
+      other is NomosDomainRequirement &&
+      other.domainKey == domainKey &&
+      other.unitSha256 == unitSha256 &&
+      other.requirementSha256 == requirementSha256;
+
+  @override
+  int get hashCode => Object.hash(domainKey, unitSha256, requirementSha256);
+
+  @override
+  String toString() =>
+      'NomosDomainRequirement($domainKey: unit $unitSha256, requirement $requirementSha256)';
+}
+
 /// The law model an application release approves, supplied once at the
 /// application's Reception. Every field is required: the office refuses to
 /// adopt without the law (its unit set), the package identity, the domain keys
@@ -24,7 +73,9 @@ final class NomosApprovedModel {
     required this.reason,
     required List<String> domainKeys,
     required this.loadPackage,
-  }) : domainKeys = List.unmodifiable(domainKeys) {
+    Map<String, NomosDomainRequirement> domainRequirements = const {},
+  })  : domainKeys = List.unmodifiable(domainKeys),
+        domainRequirements = Map.unmodifiable(domainRequirements) {
     if (!_lowerHex64.hasMatch(unitSet)) {
       throw ArgumentError.value(
         unitSet,
@@ -54,6 +105,24 @@ final class NomosApprovedModel {
         'must name the application domain keys the office observes on each workspace',
       );
     }
+    for (final entry in this.domainRequirements.entries) {
+      final requirement = entry.value;
+      if (entry.key.trim().isEmpty || requirement.domainKey != entry.key) {
+        throw ArgumentError.value(
+          domainRequirements,
+          'domainRequirements',
+          'must be keyed by the domain key each requirement names',
+        );
+      }
+      if (!_lowerHex64.hasMatch(requirement.unitSha256) ||
+          !_lowerHex64.hasMatch(requirement.requirementSha256)) {
+        throw ArgumentError.value(
+          requirement,
+          'domainRequirements',
+          "'${entry.key}' must carry the generated domain unit hash and requirement identity (64 lowercase hex each)",
+        );
+      }
+    }
   }
 
   /// THE LAW this release approves (CAP-773): the unit set identity of the
@@ -76,6 +145,14 @@ final class NomosApprovedModel {
   /// alone; keys it does not serve are ignored.
   final List<String> domainKeys;
 
+  /// THE PER-DOMAIN REQUIREMENTS this release was generated against (CAP-666):
+  /// the generated `frameworkCalls.domainRequirements`, by domain key. A served
+  /// key whose workspace serves exactly that domain unit is current for this
+  /// release whatever else its unit set carries; the office reports them and
+  /// the client inventory records them as this build's contract. Empty on a
+  /// client generated before they existed: [unitSet] alone then decides.
+  final Map<String, NomosDomainRequirement> domainRequirements;
+
   /// The exact compiled package bytes, read only when a workspace must stage
   /// them (a bundled asset, a file beside the generated facade).
   final Future<Uint8List> Function() loadPackage;