@githolon/dsl 0.108.0 → 0.108.1

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.65.0
+version: 0.65.1
 
 environment:
   sdk: ^3.5.0
@@ -16,7 +16,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.9.0
+  nomos_types: ^0.10.0
   fixnum: ^1.1.1
   json_schema: ^5.2.2
   crypto: ^3.0.0

package/dart/test/acquire_session_credentials_test.dart

@@ -128,7 +128,7 @@ void main() {
             reason: 'both concurrent acquirers get the SAME session handle');
         expect(acquired[0].workspace, 'cloud-opened-ws');
         final listed = await plane.listWorkspaces();
-        expect(listed.map((w) => w['session'].toString()),
+        expect(listed.map((workspace) => workspace.session),
             contains('cloud-opened-ws'),
             reason: 'the acquired workspace is mounted on the plane');
       });

package/dart/test/acquire_session_test.dart

@@ -6,6 +6,7 @@
 import 'dart:async';
 
 import 'package:nomos_client/src/nms_generated_runtime.dart';
+import 'package:nomos_types/nomos_kernel_protocol.dart' as protocol;
 import 'package:test/test.dart';
 
 /// A fake runner: answers connect (after a real async gap, so concurrency is observable) and
@@ -13,6 +14,7 @@ import 'package:test/test.dart';
 class FakeRunner implements BridgeTransport {
   final _incoming = StreamController<Map<String, Object?>>.broadcast();
   final List<Map<String, Object?>> sent = [];
+  final List<protocol.RuntimeRequest> runtimeRequests = [];
   final List<String>
       resident; // workspaces the plane already holds (realm.list())
 
@@ -25,10 +27,11 @@ class FakeRunner implements BridgeTransport {
   }
 
   int get connectCount => sent.where((m) => m['op'] == 'connect').length;
-  int autoSyncCount(String workspace) => sent
-      .where((m) =>
-          m['op'] == 'autoSync' &&
-          ((m['args'] as Map)['session']).toString() == workspace)
+  int autoSyncCount(String workspace) => runtimeRequests
+      .where((request) =>
+          request.whichCommand() ==
+              protocol.RuntimeRequest_Command.startAutoSync &&
+          request.startAutoSync.session == workspace)
       .length;
   Map<String, Object?> connectArgs(int i) =>
       (sent.where((m) => m['op'] == 'connect').elementAt(i)['args'] as Map)
@@ -37,6 +40,56 @@ class FakeRunner implements BridgeTransport {
   @override
   Stream<Map<String, Object?>> get messages => _incoming.stream;
 
+  @override
+  Future<protocol.RuntimeResponse> invokeRuntime(
+    protocol.RuntimeRequest request,
+  ) async {
+    runtimeRequests.add(request.deepCopy());
+    final response = protocol.RuntimeResponse(
+      protocolVersion: 2,
+      requestId: request.requestId,
+    );
+    switch (request.whichCommand()) {
+      case protocol.RuntimeRequest_Command.listWorkspaces:
+        final connected = sent
+            .where((message) => message['op'] == 'connect')
+            .map(
+                (message) => ((message['args'] as Map)['workspace']).toString())
+            .toSet();
+        response.workspaceList = protocol.WorkspaceList(
+          workspaces: [
+            for (final workspace in {...resident, ...connected})
+              protocol.WorkspaceSummary(
+                session: workspace,
+                workspace: workspace,
+                residency: connected.contains(workspace)
+                    ? protocol.WorkspaceResidency.WORKSPACE_RESIDENCY_MOUNTED
+                    : protocol.WorkspaceResidency.WORKSPACE_RESIDENCY_PARKED,
+                syncPosture: protocol
+                    .WorkspaceSyncPosture.WORKSPACE_SYNC_POSTURE_LOCAL_ONLY,
+              ),
+          ],
+        );
+        break;
+      case protocol.RuntimeRequest_Command.startAutoSync:
+        response.autoSyncStarted =
+            protocol.AutoSyncStarted(session: request.startAutoSync.session);
+        break;
+      case protocol.RuntimeRequest_Command.stopAutoSync:
+        response.autoSyncStopped =
+            protocol.AutoSyncStopped(session: request.stopAutoSync.session);
+        break;
+      case protocol.RuntimeRequest_Command.closeRealm:
+        response.realmClosed = protocol.RealmClosed();
+        break;
+      default:
+        throw StateError(
+          'FakeRunner does not implement ${request.whichCommand().name}',
+        );
+    }
+    return response;
+  }
+
   @override
   void send(Map<String, Object?> message) {
     sent.add(message);
@@ -74,8 +127,7 @@ class FakeRunner implements BridgeTransport {
           result = {
             'workspace': args['workspace'],
             'head': 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
-            if (args['ifHead'] ==
-                'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa')
+            if (args['ifHead'] == 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa')
               'unchanged': true
             else
               'snapshot': 'resident-snapshot-b64',
@@ -390,16 +442,20 @@ void main() {
 
     // Before any connect: the plane-resident (parked) workspace surfaces with an explicit non-connected state.
     var list = await bridge.listWorkspaces();
-    final before = list.firstWhere((w) => w['workspace'] == 'estate');
-    expect(before['state'], 'parked',
+    final before =
+        list.firstWhere((workspace) => workspace.workspace == 'estate');
+    expect(before.residency,
+        protocol.WorkspaceResidency.WORKSPACE_RESIDENCY_PARKED,
         reason:
             'parked custody is not connected — the app must acquire it first');
 
     // After connecting it, the SAME workspace reports connected.
     await bridge.connect(workspace: 'estate', session: 'estate');
     list = await bridge.listWorkspaces();
-    final after = list.firstWhere((w) => w['workspace'] == 'estate');
-    expect(after['state'], 'connected');
+    final after =
+        list.firstWhere((workspace) => workspace.workspace == 'estate');
+    expect(after.residency,
+        protocol.WorkspaceResidency.WORKSPACE_RESIDENCY_MOUNTED);
     await bridge.dispose();
   });
 
@@ -410,8 +466,7 @@ void main() {
     final bridge = NomosBridge(runner);
     await bridge.ready;
 
-    final saved =
-        await bridge.nomosInternalSnapshotWorkspace('born-child');
+    final saved = await bridge.nomosInternalSnapshotWorkspace('born-child');
     expect(saved.workspace, 'born-child');
     expect(saved.head, 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa');
     expect(saved.snapshot, 'resident-snapshot-b64');
@@ -420,8 +475,7 @@ void main() {
         reason:
             'save-all must not acquire an unopened child or invent host authority');
 
-    final unchanged = await bridge.nomosInternalSnapshotWorkspace(
-        'born-child',
+    final unchanged = await bridge.nomosInternalSnapshotWorkspace('born-child',
         ifHead: saved.head);
     expect(unchanged.unchanged, isTrue);
     expect(unchanged.snapshot, isNull);

package/dart/test/adv_realm_interference_test.dart

@@ -21,6 +21,7 @@ import 'dart:convert';
 import 'dart:io';
 
 import 'package:nomos_client/src/nms_conformance_runtime.dart';
+import 'package:nomos_types/nomos_kernel_protocol.dart' as protocol;
 import 'package:nomos_types/src/nomos_ref.dart' show NmsInternalNomosRefs;
 import 'package:test/test.dart';
 
@@ -405,12 +406,13 @@ void main() {
             actor: 'adv-owner',
           );
       expect(outcome.born, hasLength(1));
-      expect(outcome.birthOutcomes.first['status'], 'born');
+      expect(outcome.birthOutcomes.first.status,
+          NomosBirthOutcomeStatus.BIRTH_OUTCOME_STATUS_BORN);
       final child = outcome.born.single;
 
       // the child is resident BEFORE any session opens it — listWorkspaces sees it
       final listedPre = await plane.listWorkspaces();
-      expect(listedPre.map((w) => w['workspace']), contains(child),
+      expect(listedPre.map((workspace) => workspace.workspace), contains(child),
           reason:
               'a born child is resident on the plane before it is connected');
 
@@ -552,8 +554,8 @@ void main() {
             restoreFrom: snaps['lru-3'],
             allowUnborn: true);
         final listed = await bridge.listWorkspaces();
-        final l1 = listed.firstWhere((w) => w['workspace'] == 'lru-1');
-        expect(l1['parked'], isTrue,
+        final l1 = listed.firstWhere((workspace) => workspace.workspace == 'lru-1');
+        expect(l1.residency, protocol.WorkspaceResidency.WORKSPACE_RESIDENCY_PARKED,
             reason: 'lru-1 should be LRU-parked: $listed');
 
         // (a) session ops transparently remount from the parked snapshot, state intact

package/dart/test/cluster_births_test.dart

@@ -98,8 +98,8 @@ void main() {
           reason: 'the born workspace is estate-<sha256(owner)>');
       expect(outcome.birthOutcomes, isNotEmpty,
           reason: 'the typed birth verdict rides beside born');
-      expect(outcome.birthOutcomes.first['workspace'], outcome.born.single);
-      expect(outcome.birthOutcomes.first['status'], isNotNull);
+      expect(outcome.birthOutcomes.first.workspace, outcome.born.single);
+      expect(outcome.birthOutcomes.first.hasStatus(), isTrue);
 
       // The child handle is addressable on the plane (the loop that OPENS + reads it is the dedicated test
       // below — 'born child OPENS as a sibling session ...').
@@ -121,9 +121,10 @@ void main() {
       // child genesis folds clean and the born verdict is `born` — hard-asserted, no skip.
       expect(outcome.born, hasLength(1));
       expect(outcome.birthOutcomes, hasLength(1));
-      expect(outcome.birthOutcomes.first['status'], 'born',
+      expect(outcome.birthOutcomes.first.status,
+          NomosBirthOutcomeStatus.BIRTH_OUTCOME_STATUS_BORN,
           reason: 'the child genesis (installDomain×2 + seed) folded through the child\'s own gate offline');
-      expect(outcome.birthOutcomes.first['workspace'], outcome.born.single);
+      expect(outcome.birthOutcomes.first.workspace, outcome.born.single);
     } finally {
       await harness.dispose();
     }
@@ -138,7 +139,8 @@ void main() {
     }
     final (harness, outcome) = await _birth();
     try {
-      expect(outcome.birthOutcomes.first['status'], 'born',
+      expect(outcome.birthOutcomes.first.status,
+          NomosBirthOutcomeStatus.BIRTH_OUTCOME_STATUS_BORN,
           reason: 'precondition: the child is born on the local plane');
       final child = outcome.born.single;
 
@@ -159,7 +161,7 @@ void main() {
 
       // listWorkspaces now enumerates BOTH the parent and the newly-opened born child on the one plane.
       final listed = await harness.bridge.listWorkspaces();
-      final sessions = listed.map((w) => w['session'].toString()).toSet();
+      final sessions = listed.map((workspace) => workspace.session).toSet();
       expect(sessions, contains(child),
           reason: 'listWorkspaces surfaces the born child as a live session');
       expect(sessions, contains('estate-birth'),
@@ -188,9 +190,10 @@ void main() {
     } on BirthIncomplete catch (e) {
       expect(e.failedBirths, isNotEmpty,
           reason: 'a failed birth still reports its typed per-child verdicts');
-      expect(e.failedBirths.first['status'], isNot('born'),
+      expect(e.failedBirths.first.status,
+          isNot(NomosBirthOutcomeStatus.BIRTH_OUTCOME_STATUS_BORN),
           reason: 'an unresolvable framework hash cannot yield a born child');
-      expect((e.failedBirths.first['reason'] ?? '').toString(), isNotEmpty,
+      expect(e.failedBirths.first.reason, isNotEmpty,
           reason: 'the failure carries a human-legible reason (never a silent drop)');
     } finally {
       await harness?.dispose();

package/dart/test/cluster_local_autosync_test.dart

@@ -80,7 +80,7 @@ void main() {
           const Duration(seconds: 10),
           onTimeout: () => throw StateError(
               'listWorkspaces() hung after a local-only autoSync (dispatcher monopolized)'));
-      expect(listed.map((w) => w['session'].toString()).toSet(),
+      expect(listed.map((workspace) => workspace.session).toSet(),
           containsAll(names.toSet()));
       final sibling = await harness
           .session('estate-a')

package/dart/test/cluster_scale_test.dart

@@ -12,6 +12,7 @@ library;
 import 'dart:io';
 
 import 'package:nomos_client/src/nms_conformance_runtime.dart';
+import 'package:nomos_types/nomos_kernel_protocol.dart' as protocol;
 import 'package:test/test.dart';
 
 String get _root => '${Directory.current.path}/../..';
@@ -98,9 +99,9 @@ void main() {
 
       // listWorkspaces enumerates the whole local plane — every one of the N is present + mounted.
       final listed = await harness.bridge.listWorkspaces();
-      expect(listed.map((w) => w['session'].toString()).toSet(), names.toSet(),
+      expect(listed.map((workspace) => workspace.session).toSet(), names.toSet(),
           reason: 'listWorkspaces surfaces all $_n live workspaces');
-      expect(listed.every((w) => w['mounted'] == true), isTrue,
+      expect(listed.every((workspace) => workspace.residency == protocol.WorkspaceResidency.WORKSPACE_RESIDENCY_MOUNTED), isTrue,
           reason: 'every listed workspace is mounted');
 
       // Wall-clock sanity — dozens of live workspaces must open + drive in a CI-sane budget, not minutes.

package/dart/test/dlq_session_surface_test.dart

@@ -20,15 +20,18 @@ import 'package:test/test.dart';
 
 String get _root => '${Directory.current.path}/../..';
 String get _repoEntry => '$_root/cloud/web-client/runner/node-entry.ts';
-String get _geoDeploy => '$_root/bench/scale/fixtures/estate-geo/build/estate-geo.law.usdz';
-String get _docsDeploy => '$_root/bench/scale/fixtures/surfaced/build/surfaced.law.usdz';
+String get _geoDeploy =>
+    '$_root/bench/scale/fixtures/estate-geo/build/estate-geo.law.usdz';
+String get _docsDeploy =>
+    '$_root/bench/scale/fixtures/surfaced/build/surfaced.law.usdz';
 String get _runtimeDir =>
     Platform.environment['NOMOS_DART_RUNTIME'] ??
     Platform.environment['NOMOS_OFFLINE_RUNTIME'] ??
     '${Platform.environment['HOME'] ?? ''}/.holon/runtime';
 
 String? _missingPrereq() {
-  if (!File(_repoEntry).existsSync()) return 'in-repo runner not found at $_repoEntry';
+  if (!File(_repoEntry).existsSync())
+    return 'in-repo runner not found at $_repoEntry';
   for (final e in {
     _geoDeploy: 'bench/scale/fixtures/estate-geo',
     _docsDeploy: 'bench/scale/fixtures/surfaced',
@@ -55,12 +58,14 @@ Future<T> _leg<T>(String name, Future<T> Function() body) async {
     print('✔ DLQ $name (${sw.elapsedMilliseconds}ms)');
     return r;
   } catch (e, st) {
-    throw TestFailure('DLQ $name FAILED after ${sw.elapsedMilliseconds}ms:\n$e\n$st');
+    throw TestFailure(
+        'DLQ $name FAILED after ${sw.elapsedMilliseconds}ms:\n$e\n$st');
   }
 }
 
 void main() {
-  test('DLQ: park → surface → refused retry → law fix → retry admits → discard drains',
+  test(
+      'DLQ: park → surface → refused retry → law fix → retry admits → discard drains',
       () async {
     final missing = _missingPrereq();
     if (missing != null) {
@@ -69,7 +74,9 @@ void main() {
     }
     final harness = await NomosTestHarness.cluster(
       workspaces: {
-        'writer': [_geoDeploy], // holds the estate law — where the work is authored
+        'writer': [
+          _geoDeploy
+        ], // holds the estate law — where the work is authored
         'app': [_docsDeploy], // the jammed workspace — NO estate law yet
       },
       nodeEntry: _repoEntry,
@@ -83,7 +90,8 @@ void main() {
 
       // ── LEG 1: author REAL work under the estate law, and read its full intent bytes back
       //    through the production salvage lane. ──
-      final work = await _leg('leg 1: author two writes + salvage their intent bytes', () async {
+      final work = await _leg(
+          'leg 1: author two writes + salvage their intent bytes', () async {
         Future<void> place(String name) => writer.offerOutcome(
               domain: 'estate',
               directiveId: 'placeSite',
@@ -106,26 +114,32 @@ void main() {
             .where((w) {
           try {
             final doc =
-                jsonDecode(utf8.decode(base64Decode(w['changeB64'].toString()))) as Map;
+                jsonDecode(utf8.decode(base64Decode(w['changeB64'].toString())))
+                    as Map;
             return (doc['payload'] as Map?)?['domain'] == 'estate';
           } catch (_) {
             return false;
           }
         }).toList();
         expect(pending, hasLength(2),
-            reason: 'salvage() returns the authored estate intents with their full bytes');
-        expect(pending.every((w) => (w['id'] ?? '').toString().isNotEmpty), isTrue);
+            reason:
+                'salvage() returns the authored estate intents with their full bytes');
+        expect(pending.every((w) => (w['id'] ?? '').toString().isNotEmpty),
+            isTrue);
         return pending;
       });
 
       // ── LEG 2: park both on the jammed workspace (the shape a domain rejection parks) and
       //    assert deadLetters() surfaces them with full provenance. ──
-      await _leg('leg 2: park as dead letters → deadLetters() surfaces provenance', () async {
+      await _leg(
+          'leg 2: park as dead letters → deadLetters() surfaces provenance',
+          () async {
         final r = await app.absorbSalvage(deadLetters: [
           for (final w in work)
             {
               'id': w['id'],
-              'oid': w['id'], // provenance slot; the entry is deduped/looked up by id
+              'oid': w[
+                  'id'], // provenance slot; the entry is deduped/looked up by id
               'changeB64': w['changeB64'],
               'source': 'local',
               'error': "no active installed law declares domain 'estate'",
@@ -135,32 +149,32 @@ void main() {
         final dead = await app.deadLetters();
         expect(dead, hasLength(2));
         final entry = dead.first;
-        expect(entry['domain'], 'estate',
-            reason: 'the DLQ decodes domain/directiveId provenance from the parked bytes');
-        expect(entry['directiveId'], 'placeSite');
-        expect(entry['source'], 'local');
-        expect(entry.containsKey('changeB64'), isFalse,
-            reason: 'deadLetters() is metadata-only; the bytes stay in the durable queue');
+        expect(entry.domain, 'estate',
+            reason:
+                'the DLQ decodes domain/directiveId provenance from the parked bytes');
+        expect(entry.directive, 'placeSite');
+        expect(entry.source, 'local');
       });
 
       // ── LEG 3: retry while the law is still absent — a REFUSAL, not a loss (and, regression:
       //    not a "no remote main" throw on this local-only session). ──
       final firstId = work.first['id'].toString();
-      await _leg('leg 3: retry refuses while the law is absent; the entry stays', () async {
+      await _leg(
+          'leg 3: retry refuses while the law is absent; the entry stays',
+          () async {
         final r = await app.retryDeadLetter(firstId);
-        expect(r['ok'], isFalse, reason: 'the law still cannot merge it: $r');
+        expect(r.retried, isFalse, reason: 'the law still cannot merge it: $r');
         final dead = await app.deadLetters();
-        expect(dead, hasLength(2), reason: 'a refused retry NEVER drops the work');
-        expect(
-            dead
-                .firstWhere((d) => d['id'] == firstId)['error']
-                .toString(),
+        expect(dead, hasLength(2),
+            reason: 'a refused retry NEVER drops the work');
+        expect(dead.firstWhere((d) => d.hasId() && d.id == firstId).message,
             isNotEmpty,
             reason: 'the entry carries the fresh refusal');
       });
 
       // ── LEG 4: the domain dev ships the law fix; retry UNJAMS and the work lands, readable. ──
-      await _leg('leg 4: law fix (installDomain) → retry admits → the work is on the ledger',
+      await _leg(
+          'leg 4: law fix (installDomain) → retry admits → the work is on the ledger',
           () async {
         final usda = (jsonDecode(File(_geoDeploy).readAsStringSync())
                 as Map)['packageUsda']
@@ -178,24 +192,27 @@ void main() {
           domainHash: harness.frameworkHash,
         );
         final r = await app.retryDeadLetter(firstId);
-        expect(r['ok'], isTrue, reason: 'the unjam after the law fix: $r');
+        expect(r.retried, isTrue, reason: 'the unjam after the law fix: $r');
         final dead = await app.deadLetters();
-        expect(dead, hasLength(1), reason: 'the retried entry resolved out of the queue');
-        final rows =
-            await app.query('sitesByName', {'name': 'a day of work I refuse to lose'});
-        expect(rows, hasLength(1), reason: "the user's work landed and reads back");
+        expect(dead, hasLength(1),
+            reason: 'the retried entry resolved out of the queue');
+        final rows = await app
+            .query('sitesByName', {'name': 'a day of work I refuse to lose'});
+        expect(rows, hasLength(1),
+            reason: "the user's work landed and reads back");
       });
 
       // ── LEG 5: discard is the app's explicit drop; the queue drains; a re-retry of a gone id
       //    answers a typed refusal. ──
-      await _leg('leg 5: discard drains; retry of a gone id refuses by name', () async {
+      await _leg('leg 5: discard drains; retry of a gone id refuses by name',
+          () async {
         final secondId = work[1]['id'].toString();
         final d = await app.discardDeadLetter(secondId);
-        expect(d['ok'], isTrue);
+        expect(d.removed, 1);
         expect(await app.deadLetters(), isEmpty);
         final gone = await app.retryDeadLetter(secondId);
-        expect(gone['ok'], isFalse);
-        expect(gone['error'].toString(), contains('no dead letter'));
+        expect(gone.retried, isFalse);
+        expect(gone.message, contains('no dead letter'));
       });
     } finally {
       await harness.dispose().timeout(const Duration(seconds: 30),

package/dart/test/first_app_gauntlet_test.dart

@@ -251,7 +251,7 @@ void main() {
             const Duration(seconds: 10),
             onTimeout: () => throw StateError(
                 'listWorkspaces() hung after a local-only autoSync'));
-        expect(listed.map((w) => w['session'].toString()).toSet(),
+        expect(listed.map((workspace) => workspace.session).toSet(),
             containsAll({'home', 'docs-ws', _keyed, 'reader'}));
         await home.stopAutoSync().timeout(const Duration(seconds: 10),
             onTimeout: () => throw StateError(

package/dart/test/local_sync_inert_test.dart

@@ -5,12 +5,14 @@
 @TestOn('vm')
 library;
 
+import 'dart:convert';
 import 'dart:io';
 
 import 'package:nomos_client/src/nms_conformance_runtime.dart';
+import 'package:crypto/crypto.dart' show sha256;
 import 'package:test/test.dart';
 
-import '../../../bench/scale/fixtures/estate-birth/build/dart/src/generated/home.application.dart';
+import '../../../bench/scale/fixtures/estate-birth/build/dart/src/generated/estate.application.dart';
 
 String get _root => '${Directory.current.path}/../..';
 String get _repoEntry => '$_root/cloud/web-client/runner/node-entry.ts';
@@ -54,30 +56,24 @@ void main() {
     );
     try {
       final session = harness.session(_workspace);
-      // This is a nomos_client runtime regression test, so the raw offer below is
-      // deliberate infrastructure setup. Tenant code imports the generated package
-      // application; it cannot import the private generated client implementation.
-      await nomosInternalBindHomeApplication(session, _owner);
+      final application =
+          await nomosInternalBindEstateApplication(session, _owner);
 
-      // 1-2. offer a write on the snapshot-opened local session.
-      final facts = BirthEstateWorkspacePayload(
+      // 1-2. Offer a normal generated business call on the snapshot-opened local
+      // session. This test is about local sync, not the separate child-workspace
+      // birth ceremony.
+      final bornAt = DateTime.now().toUtc().toIso8601String();
+      final facts = SeedEstateWorkspacePayload(
         owner: _owner,
-        frameworkHash: harness.frameworkHash!,
-        lawHash: harness.lawHashes(_workspace).first,
-        bornAt: DateTime.now().toUtc().toIso8601String(),
+        estateName:
+            'estate-${sha256.convert(utf8.encode(_owner)).toString().substring(0, 40)}',
+        bornAt: bornAt,
       );
-      final birth = await session.offerOutcome(
-        domain: 'home',
-        directiveId: 'birthEstateWorkspace',
-        payload: facts.nmsInternalToPayloadJson(),
-        actor: _owner,
-      );
-      expect(birth.born, hasLength(1));
+      await application.estateOwners.seedEstateWorkspace(facts);
 
-      // 3. Infrastructure assertion: inspect Nomos's private birth record through the raw harness session.
-      // Generated tenant clients deliberately do not expose this framework query.
+      // 3. Read through the generated, typed application surface.
       final before =
-          await session.query('birthRecordsByPrincipal', {'principal': _owner});
+          await application.estateOwners.estatesByOwner(owner: _owner);
       expect(before, hasLength(1),
           reason: 'the offer must be readable BEFORE sync');
       final statusBefore = await session.custodyStatus();
@@ -86,7 +82,7 @@ void main() {
 
       // 4. local-only sync — must be a no-op in EVERY observable respect.
       final summary = await session.sync(admit: true);
-      expect(summary['localOnly'], true,
+      expect(summary.localOnly, true,
           reason: 'a local:// session syncs as the documented no-op');
 
       // 5. THE REGRESSION (co2): custody unchanged, same query returns the SAME row.
@@ -95,14 +91,15 @@ void main() {
           reason:
               'local-only sync must not consume/move pending local intents');
       final after =
-          await session.query('birthRecordsByPrincipal', {'principal': _owner});
+          await application.estateOwners.estatesByOwner(owner: _owner);
       expect(after, hasLength(1),
           reason:
               'local-only sync must be observationally inert — the row must still read');
-      final beforeData = ((before.single as Map)['data'] as Map);
-      final afterData = ((after.single as Map)['data'] as Map);
-      expect(afterData['principal'], beforeData['principal'],
-          reason: 'the SAME row, byte-for-byte semantics');
+      expect(after.single.owner, before.single.owner,
+          reason: 'the SAME typed business record remains visible');
+      expect(after.single.estateName, before.single.estateName);
+      expect(after.single.bornAt, before.single.bornAt);
+      expect(after.single.ref.toString(), before.single.ref.toString());
     } finally {
       await harness.dispose();
     }