feat(plantare): schema v12 — bilateral signed columns + repo

Adds the deferred bilateral columns to Plantares (plantare-bilateral.md
§"Schema delta"), all nullable/defaulted so v1 local rows coexist
untouched:

- pledgeId (the shared id both parties key their row by), debtorKey /
  creditorKey, debtorSignature / creditorSignature, movementId (the
  shared hand-over Movement for the provenance DAG), remoteState
  (proposed/accepted/declined — the handshake, distinct from status),
  returnKind (similar/workHours/other, default similar) + workHours.

Repo: createPlantare grows optional bilateral params; plantareByPledgeId
looks a row up by the shared id; applyPlantareSignatures counter-stamps
an incoming accept; setPlantareRemoteState records a decline. The
JSON codec carries every new field so they ride backups.

Versioned migration is guarded/idempotent like the others; schema v12
dumped, test helper regenerated, migration test covers v1..v11 → v12.
db + data + services 295/295 green.

apps/app_seeds/test/data/plantare_test.dart

@@ -89,6 +89,70 @@ void main() {
     expect((await repo.watchPlantares().first).single.dueBy, due);
   });
 
+  test('a bilateral pledge stores keys/signatures and looks up by pledgeId',
+      () async {
+    final repo = newTestRepository(db);
+    await repo.createPlantare(
+      direction: PlantareDirection.iReturn,
+      counterparty: 'Ana',
+      pledgeId: 'pledge-1',
+      debtorKey: 'dkey',
+      creditorKey: 'ckey',
+      creditorSignature: 'csig',
+      remoteState: PlantareRemoteState.proposed,
+      returnKind: PlantareReturnKind.workHours,
+      workHours: 3,
+    );
+
+    final row = await repo.plantareByPledgeId('pledge-1');
+    expect(row, isNotNull);
+    expect(row!.debtorKey, 'dkey');
+    expect(row.creditorKey, 'ckey');
+    expect(row.creditorSignature, 'csig');
+    expect(row.debtorSignature, isNull);
+    expect(row.remoteState, PlantareRemoteState.proposed);
+    expect(row.returnKind, PlantareReturnKind.workHours);
+    expect(row.workHours, 3);
+    expect(await repo.plantareByPledgeId('nope'), isNull);
+  });
+
+  test('accepting a proposal adds the counter-stub and flips to accepted',
+      () async {
+    final repo = newTestRepository(db);
+    await repo.createPlantare(
+      direction: PlantareDirection.owedToMe,
+      pledgeId: 'pledge-2',
+      debtorKey: 'dkey',
+      creditorKey: 'ckey',
+      creditorSignature: 'csig',
+      remoteState: PlantareRemoteState.proposed,
+    );
+
+    await repo.applyPlantareSignatures(
+      pledgeId: 'pledge-2',
+      debtorSignature: 'dsig',
+      remoteState: PlantareRemoteState.accepted,
+      movementId: 'mov-1',
+    );
+
+    final row = await repo.plantareByPledgeId('pledge-2');
+    expect(row!.debtorSignature, 'dsig');
+    expect(row.creditorSignature, 'csig'); // untouched
+    expect(row.remoteState, PlantareRemoteState.accepted);
+    expect(row.movementId, 'mov-1');
+  });
+
+  test('a v1 local note keeps the bilateral columns null (defaults)', () async {
+    final repo = newTestRepository(db);
+    final id = await repo.createPlantare(direction: PlantareDirection.iReturn);
+    final row = (await repo.watchPlantares().first).single;
+    expect(row.id, id);
+    expect(row.pledgeId, isNull);
+    expect(row.debtorKey, isNull);
+    expect(row.remoteState, isNull);
+    expect(row.returnKind, PlantareReturnKind.similar); // default
+  });
+
   test('commitments survive a backup round-trip (in exportInventory/import)',
       () async {
     final repoA = newTestRepository(db);
@@ -98,6 +162,12 @@ void main() {
       varietyId: vid,
       counterparty: 'Colectivo semillero',
       owedDescription: 'una mazorca',
+      pledgeId: 'pledge-3',
+      debtorKey: 'dkey',
+      creditorKey: 'ckey',
+      debtorSignature: 'dsig',
+      creditorSignature: 'csig',
+      remoteState: PlantareRemoteState.accepted,
     );
 
     final snapshot = await repoA.exportInventory();
@@ -110,5 +180,10 @@ void main() {
     final onB = await repoB.watchPlantares().first;
     expect(onB.single.counterparty, 'Colectivo semillero');
     expect(onB.single.owedDescription, 'una mazorca');
+    // The bilateral form rides the backup too.
+    expect(onB.single.pledgeId, 'pledge-3');
+    expect(onB.single.debtorSignature, 'dsig');
+    expect(onB.single.creditorSignature, 'csig');
+    expect(onB.single.remoteState, PlantareRemoteState.accepted);
   });
 }

apps/app_seeds/test/db/migration_test.dart

@@ -11,19 +11,19 @@ void main() {
     verifier = SchemaVerifier(GeneratedHelper());
   });
 
-  test('freshly created database matches the exported schema v11', () async {
-    final schema = await verifier.schemaAt(11);
+  test('freshly created database matches the exported schema v12', () async {
+    final schema = await verifier.schemaAt(12);
     final db = AppDatabase(schema.newConnection());
-    await verifier.migrateAndValidate(db, 11);
+    await verifier.migrateAndValidate(db, 12);
     await db.close();
   });
 
-  // Every historical version upgrades cleanly to the current schema (v11).
-  for (var from = 1; from <= 10; from++) {
-    test('upgrades v$from → v11 and matches the fresh schema', () async {
+  // Every historical version upgrades cleanly to the current schema (v12).
+  for (var from = 1; from <= 11; from++) {
+    test('upgrades v$from → v12 and matches the fresh schema', () async {
       final connection = await verifier.startAt(from);
       final db = AppDatabase(connection);
-      await verifier.migrateAndValidate(db, 11);
+      await verifier.migrateAndValidate(db, 12);
       await db.close();
     });
   }

apps/app_seeds/test/db/schema/schema.dart

@@ -15,6 +15,7 @@ import 'schema_v8.dart' as v8;
 import 'schema_v9.dart' as v9;
 import 'schema_v10.dart' as v10;
 import 'schema_v11.dart' as v11;
+import 'schema_v12.dart' as v12;
 
 class GeneratedHelper implements SchemaInstantiationHelper {
   @override
@@ -42,10 +43,12 @@ class GeneratedHelper implements SchemaInstantiationHelper {
         return v10.DatabaseAtV10(db);
       case 11:
         return v11.DatabaseAtV11(db);
+      case 12:
+        return v12.DatabaseAtV12(db);
       default:
         throw MissingSchemaException(version, versions);
     }
   }
 
-  static const versions = const [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
+  static const versions = const [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];
 }