test(webapp): cover the batch position allocator with concurrent turns

The concurrency test only exercised the single-message append, which
allocates its position inside one statement. Replacing the batch
allocator's atomic `next_message_position` bump with a read-then-write
left every test passing — so the invariant that concurrent writers get
disjoint ranges was not actually covered on the path a turn takes.

Four concurrent three-message batches now assert twelve distinct
positions and that each batch's own messages stayed contiguous and in
order. Against the read-then-write version this fails on
`chat_messages_chat_position_key`, which is the constraint doing the
work rather than the application code.

Author: kathiekiwi

apps/webapp/test/dashboardAgentTranscriptStore.test.ts

@@ -174,6 +174,37 @@ describe("invariant 2: concurrent different messages get distinct positions", ()
     30_000
   );
 
+  postgresTest(
+    "concurrent batches reserve ranges that don't overlap",
+    async ({ prisma, postgresContainer }) => {
+      const chatId = "chat_concurrent_batches";
+      await boot(prisma, postgresContainer.getConnectionUri(), chatId);
+
+      // Four turns writing three messages each, all at once. The ranges have to be
+      // disjoint: if two batches read the same allocator value they collide on position.
+      const batches = Array.from({ length: 4 }, (_, batch) =>
+        Array.from({ length: 3 }, (_, index) => textMessage(`b${batch}m${index}`))
+      );
+      await Promise.all(batches.map((messages) => persistMessages(agentDb, { chatId, messages })));
+
+      const stored = await rows(prisma, chatId);
+      expect(stored).toHaveLength(12);
+      expect(new Set(stored.map((row) => row.position)).size).toBe(12);
+      // And each batch's own three messages stayed together and in order.
+      for (const [batch, messages] of batches.entries()) {
+        const positions = messages.map(
+          (message) => stored.find((row) => row.message_id === message.id)!.position
+        );
+        expect(positions, `batch ${batch}`).toEqual([
+          positions[0]!,
+          positions[0]! + 1,
+          positions[0]! + 2,
+        ]);
+      }
+    },
+    30_000
+  );
+
   postgresTest(
     "the database is what forbids two messages sharing a position",
     async ({ prisma, postgresContainer }) => {