@githolon/dsl 0.113.4 → 0.115.0

package/dart/lib/src/nomos_trace.dart

@@ -0,0 +1,107 @@
+/// THE OPT-IN TIMELINE TRACE: `[nomos-trace]` lines across the whole call path.
+///
+/// One generated call (a save, a read) crosses the reception, the transport, an isolate, the
+/// native host, the Peer Office and the kernel. Every layer writes `[nomos-trace]` lines so one
+/// call can be followed end to end and each millisecond given to a layer:
+///
+///   * `c=` — this Dart call (one generated offer or query), joined to
+///   * `lr=` — the kernel request id the reception gave it, joined to
+///   * `rr=` — the Runtime v2 request id every lower layer (worker, host, office) logs.
+///
+/// `t=` is microseconds on Dart's Timeline clock; on Apple the native host and the Peer Office
+/// stamp the same clock (CLOCK_MONOTONIC_RAW), so cross-layer gaps are plain subtraction.
+/// `scripts/nomos_trace_waterfall.ts` turns a log of these lines into a per-call waterfall.
+///
+/// Off by default, including in debug. Build with `--dart-define=NOMOS_TRACE=true` (a release
+/// phone build, `flutter test`, AppSim) or set [NomosTrace.enabled] before the first call. Every
+/// Runtime v2 request is then sent with a `sampled` trace context, which is what turns the native
+/// host's and the Peer Office's lines on: one switch for the whole path. Disabled, each call site
+/// is one static bool read. Lines name operation kinds, ids, sizes and durations only: never
+/// payloads, credentials or workspace contents.
+library;
+
+import 'dart:async';
+import 'dart:developer' as developer;
+
+import 'package:meta/meta.dart' show internal;
+import 'package:nomos_types/nomos_kernel_protocol.dart' as nomos_protocol;
+
+/// See the library comment.
+abstract final class NomosTrace {
+  /// Whether `[nomos-trace]` lines are written. Per isolate: hosts that run a worker isolate pass
+  /// it on explicitly.
+  static bool enabled = const bool.fromEnvironment('NOMOS_TRACE');
+
+  static int _calls = 0;
+
+  /// Microseconds on the Timeline clock (the clock every `t=` uses).
+  static int now() => developer.Timeline.now;
+
+  /// A fresh Dart call id (`c=`).
+  static int nextCall() => ++_calls;
+
+  /// Write one line: `[nomos-trace] t=<now> L=<layer> e=<event> <fields>`. Build [fields] only
+  /// behind an `if (NomosTrace.enabled)` so a disabled build pays nothing for them.
+  static void emit(String layer, String event, String fields) {
+    // A release build's print reaches the device log (idevicesyslog -m nomos); debugPrint
+    // would throttle and batch it, which skews the very timings being read.
+    // ignore: avoid_print
+    print('[nomos-trace] t=${now()} L=$layer e=$event $fields');
+  }
+
+  /// The trace context every Runtime v2 request carries while tracing: `sampled` asks the native
+  /// host and the Peer Office to write their lines too. No ids are set, so the office keeps
+  /// deriving span ids from the request id exactly as when tracing is off.
+  @internal
+  static nomos_protocol.TraceContext sampledContext() =>
+      nomos_protocol.TraceContext(sampled: true);
+
+  /// What a Runtime v2 request asks for, as an operation kind (never argument values):
+  /// `kernelCall/offer:estate/placeAssetOnDrawing`, `kernelCall/query:rows:assetsByAssetId`, `watch`…
+  static String describeRequest(nomos_protocol.RuntimeRequest request) {
+    final command = request.whichCommand().name;
+    if (request.hasKernelCall()) {
+      return '$command/${describeCall(request.kernelCall.request)}';
+    }
+    if (request.hasWatch() && request.watch.hasQuery()) {
+      return '$command/${_describeQuery(request.watch.query)}';
+    }
+    return command;
+  }
+
+  /// A kernel request's operation kind.
+  static String describeCall(nomos_protocol.CallRequest call) {
+    if (call.hasOffer()) {
+      final offer = call.offer;
+      return offer.hasCall()
+          ? 'offer:${offer.call.domain}/${offer.call.directive}'
+          : 'offer:${offer.whichIntent().name}';
+    }
+    if (call.hasQuery()) return _describeQuery(call.query);
+    return call.whichOperation().name;
+  }
+
+  /// [source] with each data event's synchronous listener time traced as `e=watch.handler`
+  /// ([fields] identify the watch). The listener runs inside the transform's data handler, so
+  /// this is the time the application spent on one emission before yielding. Unchanged when off.
+  @internal
+  static Stream<T> timedListener<T>(Stream<T> source, String fields) {
+    if (!enabled) return source;
+    return source.transform(StreamTransformer<T, T>.fromHandlers(
+      handleData: (value, sink) {
+        final started = now();
+        sink.add(value);
+        emit('dart', 'watch.handler', '$fields us=${now() - started}');
+      },
+    ));
+  }
+
+  static String _describeQuery(nomos_protocol.QueryRequest query) {
+    if (query.hasRows()) return 'query:rows:${query.rows.id}';
+    if (query.hasPage()) return 'query:page:${query.page.id}';
+    if (query.hasById()) return 'query:byId:${query.byId.aggregateType}';
+    if (query.hasByType()) return 'query:byType:${query.byType.aggregateType}';
+    if (query.hasNamed()) return 'query:named:${query.named.operation}';
+    return 'query:${query.whichQuery().name}';
+  }
+}

package/dart/lib/src/operation_receipts.dart

@@ -8,15 +8,43 @@ enum NomosOperationPhase {
   converged,
 }
 
+/// Custody refused a write this device accepted locally: a terminal verdict, never retried.
+///
+/// Today the one such refusal Nomos reports is a duplicate birth: a workspace name is global to its
+/// namespace and fixed at birth, and another parent already owns this child's name, so the cloud
+/// refused this birth (`[birth-child-already-parented]`). The child's local copy is quarantined on this
+/// device — kept for inspection, never synced. The message names only this device's own workspaces.
+final class NomosOperationRefused implements Exception {
+  const NomosOperationRefused({
+    required this.code,
+    required this.message,
+    this.childWorkspace,
+  });
+
+  /// The typed refusal tag, e.g. `birth-child-already-parented`.
+  final String code;
+  final String message;
+
+  /// The quarantined local child, for a refused birth.
+  final String? childWorkspace;
+
+  @override
+  String toString() => 'NomosOperationRefused[$code]: $message';
+}
+
 /// Product-facing progress for one accepted write.
 final class NomosOperationStatus {
-  const NomosOperationStatus(this.phase, {this.updatedAt});
+  const NomosOperationStatus(this.phase, {this.updatedAt, this.refusal});
 
   final NomosOperationPhase phase;
   final DateTime? updatedAt;
 
+  /// Set when custody refused this write: terminal; [phase] stays [NomosOperationPhase.locallyAccepted].
+  final NomosOperationRefused? refusal;
+
   bool get isAdmitted => phase != NomosOperationPhase.locallyAccepted;
   bool get isConverged => phase == NomosOperationPhase.converged;
+  bool get isRefused => refusal != null;
 }
 
 /// Awaitable projection of typed peer-runtime receipts for one stable intent.
@@ -36,13 +64,36 @@ final class NomosOperationReceipt {
     yield* _changes.stream;
   }
 
-  Future<void> get admitted => _status.isAdmitted
-      ? Future<void>.value()
-      : watch().firstWhere((status) => status.isAdmitted).then((_) {});
+  /// Completes when remote custody admits this write; completes with a
+  /// [NomosOperationRefused] error when custody refuses it.
+  Future<void> get admitted => _settled((status) => status.isAdmitted);
+
+  /// Completes when this write has converged; completes with a
+  /// [NomosOperationRefused] error when custody refuses it.
+  Future<void> get converged => _settled((status) => status.isConverged);
+
+  Future<void> _settled(bool Function(NomosOperationStatus) reached) {
+    final refusal = _status.refusal;
+    if (refusal != null) return Future<void>.error(refusal);
+    if (reached(_status)) return Future<void>.value();
+    return watch()
+        .firstWhere((status) => status.isRefused || reached(status))
+        .then((status) {
+      final refused = status.refusal;
+      if (refused != null) throw refused;
+    });
+  }
 
-  Future<void> get converged => _status.isConverged
-      ? Future<void>.value()
-      : watch().firstWhere((status) => status.isConverged).then((_) {});
+  void _refuse(NomosOperationRefused refusal) {
+    if (_status.isRefused || _status.isAdmitted) return;
+    _status = NomosOperationStatus(
+      _status.phase,
+      updatedAt: DateTime.now(),
+      refusal: refusal,
+    );
+    if (!_changes.isClosed) _changes.add(_status);
+    unawaited(_changes.close());
+  }
 
   void _advance(NomosOperationPhase phase) {
     if (phase.index <= _status.phase.index) return;
@@ -81,6 +132,22 @@ final class NmsOperationReceiptProjection {
   NomosOperationReceipt? birthFor(String workspace) => _births[workspace];
 
   void advance(String workspace, nomos_protocol.SyncWorkspaceResponse result) {
+    // Custody refused one of this workspace's births (the child's name already has another parent):
+    // the creation receipt of that child reports the typed, terminal refusal (CAP-804).
+    for (final birth in result.birthOutcomes) {
+      if (birth.status !=
+              nomos_protocol.BirthOutcomeStatus.BIRTH_OUTCOME_STATUS_REFUSED ||
+          birth.code != 'birth-child-already-parented') {
+        continue;
+      }
+      final child =
+          birth.childWorkspace.isNotEmpty ? birth.childWorkspace : birth.workspace;
+      _births[child]?._refuse(NomosOperationRefused(
+        code: birth.code,
+        message: birth.hasRefusal() ? birth.refusal.message : birth.reason,
+        childWorkspace: child,
+      ));
+    }
     final pending = _pending[workspace];
     if (pending == null || pending.isEmpty) return;
 

package/dart/lib/src/reception/dart_reception.dart

@@ -51,7 +51,8 @@ import '../generated_call.dart'
         NmsGeneratedCall,
         NmsGeneratedQuery,
         NmsGeneratedResult,
-        NmsInternalGeneratedResults;
+        NmsInternalGeneratedResults,
+        nmsGeneratedCallCreatedAt;
 import '../application_model_adoption.dart'
     show
         NmsApprovedModelLawPackageSource,
@@ -63,8 +64,10 @@ import '../application_model_adoption.dart'
 import '../application_framework_calls.dart'
     show OwnedCustody, OwnedDeviceRequest;
 import '../kernel_primitives.dart' show NmsKernelPrimitives;
+import '../nomos_trace.dart' show NomosTrace;
 import '../observed_session_directory.dart' show NmsObservedSessionDirectory;
 import '../replica_readiness.dart' show nmsUntilReplicaReady;
+import '../rows_watch.dart' show NmsRowsMerge, nmsMergeRows;
 import '../operation_receipts.dart'
     show NmsOperationReceiptProjection, NomosOperationReceipt;
 import 'event_desk.dart' show ReceptionEventDesk;
@@ -91,7 +94,11 @@ export '../sync_status_projection.dart'
         WorkspaceFollowStatus,
         WorkspaceFollowPhase;
 export '../operation_receipts.dart'
-    show NomosOperationPhase, NomosOperationReceipt, NomosOperationStatus;
+    show
+        NomosOperationPhase,
+        NomosOperationReceipt,
+        NomosOperationRefused,
+        NomosOperationStatus;
 export 'progress_desk.dart'
     show
         KernelLawHydrationStep,
@@ -565,6 +572,17 @@ class NomosOwnedDeviceApprovalPreparation {
   });
 }
 
+/// Whether generated offers ask the kernel for its phase timings, which this
+/// reception prints as `[nomos-kernel-perf]` diagnostics. On by default in
+/// debug and profile builds. A release build leaves them off: carrying the spans
+/// costs the kernel, the Peer Office and this isolate work on every write that
+/// nobody reads. `--dart-define=NOMOS_KERNEL_SPANS=false` measures a profile
+/// build as a release user experiences it; `=true` restores them in release.
+const bool kNomosOfferKernelSpans = bool.fromEnvironment(
+  'NOMOS_KERNEL_SPANS',
+  defaultValue: !bool.fromEnvironment('dart.vm.product'),
+);
+
 /// The result of [DartReception.offerCreates]: the new local [head], every aggregate the plan minted, and —
 /// for a `.births()` directive — the child workspace(s) the offer brought into being on this local plane.
 /// The proof material a generated offer presents to the kernel.
@@ -890,6 +908,15 @@ class DartReception {
       );
       return;
     }
+    if (event.hasReadAccessPreparation()) {
+      // The read itself still ends typed (rows, or NomosUnavailable with
+      // credentialUnavailable); this only says why it is taking a moment.
+      final preparation = event.readAccessPreparation;
+      // ignore: avoid_print
+      print('[nomos-read-access] enrolling this device to read '
+          'workspace=${preparation.workspace} request=${preparation.requestId}');
+      return;
+    }
     if (event.hasReady()) {
       final stale = _staleBundleError(event.ready.runtimeVersion);
       if (stale != null && !allowStaleRunnerBundle) {
@@ -946,6 +973,19 @@ class DartReception {
     if (event.hasLinkChanged()) {
       _eventPlane._events.publishSync(event);
       final session = event.hasSession() ? event.session : null;
+      if (NomosTrace.enabled && event.linkChanged.hasClosure()) {
+        // How the live connection ended (CAP-683): who closed it, how, and what it had carried.
+        final closure = event.linkChanged.closure;
+        NomosTrace.emit(
+            'dart',
+            'link.closed',
+            'ws=${closure.workspace} conn=${closure.connectionId} '
+                'by=${closure.socket.initiator.name} '
+                'code=${closure.socket.hasCode() ? closure.socket.code : '-'} '
+                'clean=${closure.socket.clean} openMs=${closure.openMillis} '
+                'admissions=${closure.admissions} '
+                'unanswered=${closure.unansweredBatches}');
+      }
       if (event.linkChanged.status ==
           nomos_protocol.LinkStatus.LINK_STATUS_CLOSED) {
         final closedAt = DateTime.now();
@@ -1692,7 +1732,6 @@ class DartReception {
   Future<NomosOfferOutcome> offerGeneratedCallOutcome({
     required NmsGeneratedCall call,
     String? actor,
-    String? domainHash,
     String? session,
     String? authorSecret,
     NomosBirthCertificate? birthCertificate,
@@ -1729,11 +1768,27 @@ class DartReception {
     // ignore: avoid_print
     print('[nomos-offer] dispatch ${call.domain}/${call.directive} in '
         '$workspace using ${authenticationProof.name}');
+    // Opt-in timeline (nomos_trace.dart): this call's id, and when the generated code made it.
+    final traceCall = NomosTrace.enabled ? NomosTrace.nextCall() : 0;
+    final traceBegin = NomosTrace.enabled ? NomosTrace.now() : 0;
+    if (NomosTrace.enabled) {
+      final created = nmsGeneratedCallCreatedAt(call);
+      NomosTrace.emit(
+          'dart',
+          'call.begin',
+          'c=$traceCall op=offer:${call.domain}/${call.directive} '
+              'sinceCreateUs=${created == 0 ? -1 : traceBegin - created}');
+    }
     Future<nomos_protocol.CallResponse> attempt() async {
       final requestNumber = ++plane._sequences.request;
       final requestId = '$runtimeSession:offer:$requestNumber';
       final observer = NomosWrite.captureObserver();
       if (observer != null) plane._writeObservers[requestId] = observer;
+      final sent = NomosTrace.enabled ? NomosTrace.now() : 0;
+      if (NomosTrace.enabled) {
+        NomosTrace.emit('dart', 'call.send',
+            'c=$traceCall lr=$requestId sinceBeginUs=${sent - traceBegin}');
+      }
       try {
         return await kernelTransport.callKernel(
           session: runtimeSession,
@@ -1758,9 +1813,8 @@ class DartReception {
                     ? const <int>[]
                     : base64Decode(explicitSecret),
                 deferProjection: true,
-                spans: true,
+                spans: kNomosOfferKernelSpans,
               ),
-              controllerLawHash: domainHash,
               conflictSnapshots: conflictSnapshots,
               birthCertificate: birthCertificate,
             ),
@@ -1770,6 +1824,10 @@ class DartReception {
       } finally {
         plane._writeObservers.remove(requestId);
         observer?.call(const NomosWriteProgress(NomosWritePhase.running));
+        if (NomosTrace.enabled) {
+          NomosTrace.emit('dart', 'call.reply',
+              'c=$traceCall lr=$requestId us=${NomosTrace.now() - sent}');
+        }
       }
     }
 
@@ -1791,6 +1849,10 @@ class DartReception {
       response = await attempt();
     }
     if (response.hasFailure()) {
+      if (NomosTrace.enabled) {
+        NomosTrace.emit('dart', 'call.end',
+            'c=$traceCall outcome=failure us=${NomosTrace.now() - traceBegin}');
+      }
       // ignore: avoid_print
       print('[nomos-offer] refused ${call.domain}/${call.directive} in '
           '$workspace: ${response.failure.code}: ${response.failure.message}');
@@ -1850,6 +1912,10 @@ class DartReception {
     for (final child in born) {
       plane._receipts.rememberBirth(child, receipt);
     }
+    if (NomosTrace.enabled) {
+      NomosTrace.emit('dart', 'call.end',
+          'c=$traceCall outcome=admitted us=${NomosTrace.now() - traceBegin}');
+    }
     return NomosOfferOutcome(
       head: admitted.head,
       intentId: admitted.intentId,
@@ -2066,15 +2132,23 @@ class DartReception {
 
   /// Framework-private organisational read used by generated `describe()`. The runner joins the parent
   /// ledger's verified birth witnesses and lifecycle facts; tenant code only receives safe child links.
+  ///
+  /// On a cold mount the office answers "not ready yet" while it prepares the parent's birth
+  /// records (CAP-824); this waits that out like every other one-shot read, so a caller sees the
+  /// children or a real error, never an empty list that fills in by itself a moment later.
   Future<List<nomos_protocol.ChildWorkspace>> nomosFrameworkChildWorkspaces(
       {String? namespace}) async {
-    final response = await _invokeRuntimeV2(
-      nomos_protocol.RuntimeRequest(
-        listChildWorkspaces: nomos_protocol.ListChildWorkspacesRequest(
-          session: _runtimeSession(),
-          namespace: namespace,
+    final session = _runtimeSession();
+    final response = await nmsUntilReplicaReady(
+      () => _invokeRuntimeV2(
+        nomos_protocol.RuntimeRequest(
+          listChildWorkspaces: nomos_protocol.ListChildWorkspacesRequest(
+            session: session,
+            namespace: namespace,
+          ),
         ),
       ),
+      synced: _eventPlane._events.workspacesSynced,
     );
     if (!response.hasChildWorkspaces()) {
       throw StateError(
@@ -2550,9 +2624,22 @@ class DartReception {
     // overlapping logical request identities despite sharing one executor.
     // A copy still being fetched or opened answers "not ready yet": ask again
     // rather than hand every caller a state that passes by itself.
+    final traceCall = NomosTrace.enabled ? NomosTrace.nextCall() : 0;
+    final traceBegin = NomosTrace.enabled ? NomosTrace.now() : 0;
+    if (NomosTrace.enabled) {
+      NomosTrace.emit('dart', 'call.begin',
+          'c=$traceCall op=${NomosTrace.describeCall(nomos_protocol.CallRequest(query: query))}');
+    }
     final response = await nmsUntilReplicaReady(
       () {
         final requestNumber = ++plane._sequences.request;
+        if (NomosTrace.enabled) {
+          NomosTrace.emit(
+              'dart',
+              'call.send',
+              'c=$traceCall lr=$runtimeSession:query:$requestNumber '
+                  'sinceBeginUs=${NomosTrace.now() - traceBegin}');
+        }
         return (transport as NomosKernelCallTransport).callKernel(
           session: runtimeSession,
           // An explicit device key is an additional proof, not a replacement for
@@ -2569,6 +2656,13 @@ class DartReception {
       },
       synced: _eventPlane._events.workspacesSynced,
     );
+    if (NomosTrace.enabled) {
+      NomosTrace.emit(
+          'dart',
+          'call.end',
+          'c=$traceCall outcome=${response.whichOutcome().name} '
+              'us=${NomosTrace.now() - traceBegin}');
+    }
     if (response.hasFailure()) {
       throw StateError('${response.failure.code}: ${response.failure.message}');
     }
@@ -2664,10 +2758,16 @@ class DartReception {
       birthEvidence: posture.birthEvidence.status,
       birthEvidenceDetail: posture.birthEvidence.detail,
     );
+    // An enrolled device proves its principal with its own key and carries no
+    // provider token by design (D22): name that, rather than `missingToken`
+    // and `unresolved`, which read like a fault.
+    final tokenless = result.enrolledDevice &&
+        result.providerToken == NomosProviderTokenVerification.missingToken;
     print(
         '[nomos-auth-posture] workspace=${_eventPlane._sessions.workspaceFor(session ?? _sessionName ?? '')} '
-        'token=${result.providerToken.name} enrolled=${result.enrolledDevice} '
-        'principal=${result.resolvedPrincipal.isEmpty ? 'unresolved' : 'resolved'}');
+        'token=${tokenless ? 'notCarried(enrolledDevice)' : result.providerToken.name} '
+        'enrolled=${result.enrolledDevice} '
+        'principal=${result.resolvedPrincipal.isNotEmpty ? 'resolved' : tokenless ? 'byDeviceSigner' : 'unresolved'}');
     return result;
   }
 
@@ -2676,16 +2776,15 @@ class DartReception {
   /// must already be bound to the principal's receiving-group workspace. The
   /// shared desk owns whatever placement, identity and birth work the operation
   /// requires. Its convergence tail runs as background correspondence and reports on
-  /// [receivingGroupConvergence]. [contract] is the application's law identity
-  /// from the compiled descriptor; tenant seed steps are law, never carried
-  /// here. A typed refusal surfaces as a [NomosRuntimeError] carrying the
+  /// [receivingGroupConvergence]. The Home is born under the law its platform
+  /// serves, which the desk observes at birth; tenant seed steps are law, never
+  /// carried here. A typed refusal surfaces as a [NomosRuntimeError] carrying the
   /// desk's own code (`nomos.runtime.receiving_group_*`).
   @internal
   Future<nomos_protocol.ReceivingGroupOpened> nmsOpenReceivingGroup({
     required String application,
     required String principal,
     required String authToken,
-    required nomos_protocol.ApplicationBirthContract contract,
     bool verifyHistory = false,
     String? session,
     nomos_protocol.ConsoleEnrolmentRoute? enrolment,
@@ -2697,7 +2796,6 @@ class DartReception {
           application: application,
           principal: principal,
           authToken: utf8.encode(authToken),
-          contract: contract,
           verifyHistory: verifyHistory,
           enrolment: enrolment,
         ),
@@ -2954,6 +3052,51 @@ class DartReception {
         intervalMs: intervalMs,
       );
 
+  /// Reactive rows of a declared query, kept current by kernel deltas (CAP-731).
+  ///
+  /// The watch opts into row deltas: after its first complete result, each
+  /// local frontier advance delivers only the rows that changed (decoded with
+  /// the same generated [decode]) and the ids that left. The rows are merged
+  /// by [idOf] in the kernel's id order; a row the change did not touch keeps
+  /// its identity, and nothing is emitted when nothing changed. A delta that
+  /// does not start at this watch's position ends the stream with
+  /// [NomosWatchPositionMismatch].
+  Stream<List<T>> nmsWatchRows<T>(
+    NmsGeneratedQuery query, {
+    required List<T> Function(NmsGeneratedResult result) decode,
+    required String Function(T row) idOf,
+    List<NomosScopeKey>? keys,
+    String? principal,
+    String? session,
+    int intervalMs = _defaultWatchSafetyPollMs,
+  }) =>
+      NomosTrace.timedListener(
+          nmsMergeRows(
+            _nmsWatchQuery<nomos_protocol.WatchChanged>(
+              nomos_protocol.QueryRequest(
+                rows: nomos_protocol.RowsQuery(
+                  id: query.query,
+                  principal: principal ?? '',
+                  applicationArguments: google_protobuf.Any(
+                    typeUrl: query.protobufType,
+                    value: query.protobufPayload,
+                  ),
+                ),
+              ),
+              resultFormat: nomos_protocol
+                  .QueryResultFormat.QUERY_RESULT_FORMAT_APPLICATION_PROTOBUF,
+              decode: (changed) => changed,
+              acceptRowDelta: true,
+              keys: keys,
+              principal: principal,
+              session: session,
+              intervalMs: intervalMs,
+            ),
+            NmsRowsMerge<T>(decode: decode, idOf: idOf),
+          ),
+          // The application's own listener time per emission (the inner watch's is the merge).
+          'q=query:rows:${query.query} stage=app');
+
   /// Reactive form of [nmsQueryUsda]. Subscription mechanics are Runtime v2
   /// protobuf; each emission is the kernel's nominal USDA result and is decoded
   /// only by the generated domain client which owns [query].
@@ -3054,6 +3197,7 @@ class DartReception {
     nomos_protocol.QueryRequest request, {
     required nomos_protocol.QueryResultFormat resultFormat,
     required T Function(nomos_protocol.WatchChanged) decode,
+    bool acceptRowDelta = false,
     List<NomosScopeKey>? keys,
     String? principal,
     String? session,
@@ -3070,6 +3214,9 @@ class DartReception {
       ..resultFormat = resultFormat;
     final NmsTypedWatchHandle<T> watch = plane._events.typedWatches.open<T>(
       session: runtimeSession,
+      label: NomosTrace.enabled
+          ? NomosTrace.describeCall(nomos_protocol.CallRequest(query: request))
+          : '',
       decode: decode,
       stop: _unwatch,
       start: (subscriptionId) async {
@@ -3081,6 +3228,7 @@ class DartReception {
               kind: nomos_protocol.WatchKind.WATCH_KIND_QUERY,
               query: request,
               intervalMillis: intervalMs,
+              acceptRowDelta: acceptRowDelta,
             ),
           ),
         );
@@ -4160,9 +4308,18 @@ class NomosSession extends DartReception {
         adoptApplicationModel: nomos_protocol.AdoptApplicationModelRequest(
           session: workspace,
           lawSha256: model.lawSha256,
+          unitSet: model.unitSet,
           domainKeys: model.domainKeys,
           acceptanceReason: model.reason,
           dryRun: dryRun,
+          domainRequirements: [
+            for (final requirement in model.domainRequirements.values)
+              nomos_protocol.DomainUnitRequirement(
+                domainKey: requirement.domainKey,
+                unitSha256: requirement.unitSha256,
+                requirementSha256: requirement.requirementSha256,
+              ),
+          ],
         ),
       ),
     );