@githolon/dsl 0.117.1 → 0.119.11

package/dart/lib/src/sync_status_projection.dart

@@ -35,6 +35,56 @@ final class TransferProgress {
       );
 }
 
+/// What this device holds of a workspace for reading (Jack's rule, 11 Oct 2026: the UI never waits
+/// on the network). A read answers at once from what is on the device; when nothing servable is
+/// here yet it answers empty, and this says why, so a presentation shows "downloading" or
+/// "updating" beside what it has instead of a spinner over everything.
+enum LocalCopyReadiness {
+  /// Reads answer from this device's copy.
+  ready,
+
+  /// Never on this device: its FIRST download is under way (Jack, 11 Oct 2026). Reads answer empty
+  /// and writes are refused at once until it is here. One-time per workspace per device: a landed
+  /// copy persists across kills, updates and reboots, so this never returns for it. Once the copy
+  /// lands it is [arriving] (its indexes are being prepared) until a read answers from it.
+  firstDownload,
+
+  /// Not on this device yet: never fetched, fetched or refetched with nothing servable yet, or
+  /// still opening. The copy's sync was asked for as the application's own work; reads and
+  /// watches answer again when it lands.
+  arriving,
+
+  /// On this device, but its read index is being rebuilt under the law its head has adopted, and
+  /// this application cannot decode the index it replaces. Reads answer again once it is rebuilt.
+  updating,
+
+  /// On this device, but the copy is DAMAGED and is being repaired: its local Git history is
+  /// incomplete (a commit the kernel needs is missing, `commit … unreadable`), the copy cannot be
+  /// read, or it is being refetched from its provider. Reads answer what they can (often empty);
+  /// writes cannot be admitted against it. A sync round over such a copy may still "complete"
+  /// (nothing pulled, head unchanged), so a completed round is NOT evidence that this workspace is
+  /// in sync. Derived from a read answering `localReplicaNotReady` with an incomplete-history or
+  /// refetching reason, and from a sync round failing because a commit of this copy is unreadable.
+  /// Cleared when a read answers from the copy again, or its copy is replaced by a refetch.
+  repairing,
+}
+
+/// Why a "not readable here yet" answer or a failed round means the copy is damaged and being
+/// repaired, rather than arriving for the first time. Matches the Peer Office's own words
+/// (`local Git history is incomplete`, `cannot be read`, `being refetched`, `drop the local copy`)
+/// and the kernel's (`commit <sha> unreadable`, `incomplete custody`).
+final RegExp _damagedCopyWords = RegExp(
+  r'local Git history is incomplete|local copy of .* cannot be read|being refetched|'
+  r'drop the local copy|incomplete custody|commit [0-9a-f]{7,40} unreadable|'
+  r'nomos\.runtime\.local_copy_refetching',
+  caseSensitive: false,
+);
+
+/// True when [text] (an unavailable answer's detail, or a failed round's message) says this
+/// device's copy of a workspace is damaged and being repaired.
+bool nmsSaysCopyDamaged(String? text) =>
+    text != null && text.isNotEmpty && _damagedCopyWords.hasMatch(text);
+
 enum SyncPhase {
   checking,
   idle,
@@ -244,6 +294,57 @@ final class WorkspaceFollowStatus {
       !current && (custodianWarming?.isStalled(now) ?? false);
 }
 
+/// Work a sync round left owed between this device and a workspace's server: changes made here
+/// that have not reached it ([outbound]), or the server's changes this device has not taken in.
+///
+/// A completed round is NOT evidence that owed work went away (Jack's iPad, 11 Oct 2026: a round
+/// ended `deferred=1`, the next did nothing, pulled nothing and kept the head, and the app said
+/// "in sync" while the estate was 16 commits behind). The projection keeps this until a round
+/// shows progress: its offers admitted, its main advanced or pulled, its bookmark or head moved,
+/// or the copy replaced by a refetch.
+final class UnsharedSyncWork {
+  const UnsharedSyncWork({
+    required this.since,
+    required this.outbound,
+    this.detail,
+    this.localHead = '',
+    this.trackedHead = '',
+  });
+
+  /// When this peer first saw the work owed (the first round that left it).
+  final DateTime since;
+
+  /// The device holds changes above the server's bookmark that a round could not share. False:
+  /// the owed work is the server's, not yet received here.
+  final bool outbound;
+
+  /// The round's own explanation (a deferral, a blocked offer), never exception text.
+  final String? detail;
+
+  /// The heads the last owed round ended at: a later round that moves either one made progress.
+  final String localHead;
+  final String trackedHead;
+
+  /// How long the work has been owed at [now].
+  Duration age(DateTime now) {
+    final value = now.difference(since);
+    return value.isNegative ? Duration.zero : value;
+  }
+
+  @override
+  bool operator ==(Object other) =>
+      other is UnsharedSyncWork &&
+      other.since == since &&
+      other.outbound == outbound &&
+      other.detail == detail &&
+      other.localHead == localHead &&
+      other.trackedHead == trackedHead;
+
+  @override
+  int get hashCode =>
+      Object.hash(since, outbound, detail, localHead, trackedHead);
+}
+
 /// Disposable UI projection of typed peer-runtime sync observations.
 final class SyncStatus {
   const SyncStatus({
@@ -267,10 +368,27 @@ final class SyncStatus {
     this.preparingWorkspaces = 0,
     this.retryingWorkspaces = 0,
     this.preparationActivity,
+    this.localCopy = LocalCopyReadiness.ready,
+    this.repairingCopies = const {},
+    this.unsharedWork = const {},
   });
 
   final SyncPhase phase;
 
+  /// Every workspace with sync work owed between this device and its server
+  /// ([UnsharedSyncWork]), the same on the application's status and on each session's. Status
+  /// only: a presentation must not count such a workspace as in sync.
+  final Map<String, UnsharedSyncWork> unsharedWork;
+
+  /// Every workspace whose copy on this device is damaged and being repaired
+  /// ([LocalCopyReadiness.repairing]), with when this peer first saw it so. Status only: a
+  /// presentation must not count such a workspace as in sync, and holds editing back for it.
+  final Map<String, DateTime> repairingCopies;
+
+  /// Session status only: whether this workspace's reads answered from a copy on this device, or
+  /// answered empty because it is still arriving or updating. Set by the reads themselves.
+  final LocalCopyReadiness localCopy;
+
   /// The live link to this workspace's upstream is open, so a settled status is current NOW:
   /// the upstream pushes every new frontier and an idle follow runs no round. On the
   /// application status: every connected workspace is settled and live.
@@ -350,6 +468,9 @@ final class SyncStatus {
     int? retryingWorkspaces,
     String? preparationActivity,
     bool clearPreparationActivity = false,
+    LocalCopyReadiness? localCopy,
+    Map<String, DateTime>? repairingCopies,
+    Map<String, UnsharedSyncWork>? unsharedWork,
   }) =>
       SyncStatus(
         phase: phase ?? this.phase,
@@ -374,9 +495,31 @@ final class SyncStatus {
         preparationActivity: clearPreparationActivity
             ? null
             : preparationActivity ?? this.preparationActivity,
+        localCopy: localCopy ?? this.localCopy,
+        repairingCopies: repairingCopies ?? this.repairingCopies,
+        unsharedWork: unsharedWork ?? this.unsharedWork,
       );
 }
 
+bool _sameUnshared(
+    Map<String, UnsharedSyncWork> left, Map<String, UnsharedSyncWork> right) {
+  if (identical(left, right)) return true;
+  if (left.length != right.length) return false;
+  for (final entry in left.entries) {
+    if (right[entry.key] != entry.value) return false;
+  }
+  return true;
+}
+
+bool _sameRepairs(Map<String, DateTime> left, Map<String, DateTime> right) {
+  if (identical(left, right)) return true;
+  if (left.length != right.length) return false;
+  for (final entry in left.entries) {
+    if (right[entry.key] != entry.value) return false;
+  }
+  return true;
+}
+
 bool _sameTransfer(TransferProgress? left, TransferProgress? right) =>
     identical(left, right) ||
     (left != null &&
@@ -427,7 +570,10 @@ bool _sameStatus(SyncStatus left, SyncStatus right) =>
     left.followReportAt == right.followReportAt &&
     left.preparingWorkspaces == right.preparingWorkspaces &&
     left.retryingWorkspaces == right.retryingWorkspaces &&
-    left.preparationActivity == right.preparationActivity;
+    left.preparationActivity == right.preparationActivity &&
+    left.localCopy == right.localCopy &&
+    _sameRepairs(left.repairingCopies, right.repairingCopies) &&
+    _sameUnshared(left.unsharedWork, right.unsharedWork);
 
 /// One projection owner for application-wide and per-session sync status.
 /// It has no timers, networking, retries, credentials, or custody authority.
@@ -449,6 +595,172 @@ final class NmsSyncStatusProjection {
   int _preparingWorkspaces = 0;
   int _retryingWorkspaces = 0;
   String? _preparationActivity;
+  final Map<String, DateTime> _repairing = {};
+
+  /// Workspaces whose copy here is damaged and being repaired, with when that was first seen.
+  Map<String, DateTime> get repairingCopies => Map.unmodifiable(_repairing);
+
+  /// Records that [workspace]'s copy on this device is damaged and being repaired (status only).
+  /// Its session (if any) reports [LocalCopyReadiness.repairing] and every status carries it in
+  /// [SyncStatus.repairingCopies] until [markRepaired]. Idempotent: the first sighting's time stays.
+  void markRepairing(String workspace, {DateTime? at}) {
+    if (workspace.isEmpty || _repairing.containsKey(workspace)) return;
+    _repairing[workspace] = at ?? DateTime.now();
+    _republishRepairs(workspace);
+  }
+
+  /// [workspace]'s copy answers again (a read answered from it, or a refetch replaced it).
+  void markRepaired(String workspace) {
+    if (_repairing.remove(workspace) == null) return;
+    _republishRepairs(workspace);
+  }
+
+  final Map<String, UnsharedSyncWork> _unshared = {};
+
+  /// Workspaces whose owed record a deferral or a blocked receipt set: only progress clears it.
+  final Set<String> _heldBackByDeferral = {};
+
+  /// Sessions (and the application, under the empty key) whose idle round this projection showed
+  /// as syncing because work was owed: once it is no longer owed, they are idle again.
+  final Set<String> _heldBack = {};
+
+  /// Workspaces with sync work owed between this device and their server.
+  Map<String, UnsharedSyncWork> get unsharedWork => Map.unmodifiable(_unshared);
+
+  /// Folds one completed round of [workspace] into the owed-work record (status only).
+  ///
+  /// A round that leaves work owed (deferred, an offer it could not share, a blocked receipt,
+  /// still ahead of a server that has not admitted it) records it, keeping the first sighting's
+  /// time. A later round clears it only when it shows progress: offers admitted, main advanced or
+  /// pulled, the bookmark or the head moved, or the copy replaced. A round that did nothing at the
+  /// same heads leaves it owed. Returns whether the record changed.
+  bool observeRound(
+    String workspace,
+    nomos_protocol.SyncWorkspaceResponse result, {
+    DateTime? at,
+    String? detail,
+  }) {
+    if (workspace.isEmpty) return false;
+    final previous = _unshared[workspace];
+    final localHead = result.currentHead;
+    final trackedHead = result.previousHead;
+    final receipt = result.hasOfferReceipt() ? result.offerReceipt : null;
+    final admittedHere = receipt != null &&
+        receipt.hasAdmission() &&
+        receipt.admission.main.isNotEmpty &&
+        receipt.admission.main == localHead;
+    // Admitted remotely, only waiting for the server's seal: the work reached the server.
+    final awaitingSeal = result.stillAhead && admittedHere;
+    // The server was only opening the workspace (it restarted): it judged nothing, so this round
+    // found nothing owed. Its `deferred`/`directOfferDeferred` are the timed-retry reading for
+    // older readers (workspace_sync.ts #finishWarming). Counting them left a level workspace
+    // "not caught up - retrying" for ever: the next round levels over its stream, moves no head,
+    // and a round that did nothing never clears owed work. Local work above the bookmark is
+    // still owed (`stillAhead` with differing heads).
+    final warming = result.hasCustodianWarmingRetryAfterMillis();
+    // This copy's main IS the main it tracks and the round deferred nothing: what is outstanding
+    // is the server's own seal of that main, not anything this copy has yet to receive or send
+    // (workspace_sync.ts #present: `stillAhead` is also "the server's main is not durable yet").
+    // Prod web, 12 Oct 2026: after two workspaces' law was promoted, every reload said they
+    // "haven't caught up with the server - retrying" while the copy was level and edits flowed.
+    final levelAwaitingSeal = result.stillAhead &&
+        localHead.isNotEmpty &&
+        localHead == trackedHead &&
+        result.deferred == 0 &&
+        !result.directOfferDeferred;
+    final ahead = warming
+        ? localHead.isNotEmpty && localHead != trackedHead
+        : result.stillAhead && !levelAwaitingSeal;
+    final owed =
+        (!warming && (result.deferred > 0 || result.directOfferDeferred)) ||
+            (receipt?.hasBlocked() ?? false) ||
+            (ahead && !awaitingSeal);
+    final progressed = result.mainAdvanced ||
+        result.pulled ||
+        result.admitted > 0 ||
+        result.custodyReplaced ||
+        admittedHere ||
+        (previous != null &&
+            (previous.localHead != localHead ||
+                previous.trackedHead != trackedHead));
+    // A round the server (or a dependency) actually held back: counted deferrals or a blocked
+    // receipt. Only progress clears what such a round left owed (CAP-923, the iPad sequence).
+    final heldBack =
+        !warming && (result.deferred > 0 || (receipt?.hasBlocked() ?? false));
+    // A clean round at one head: this copy's main is the main it tracks, nothing deferred or
+    // blocked. It clears an inbound record no deferral set (a round answered "another round is
+    // converging this workspace", another device's admission heard before its round, a main
+    // not yet sealed): nothing was ever held back, so there is no progress to wait for.
+    final level = localHead.isNotEmpty && localHead == trackedHead;
+    if (!owed) {
+      if (previous == null) return false;
+      final settledLevel = level &&
+          !previous.outbound &&
+          !_heldBackByDeferral.contains(workspace);
+      if (!progressed && !settledLevel) return false;
+      _unshared.remove(workspace);
+      _heldBackByDeferral.remove(workspace);
+    } else {
+      if (heldBack) _heldBackByDeferral.add(workspace);
+      final next = UnsharedSyncWork(
+        since: previous?.since ?? at ?? DateTime.now(),
+        outbound: localHead.isNotEmpty && localHead != trackedHead,
+        detail: detail ?? previous?.detail,
+        localHead: localHead,
+        trackedHead: trackedHead,
+      );
+      if (previous == next) return false;
+      _unshared[workspace] = next;
+    }
+    _republishUnshared(workspace);
+    return true;
+  }
+
+  /// [workspace]'s owed work is resolved some other way (its copy replaced or dropped).
+  void clearUnshared(String workspace) {
+    _heldBackByDeferral.remove(workspace);
+    if (_unshared.remove(workspace) == null) return;
+    _republishUnshared(workspace);
+  }
+
+  void _republishUnshared(String workspace) {
+    SyncStatus released(
+            String key, SyncStatus status) =>
+        _heldBack.contains(key) &&
+                !(key.isEmpty
+                    ? _unshared.isNotEmpty
+                    : _unshared.containsKey(key)) &&
+                status.phase == SyncPhase.syncing
+            ? status.copyWith(phase: SyncPhase.idle, ahead: 0, behind: 0)
+            : status;
+    pushSession(workspace, released(workspace, statusFor(workspace)));
+    for (final other in _bySession.keys.toList(growable: false)) {
+      if (other != workspace)
+        pushSession(other, released(other, _bySession[other]!));
+    }
+    _pushApplication(released('', _current));
+  }
+
+  void _republishRepairs(String workspace) {
+    {
+      final session = statusFor(workspace);
+      final repairing = _repairing.containsKey(workspace);
+      pushSession(
+        workspace,
+        session.copyWith(
+          localCopy: repairing
+              ? LocalCopyReadiness.repairing
+              : session.localCopy == LocalCopyReadiness.repairing
+                  ? LocalCopyReadiness.ready
+                  : session.localCopy,
+        ),
+      );
+    }
+    for (final other in _bySession.keys.toList(growable: false)) {
+      if (other != workspace) pushSession(other, _bySession[other]!);
+    }
+    _pushApplication(_current);
+  }
 
   Stream<SyncStatus> get applicationStream => _application.stream;
   SyncStatus get applicationStatus => _current;
@@ -519,7 +831,22 @@ final class NmsSyncStatusProjection {
     foldApplication(connectedSessions);
   }
 
-  void pushSession(String session, SyncStatus status) {
+  void pushSession(String session, SyncStatus input) {
+    // A damaged copy stays "repairing" whatever else a round or a read reports, until it is
+    // repaired: a completed round over it is not evidence that it is readable or writable.
+    var status = input.copyWith(
+        repairingCopies: repairingCopies, unsharedWork: unsharedWork);
+    if (_repairing.containsKey(session) &&
+        status.localCopy != LocalCopyReadiness.repairing) {
+      status = status.copyWith(localCopy: LocalCopyReadiness.repairing);
+    }
+    // Owed work is never settled, whatever a later round that did nothing reports.
+    if (_unshared.containsKey(session) && status.phase == SyncPhase.idle) {
+      status = status.copyWith(phase: SyncPhase.syncing, clearCounts: true);
+      _heldBack.add(session);
+    } else {
+      _heldBack.remove(session);
+    }
     final previous = _bySession[session];
     if (previous != null && _sameStatus(previous, status)) return;
     _bySession[session] = status;
@@ -609,7 +936,14 @@ final class NmsSyncStatusProjection {
         .any((status) => !liveNow(status) && status.lastSyncedAt == null)) {
       lastSynced = null;
     }
-    if (allLive) lastSynced = DateTime.now();
+    // Live is current now. While it STAYS live, keep the moment it became live: a fresh
+    // timestamp on every recompute made each follow or round report a "new" status, so every
+    // listener rebuilt for nothing (CAP-930: the app's status stream emitted 70x in 5 s).
+    if (allLive) {
+      lastSynced = _current.live && _current.lastSyncedAt != null
+          ? _current.lastSyncedAt
+          : DateTime.now();
+    }
 
     _pushApplication(
       SyncStatus(
@@ -635,7 +969,15 @@ final class NmsSyncStatusProjection {
     );
   }
 
-  void _pushApplication(SyncStatus status) {
+  void _pushApplication(SyncStatus input) {
+    var status = input.copyWith(
+        repairingCopies: repairingCopies, unsharedWork: unsharedWork);
+    if (_unshared.isNotEmpty && status.phase == SyncPhase.idle) {
+      status = status.copyWith(phase: SyncPhase.syncing, clearCounts: true);
+      _heldBack.add('');
+    } else {
+      _heldBack.remove('');
+    }
     if (_sameStatus(_current, status)) return;
     _current = status;
     if (!_application.isClosed) _application.add(status);

package/dart/lib/src/sync_status_reducer.dart

@@ -96,6 +96,10 @@ SyncStatus reduceSyncCompletion(
                       : SyncPhase.idle;
   final settled = phase == SyncPhase.idle;
   return SyncStatus(
+    // What the reads found of this copy is theirs to say; a round does not reset it.
+    localCopy: current.localCopy,
+    repairingCopies: current.repairingCopies,
+    unsharedWork: current.unsharedWork,
     phase: phase,
     ahead: settled ? 0 : null,
     behind: settled ? 0 : null,
@@ -109,6 +113,10 @@ SyncStatus reduceSyncCompletion(
   );
 }
 
+/// The round's own words for work it left owed (a deferral or a blocked offer), or null.
+String? nmsOwedWorkDetail(protocol.SyncWorkspaceResponse result) =>
+    result.hasOfferReceipt() ? _receiptIssue(result.offerReceipt) : null;
+
 /// Preserve the receiving office's explanation, not just its aggregate count.
 String? _receiptIssue(protocol.CustodyOfferReceipt receipt) {
   if (receipt.hasFailure()) return receipt.failure.message;
@@ -171,3 +179,39 @@ SyncStatus locallyAdmitted(SyncStatus current) => current.copyWith(
       clearCounts: true,
       clearError: true,
     );
+
+final RegExp _workspaceInMessage = RegExp(r'\bworkspace=([A-Za-z0-9_.\-]+)');
+
+/// The workspace whose copy on this device a completed round says is damaged and being repaired,
+/// or null. A round fails with the kernel unable to read one of the copy's commits
+/// (`nomos.runtime.component_failure` … `commit <sha> unreadable`, `incomplete custody`), or
+/// completes waiting while the copy is refetched (`nomos.runtime.local_copy_refetching`). The
+/// workspace is the failure's own, else the round's result's, else the one its message names,
+/// else the session the event was scoped to. Status only: nothing is retried or repaired here.
+String? nmsDamagedCopyOf(
+  protocol.SyncCompleted completed, {
+  String? session,
+}) {
+  String? message;
+  String? workspace;
+  if (completed.hasFailure()) {
+    final failure = completed.failure;
+    message = '${failure.code}: ${failure.message}';
+    if (failure.hasWorkspace() && failure.workspace.isNotEmpty) {
+      workspace = failure.workspace;
+    }
+  } else if (completed.hasResult() && completed.result.hasDiscoveryError()) {
+    message = completed.result.discoveryError.message;
+  }
+  if (!nmsSaysCopyDamaged(message)) return null;
+  if (workspace == null &&
+      completed.hasResult() &&
+      completed.result.workspace.isNotEmpty) {
+    workspace = completed.result.workspace;
+  }
+  workspace ??= _workspaceInMessage.firstMatch(message!)?.group(1);
+  if (workspace == null && session != null && session.isNotEmpty) {
+    workspace = session;
+  }
+  return workspace;
+}

package/dart/lib/src/test_harness.dart

@@ -1718,6 +1718,7 @@ class NomosTestHarness {
                   !{
                     NomosUnavailableReason.localReplicaNotReady,
                     NomosUnavailableReason.workspaceOpening,
+                    NomosUnavailableReason.firstDownload,
                   }.contains(unavailable.reason) ||
                   DateTime.now().isAfter(deadline)) rethrow;
               onDiagnostic?.call(

package/dart/lib/src/typed_watch_registry.dart

@@ -5,7 +5,13 @@ import 'package:nomos_types/nomos_types.dart'
     show NomosErrorInfo, NomosUnavailable, nomosErrorFromInfo;
 
 import 'nomos_trace.dart' show NomosTrace;
-import 'replica_readiness.dart' show NmsReplicaWake;
+import 'replica_readiness.dart'
+    show
+        NmsLocalCopyReport,
+        NmsReplicaWake,
+        nmsIsReplicaNotReady,
+        nmsLocalCopyReadiness;
+import 'sync_status_projection.dart' show LocalCopyReadiness;
 
 final class NmsTypedWatchHandle<T> {
   const NmsTypedWatchHandle({required this.id, required this.stream});
@@ -16,9 +22,14 @@ final class NmsTypedWatchHandle<T> {
 
 /// Correlates generated Runtime v2 watch events with Dart stream listeners.
 /// It neither polls nor evaluates a query; the peer runtime owns both.
+///
+/// A watch never waits before it shows something. When its workspace's copy is not readable
+/// here yet (still arriving, or its index updating under a new law), the watch emits the query's
+/// empty answer at once, reports the copy's readiness, and registers in the background; the
+/// registration's first result then replaces the empty one.
 final class NmsTypedWatchRegistry {
   /// [synced] names each workspace whose sync round just completed; a watch
-  /// waiting for its copy registers at that moment rather than after a sleep.
+  /// whose copy was not here yet registers at that moment rather than after a sleep.
   NmsTypedWatchRegistry({Stream<String>? synced}) : _synced = synced;
 
   final Stream<String>? _synced;
@@ -32,6 +43,8 @@ final class NmsTypedWatchRegistry {
     required Future<void> Function(String subscriptionId) start,
     required Future<void> Function(String subscriptionId) stop,
     String label = '',
+    nomos_protocol.WatchChanged? Function(String subscriptionId)? pending,
+    NmsLocalCopyReport? report,
   }) {
     if (_closed) throw StateError('Reception watch registry is closed');
     final id = '$session:watch:${++_sequence}';
@@ -40,6 +53,8 @@ final class NmsTypedWatchRegistry {
       traceFields: NomosTrace.enabled ? 'sub=$id q=$label' : '',
       synced: _synced,
       decode: decode,
+      pending: pending == null ? null : () => pending(id),
+      report: report,
       start: () {
         if (_closed) throw StateError('Reception watch registry is closed');
         _watches[id] = watch;
@@ -92,21 +107,35 @@ final class _TypedWatch<T> implements _RegisteredWatch {
   final String _traceFields;
   final Stream<String>? _synced;
   final T Function(nomos_protocol.WatchChanged) _decode;
+  final nomos_protocol.WatchChanged? Function()? _pending;
+  final NmsLocalCopyReport? _report;
   final Future<void> Function() _start;
   final Future<void> Function() _stop;
   late final StreamController<T> controller;
   Future<void>? _starting;
   Future<void>? _stopping;
 
+  /// The peer has delivered a result for this watch: it is registered, whatever its own
+  /// registration call last answered.
+  bool _delivered = false;
+
+  /// The empty answer was emitted while the copy is not readable here yet.
+  bool _emittedPending = false;
+  NmsReplicaWake? _wake;
+
   _TypedWatch({
     required String traceFields,
     required Stream<String>? synced,
     required T Function(nomos_protocol.WatchChanged) decode,
+    required nomos_protocol.WatchChanged? Function()? pending,
+    required NmsLocalCopyReport? report,
     required Future<void> Function() start,
     required Future<void> Function() stop,
   })  : _traceFields = traceFields,
         _synced = synced,
         _decode = decode,
+        _pending = pending,
+        _report = report,
         _start = start,
         _stop = stop {
     controller = StreamController<T>(
@@ -122,29 +151,58 @@ final class _TypedWatch<T> implements _RegisteredWatch {
   }
 
   /// A workspace that is still opening, syncing or building its read index answers a
-  /// retryable [NomosUnavailable]. That is a wait, not a result: the watch registers once
-  /// the replica is ready instead of ending its stream on a state that has already passed.
+  /// retryable [NomosUnavailable]. That is not a result to end the stream on, and it is not a
+  /// reason to show nothing: the watch emits the query's empty answer at once (when it has one),
+  /// reports the copy as arriving or updating, and keeps registering in the background. Each
+  /// re-ask is paced by [NmsReplicaWake] (cut short by the workspace's sync) and keeps the
+  /// workspace urgent in the peer's background queue; nobody waits on it.
   Future<void> _startWhenReady() async {
-    final wake = NmsReplicaWake(_synced);
+    final wake = _wake = NmsReplicaWake(_synced);
     try {
       for (var attempt = 0;; attempt++) {
         wake.asking();
         try {
-          return await _start();
+          await _start();
+          return;
         } on NomosUnavailable catch (unavailable) {
           if (!unavailable.retryable) rethrow;
+          if (nmsIsReplicaNotReady(unavailable)) {
+            if (!_delivered) _report?.call(nmsLocalCopyReadiness(unavailable));
+            _emitPending();
+          }
+          if (_delivered || controller.isClosed || _stopping != null) return;
           await wake.wait(unavailable, attempt);
-          if (controller.isClosed || _stopping != null) return;
+          if (_delivered || controller.isClosed || _stopping != null) return;
         }
       }
     } finally {
+      _wake = null;
       await wake.close();
     }
   }
 
+  void _emitPending() {
+    if (_emittedPending || _delivered || controller.isClosed) return;
+    final pending = _pending?.call();
+    if (pending == null) return;
+    _emittedPending = true;
+    try {
+      controller.add(_decode(pending));
+    } catch (error, stackTrace) {
+      controller.addError(error, stackTrace);
+    }
+  }
+
   @override
   void deliver(nomos_protocol.WatchChanged changed) {
     if (controller.isClosed) return;
+    if (!changed.hasFailure() && !_delivered) {
+      // Registered (possibly by a registration the peer finished after answering "not ready"):
+      // stop re-asking, and the copy now answers from this device.
+      _delivered = true;
+      _wake?.wakeNow();
+      _report?.call(LocalCopyReadiness.ready);
+    }
     if (changed.hasFailure()) {
       controller.addError(
         nomosErrorFromInfo(NomosErrorInfo(
@@ -177,6 +235,8 @@ final class _TypedWatch<T> implements _RegisteredWatch {
   }
 
   Future<void> _cancel() => _stopping ??= () async {
+        // A registration pacing its next ask stops now rather than at its timer.
+        _wake?.wakeNow();
         if (_starting == null) return;
         await _starting;
         await _stop();

package/dart/pubspec.lock

@@ -222,7 +222,7 @@ packages:
       path: "../dart_types"
       relative: true
     source: path
-    version: "0.15.0"
+    version: "0.15.2"
   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.70.4
+version: 0.70.11
 
 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.15.0
+  nomos_types: ^0.15.2
   fixnum: ^1.1.1
   json_schema: ^5.2.2
   crypto: ^3.0.0