@githolon/dsl 0.119.9 → 0.119.12

package/dart/lib/src/sync_status_projection.dart

@@ -2,6 +2,8 @@ import 'dart:async';
 
 import 'package:nomos_types/nomos_kernel_protocol.dart' as nomos_protocol;
 
+import 'nomos_trace.dart';
+
 import 'application_model_adoption.dart' show NomosModelAdoptionProgress;
 
 /// Live byte progress reported by the peer runtime for one custody transfer.
@@ -587,6 +589,10 @@ final class NmsSyncStatusProjection {
   final Map<String, SyncStatus> _bySession = {};
   final Map<String, StreamController<SyncStatus>> _sessionStreams = {};
   SyncStatus _current = const SyncStatus();
+  // Keep the session result separately from readiness overlays. A final follow
+  // or preparation report can then release checking without another session
+  // event, and cannot erase a session's error, offline or pending state.
+  SyncStatus _applicationInput = const SyncStatus();
   int? _followed;
   int? _followsInSync;
   int? _followsLive;
@@ -738,7 +744,7 @@ final class NmsSyncStatusProjection {
       if (other != workspace)
         pushSession(other, released(other, _bySession[other]!));
     }
-    _pushApplication(released('', _current));
+    _pushApplication(released('', _applicationInput));
   }
 
   void _republishRepairs(String workspace) {
@@ -759,7 +765,7 @@ final class NmsSyncStatusProjection {
     for (final other in _bySession.keys.toList(growable: false)) {
       if (other != workspace) pushSession(other, _bySession[other]!);
     }
-    _pushApplication(_current);
+    _pushApplication(_applicationInput);
   }
 
   Stream<SyncStatus> get applicationStream => _application.stream;
@@ -794,7 +800,7 @@ final class NmsSyncStatusProjection {
     _followStatuses = List.unmodifiable(statuses);
     _followReportAt = observedAt;
     _pushApplication(
-      _current.copyWith(
+      _applicationInput.copyWith(
           followed: followed,
           followsInSync: inSync,
           followsLive: live,
@@ -810,7 +816,7 @@ final class NmsSyncStatusProjection {
     _preparingWorkspaces = preparing;
     _retryingWorkspaces = retrying;
     _preparationActivity = activity;
-    _pushApplication(_current.copyWith(
+    _pushApplication(_applicationInput.copyWith(
       preparingWorkspaces: preparing,
       retryingWorkspaces: retrying,
       preparationActivity: activity,
@@ -824,7 +830,7 @@ final class NmsSyncStatusProjection {
     required SyncStatus Function(SyncStatus current) change,
   }) {
     if (session == null || session.isEmpty) {
-      _pushApplication(change(_current));
+      _pushApplication(change(_applicationInput));
       return;
     }
     pushSession(session, change(statusFor(session)));
@@ -850,6 +856,12 @@ final class NmsSyncStatusProjection {
     final previous = _bySession[session];
     if (previous != null && _sameStatus(previous, status)) return;
     _bySession[session] = status;
+    if (NomosTrace.enabled) {
+      NomosTrace.emit('dart', 'sync.session',
+          'session=$session phase=${status.phase.name} live=${status.live} '
+          'ahead=${status.ahead} behind=${status.behind} '
+          'owed=${_unshared.containsKey(session)} copy=${status.localCopy.name}');
+    }
     if (!_changes.isClosed) _changes.add(null);
     final controller = _sessionStreams[session];
     if (controller != null && !controller.isClosed) controller.add(status);
@@ -970,6 +982,7 @@ final class NmsSyncStatusProjection {
   }
 
   void _pushApplication(SyncStatus input) {
+    _applicationInput = input;
     var status = input.copyWith(
         repairingCopies: repairingCopies, unsharedWork: unsharedWork);
     if (_unshared.isNotEmpty && status.phase == SyncPhase.idle) {
@@ -978,8 +991,32 @@ final class NmsSyncStatusProjection {
     } else {
       _heldBack.remove('');
     }
+    // Bound interactions are only part of the application's inventory. A
+    // background follow may still be checking/preparing or have queued writes.
+    // Its complete live report can withhold currency, never manufacture it for
+    // an unknown or pending session. Keep the underlying session counts intact.
+    final followsPending = _followed != null && _followed! > 0 &&
+        (_followsInSync != _followed || _followsLive != _followed ||
+         _followStatuses.length != _followed ||
+         _followStatuses.any((follow) => !follow.current ||
+             (follow.unsent ?? 0) > 0 || (follow.unacknowledged ?? 0) > 0));
+    if (status.phase == SyncPhase.idle &&
+        (followsPending || _preparingWorkspaces > 0 || _retryingWorkspaces > 0 ||
+         _repairing.isNotEmpty)) {
+      status = status.copyWith(phase: SyncPhase.checking, live: false);
+    }
     if (_sameStatus(_current, status)) return;
     _current = status;
+    if (NomosTrace.enabled) {
+      final pending = _bySession.entries
+          .where((entry) => entry.value.phase != SyncPhase.idle)
+          .map((entry) => '${entry.key}:${entry.value.phase.name}')
+          .join(',');
+      NomosTrace.emit('dart', 'sync.aggregate',
+          'phase=${status.phase.name} live=${status.live} '
+          'followed=${status.followed} settled=${status.followsInSync} '
+          'owed=${_unshared.length} pending=[$pending]');
+    }
     if (!_application.isClosed) _application.add(status);
   }
 

package/dart/pubspec.lock

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

package/dart/test/sync_reconnect_convergence_test.dart

@@ -0,0 +1,246 @@
+import 'dart:async';
+import 'package:fixnum/fixnum.dart';
+import 'package:nomos_client/src/peer_application_streams.dart';
+import 'package:nomos_client/src/background_work.dart';
+import 'package:nomos_client/src/nms_generated_runtime.dart';
+import 'package:nomos_types/nomos_kernel_protocol.dart' as p;
+import 'package:test/test.dart';
+
+final class _Office
+    with NomosRuntimeV2KernelCalls
+    implements PeerOfficeConnection {
+  final events = StreamController<p.RuntimeEvent>.broadcast(sync: true);
+  int sequence = 0;
+  @override
+  Stream<p.RuntimeEvent> get runtimeEvents => events.stream;
+  @override
+  int nextRuntimeRequestId() => ++sequence;
+  @override
+  Future<p.RuntimeResponse> invokeRuntime(p.RuntimeRequest request) async {
+    if (request.hasBindSession()) {
+      return p.RuntimeResponse(
+          protocolVersion: 2,
+          requestId: request.requestId,
+          sessionBound: p.SessionBound(
+              workspace: request.bindSession.workspace,
+              session: request.bindSession.session,
+              credentialCapability: request.bindSession.session));
+    }
+    if (request.hasCloseRealm()) {
+      return p.RuntimeResponse(
+          protocolVersion: 2,
+          requestId: request.requestId,
+          realmClosed: p.RealmClosed());
+    }
+    fail('Unexpected command: ${request.whichCommand()}');
+  }
+
+  void link(String workspace, bool open) => events.add(p.RuntimeEvent(
+      session: workspace,
+      linkChanged: p.LinkChanged(
+          status: open
+              ? p.LinkStatus.LINK_STATUS_OPEN
+              : p.LinkStatus.LINK_STATUS_CLOSED)));
+  void round(String workspace,
+          {bool deferred = false,
+          bool progressed = false,
+          bool awaitingSeal = false}) =>
+      events.add(p.RuntimeEvent(
+          session: workspace,
+          syncCompleted: p.SyncCompleted(
+              result: p.SyncWorkspaceResponse(
+                  workspace: workspace,
+                  previousHead: 'head',
+                  currentHead: 'head',
+                  deferred: deferred ? Int64.ONE : Int64.ZERO,
+                  directOfferDeferred: deferred,
+                  stillAhead: deferred || awaitingSeal,
+                  pulled: progressed,
+                  mainAdvanced: progressed,
+                  offerReceipt: awaitingSeal
+                      ? p.CustodyOfferReceipt(
+                          admission: p.CustodyOfferAdmissionReceipt(
+                              main: 'head', sealedMain: 'older'))
+                      : null))));
+}
+
+void main() {
+  late _Office office;
+  late DartReception reception;
+  setUp(() async {
+    office = _Office();
+    reception = DartReception(office);
+    for (final workspace in ['estate', 'catalogue']) {
+      await reception.bindSession(workspace: workspace, session: workspace);
+      office.link(workspace, true);
+      office.round(workspace);
+    }
+  });
+  tearDown(() async {
+    await reception.dispose();
+    await office.events.close();
+  });
+  test(
+      'automatic projection refreshes preserve updates without claiming user priority',
+      () async {
+    final streams = NmsPeerApplicationStreamView(
+      session: reception.session('estate'),
+      statusProjection: (_) => throw UnimplementedError(),
+    );
+    final backgroundReads = <bool>[];
+    final subscription = streams.refreshOn(
+      read: () async {
+        await Future<void>.delayed(Duration.zero);
+        backgroundReads.add(nomosInBackground);
+        return backgroundReads.length;
+      },
+      changes: [streams.workspaceChanges],
+    ).listen((_) {});
+    addTearDown(subscription.cancel);
+    await Future<void>.delayed(const Duration(milliseconds: 10));
+    expect(backgroundReads, [false],
+        reason: 'the initial visible read retains user priority');
+    office.round('catalogue');
+    await Future<void>.delayed(const Duration(milliseconds: 10));
+    expect(backgroundReads, [false, true],
+        reason: 'cross-workspace projections still refresh automatically');
+    office.round('estate', progressed: true);
+    await Future<void>.delayed(const Duration(milliseconds: 10));
+    expect(backgroundReads, [false, true, true]);
+    expect(nomosInBackground, isFalse,
+        reason: 'automatic work must not demote subsequent user actions');
+  });
+  test('a refresh coalesced behind the initial read runs in background',
+      () async {
+    final streams = NmsPeerApplicationStreamView(
+      session: reception.session('estate'),
+      statusProjection: (_) => throw UnimplementedError(),
+    );
+    final initial = Completer<void>();
+    final priorities = <bool>[];
+    final done = Completer<void>();
+    final subscription = streams.refreshOn(
+      read: () async {
+        priorities.add(nomosInBackground);
+        if (priorities.length == 1) await initial.future;
+        if (priorities.length == 2) done.complete();
+        return priorities.length;
+      },
+      changes: [streams.workspaceChanges],
+    ).listen((_) {});
+    addTearDown(subscription.cancel);
+    await Future<void>.delayed(Duration.zero);
+    office.round('catalogue');
+    await Future<void>.delayed(Duration.zero);
+    initial.complete();
+    await done.future.timeout(const Duration(seconds: 1));
+    expect(priorities, [false, true]);
+  });
+  test(
+      'CAP-791: final reconnect result releases both session and aggregate debt',
+      () {
+    for (final workspace in ['estate', 'catalogue'])
+      office.link(workspace, false);
+    expect(reception.currentStatus.phase, SyncPhase.offline);
+    for (final workspace in ['estate', 'catalogue'])
+      office.link(workspace, true);
+    expect(reception.currentStatus.phase, SyncPhase.checking);
+    office.round('estate', deferred: true);
+    office.round('catalogue');
+    expect(reception.currentStatus.phase, SyncPhase.syncing);
+    office.round('estate', progressed: true);
+    expect(reception.session('estate').currentStatus.phase, SyncPhase.idle);
+    expect(reception.currentStatus.unsharedWork, isEmpty);
+    expect(reception.currentStatus.phase, SyncPhase.idle,
+        reason: 'no later event may be needed to refold released debt');
+    expect(reception.currentStatus.live, isTrue);
+    expect(reception.currentStatus.ahead, 0);
+  });
+  test('one recovered workspace cannot clear another workspace\'s debt', () {
+    office.round('estate', deferred: true);
+    office.round('catalogue', deferred: true);
+    office.round('estate', progressed: true);
+    expect(reception.currentStatus.phase, SyncPhase.syncing);
+    expect(reception.currentStatus.unsharedWork.keys, ['catalogue']);
+    office.round('catalogue', progressed: true);
+    expect(reception.currentStatus.phase, SyncPhase.idle);
+  });
+  test('no-progress result cannot clear a real deferral', () {
+    office.round('estate', deferred: true);
+    office.round('estate');
+    expect(reception.currentStatus.phase, SyncPhase.syncing);
+    expect(reception.currentStatus.unsharedWork.keys, ['estate']);
+  });
+  test('clearing debt cannot conceal an offline sibling or unsealed admission',
+      () {
+    office.round('estate', deferred: true);
+    office.link('catalogue', false);
+    office.round('estate', progressed: true);
+    expect(reception.currentStatus.phase, SyncPhase.offline);
+    office.link('catalogue', true);
+    office.round('catalogue', awaitingSeal: true);
+    expect(reception.currentStatus.phase, SyncPhase.awaitingRemoteDurability);
+    office.round('catalogue');
+    expect(reception.currentStatus.phase, SyncPhase.idle);
+  });
+  test('settled inventory does not override an unknown late-bound session',
+      () async {
+    await reception.bindSession(workspace: 'foreign', session: 'foreign');
+    office.events.add(p.RuntimeEvent(
+        followsSummary:
+            p.FollowsSummary(followed: 3, settled: 3, live: 3, workspaces: [
+      for (final name in ['estate', 'catalogue', 'foreign'])
+        p.FollowObservation(
+            workspace: name,
+            phase: p.FollowObservationPhase.FOLLOW_OBSERVATION_PHASE_SETTLED,
+            live: true)
+    ])));
+    expect(reception.currentStatus.phase, SyncPhase.checking);
+    expect(reception.currentStatus.ahead, isNull);
+    // The peer's exact-head retained-follow result, not the tally, confirms it.
+    office.round('foreign');
+    office.link('foreign', true);
+    expect(reception.currentStatus.phase, SyncPhase.idle);
+    expect(reception.currentStatus.live, isTrue);
+  });
+
+  test('a genuine failure remains visible when another workspace recovers', () {
+    office.round('estate', deferred: true);
+    office.events.add(p.RuntimeEvent(
+        session: 'catalogue',
+        syncCompleted: p.SyncCompleted(
+            failure: p.RuntimeFailure(
+                code: 'auth.denied', message: 'Access revoked'))));
+    office.round('estate', progressed: true);
+    expect(reception.currentStatus.phase, SyncPhase.error);
+    expect(reception.currentStatus.lastError, contains('Access revoked'));
+  });
+  test(
+      'application waits for unbound background follows and releases on their report',
+      () {
+    void follows(int settled) => office.events.add(p.RuntimeEvent(
+            followsSummary: p.FollowsSummary(
+                followed: 3,
+                settled: settled,
+                live: 3,
+                workspaces: [
+              for (final name in ['estate', 'catalogue', 'foreign'])
+                p.FollowObservation(
+                    workspace: name,
+                    live: true,
+                    phase: name == 'foreign' && settled != 3
+                        ? p.FollowObservationPhase
+                            .FOLLOW_OBSERVATION_PHASE_RUNNING
+                        : p.FollowObservationPhase
+                            .FOLLOW_OBSERVATION_PHASE_SETTLED)
+            ])));
+    follows(2);
+    expect(reception.currentStatus.phase, SyncPhase.checking);
+    expect(reception.currentStatus.live, isFalse);
+    office.round('estate');
+    expect(reception.currentStatus.phase, SyncPhase.checking);
+    follows(3);
+    expect(reception.currentStatus.phase, SyncPhase.idle);
+    expect(reception.currentStatus.live, isTrue);
+  });
+}

package/dart/test/sync_status_preparation_report_test.dart

@@ -26,4 +26,74 @@ void main() {
     expect(projection.applicationStatus.preparationActivity, isNull);
     await projection.close();
   });
+  test('preparation keeps a settled application non-current until it finishes',
+      () async {
+    final projection = NmsSyncStatusProjection();
+    addTearDown(projection.close);
+    projection.pushSession(
+        'estate',
+        const SyncStatus(
+            phase: SyncPhase.idle, ahead: 0, behind: 0, live: true));
+    projection.foldApplication(['estate']);
+    projection.updatePreparationCounts(1, 1, activity: 'Preparing catalogue');
+    expect(projection.applicationStatus.phase, SyncPhase.checking);
+    expect(projection.applicationStatus.live, isFalse);
+    projection.foldApplication(['estate']);
+    expect(projection.applicationStatus.phase, SyncPhase.checking);
+    projection.updatePreparationCounts(0, 0);
+    expect(projection.applicationStatus.phase, SyncPhase.idle);
+    expect(projection.applicationStatus.live, isTrue);
+  });
+
+  test(
+      'completed follow/preparation reports never clear session-owned debt or failures',
+      () async {
+    for (final phase in [
+      SyncPhase.checking,
+      SyncPhase.syncing,
+      SyncPhase.awaitingRemoteDurability,
+      SyncPhase.offline,
+      SyncPhase.error
+    ]) {
+      final projection = NmsSyncStatusProjection();
+      addTearDown(projection.close);
+      projection.pushSession('estate', SyncStatus(phase: phase));
+      projection.foldApplication(['estate']);
+      projection.updatePreparationCounts(1, 1);
+      projection.updateFollows(1, 1, live: 1, statuses: const [
+        WorkspaceFollowStatus(
+            workspace: 'estate',
+            phase: WorkspaceFollowPhase.settled,
+            live: true)
+      ]);
+      projection.updatePreparationCounts(0, 0);
+      expect(projection.applicationStatus.phase, phase);
+      expect(projection.applicationStatus.ahead, isNull);
+    }
+  });
+
+  test('queued stream writes and incomplete reports withhold currency',
+      () async {
+    final projection = NmsSyncStatusProjection();
+    addTearDown(projection.close);
+    projection.pushSession(
+        'estate',
+        const SyncStatus(
+            phase: SyncPhase.idle, ahead: 0, behind: 0, live: true));
+    projection.foldApplication(['estate']);
+    projection.updateFollows(1, 1, live: 1);
+    expect(projection.applicationStatus.phase, SyncPhase.checking);
+    for (final (unsent, unacknowledged) in [(1, 0), (0, 1), (0, 0)]) {
+      projection.updateFollows(1, 1, live: 1, statuses: [
+        WorkspaceFollowStatus(
+            workspace: 'estate',
+            phase: WorkspaceFollowPhase.settled,
+            live: true,
+            unsent: unsent,
+            unacknowledged: unacknowledged)
+      ]);
+      expect(projection.applicationStatus.phase,
+          unsent + unacknowledged == 0 ? SyncPhase.idle : SyncPhase.checking);
+    }
+  });
 }

package/dart/test/workspace_preparation_upkeep_test.dart

@@ -37,12 +37,14 @@ void main() {
         ),
       ),
     );
-    expect(reads.active, isTrue,
-        reason: 'a read index still being built is real preparation');
+    expect(
+      reads.active,
+      isTrue,
+      reason: 'a read index still being built is real preparation',
+    );
   });
 
-  test('upkeep backing off after a failure is not a sync problem (CAP-693)',
-      () {
+  test('upkeep backing off after a failure is not a sync problem (CAP-693)', () {
     // A shallow device's Git upkeep was refused by the kernel; the status turned orange though
     // every read and write still worked.
     final failingUpkeep = WorkspacePreparationReport.fromMaintenance(
@@ -63,7 +65,39 @@ void main() {
         retryAfterMillis: 4000,
       ),
     );
-    expect(failingReads.retrying, isTrue,
-        reason: 'preparation a read waits on still shows');
+    expect(
+      failingReads.retrying,
+      isTrue,
+      reason: 'preparation a read waits on still shows',
+    );
   });
+
+  test(
+    'a pack tidy that fails after a sync is upkeep backing off, not a sync problem (CAP-952)',
+    () {
+      // Prod web, 13 Oct 2026: the kernel refused a repack after an incoming sync ("repack header
+      // …: object could not be found"). The sync icon stayed amber on "Still preparing" for the
+      // back-off while all 34 workspaces were up to date.
+      final failingAfterSync = WorkspacePreparationReport.fromMaintenance(
+        protocol.ReadMaintenanceProgress(
+          workspace: 'estate',
+          cause: protocol.ReadMaintenanceCause.READ_MAINTENANCE_CAUSE_SYNC,
+          retryAfterMillis: 1800000,
+        ),
+      );
+      expect(failingAfterSync.retrying, isFalse);
+      expect(failingAfterSync.upkeepRetrying, isTrue);
+      expect(failingAfterSync.active, isFalse);
+
+      // The read index a sync owes travels under its own read cause and still counts.
+      final indexAfterSync = WorkspacePreparationReport.fromMaintenance(
+        protocol.ReadMaintenanceProgress(
+          workspace: 'estate',
+          cause: protocol.ReadMaintenanceCause.READ_MAINTENANCE_CAUSE_RESIDENCY,
+          retryAfterMillis: 1000,
+        ),
+      );
+      expect(indexAfterSync.retrying, isTrue);
+    },
+  );
 }

package/dart_types/CHANGELOG.md

@@ -1,3 +1,11 @@
+## 0.15.3
+
+- Add a typed physical network-restored observation to wake transport retries without changing sync evidence.
+
+- `HostHealth.ingress` (`KernelIngressSnapshot`) in the runtime v2 residency protocol: the kernel execution ingress a host reports (CAP-964).
+
+- `KernelIngressSnapshot` reports posted and waiting requests per lane, the in-flight window, abandoned requests and deduplicated law-product imports (CAP-967).
+
 ## 0.15.2
 
 Add the shared kernel protocol fields for owned pack import continuations, cancellation and deferred admission.

package/dart_types/lib/src/proto/nomos/runtime/v2/correspondence_desk.pb.dart

@@ -12270,6 +12270,104 @@ class PeerGitRefsFetched extends $pb.GeneratedMessage {
   void clearDeferred() => $_clearField(3);
 }
 
+/// Physical host observation: the network returned after being unavailable.
+/// Wake eligible retries once; this is never a sync or durability receipt.
+class NetworkRestoredRequest extends $pb.GeneratedMessage {
+  factory NetworkRestoredRequest() => create();
+
+  NetworkRestoredRequest._();
+
+  factory NetworkRestoredRequest.fromBuffer($core.List<$core.int> data,
+          [$pb.ExtensionRegistry registry = $pb.ExtensionRegistry.EMPTY]) =>
+      create()..mergeFromBuffer(data, registry);
+  factory NetworkRestoredRequest.fromJson($core.String json,
+          [$pb.ExtensionRegistry registry = $pb.ExtensionRegistry.EMPTY]) =>
+      create()..mergeFromJson(json, registry);
+
+  static final $pb.BuilderInfo _i = $pb.BuilderInfo(
+      _omitMessageNames ? '' : 'NetworkRestoredRequest',
+      package:
+          const $pb.PackageName(_omitMessageNames ? '' : 'nomos.runtime.v2'),
+      createEmptyInstance: create)
+    ..hasRequiredFields = false;
+
+  @$core.Deprecated('See https://github.com/google/protobuf.dart/issues/998.')
+  NetworkRestoredRequest clone() => deepCopy();
+  @$core.Deprecated('See https://github.com/google/protobuf.dart/issues/998.')
+  NetworkRestoredRequest copyWith(
+          void Function(NetworkRestoredRequest) updates) =>
+      super.copyWith((message) => updates(message as NetworkRestoredRequest))
+          as NetworkRestoredRequest;
+
+  @$core.override
+  $pb.BuilderInfo get info_ => _i;
+
+  @$core.pragma('dart2js:noInline')
+  static NetworkRestoredRequest create() => NetworkRestoredRequest._();
+  @$core.override
+  NetworkRestoredRequest createEmptyInstance() => create();
+  @$core.pragma('dart2js:noInline')
+  static NetworkRestoredRequest getDefault() => _defaultInstance ??=
+      $pb.GeneratedMessage.$_defaultFor<NetworkRestoredRequest>(create);
+  static NetworkRestoredRequest? _defaultInstance;
+}
+
+class NetworkRestored extends $pb.GeneratedMessage {
+  factory NetworkRestored({
+    $core.int? linksRetried,
+  }) {
+    final result = create();
+    if (linksRetried != null) result.linksRetried = linksRetried;
+    return result;
+  }
+
+  NetworkRestored._();
+
+  factory NetworkRestored.fromBuffer($core.List<$core.int> data,
+          [$pb.ExtensionRegistry registry = $pb.ExtensionRegistry.EMPTY]) =>
+      create()..mergeFromBuffer(data, registry);
+  factory NetworkRestored.fromJson($core.String json,
+          [$pb.ExtensionRegistry registry = $pb.ExtensionRegistry.EMPTY]) =>
+      create()..mergeFromJson(json, registry);
+
+  static final $pb.BuilderInfo _i = $pb.BuilderInfo(
+      _omitMessageNames ? '' : 'NetworkRestored',
+      package:
+          const $pb.PackageName(_omitMessageNames ? '' : 'nomos.runtime.v2'),
+      createEmptyInstance: create)
+    ..aI(1, _omitFieldNames ? '' : 'linksRetried',
+        fieldType: $pb.PbFieldType.OU3)
+    ..hasRequiredFields = false;
+
+  @$core.Deprecated('See https://github.com/google/protobuf.dart/issues/998.')
+  NetworkRestored clone() => deepCopy();
+  @$core.Deprecated('See https://github.com/google/protobuf.dart/issues/998.')
+  NetworkRestored copyWith(void Function(NetworkRestored) updates) =>
+      super.copyWith((message) => updates(message as NetworkRestored))
+          as NetworkRestored;
+
+  @$core.override
+  $pb.BuilderInfo get info_ => _i;
+
+  @$core.pragma('dart2js:noInline')
+  static NetworkRestored create() => NetworkRestored._();
+  @$core.override
+  NetworkRestored createEmptyInstance() => create();
+  @$core.pragma('dart2js:noInline')
+  static NetworkRestored getDefault() => _defaultInstance ??=
+      $pb.GeneratedMessage.$_defaultFor<NetworkRestored>(create);
+  static NetworkRestored? _defaultInstance;
+
+  @$pb.TagNumber(1)
+  $core.int get linksRetried => $_getIZ(0);
+  @$pb.TagNumber(1)
+  set linksRetried($core.int value) => $_setUnsignedInt32(0, value);
+  @$pb.TagNumber(1)
+  $core.bool hasLinksRetried() => $_has(0);
+  @$pb.TagNumber(1)
+  void clearLinksRetried() => $_clearField(1);
+}
+
 const $core.bool _omitFieldNames =
     $core.bool.fromEnvironment('protobuf.omit_field_names');
 const $core.bool _omitMessageNames =