feat: Beute L3–L5 (3D-Szene, Umbauen, Durchsicht, offline) und Diktat (T7 L1)

Beute L3 Runden 2+3 und Review-Fixes:
- Glas-Holo ohne warmes Leuchten, Wanderboden-Fuss, Fokusflug mit
  Geist-Ansicht, Inhalte im Fokus, Rähmchen mit Art-Farbe beim Anheben
- Hinweis-Geometrie je Zarge nur einmal je Layout gebaut; Drehen mit
  Pointer-Capture, endet auch bei Loslassen ausserhalb (rig-pointer.ts)
- Tiefenunschärfe ab 55 fps, Leistungsprobe bei jeder Bewegungsstufe,
  Context-Loss-Listener aufgeräumt, Trefferboxen als skalierte Einheitsbox

Beute L4 Umbauen (/colonies/[id]/hive): Entwurf mit Basis-Schnappschuss
beim ersten Schritt, Rückgängig/Wiederholen, Hinweis bei Serverstand-
Änderung, Konfliktblatt.

Beute L5:
- Durchsicht-Abschnitt „Beute“: Aufbau-Änderungen in der Durchsicht,
  Blatt-Formulare stoppen das Submit-Bubbling durch Portale (sonst
  speicherte „Speichern“ im Blatt die ganze Durchsicht), Fokus nach
  Rückgängig, Folgevorschläge beim Speichern
- Offline: Beute im Offline-Paket, Warteschlange pending-hive-changes
  (DB v5), Abarbeiten in Reihenfolge, keine Online-Änderung überholt
  wartende, Hinweis bei abgelehnter Änderung mit „Warteschlange öffnen“

T7 L1 Diktat: Spracherkennungs-Kapsel (Web Speech API), Einwilligung
standardmässig aus, Diktat-Knopf an Freitextfeldern, Seite
„Sprache & Datenschutz“; axe-core als exakte devDependency.

Backend: NotificationsService liest Empfänger und schreibt in einer
Transaktion mit FOR KEY SHARE (paralleles Löschen eines Benutzers
führte zu P2003 und verzögerten Vorschlägen; Ursache der wackeligen
Endtests). Zwei e2e-Prüfungen gegen geteilten DB-Zustand entschärft.

Gates: Frontend lint, typecheck, 2740 Tests, build; Backend lint,
typecheck, 4266 Unit-Tests, build; parallele e2e 3x grün (978).
Browser-Prüfung 1280/390 px, Tastatur, offline, reduced motion.

Refs #19 #20 #21 #22 #27 #32

Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]>

ApiCore-Frontend/src/components/hive/use-hive-mutation.ts

@@ -5,11 +5,16 @@ import { useRouter } from "next/navigation";
 import { useQueryClient } from "@tanstack/react-query";
 import { berlinCalendarDay } from "@/lib/dates";
 import { ApiError } from "@/lib/auth/api-client";
+import { useCurrentUserId } from "@/lib/auth/auth-context";
 import { hiveConflictOf, hiveKeys, postHiveChange } from "@/lib/hive/api";
 import { deriveHiveFacts } from "@/lib/hive/facts";
+import { hasQueuedHiveChange } from "@/lib/hive/pending";
 import { applyHiveOps } from "@/lib/hive/ops";
 import { fetchColonyTreatments } from "@/lib/treatments/api";
+import { queueHiveChange } from "@/lib/offline/db";
 import { newIdempotencyKey } from "@/lib/offline/idempotency";
+import { syncPendingEntries } from "@/lib/offline/sync";
+import { OFFLINE_QUEUE_QUERY_KEY } from "@/lib/offline/use-capture-mutation";
 import type {
   ClientHiveChangeSource,
   HiveApplyResult,
@@ -31,7 +36,12 @@ export interface HiveConflict {
 }
 
 export interface HiveMutation {
-  submit(ops: HiveOp[], source: ClientHiveChangeSource, occurredOn?: string): Promise<HiveSetupView>;
+  /** Resolves with the saved setup; null when the change was queued and no setup is loaded to show it on. */
+  submit(
+    ops: HiveOp[],
+    source: ClientHiveChangeSource,
+    occurredOn?: string,
+  ): Promise<HiveSetupView | null>;
   conflict: HiveConflict | null;
   /** "retry" sends the ops again against the current state (new key); "discard" drops them. */
   resolveConflict(action: "retry" | "discard"): Promise<void>;
@@ -66,10 +76,14 @@ function withState(view: HiveSetupView, state: HiveState, version: number, catal
  * (optimistic); a failure refetches it. One submit at a time. An attempt keeps
  * its idempotency key across manual re-presses after a network error or 5xx;
  * a retry after a conflict gets a fresh one. Follow-up toasts are suggestions only.
+ * A card change that fails at network level goes into the offline queue
+ * `pending-hive-changes` under the same key (spec 10); the card shows it from
+ * there, so the cache keeps the state it had.
  */
 export function useHiveMutation(colonyId: string, catalog: HiveCatalog): HiveMutation {
   const queryClient = useQueryClient();
   const router = useRouter();
+  const ownerUserId = useCurrentUserId();
   const [conflict, setConflict] = useState<HiveConflict | null>(null);
   const [pendingCount, setPendingCount] = useState(0);
   const lastAttempt = useRef<Attempt | null>(null);
@@ -105,7 +119,7 @@ export function useHiveMutation(colonyId: string, catalog: HiveCatalog): HiveMut
   );
 
   const run = useCallback(
-    async (attempt: Attempt): Promise<HiveSetupView> => {
+    async (attempt: Attempt): Promise<HiveSetupView | null> => {
       if (inFlight.current) throw new Error(HIVE_BUSY_MESSAGE);
       inFlight.current = true;
       const { ops, source, occurredOn } = attempt;
@@ -117,6 +131,17 @@ export function useHiveMutation(colonyId: string, catalog: HiveCatalog): HiveMut
         // A running refetch must not overwrite the optimistic state.
         await queryClient.cancelQueries({ queryKey });
         const previous = queryClient.getQueryData<HiveSetupView>(queryKey);
+        // Behind an earlier queued change of this colony it must not overtake: queue it too,
+        // whether or not the card has a setup loaded.
+        if (ownerUserId && source === "CARD" && (await hasQueuedHiveChange(colonyId, ownerUserId))) {
+          await queueHiveChange({ colonyId, occurredOn, source, ops }, key, ownerUserId);
+          void queryClient.invalidateQueries({ queryKey: OFFLINE_QUEUE_QUERY_KEY });
+          // Online again, the queue goes out in order.
+          void syncPendingEntries(ownerUserId, { afterChange: true }).catch(() => undefined);
+          if (!previous) return null;
+          const queued = applyHiveOps(previous.state, ops, catalog);
+          return queued.ok ? withState(previous, queued.state, previous.version, catalog) : previous;
+        }
         if (previous) {
           const applied = applyHiveOps(previous.state, ops, catalog);
           if (applied.ok) {
@@ -153,6 +178,16 @@ export function useHiveMutation(colonyId: string, catalog: HiveCatalog): HiveMut
               ops,
               preview: applyHiveOps(body.current.state, ops, catalog),
             });
+          } else if (previous && ownerUserId && source === "CARD" && !(error instanceof ApiError)) {
+            // No network: queue it. The pending ops are shown on top of the loaded state.
+            await queueHiveChange({ colonyId, occurredOn, source, ops }, key, ownerUserId);
+            failedKey.current = null;
+            lastAttempt.current = null;
+            if (optimistic && queryClient.getQueryData(queryKey) === optimistic) {
+              queryClient.setQueryData(queryKey, previous);
+            }
+            void queryClient.invalidateQueries({ queryKey: OFFLINE_QUEUE_QUERY_KEY });
+            return optimistic ?? previous;
           } else {
             failedKey.current = isAmbiguousFailure(error) ? { signature, key } : null;
             // Restore only if nobody changed the cache since our optimistic write; then refetch.
@@ -168,7 +203,7 @@ export function useHiveMutation(colonyId: string, catalog: HiveCatalog): HiveMut
         setPendingCount((count) => count - 1);
       }
     },
-    [catalog, colonyId, queryClient, queryKey, suggestFollowUps],
+    [catalog, colonyId, ownerUserId, queryClient, queryKey, suggestFollowUps],
   );
 
   const submit = useCallback(