Merge pull request 'dev' (#240) from dev into main

Reviewed-on: #240
2026-10-02 16:30:02 +00:00
parent e7d6c482ad 7e6c2fbac5
commit daaed01d02
17 changed files with 827 additions and 202 deletions
--- a/backend/db/migrations/0078_chat_visibility.sql
+++ b/backend/db/migrations/0078_chat_visibility.sql
@@ -0,0 +1,8 @@
+ALTER TABLE "projects" ADD COLUMN IF NOT EXISTS "chat_enabled" boolean NOT NULL DEFAULT true;
+--> statement-breakpoint
+CREATE TABLE "communication_hidden_rooms" (
+    "tenant_id" bigint NOT NULL REFERENCES "tenants"("id") ON DELETE CASCADE,
+    "user_id" uuid NOT NULL REFERENCES "auth_users"("id") ON DELETE CASCADE,
+    "room_key" text NOT NULL,
+    PRIMARY KEY ("tenant_id", "user_id", "room_key")
+);
--- a/backend/db/migrations/meta/_journal.json
+++ b/backend/db/migrations/meta/_journal.json
@@ -526,6 +526,13 @@
      "when": 1790899200000,
      "tag": "0077_scanner_inbox_preparation",
      "breakpoints": true
+    },
+    {
+      "idx": 75,
+      "version": "7",
+      "when": 1790985600000,
+      "tag": "0078_chat_visibility",
+      "breakpoints": true
    }
  ]
 }
--- a/backend/db/schema/communication_hidden_rooms.ts
+++ b/backend/db/schema/communication_hidden_rooms.ts
@@ -0,0 +1,10 @@
+import { bigint, pgTable, primaryKey, text, uuid } from "drizzle-orm/pg-core"
+import { authUsers } from "./auth_users"
+import { tenants } from "./tenants"
+
+// Room keys also cover collaboration bindings and not-yet-provisioned chats.
+export const communicationHiddenRooms = pgTable("communication_hidden_rooms", {
+    tenantId: bigint("tenant_id", { mode: "number" }).notNull().references(() => tenants.id, { onDelete: "cascade" }),
+    userId: uuid("user_id").notNull().references(() => authUsers.id, { onDelete: "cascade" }),
+    roomKey: text("room_key").notNull(),
+}, table => ({ pk: primaryKey({ columns: [table.tenantId, table.userId, table.roomKey] }) }))
--- a/backend/db/schema/index.ts
+++ b/backend/db/schema/index.ts
@@ -19,6 +19,7 @@ export * from "./communication_rooms"
 export * from "./communication_room_members"
 export * from "./communication_messages"
 export * from "./communication_room_reads"
+export * from "./communication_hidden_rooms"
 export * from "./contacts"
 export * from "./contracts"
 export * from "./contracttypes"
--- a/backend/db/schema/projects.ts
+++ b/backend/db/schema/projects.ts
@@ -66,6 +66,8 @@ export const projects = pgTable("projects", {

    archived: boolean("archived").notNull().default(false),

+    chatEnabled: boolean("chat_enabled").notNull().default(true),
+
    customerRef: text("customerRef"),

    updatedAt: timestamp("updated_at", { withTimezone: true }),
--- a/backend/src/modules/communication-access.ts
+++ b/backend/src/modules/communication-access.ts
@@ -15,9 +15,18 @@ export function managesProjects(req: any): boolean {
    return Boolean(req.user?.is_admin || req.hasPermission?.("organisation.projects.write"))
 }

+export function projectChatSettingError(req: any, body: Record<string, unknown>, previous = true) {
+    if (!Object.prototype.hasOwnProperty.call(body, "chatEnabled")) return null
+    if (typeof body.chatEnabled !== "boolean") return { statusCode: 400, error: "Projektchat aktiviert muss ein Wahrheitswert sein" }
+    if (body.chatEnabled !== previous && !managesProjects(req)) {
+        return { statusCode: 403, error: "Keine Berechtigung zum Ändern des Projektchats" }
+    }
+    return null
+}
+
 export async function projectChatAccess(db: any, req: any, projectId?: number) {
    const tenantId = Number(req.user?.tenant_id)
-    const conditions = [eq(projects.tenant, tenantId), eq(projects.archived, false)]
+    const conditions = [eq(projects.tenant, tenantId), eq(projects.archived, false), eq(projects.chatEnabled, true)]
    if (projectId !== undefined) conditions.push(eq(projects.id, projectId))
    const rows = await db.select().from(projects).where(and(...conditions))
    if (managesProjects(req)) return rows
--- a/backend/src/routes/communication.ts
+++ b/backend/src/routes/communication.ts
@@ -9,6 +9,7 @@ import {
    communicationRoomMembers,
    communicationRoomReads,
    communicationRooms,
+    communicationHiddenRooms,
    notificationsItems,
    projects,
 } from "../../db/schema"
@@ -244,6 +245,28 @@ export default async function communicationRoutes(server: FastifyInstance) {

    server.get("/communication/chat/status", async () => ({ ready: true, provider: "fedeo" }))

+    server.get("/communication/chat/room-preferences", async (req: any) => {
+        const tenantId = await requireTenant(req)
+        const hidden = await server.db.select({ key: communicationHiddenRooms.roomKey }).from(communicationHiddenRooms)
+            .where(and(eq(communicationHiddenRooms.tenantId, tenantId), eq(communicationHiddenRooms.userId, req.user.user_id)))
+        return { hiddenRoomKeys: hidden.map(room => room.key) }
+    })
+
+    server.put("/communication/chat/room-preferences", async (req: any, reply) => {
+        const tenantId = await requireTenant(req)
+        const { roomKey, hidden } = req.body || {}
+        if (typeof hidden !== "boolean" || typeof roomKey !== "string" || roomKey.length > 200
+            || !/^(?:[a-z0-9._=-]+|collaboration:[a-f0-9-]{36})$/.test(roomKey)) {
+            return reply.code(400).send({ error: "Ungültige Raumeinstellung" })
+        }
+        const value = { tenantId, userId: req.user.user_id, roomKey }
+        if (hidden) await server.db.insert(communicationHiddenRooms).values(value).onConflictDoNothing()
+        else await server.db.delete(communicationHiddenRooms).where(and(
+            eq(communicationHiddenRooms.tenantId, tenantId), eq(communicationHiddenRooms.userId, req.user.user_id),
+            eq(communicationHiddenRooms.roomKey, roomKey)))
+        return { roomKey, hidden }
+    })
+
    server.get("/communication/chat/users", async (req: any) => {
        const tenantId = await requireTenant(req)
        return { users: (await tenantUsers(tenantId)).map((user) => ({
--- a/backend/src/routes/resources/main.ts
+++ b/backend/src/routes/resources/main.ts
@@ -1,4 +1,5 @@
 import { validateCostCentreParent } from "../../modules/cost-centre-hierarchy.service"
+import { projectChatSettingError } from "../../modules/communication-access"
 import { FastifyInstance } from "fastify"
 import {
    eq,
@@ -942,6 +943,10 @@ export default async function resourceRoutes(server: FastifyInstance) {
            const table = config.table;

            let createData: Record<string, any> = { ...body, tenant: req.user.tenant_id, archived: false };
+            if (resource === "projects") {
+                const error = projectChatSettingError(req, createData)
+                if (error) return reply.code(error.statusCode).send({ error: error.error })
+            }

            if (resource === "members") {
                createData = normalizeMemberPayload(createData)
@@ -1095,6 +1100,11 @@ export default async function resourceRoutes(server: FastifyInstance) {
                return reply.code(404).send({ error: "Resource not found" })
            }

+            if (resource === "projects") {
+                const error = projectChatSettingError(req, body, oldRecord.chatEnabled)
+                if (error) return reply.code(error.statusCode).send({ error: error.error })
+            }
+
            let data: Record<string, any> = { ...body }
            delete data.updatedAt
            delete data.updated_at
--- a/backend/tests/chatVisibility.test.ts
+++ b/backend/tests/chatVisibility.test.ts
@@ -0,0 +1,110 @@
+import assert from "node:assert/strict"
+import test from "node:test"
+import { randomUUID } from "node:crypto"
+import { readFile } from "node:fs/promises"
+import Fastify from "fastify"
+import communicationRoutes from "../src/routes/communication"
+import resourceRoutes from "../src/routes/resources/main"
+import { projectChatSettingError } from "../src/modules/communication-access"
+import { collaborationDatabase, testDatabaseUrl } from "./helpers/collaboration-db"
+
+test("changing the project chat switch requires project management permission and a boolean", () => {
+    const member = { user: {}, hasPermission: () => false }
+    const manager = { user: {}, hasPermission: (permission: string) => permission === "organisation.projects.write" }
+    assert.equal(projectChatSettingError(member, {}), null)
+    assert.equal(projectChatSettingError(member, { chatEnabled: true }), null)
+    assert.equal(projectChatSettingError(member, { chatEnabled: false }, false), null)
+    assert.equal(projectChatSettingError(member, { chatEnabled: false })?.statusCode, 403)
+    assert.equal(projectChatSettingError(member, { chatEnabled: true }, false)?.statusCode, 403)
+    assert.equal(projectChatSettingError(manager, { chatEnabled: false }), null)
+    assert.equal(projectChatSettingError({ user: { is_admin: true } }, { chatEnabled: true }, false), null)
+    for (const invalid of [null, "false", 0, {}]) assert.equal(projectChatSettingError(manager, { chatEnabled: invalid })?.statusCode, 400)
+})
+
+test("migration keeps existing and newly created project chats enabled", { skip: !testDatabaseUrl }, async () => {
+    const fixture = await collaborationDatabase()
+    try {
+        await fixture.pool.query("ALTER TABLE projects DROP COLUMN chat_enabled")
+        await fixture.pool.query("INSERT INTO projects (id,tenant,name) VALUES (1,1,'Existing')")
+        await fixture.pool.query(await readFile(new URL("../db/migrations/0078_chat_visibility.sql", import.meta.url), "utf8"))
+        await fixture.pool.query("INSERT INTO projects (id,tenant,name) VALUES (2,1,'New')")
+        assert.deepEqual((await fixture.pool.query("SELECT chat_enabled FROM projects ORDER BY id")).rows, [{ chat_enabled: true }, { chat_enabled: true }])
+    } finally { await fixture.close() }
+})
+
+test("hidden rooms persist per user and tenant without changing room memberships", { skip: !testDatabaseUrl }, async () => {
+    const fixture = await collaborationDatabase(["0078_chat_visibility.sql"]), app = Fastify()
+    const user = randomUUID(), other = randomUUID(), collaborationKey = `collaboration:${randomUUID()}`
+    try {
+        await fixture.pool.query("INSERT INTO tenants(id,name) VALUES (1,'A'),(2,'B')")
+        await fixture.pool.query("INSERT INTO auth_users(id,email) VALUES ($1,'a@example.test'),($2,'b@example.test')", [user, other])
+        await fixture.pool.query("INSERT INTO auth_tenant_users(tenant_id,user_id) VALUES (1,$1),(2,$1),(1,$2)", [user, other])
+        app.decorate("db", fixture.db)
+        app.addHook("preHandler", async (req: any) => {
+            req.user = { tenant_id: Number(req.headers["x-tenant"] || 1), user_id: req.headers["x-user"] || user }
+            req.hasPermission = () => false
+        })
+        await app.register(communicationRoutes)
+        const url = "/communication/chat/room-preferences"
+        for (const roomKey of ["allgemein", "project_1", collaborationKey, collaborationKey]) {
+            const result = await app.inject({ method: "PUT", url, payload: { roomKey, hidden: true, userId: other, tenantId: 2 } })
+            assert.equal(result.statusCode, 200, result.body)
+        }
+        assert.deepEqual((await app.inject(url)).json().hiddenRoomKeys.sort(), ["allgemein", "project_1", collaborationKey].sort())
+        assert.deepEqual((await app.inject({ url, headers: { "x-user": other } })).json().hiddenRoomKeys, [])
+        assert.deepEqual((await app.inject({ url, headers: { "x-tenant": "2" } })).json().hiddenRoomKeys, [])
+        assert.equal((await fixture.pool.query("SELECT count(*) FROM communication_room_members")).rows[0].count, "0")
+        await app.inject({ method: "PUT", url, payload: { roomKey: collaborationKey, hidden: false } })
+        assert.deepEqual((await app.inject(url)).json().hiddenRoomKeys.sort(), ["allgemein", "project_1"])
+        for (const payload of [{ roomKey: "allgemein", hidden: "false" }, { roomKey: "../secret", hidden: true }, { roomKey: "", hidden: true }]) {
+            assert.equal((await app.inject({ method: "PUT", url, payload })).statusCode, 400)
+        }
+        await fixture.pool.query("DELETE FROM auth_tenant_users WHERE tenant_id=1 AND user_id=$1", [user])
+        assert.equal((await app.inject(url)).statusCode, 403)
+        assert.equal((await app.inject({ method: "PUT", url, payload: { roomKey: "allgemein", hidden: false } })).statusCode, 403)
+    } finally { await app.close(); await fixture.close() }
+})
+
+test("disabling in the project form blocks list, provision, reads and writes until re-enabled", { skip: !testDatabaseUrl }, async () => {
+    const fixture = await collaborationDatabase(), app = Fastify()
+    const user = randomUUID(), profile = randomUUID()
+    try {
+        await fixture.pool.query("INSERT INTO tenants(id,name) VALUES (1,'A'),(2,'B')")
+        await fixture.pool.query("INSERT INTO auth_users(id,email) VALUES ($1,'a@example.test')", [user])
+        await fixture.pool.query("INSERT INTO auth_tenant_users(tenant_id,user_id) VALUES (1,$1)", [user])
+        await fixture.pool.query("INSERT INTO auth_profiles(id,tenant_id,user_id) VALUES ($1,1,$2)", [profile, user])
+        await fixture.pool.query("INSERT INTO projects(id,tenant,name,profiles) VALUES (1,1,'Project',ARRAY[$1]::uuid[]),(2,2,'Other tenant','{}')", [profile])
+        app.decorate("db", fixture.db)
+        app.addHook("preHandler", async (req: any) => {
+            req.user = { tenant_id: 1, user_id: user, is_admin: req.headers["x-admin"] === "true" }
+            req.hasPermission = (permission: string) => permission === "organisation.projects.write" && req.headers["x-manager"] === "true"
+        })
+        await app.register(communicationRoutes)
+        await app.register(resourceRoutes)
+        const update = (chatEnabled: unknown, headers = { "x-manager": "true" }) => app.inject({ method: "PUT", url: "/resource/projects/1", headers, payload: { chatEnabled } })
+        const provision = await app.inject({ method: "POST", url: "/communication/chat/project-rooms/1/provision" })
+        assert.equal(provision.statusCode, 200, provision.body)
+        const roomId = provision.json().id
+        await fixture.pool.query("INSERT INTO communication_messages(tenant_id,room_id,author_user_id,body) VALUES (1,$1,$2,'Preserved history')", [roomId, user])
+        assert.equal((await update(false, { "x-manager": "false" })).statusCode, 403)
+        assert.equal((await update("false")).statusCode, 400)
+        assert.equal((await app.inject({ method: "PUT", url: "/resource/projects/2", headers: { "x-manager": "true" }, payload: { chatEnabled: false } })).statusCode, 404)
+        assert.equal((await update(false)).statusCode, 200)
+        assert.deepEqual((await app.inject("/communication/chat/project-rooms")).json().rooms, [])
+        assert.equal((await app.inject({ method: "POST", url: "/communication/chat/project-rooms/1/provision" })).statusCode, 404)
+        for (const suffix of ["messages", "sync", "members"]) {
+            assert.equal((await app.inject(`/communication/chat/rooms/project_1/${suffix}`)).statusCode, 404)
+            assert.equal((await app.inject({ url: `/communication/chat/rooms/project_1/${suffix}`, headers: { "x-admin": "true" } })).statusCode, 404)
+        }
+        for (const suffix of ["messages", "read"]) assert.equal((await app.inject({ method: "POST", url: `/communication/chat/rooms/project_1/${suffix}`, payload: { text: "Rejected", messageId: 1 } })).statusCode, 404)
+        assert.deepEqual((await app.inject("/communication/chat/unread")).json().rooms, {})
+        assert.equal((await update(true, { "x-manager": "false" })).statusCode, 403)
+        assert.equal((await update(true)).statusCode, 200)
+        const history = await app.inject("/communication/chat/rooms/project_1/messages")
+        assert.equal(history.statusCode, 200, history.body)
+        assert.deepEqual(history.json().messages.map(message => message.body), ["Preserved history"])
+        assert.equal((await app.inject("/communication/chat/project-rooms")).json().rooms.length, 1)
+        const create = await app.inject({ method: "POST", url: "/resource/projects", payload: { id: 3, name: "Disabled", projectNumber: "P-3", chatEnabled: false } })
+        assert.equal(create.statusCode, 403)
+    } finally { await app.close(); await fixture.close() }
+})
--- a/backend/tests/helpers/collaboration-db.ts
+++ b/backend/tests/helpers/collaboration-db.ts
@@ -25,7 +25,7 @@ export async function collaborationDatabase(migrations: string[] = []) {
                let suffix = column.primary ? " PRIMARY KEY" : ""
                if (column.name === "id" && column.getSQLType() === "uuid") suffix += " DEFAULT gen_random_uuid()"
                if (column.columnType === "PgTimestamp") suffix += " DEFAULT now()"
-                if (column.getSQLType() === "boolean") suffix += " DEFAULT false"
+                if (column.getSQLType() === "boolean") suffix += ` DEFAULT ${column.default === true ? "true" : "false"}`
                return `"${column.name}" ${column.getSQLType()}${suffix}`
            })
            await pool.query(`CREATE TABLE "${getTableName(table)}" (${columns.join(",")})`)
--- a/docs/chat-foederation-konzept.md
+++ b/docs/chat-foederation-konzept.md
@@ -285,6 +285,10 @@ Als erster nutzbarer Meilenstein wird **ein abgegrenzter Projekt-Unterraum mit e

 Unter **Kommunikation → Zusammenarbeit** können interne Teilnehmer ihre eigenen Unterräume und Einladungen öffnen. Projektverantwortliche mit `organisation.projects.write` beziehungsweise Administratoren können Unterräume verwalten und freie Partnerchats anlegen. Der Projektkopf verlinkt ebenfalls auf die Zusammenarbeit. Die Verwaltung eines Raums berechtigt weiterhin nicht zum Lesen seiner Nachrichten; nur der Ersteller wird bei der Anlage automatisch Teilnehmer.

+Unter **Kommunikation → Chat** erscheinen diese Unterräume ebenfalls in der Raumgruppe **Zusammenarbeit**, einschließlich instanzübergreifender Räume und Ungelesen-Zähler. Einladungen lassen sich dort direkt annehmen oder ablehnen; nach der Annahme öffnet sich der Raum. Nachrichten, Teilnehmer und ausdrücklich freigegebene Projektinformationen werden direkt im normalen Chat angezeigt. **Details und Freigaben** öffnet die bestehende Verwaltungsansicht für den ausgewählten Raum; **Im Chat öffnen** führt zurück. Sichtbar sind ausschließlich Räume mit eigener Teilnahme, keine lediglich verwaltbaren Räume. Interne Chaträume und Unterräume behalten ihre getrennten Berechtigungsprüfungen.
+
+Die Chatansicht nutzt die volle verfügbare Fläche. Über das Augensymbol lassen sich beliebige Räume persönlich ausblenden und unter **Ausgeblendete Räume** wieder einblenden. Diese Auswahl wird pro Benutzer und Mandant gespeichert und bleibt auf anderen Geräten erhalten; Teilnahme, Nachrichten und Benachrichtigungseinstellungen werden dadurch nicht geändert. Unter **Projekt → Bearbeiten → Projektchat aktiviert** können Projektverantwortliche den internen Projektchat für alle Teilnehmer deaktivieren. Er verschwindet aus der Chatliste und ist auch über direkte Aufrufe nicht mehr les- oder beschreibbar. Beim erneuten Aktivieren bleibt der bisherige Verlauf erhalten. Bestehende und neue Projekte starten mit aktiviertem Projektchat. Separat freigegebene Unterräume bleiben unabhängig davon verwaltbar.
+
 Einladungen unterstützen eigene Mitarbeiter, persönliche FEDEO-Kontaktadressen und Gäste ohne FEDEO-Konto. Eine Kontaktadresse bezeichnet immer genau einen Benutzer in einem Heimatmandanten. Sie lässt sich in der Zusammenarbeit kopieren. Kontakte anderer Mandanten derselben Instanz benötigen keinen Server-Server-Transport. Fremde Instanzen müssen auf beiden Seiten im jeweiligen Mandanten unter **Partnerinstanzen** freigegeben sein. Beim Empfänger erscheint ein Angebot, das ausdrücklich angenommen oder abgelehnt wird.

 Gäste erhalten ausschließlich einen Projekt-Unterraum. Der Link öffnet `/guest`; ein achtstelliger, zehn Minuten gültiger Einmalcode wird an die eingeladene Adresse geschickt. Nach fünf falschen Versuchen ist der Code gesperrt. Die eigene Gastsitzung gilt zwölf Stunden und wird nicht als reguläres FEDEO-Token akzeptiert. Für spätere Anmeldungen bietet die Gastoberfläche eine als Lesezeichen speicherbare Adresse mit öffentlicher Workspace-ID an. Ohne gewähltes Ablaufdatum gilt die Teilnahme eines Gasts 30 Tage. Der Einladungslink allein erlaubt keinen Inhaltszugriff.
@@ -297,7 +301,7 @@ Bei einem vorübergehend nicht erreichbaren Eigentümer sind bereits geladene Na

 ### Einrichtung

-1. Vor dem Backendstart die additiven Migrationen `0075_project_collaboration.sql` und `0076_collaboration_federation.sql` über den bestehenden Migrationslauf einspielen. Der Selfhost-Container führt standardmäßig `npm run migrate` aus. Bestehende interne Chats bleiben getrennt; kein vorhandener Chat wird automatisch freigegeben.
+1. Vor dem Backendstart die additiven Migrationen `0075_project_collaboration.sql`, `0076_collaboration_federation.sql` und `0078_chat_visibility.sql` über den bestehenden Migrationslauf einspielen. Der Selfhost-Container führt standardmäßig `npm run migrate` aus. Bestehende interne Chats bleiben getrennt; kein vorhandener Chat wird automatisch freigegeben.
 2. Die vorhandene `API_BASE_URL` wird als Föderationsadresse verwendet, einschließlich des Reverse-Proxy-Präfixes, etwa `https://fedeo.example/backend`. Gastlinks werden aus deren Ursprung `https://fedeo.example` abgeleitet. Zusätzliche URL-Variablen sind im Standardbetrieb nicht nötig. Für Gastcodes und optional versendete Einladungs-E-Mails muss der bestehende SMTP-Versand funktionieren. Den vorhandenen `ENCRYPTION_KEY` beibehalten; er muss ein stabiler 64-stelliger Hex-Schlüssel sein.
 3. Der Standard ist jetzt `FEDEO_FEDERATION_ENABLED=auto`, auch wenn die Variable nicht gesetzt ist. Mit gültiger HTTPS-API-Adresse auf Port 443 und gültigem Verschlüsselungsschlüssel wird Föderation automatisch bereitgestellt. Lokale HTTP-Entwicklungsumgebungen oder unvollständige Konfigurationen bleiben ohne Föderation startfähig; die Partnerverwaltung nennt den fehlenden Konfigurationswert. `false` schaltet Föderation ausdrücklich ab. `true` erzwingt die Aktivierung und meldet eine ungültige Konfiguration bereits beim Start. Nur bei abweichender Infrastruktur `FEDEO_FEDERATION_URL` oder `FEDEO_PUBLIC_URL` setzen; beide überschreiben die automatisch abgeleiteten Werte. Ein separates Föderationsgateway verändert die Gast-Webadresse nicht automatisch.
 4. Der Proxy muss `GET <API-Adresse>/.well-known/fedeo-federation` und `POST <API-Adresse>/federation/v1/rpc` durchreichen und darf JSON-Body oder Signaturheader nicht verändern. Externe Ziele benötigen öffentlich auflösbare HTTPS-Adressen auf Port 443. Private/reservierte IPv4- und IPv6-Ziele sowie Weiterleitungen werden abgewiesen; die geprüfte DNS-Adresse wird für die TLS-Verbindung festgehalten.
--- a/frontend/components/CollaborationRoom.vue
+++ b/frontend/components/CollaborationRoom.vue
@@ -1,5 +1,5 @@
 <script setup>
-const props = defineProps({ roomId: { type: String, required: true }, api: { type: Function, required: true }, base: { type: String, default: '/api/collaboration' } })
+const props = defineProps({ roomId: { type: String, required: true }, api: { type: Function, required: true }, base: { type: String, default: '/api/collaboration' }, embedded: { type: Boolean, default: false } })
 const emit = defineEmits(['changed', 'unauthorized'])
 const room = ref(null), messages = ref([]), members = ref([]), draft = ref(''), error = ref('')
 const loading = ref(false), sending = ref(false), olderLoading = ref(false), hasMore = ref(false), viewport = ref(null)
@@ -95,9 +95,9 @@ onBeforeUnmount(() => { ++generation; clearInterval(timer) })
 </script>

 <template>
-  <section class="flex min-h-[32rem] min-w-0 flex-col rounded-xl border border-gray-200 bg-white dark:border-gray-700 dark:bg-gray-900">
+  <section class="flex min-w-0 flex-col bg-white dark:bg-gray-900" :class="embedded ? 'min-h-0 overflow-hidden' : 'min-h-[32rem] rounded-xl border border-gray-200 dark:border-gray-700'">
    <header class="border-b border-gray-200 p-4 dark:border-gray-700">
-      <h2 class="text-lg font-semibold">{{ room?.name || 'Unterraum' }}</h2>
+      <div class="flex flex-wrap items-center justify-between gap-2"><h2 class="text-lg font-semibold">{{ room?.name || 'Unterraum' }}</h2><slot name="actions" /></div>
      <p v-if="room?.topic" class="mt-1 text-sm text-gray-500">{{ room.topic }}</p>
      <p v-if="members.length" class="mt-2 text-xs text-gray-500">{{ members.map(m => `${m.name}${m.kind === 'guest' ? ' (Gast)' : ''}`).join(' · ') }}</p>
    </header>
@@ -110,7 +110,7 @@ onBeforeUnmount(() => { ++generation; clearInterval(timer) })
      <p v-if="room.overview.date">Termin: {{ room.overview.date }}</p>
      <p v-if="room.overview.description" class="mt-1 whitespace-pre-wrap">{{ room.overview.description }}</p>
    </div>
-    <div ref="viewport" class="max-h-[60vh] min-h-[18rem] flex-1 space-y-3 overflow-y-auto p-4" aria-live="polite">
+    <div ref="viewport" class="flex-1 space-y-3 overflow-y-auto p-4" :class="embedded ? 'min-h-0' : 'max-h-[60vh] min-h-[18rem]'" aria-live="polite">
      <p v-if="loading" class="text-sm text-gray-500">Nachrichten werden geladen …</p>
      <button v-if="hasMore" class="block w-full text-center text-sm text-green-700 underline" :disabled="olderLoading" @click="older">{{ olderLoading ? 'Wird geladen …' : 'Ältere Nachrichten laden' }}</button>
      <p v-if="room && !loading && !messages.length" class="py-12 text-center text-sm text-gray-500">Hier beginnt eure Unterhaltung. Du siehst Nachrichten ab deinem Beitritt.</p>
--- a/frontend/pages/communication/chat.vue
+++ b/frontend/pages/communication/chat.vue
@@ -1,219 +1,274 @@
 <script setup>
 const toast = useToast()
 const { $api } = useNuxtApp()
+const auth = useAuthStore()
 const route = useRoute()
 const router = useRouter()

-const baseRooms = ref([])
-const projectRooms = ref([])
-const directRooms = ref([])
-const unreadRooms = ref({})
-const messages = ref([])
-const members = ref([])
-const draft = ref("")
-const activeRoomKey = ref(typeof route.query.room === "string" ? route.query.room : "allgemein")
-const loading = ref(true)
-const roomLoading = ref(false)
-const sending = ref(false)
-const creating = ref(false)
-const showRoomForm = ref(false)
-const messagesViewport = ref(null)
-const roomForm = reactive({ name: "", key: "", topic: "" })
-let pollTimer = null
-let pollBusy = false
-let syncAfterId = 0
-
-const normalizeRoomKey = (value) => String(value || "")
-  .toLowerCase()
-  .normalize("NFKD")
-  .replace(/[\u0300-\u036f]/g, "")
-  .replace(/ß/g, "ss")
-  .replace(/[^a-z0-9._=-]+/g, "_")
-  .replace(/_+/g, "_")
-  .replace(/^[._=-]+|[._=-]+$/g, "")
+const baseRooms = ref([]), projectRooms = ref([]), directRooms = ref([]), collaborationRooms = ref([])
+const invitations = ref([]), invitationBusy = ref(''), collaborationError = ref(''), listError = ref('')
+const unreadRooms = ref({}), messages = ref([]), members = ref([]), draft = ref('')
+const requestedRoom = () => typeof route.query.room === 'string' ? route.query.room : 'allgemein'
+const activeRoomKey = ref(requestedRoom())
+const loading = ref(true), roomLoading = ref(false), sending = ref(false), creating = ref(false)
+const showRoomForm = ref(false), messagesViewport = ref(null)
+const hiddenRoomKeys = ref([]), showHiddenRooms = ref(false), preferenceBusy = ref(''), preferenceError = ref('')
+const preferencesReady = ref(false)
+const roomForm = reactive({ name: '', key: '', topic: '' })
+const session = computed(() => `${auth.user?.id || auth.user?.user_id || ''}:${auth.activeTenant || ''}`)
+const hasSession = computed(() => !!auth.user && !!auth.activeTenant)
+let pollTimer, listTimer, pollBusy = false, mounted = false, disposed = false
+let scopeVersion = 0, roomVersion = 0, collaborationRequest = 0, nativeListRequest = 0, syncAfterId = 0
+const currentScope = version => !disposed && version === scopeVersion
+const selection = () => ({ scope: scopeVersion, version: roomVersion, key: activeRoomKey.value })
+const currentSelection = request => currentScope(request.scope) && request.version === roomVersion && request.key === activeRoomKey.value
+const errorMessage = error => error?.data?.message || error?.data?.error || 'Die Anfrage konnte nicht ausgeführt werden.'
+// Colons cannot occur in normalized internal room keys, so both room types stay unambiguous.
+const collaborationKey = id => `collaboration:${id}`
+const nativeEndpoint = (key, suffix = '') => `/api/communication/chat/rooms/${encodeURIComponent(key)}${suffix}`

+const normalizeRoomKey = value => String(value || '')
+  .toLowerCase().normalize('NFKD').replace(/[\u0300-\u036f]/g, '').replace(/ß/g, 'ss')
+  .replace(/[^a-z0-9._=-]+/g, '_').replace(/_+/g, '_').replace(/^[._=-]+|[._=-]+$/g, '')
 const roomKeyPreview = computed(() => normalizeRoomKey(roomForm.key || roomForm.name))
 const decoratedRooms = computed(() => [
-  ...baseRooms.value.map((room) => ({ ...room, group: "Räume", icon: "i-heroicons-chat-bubble-left-right" })),
-  ...projectRooms.value.map((room) => ({ ...room, group: "Projekte", icon: "i-heroicons-briefcase" })),
-  ...directRooms.value.map((room) => ({ ...room, group: "Direktnachrichten", icon: "i-heroicons-user-circle" }))
-].map((room) => ({ ...room, unread: unreadRooms.value[room.key]?.count || 0 })))
-const groupedRooms = computed(() => ["Räume", "Projekte", "Direktnachrichten"]
-  .map((label) => ({ label, rooms: decoratedRooms.value.filter((room) => room.group === label) }))
-  .filter((group) => group.rooms.length))
-const activeRoom = computed(() => decoratedRooms.value.find((room) => room.key === activeRoomKey.value) || null)
-const roomEndpoint = computed(() => `/api/communication/chat/rooms/${encodeURIComponent(activeRoomKey.value)}`)
+  ...[
+    ...baseRooms.value.map(room => ({ ...room, group: 'Räume', icon: 'i-heroicons-chat-bubble-left-right' })),
+    ...projectRooms.value.map(room => ({ ...room, group: 'Projekte', icon: 'i-heroicons-briefcase' })),
+    ...directRooms.value.map(room => ({ ...room, group: 'Direktnachrichten', icon: 'i-heroicons-user-circle' }))
+  ].map(room => ({ ...room, source: 'internal', unread: unreadRooms.value[room.key]?.count || 0 })),
+  ...collaborationRooms.value.map(room => ({ ...room, key: collaborationKey(room.id), source: 'collaboration', exists: true,
+    group: 'Zusammenarbeit', icon: 'i-heroicons-user-group', unread: room.unread || 0 }))
+])
+const visibleRooms = computed(() => decoratedRooms.value.filter(room => !hiddenRoomKeys.value.includes(room.key)))
+const hiddenRooms = computed(() => decoratedRooms.value.filter(room => hiddenRoomKeys.value.includes(room.key)))
+const groupedRooms = computed(() => ['Räume', 'Projekte', 'Direktnachrichten', 'Zusammenarbeit']
+  .map(label => ({ label, rooms: visibleRooms.value.filter(room => room.group === label) }))
+  .filter(group => group.rooms.length))
+const activeRoom = computed(() => visibleRooms.value.find(room => room.key === activeRoomKey.value) || null)
+const isCollaboration = computed(() => activeRoom.value?.source === 'collaboration')
+const isInternal = computed(() => activeRoom.value?.source === 'internal')

-const mergeMessages = (incoming) => {
-  const byId = new Map(messages.value.map((message) => [message.id, message]))
+function clearMessages() { messages.value = []; members.value = []; draft.value = ''; syncAfterId = 0; roomLoading.value = false; sending.value = false }
+function mergeMessages(incoming) {
+  const byId = new Map(messages.value.map(message => [message.id, message]))
  for (const message of incoming || []) byId.set(message.id, message)
-  messages.value = Array.from(byId.values()).sort((a, b) => Number(a.id) - Number(b.id))
-  syncAfterId = Number(messages.value.at(-1)?.id || syncAfterId)
+  messages.value = [...byId.values()].sort((a, b) => Number(a.id) - Number(b.id))
+  syncAfterId = Number(messages.value.at(-1)?.id || 0)
 }
-
-const scrollToBottom = async () => {
+const scrollToBottom = async request => {
  await nextTick()
-  if (messagesViewport.value) messagesViewport.value.scrollTop = messagesViewport.value.scrollHeight
+  if (currentSelection(request) && messagesViewport.value) messagesViewport.value.scrollTop = messagesViewport.value.scrollHeight
 }

-const loadUnread = async () => {
+async function loadUnread(scope = scopeVersion) {
+  if (!hasSession.value || !currentScope(scope)) return
  try {
-    unreadRooms.value = (await $api("/api/communication/chat/unread")).rooms || {}
-  } catch {
-    unreadRooms.value = {}
-  }
+    const result = await $api('/api/communication/chat/unread')
+    if (currentScope(scope)) unreadRooms.value = result.rooms || {}
+  } catch { /* A count failure must not interrupt an open conversation. */ }
 }
-
-const loadRoomLists = async () => {
+async function loadRoomLists(scope = scopeVersion) {
+  if (!hasSession.value || !currentScope(scope)) return
+  const request = ++nativeListRequest
+  try {
    const [rooms, projects, directs] = await Promise.all([
-    $api("/api/communication/chat/rooms"),
-    $api("/api/communication/chat/project-rooms"),
-    $api("/api/communication/chat/direct-rooms")
+      $api('/api/communication/chat/rooms'), $api('/api/communication/chat/project-rooms'), $api('/api/communication/chat/direct-rooms')
    ])
-  baseRooms.value = rooms.rooms || []
-  projectRooms.value = projects.rooms || []
-  directRooms.value = directs.rooms || []
+    if (!currentScope(scope) || request !== nativeListRequest) return
+    baseRooms.value = rooms.rooms || []; projectRooms.value = projects.rooms || []; directRooms.value = directs.rooms || []
+    listError.value = ''
+  } catch (error) { if (currentScope(scope) && request === nativeListRequest) listError.value = errorMessage(error) }
 }
-
-const markRead = async () => {
-  if (!activeRoom.value?.exists) return
+async function loadCollaboration(scope = scopeVersion) {
+  if (!hasSession.value || !currentScope(scope)) return
+  const request = ++collaborationRequest
  try {
-    await $api(`${roomEndpoint.value}/read`, {
-      method: "POST",
-      body: { messageId: Number(messages.value.at(-1)?.id || 0) }
-    })
-    unreadRooms.value = { ...unreadRooms.value, [activeRoomKey.value]: { count: 0, mentions: 0 } }
-  } catch {
-    // Der Lesestatus darf die Unterhaltung nicht blockieren.
-  }
-}
-
-const loadActiveRoom = async () => {
-  if (!activeRoom.value?.exists) return
-  roomLoading.value = true
-  syncAfterId = 0
-  try {
-    const [messageResult, memberResult] = await Promise.all([
-      $api(`${roomEndpoint.value}/messages`),
-      $api(`${roomEndpoint.value}/members`)
-    ])
-    messages.value = []
-    mergeMessages(messageResult.messages || [])
-    members.value = memberResult.members || []
-    await markRead()
-    await scrollToBottom()
+    const result = await $api('/api/collaboration')
+    if (!currentScope(scope) || request !== collaborationRequest) return
+    // Managed rooms alone never grant chat access. Only explicit memberships enter this list.
+    collaborationRooms.value = result.rooms || []; invitations.value = result.invitations || []
+    collaborationError.value = ''
  } catch (error) {
-    toast.add({ title: error?.data?.error || "Chatraum konnte nicht geladen werden", color: "error" })
-  } finally {
-    roomLoading.value = false
+    if (!currentScope(scope) || request !== collaborationRequest) return
+    collaborationError.value = errorMessage(error)
+    if ([401, 403].includes(error?.statusCode || error?.status)) { collaborationRooms.value = []; invitations.value = [] }
  }
 }
+async function refreshLists() {
+  const scope = scopeVersion
+  await Promise.all([loadRoomLists(scope), loadUnread(scope), loadCollaboration(scope)])
+}

-const provisionRoom = async (room) => {
-  const endpoint = room.type === "project"
+async function loadRoomPreferences(scope = scopeVersion) {
+  if (!hasSession.value || !currentScope(scope)) return
+  try {
+    const result = await $api('/api/communication/chat/room-preferences')
+    if (!currentScope(scope)) return
+    hiddenRoomKeys.value = result.hiddenRoomKeys || []
+    preferencesReady.value = true; preferenceError.value = ''
+  } catch (error) {
+    if (currentScope(scope)) preferenceError.value = errorMessage(error)
+  }
+}
+async function setRoomHidden(room, hidden) {
+  if (preferenceBusy.value || !preferencesReady.value) return
+  const scope = scopeVersion
+  preferenceBusy.value = room.key
+  try {
+    await $api('/api/communication/chat/room-preferences', { method: 'PUT', body: { roomKey: room.key, hidden } })
+    if (!currentScope(scope)) return
+    hiddenRoomKeys.value = hidden
+      ? [...new Set([...hiddenRoomKeys.value, room.key])]
+      : hiddenRoomKeys.value.filter(key => key !== room.key)
+    if (hidden && activeRoomKey.value === room.key) {
+      ++roomVersion; activeRoomKey.value = ''; clearMessages()
+      const next = visibleRooms.value.find(candidate => candidate.exists)
+      if (next) await selectRoom(next)
+      else await router.replace({ query: { ...route.query, room: undefined } })
+    } else if (!hidden) {
+      const restored = visibleRooms.value.find(candidate => candidate.key === room.key)
+      if (restored) await selectRoom(restored)
+    }
+  } catch (error) { if (currentScope(scope)) toast.add({ title: errorMessage(error), color: 'error' }) }
+  finally { if (currentScope(scope)) preferenceBusy.value = '' }
+}
+
+async function markRead(request) {
+  if (!currentSelection(request) || !isInternal.value || !activeRoom.value?.exists) return
+  const messageId = Number(messages.value.at(-1)?.id || 0)
+  try {
+    await $api(nativeEndpoint(request.key, '/read'), { method: 'POST', body: { messageId } })
+    if (currentSelection(request)) unreadRooms.value = { ...unreadRooms.value, [request.key]: { count: 0, mentions: 0 } }
+  } catch { /* Read receipts must not interrupt the conversation. */ }
+}
+async function loadActiveRoom(request = selection()) {
+  if (!currentSelection(request) || !isInternal.value || !activeRoom.value?.exists) return
+  roomLoading.value = true
+  try {
+    const [result, people] = await Promise.all([
+      $api(nativeEndpoint(request.key, '/messages')), $api(nativeEndpoint(request.key, '/members'))
+    ])
+    if (!currentSelection(request)) return
+    messages.value = []; mergeMessages(result.messages); members.value = people.members || []
+    await markRead(request); await scrollToBottom(request)
+  } catch (error) {
+    if (currentSelection(request)) toast.add({ title: errorMessage(error), color: 'error' })
+  } finally { if (currentSelection(request)) roomLoading.value = false }
+}
+async function selectRoom(room) {
+  if (hiddenRoomKeys.value.includes(room.key)) return
+  ++roomVersion; activeRoomKey.value = room.key; clearMessages()
+  let request = selection()
+  try {
+    if (room.source !== 'collaboration' && !room.exists) {
+      const endpoint = room.type === 'project'
        ? `/api/communication/chat/project-rooms/${room.projectId}/provision`
        : `/api/communication/chat/direct-rooms/${encodeURIComponent(room.userId)}/provision`
-  const created = await $api(endpoint, { method: "POST" })
-  await loadRoomLists()
-  activeRoomKey.value = created.key
-  await router.replace({ query: { ...route.query, room: created.key } })
-}
-
-const selectRoom = async (room) => {
-  try {
-    if (!room.exists) await provisionRoom(room)
-    else {
-      activeRoomKey.value = room.key
-      await router.replace({ query: { ...route.query, room: room.key } })
-    }
-    messages.value = []
-    members.value = []
-    await loadActiveRoom()
-  } catch (error) {
-    toast.add({ title: error?.data?.error || "Chatraum konnte nicht geöffnet werden", color: "error" })
+      const created = await $api(endpoint, { method: 'POST' })
+      if (!currentSelection(request)) return
+      await loadRoomLists(request.scope)
+      if (!currentSelection(request)) return
+      activeRoomKey.value = created.key; request = selection()
    }
+    await router.replace({ query: { ...route.query, room: request.key } })
+    if (currentSelection(request)) await loadActiveRoom(request)
+  } catch (error) { if (currentSelection(request)) toast.add({ title: errorMessage(error), color: 'error' }) }
 }
-
-const createRoom = async () => {
-  if (!roomForm.name.trim()) return
+async function createRoom() {
+  if (!roomForm.name.trim() || creating.value) return
+  const scope = scopeVersion
  creating.value = true
  try {
-    const created = await $api("/api/communication/chat/rooms", {
-      method: "POST",
-      body: { name: roomForm.name, key: roomKeyPreview.value, topic: roomForm.topic }
+    const created = await $api('/api/communication/chat/rooms', {
+      method: 'POST', body: { name: roomForm.name, key: roomKeyPreview.value, topic: roomForm.topic }
    })
-    Object.assign(roomForm, { name: "", key: "", topic: "" })
-    showRoomForm.value = false
-    await loadRoomLists()
-    await selectRoom(created)
-  } catch (error) {
-    toast.add({ title: error?.data?.error || "Chatraum konnte nicht erstellt werden", color: "error" })
-  } finally {
-    creating.value = false
-  }
+    if (!currentScope(scope)) return
+    Object.assign(roomForm, { name: '', key: '', topic: '' }); showRoomForm.value = false
+    await loadRoomLists(scope)
+    if (currentScope(scope)) await selectRoom(created)
+  } catch (error) { if (currentScope(scope)) toast.add({ title: errorMessage(error), color: 'error' }) }
+  finally { if (currentScope(scope)) creating.value = false }
 }
-
-const sendMessage = async () => {
-  const text = draft.value.trim()
-  if (!text || sending.value || !activeRoom.value?.exists) return
-  sending.value = true
-  draft.value = ""
+async function respondToInvitation(id, accept) {
+  if (invitationBusy.value) return
+  const scope = scopeVersion
+  invitationBusy.value = id
  try {
-    const message = await $api(`${roomEndpoint.value}/messages`, { method: "POST", body: { text } })
-    mergeMessages([message])
-    await markRead()
-    await scrollToBottom()
-  } catch (error) {
-    draft.value = text
-    toast.add({ title: error?.data?.error || "Nachricht konnte nicht gesendet werden", color: "error" })
-  } finally {
-    sending.value = false
-  }
+    const result = await $api(`/api/collaboration/invitations/${encodeURIComponent(id)}/${accept ? 'accept' : 'decline'}`, { method: 'POST' })
+    if (!currentScope(scope)) return
+    await loadCollaboration(scope)
+    if (!currentScope(scope)) return
+    const room = decoratedRooms.value.find(room => room.key === collaborationKey(result.roomId))
+    if (accept && room) await selectRoom(room)
+  } catch (error) { if (currentScope(scope)) toast.add({ title: errorMessage(error), color: 'error' }) }
+  finally { if (currentScope(scope)) invitationBusy.value = '' }
 }
-
-const pollMessages = async () => {
-  if (pollBusy || document.hidden || !activeRoom.value?.exists) return
+async function sendMessage() {
+  const text = draft.value.trim(), request = selection()
+  if (!text || sending.value || !isInternal.value || !activeRoom.value?.exists) return
+  sending.value = true; draft.value = ''
+  try {
+    const message = await $api(nativeEndpoint(request.key, '/messages'), { method: 'POST', body: { text } })
+    if (!currentSelection(request)) return
+    mergeMessages([message]); await markRead(request); await scrollToBottom(request)
+  } catch (error) {
+    if (currentSelection(request)) { draft.value = text; toast.add({ title: errorMessage(error), color: 'error' }) }
+  } finally { if (currentSelection(request)) sending.value = false }
+}
+async function pollMessages() {
+  if (pollBusy || loading.value || roomLoading.value || document.hidden || !isInternal.value || !activeRoom.value?.exists) return
+  const request = selection()
  pollBusy = true
  try {
-    const result = await $api(`${roomEndpoint.value}/sync?afterId=${syncAfterId}`)
-    if (result.messages?.length) {
-      mergeMessages(result.messages)
-      await markRead()
-      await scrollToBottom()
-    }
-    await loadUnread()
-  } catch {
-    // Beim nächsten Intervall erneut versuchen.
-  } finally {
-    pollBusy = false
-  }
-}
-
-const formatMessageTime = (timestamp) => new Intl.DateTimeFormat("de-DE", {
-  day: "2-digit", month: "2-digit", hour: "2-digit", minute: "2-digit"
-}).format(new Date(timestamp))
-
-onMounted(async () => {
-  try {
-    await Promise.all([loadRoomLists(), loadUnread()])
-    if (!activeRoom.value) activeRoomKey.value = "allgemein"
-    await loadActiveRoom()
-    pollTimer = window.setInterval(pollMessages, 2500)
+    const result = await $api(nativeEndpoint(request.key, `/sync?afterId=${syncAfterId}`))
+    if (!currentSelection(request)) return
+    if (result.messages?.length) { mergeMessages(result.messages); await markRead(request); await scrollToBottom(request) }
+    await loadUnread(request.scope)
  } catch (error) {
-    toast.add({ title: error?.data?.error || "Chat konnte nicht geladen werden", color: "error" })
-  } finally {
-    loading.value = false
+    if (currentSelection(request) && [401, 403, 404, 410].includes(error?.statusCode || error?.status)) {
+      ++roomVersion; clearMessages(); void loadRoomLists(request.scope)
    }
-})
+  } finally { pollBusy = false }
+}
+const formatMessageTime = timestamp => new Intl.DateTimeFormat('de-DE', { day: '2-digit', month: '2-digit', hour: '2-digit', minute: '2-digit' }).format(new Date(timestamp))

-onBeforeUnmount(() => {
-  if (pollTimer) window.clearInterval(pollTimer)
+async function initialize() {
+  const scope = ++scopeVersion
+  ++roomVersion; clearMessages()
+  baseRooms.value = []; projectRooms.value = []; directRooms.value = []; collaborationRooms.value = []; invitations.value = []
+  unreadRooms.value = {}; invitationBusy.value = ''; collaborationError.value = ''; listError.value = ''; creating.value = false
+  hiddenRoomKeys.value = []; showHiddenRooms.value = false; preferenceBusy.value = ''; preferenceError.value = ''; preferencesReady.value = false
+  showRoomForm.value = false; Object.assign(roomForm, { name: '', key: '', topic: '' })
+  activeRoomKey.value = requestedRoom(); loading.value = true
+  await Promise.all([refreshLists(), loadRoomPreferences(scope)])
+  if (!currentScope(scope)) return
+  loading.value = false
+  const room = activeRoom.value || (activeRoomKey.value === 'allgemein' ? visibleRooms.value.find(room => room.exists) : null)
+  if (room) await selectRoom(room)
+}
+watch(session, () => { if (mounted) void initialize() }, { flush: 'sync' })
+watch(() => activeRoom.value?.key, (key, previous) => {
+  if (!key && previous && !loading.value) { ++roomVersion; clearMessages() }
 })
+watch(() => route.query.room, () => {
+  if (!mounted || loading.value || requestedRoom() === activeRoomKey.value) return
+  const room = visibleRooms.value.find(room => room.key === requestedRoom())
+  if (room) void selectRoom(room)
+  else { ++roomVersion; activeRoomKey.value = requestedRoom(); clearMessages() }
+})
+onMounted(() => {
+  mounted = true; void initialize()
+  pollTimer = window.setInterval(pollMessages, 2500)
+  listTimer = window.setInterval(() => { if (!document.hidden && !loading.value) void refreshLists() }, 15000)
+})
+onBeforeUnmount(() => { disposed = true; ++scopeVersion; ++roomVersion; clearInterval(pollTimer); clearInterval(listTimer) })
 </script>

 <template>
-  <div class="flex min-h-0 flex-1 bg-gray-50 p-4 sm:p-6">
-    <div class="mx-auto grid h-[calc(100vh-8rem)] w-full max-w-7xl grid-cols-1 overflow-hidden rounded-xl border border-gray-200 bg-white shadow-sm lg:grid-cols-[19rem_minmax(0,1fr)_15rem]">
+  <div class="flex h-full min-h-0 min-w-0 w-full flex-1 overflow-hidden bg-white">
+    <div class="grid h-full min-h-0 w-full flex-1 grid-cols-1 grid-rows-[minmax(8rem,30%)_minmax(0,1fr)] overflow-hidden lg:grid-rows-1"
+      :class="isCollaboration ? 'lg:grid-cols-[19rem_minmax(0,1fr)]' : 'lg:grid-cols-[19rem_minmax(0,1fr)_15rem]'">
      <aside class="min-h-0 overflow-y-auto border-r border-gray-200 p-4">
        <div class="mb-4 flex items-center justify-between">
          <div>
@@ -233,30 +288,67 @@ onBeforeUnmount(() => {
          </div>
        </form>

+        <UButton to="/communication/collaboration" icon="i-heroicons-user-group" color="neutral" variant="outline" size="xs" class="mb-4 w-full justify-center">Unterräume und Freigaben</UButton>
+        <p v-if="listError" role="alert" class="mb-3 text-xs text-red-700">{{ listError }} <button class="underline" @click="loadRoomLists()">Erneut laden</button></p>
+        <p v-if="collaborationError" role="alert" class="mb-3 text-xs text-red-700">Zusammenarbeit: {{ collaborationError }} <button class="underline" @click="loadCollaboration()">Erneut laden</button></p>
+        <p v-if="preferenceError" role="alert" class="mb-3 text-xs text-red-700">Raumeinstellungen: {{ preferenceError }} <button class="underline" @click="loadRoomPreferences()">Erneut laden</button></p>
+        <section v-if="invitations.length" class="mb-5 space-y-2" aria-label="Einladungen">
+          <h2 class="px-2 text-xs font-semibold uppercase tracking-wide text-gray-400">Einladungen</h2>
+          <div v-for="invitation in invitations" :key="invitation.id" class="rounded-lg border border-primary-200 bg-primary-50 p-3">
+            <p class="text-sm font-medium">{{ invitation.name }}</p>
+            <p class="text-xs text-gray-500">{{ invitation.ownerName }} · {{ invitation.role === 'reader' ? 'Nur lesen' : 'Lesen und schreiben' }}</p>
+            <p v-if="invitation.overviewAllowed" class="mt-1 text-xs text-gray-500">Projektübersicht freigegeben</p>
+            <div class="mt-2 flex gap-2">
+              <UButton size="xs" :disabled="!!invitationBusy" @click="respondToInvitation(invitation.id, true)">Annehmen</UButton>
+              <UButton size="xs" variant="ghost" color="neutral" :disabled="!!invitationBusy" @click="respondToInvitation(invitation.id, false)">Ablehnen</UButton>
+            </div>
+          </div>
+        </section>
+
        <div v-if="loading" class="py-8 text-center text-sm text-gray-500">Chat wird geladen …</div>
        <div v-else class="space-y-5">
          <section v-for="group in groupedRooms" :key="group.label">
            <h2 class="mb-1 px-2 text-xs font-semibold uppercase tracking-wide text-gray-400">{{ group.label }}</h2>
-            <button
+            <div
              v-for="room in group.rooms"
              :key="room.key"
-              type="button"
-              class="mb-1 flex w-full items-center gap-3 rounded-lg px-2 py-2 text-left transition hover:bg-gray-100"
+              class="mb-1 flex w-full items-center rounded-lg transition hover:bg-gray-100"
              :class="room.key === activeRoomKey ? 'bg-primary-50 text-primary-700' : 'text-gray-700'"
+            >
+              <button
+                type="button"
+                class="flex min-w-0 flex-1 items-center gap-3 px-2 py-2 text-left"
                @click="selectRoom(room)"
              >
                <UIcon :name="room.icon" class="size-5 shrink-0" />
                <span class="min-w-0 flex-1">
                  <span class="block truncate text-sm font-medium">{{ room.name }}</span>
-                <span class="block truncate text-xs text-gray-400">{{ room.topic }}</span>
+                  <span class="block truncate text-xs text-gray-400">{{ room.source === 'collaboration' ? room.ownerName || 'Projekt-Unterraum' : room.topic }}{{ room.remote ? ' · Extern' : '' }}{{ room.status === 'archived' ? ' · Archiviert' : '' }}</span>
                </span>
                <UBadge v-if="room.unread" color="primary" size="xs">{{ room.unread }}</UBadge>
              </button>
+              <UButton icon="i-heroicons-eye-slash" color="neutral" variant="ghost" size="xs" class="mr-1 shrink-0" :aria-label="`${room.name} ausblenden`" title="Für mich ausblenden" :disabled="!preferencesReady || !!preferenceBusy" @click="setRoomHidden(room, true)" />
+            </div>
+          </section>
+          <p v-if="!visibleRooms.length" class="px-2 text-sm text-gray-500">Keine sichtbaren Räume. Du kannst ausgeblendete Räume unten wieder einblenden.</p>
+          <section v-if="hiddenRooms.length" aria-label="Ausgeblendete Räume">
+            <button type="button" class="flex w-full items-center justify-between px-2 py-2 text-left text-xs font-semibold text-gray-500" :aria-expanded="showHiddenRooms" @click="showHiddenRooms = !showHiddenRooms">
+              <span>Ausgeblendete Räume ({{ hiddenRooms.length }})</span><UIcon :name="showHiddenRooms ? 'i-heroicons-chevron-up' : 'i-heroicons-chevron-down'" />
+            </button>
+            <div v-if="showHiddenRooms" class="space-y-1">
+              <div v-for="room in hiddenRooms" :key="room.key" class="flex items-center gap-2 px-2 py-1">
+                <span class="min-w-0 flex-1 truncate text-sm text-gray-500">{{ room.name }}</span>
+                <UButton icon="i-heroicons-eye" variant="ghost" color="neutral" size="xs" :aria-label="`${room.name} einblenden`" :disabled="!!preferenceBusy" @click="setRoomHidden(room, false)">Einblenden</UButton>
+              </div>
+            </div>
          </section>
        </div>
      </aside>

-      <main class="flex min-h-0 flex-col">
+      <CollaborationRoom v-if="!loading && isCollaboration" :key="`${session}:${activeRoom.id}`" :room-id="activeRoom.id" :api="$api" embedded @changed="loadCollaboration()" @unauthorized="loadCollaboration()">
+        <template #actions><UButton :to="{ path: '/communication/collaboration', query: { room: activeRoom.id } }" color="neutral" variant="outline" size="xs">Details und Freigaben</UButton></template>
+      </CollaborationRoom>
+      <main v-else class="flex min-h-0 flex-col">
        <header class="border-b border-gray-200 px-5 py-4">
          <h2 class="font-semibold text-gray-900">{{ activeRoom?.name || "Chat" }}</h2>
          <p class="truncate text-sm text-gray-500">{{ activeRoom?.topic || "Wähle links einen Chatraum aus." }}</p>
@@ -264,6 +356,7 @@ onBeforeUnmount(() => {

        <div ref="messagesViewport" class="min-h-0 flex-1 overflow-y-auto px-4 py-5 sm:px-6">
          <div v-if="roomLoading" class="py-10 text-center text-sm text-gray-500">Nachrichten werden geladen …</div>
+          <div v-else-if="!activeRoom" class="py-10 text-center text-sm text-gray-500">Dieser Chatraum ist nicht verfügbar. Wähle links einen anderen Raum.</div>
          <div v-else-if="!messages.length" class="flex h-full flex-col items-center justify-center text-center text-gray-400">
            <UIcon name="i-heroicons-chat-bubble-oval-left-ellipsis" class="mb-3 size-10" />
            <p class="font-medium">Noch keine Nachrichten</p>
@@ -286,7 +379,7 @@ onBeforeUnmount(() => {
        </form>
      </main>

-      <aside class="hidden min-h-0 overflow-y-auto border-l border-gray-200 p-4 lg:block">
+      <aside v-if="!isCollaboration" class="hidden min-h-0 overflow-y-auto border-l border-gray-200 p-4 lg:block">
        <h2 class="mb-3 text-sm font-semibold text-gray-900">Teilnehmer</h2>
        <div class="space-y-3">
          <div v-for="member in members" :key="member.userId" class="flex items-center gap-3">
--- a/frontend/pages/communication/collaboration.vue
+++ b/frontend/pages/communication/collaboration.vue
@@ -2,7 +2,7 @@
 const { $api } = useNuxtApp()
 const route = useRoute()
 const state = ref({ rooms: [], invitations: [], managedRooms: [], projects: [], canManage: false, contact: '' })
-const contacts = ref([]), selected = ref(''), error = ref(''), busy = ref(false), showCreate = ref(false), showManagement = ref(false)
+const contacts = ref([]), selected = ref(typeof route.query.room === 'string' ? route.query.room : ''), error = ref(''), busy = ref(false), showCreate = ref(false), showManagement = ref(false)
 const management = ref({ members: [], invitations: [] }), inviteResult = ref(null)
 const create = reactive({ name: '', topic: '', projectId: String(route.query.project || '') })
 const invite = reactive({ kind: 'user', userId: '', name: '', email: '', contact: '', role: 'participant', overviewAllowed: false, expiresAt: '', sendEmail: true })
@@ -73,6 +73,7 @@ async function savePartner(origin, active = true) {
  })
 }
 watch(selected, () => { showManagement.value = false; inviteResult.value = null; management.value = { members: [], invitations: [] } })
+watch(() => route.query.room, id => { if (typeof id === 'string') selected.value = id })
 let timer
 onMounted(async () => { await refresh(); timer = setInterval(() => { if (!document.hidden && !busy.value) void refresh() }, 15000) })
 onBeforeUnmount(() => clearInterval(timer))
@@ -120,7 +121,10 @@ onBeforeUnmount(() => clearInterval(timer))
        </button>
      </aside>
      <div class="min-w-0 space-y-4">
+        <div class="flex flex-wrap gap-2">
+          <UButton v-if="readable" :to="{ path: '/communication/chat', query: { room: `collaboration:${selected}` } }" variant="outline">Im Chat öffnen</UButton>
          <UButton v-if="selectedManaged" variant="outline" :disabled="busy" @click="run(async () => { await loadManagement(); showManagement = !showManagement })">Teilnehmer und Freigaben verwalten</UButton>
+        </div>
        <section v-if="showManagement && selectedManaged" class="space-y-5 rounded-xl border border-gray-200 p-4 dark:border-gray-700">
          <form class="space-y-3" @submit.prevent="invitePerson">
            <h2 class="font-semibold">Person in diesen Unterraum einladen</h2>
--- a/frontend/stores/data.js
+++ b/frontend/stores/data.js
@@ -1717,6 +1717,16 @@ export const useDataStore = defineStore('data', () => {
                    key: "customerRef",
                    label: "Referenz des Kunden",
                    inputType: "text"
+                },{
+                    key: "chatEnabled",
+                    label: "Projektchat aktiviert",
+                    inputType: "bool",
+                    component: active,
+                    defaultValue: true,
+                    disabledFunction: () => {
+                        const auth = useAuthStore()
+                        return !auth.user?.is_admin && !auth.hasPermission('organisation.projects.write')
+                    }
                },{
                    key: "notes",
                    label: "Notizen",
--- a/frontend/tests/chat-collaboration.test.cjs
+++ b/frontend/tests/chat-collaboration.test.cjs
@@ -0,0 +1,329 @@
+const { test } = require('node:test')
+const assert = require('node:assert/strict')
+const fs = require('node:fs')
+const vm = require('node:vm')
+const vue = require('vue')
+
+const settle = () => new Promise(setImmediate)
+const deferred = () => {
+  let resolve
+  const promise = new Promise(done => { resolve = done })
+  return { promise, resolve }
+}
+const source = fs.readFileSync(`${__dirname}/../pages/communication/chat.vue`, 'utf8').match(/<script setup>([\s\S]*?)<\/script>/)[1]
+const nativeRoom = { key: 'allgemein', name: 'Allgemein', exists: true, type: 'general' }
+const sharedRoom = { id: 'shared-room', name: 'Partnerchat', remote: true, unread: 3 }
+
+function fixture(override = () => undefined) {
+  return async (url, options) => {
+    const result = override(url, options)
+    if (result !== undefined) return result
+    if (url === '/api/collaboration') return { rooms: [sharedRoom], invitations: [], managedRooms: [{ id: 'admin-only' }] }
+    if (url === '/api/communication/chat/room-preferences') return { hiddenRoomKeys: [] }
+    if (url === '/api/communication/chat/rooms') return { rooms: [nativeRoom] }
+    if (url.endsWith('/project-rooms') || url.endsWith('/direct-rooms')) return { rooms: [] }
+    if (url.endsWith('/unread')) return { rooms: { allgemein: { count: 2 } } }
+    if (url.endsWith('/members')) return { members: [{ userId: 'member', displayName: 'Kollege' }] }
+    if (url.includes('/sync?')) return { messages: [] }
+    if (url.endsWith('/messages')) return { messages: [{ id: 1, body: 'Interne Nachricht' }] }
+    if (url.endsWith('/read')) return {}
+    throw new Error(`Unexpected request: ${url}`)
+  }
+}
+
+function setup(api = fixture(), query = {}) {
+  const auth = vue.reactive({ user: { id: 'user-1' }, activeTenant: '1' })
+  const route = vue.reactive({ query })
+  const calls = [], toasts = [], timers = new Map()
+  let mount, unmount, timerId = 0
+  const scope = vue.effectScope()
+  const context = vm.createContext({
+    ref: vue.ref, reactive: vue.reactive, computed: vue.computed, watch: vue.watch, nextTick: vue.nextTick,
+    useToast: () => ({ add: item => toasts.push(item) }),
+    useAuthStore: () => auth, useRoute: () => route,
+    useRouter: () => ({ replace: async location => { route.query = location.query } }),
+    useNuxtApp: () => ({ $api: (url, options) => { calls.push({ url, options }); return api(url, options) } }),
+    onMounted: handler => { mount = handler }, onBeforeUnmount: handler => { unmount = handler },
+    window: { setInterval: handler => { timers.set(++timerId, handler); return timerId } },
+    clearInterval: id => timers.delete(id), document: { hidden: false },
+  })
+  scope.run(() => vm.runInContext(source, context))
+  return { auth, route, calls, toasts, timers, mount, close: () => { unmount(); scope.stop() }, run: code => vm.runInContext(code, context) }
+}
+
+test('only member rooms enter normal chat, with separate keys, groups and unread counts', async t => {
+  const ui = setup()
+  t.after(ui.close)
+  await ui.run('refreshLists()')
+  assert.equal(ui.run('decoratedRooms.value.length'), 2)
+  assert.equal(ui.run('decoratedRooms.value.find(r => r.source === "collaboration").key'), 'collaboration:shared-room')
+  assert.equal(ui.run('groupedRooms.value.at(-1).label'), 'Zusammenarbeit')
+  assert.equal(ui.run('decoratedRooms.value.at(-1).unread'), 3)
+  assert.equal(ui.run('decoratedRooms.value[0].unread'), 2)
+  assert.equal(ui.run('decoratedRooms.value.some(r => r.id === "admin-only")'), false)
+})
+
+test('opening a collaboration deep link never provisions, reads or sends through native chat APIs', async t => {
+  const ui = setup(fixture(), { room: 'collaboration:shared-room' })
+  t.after(ui.close)
+  ui.mount()
+  await settle()
+  assert.equal(ui.run('isCollaboration.value'), true)
+  assert.equal(ui.route.query.room, 'collaboration:shared-room')
+  ui.run('draft.value = "Partnernachricht"')
+  await ui.run('pollMessages()')
+  await ui.run('sendMessage()')
+  assert.equal(ui.calls.some(({ url }) => url.startsWith('/api/communication/chat/rooms/')), false)
+  ui.route.query = { room: 'allgemein' }
+  await settle()
+  assert.equal(ui.run('isInternal.value'), true)
+  assert.equal(ui.run('messages.value[0].body'), 'Interne Nachricht')
+  ui.route.query = { room: 'collaboration:shared-room' }
+  await settle()
+  assert.equal(ui.run('isCollaboration.value'), true)
+  assert.equal(ui.run('messages.value.length'), 0)
+})
+
+test('accepting an invitation opens the returned local binding and clears the invitation', async t => {
+  let accepted = false
+  const ui = setup(fixture(url => {
+    if (url === '/api/collaboration/invitations/invite/accept') { accepted = true; return { roomId: sharedRoom.id } }
+    if (url === '/api/collaboration') return { rooms: accepted ? [sharedRoom] : [], invitations: accepted ? [] : [{ id: 'invite' }] }
+  }))
+  t.after(ui.close)
+  ui.mount()
+  await settle()
+  assert.equal(ui.run('invitations.value.length'), 1)
+  await ui.run('respondToInvitation("invite", true)')
+  assert.equal(ui.run('invitations.value.length'), 0)
+  assert.equal(ui.run('isCollaboration.value'), true)
+  assert.equal(ui.route.query.room, 'collaboration:shared-room')
+  assert.equal(ui.calls.find(({ url }) => url.endsWith('/accept')).options.method, 'POST')
+})
+
+test('declining an invitation keeps the current chat open', async t => {
+  let declined = false
+  const ui = setup(fixture(url => {
+    if (url.endsWith('/invite/decline')) { declined = true; return { ok: true } }
+    if (url === '/api/collaboration') return { rooms: [], invitations: declined ? [] : [{ id: 'invite' }] }
+  }))
+  t.after(ui.close)
+  ui.mount()
+  await settle()
+  await ui.run('respondToInvitation("invite", false)')
+  assert.equal(ui.run('invitations.value.length'), 0)
+  assert.equal(ui.run('activeRoomKey.value'), 'allgemein')
+  assert.equal(ui.run('messages.value[0].body'), 'Interne Nachricht')
+})
+
+test('a late native room load cannot populate a collaboration room or mark it read', async t => {
+  const pending = deferred()
+  const ui = setup(fixture(url => url.endsWith('/allgemein/messages') ? pending.promise : undefined))
+  t.after(ui.close)
+  ui.mount()
+  await settle()
+  await ui.run('selectRoom(decoratedRooms.value.find(r => r.source === "collaboration"))')
+  pending.resolve({ messages: [{ id: 99, body: 'Late private content' }] })
+  await settle()
+  assert.equal(ui.run('messages.value.length'), 0)
+  assert.equal(ui.run('members.value.length'), 0)
+  assert.equal(ui.run('roomLoading.value'), false)
+  assert.equal(ui.calls.some(({ url }) => url.endsWith('/read')), false)
+})
+
+test('late sync and send results cannot overwrite the selected collaboration room', async t => {
+  const sync = deferred(), send = deferred()
+  const ui = setup(fixture((url, options) => {
+    if (url.includes('/sync?')) return sync.promise
+    if (url.endsWith('/messages') && options?.method === 'POST') return send.promise
+  }))
+  t.after(ui.close)
+  ui.mount()
+  await settle()
+  const polling = ui.run('pollMessages()')
+  ui.run('draft.value = "Internal draft"')
+  const sending = ui.run('sendMessage()')
+  await ui.run('selectRoom(decoratedRooms.value.find(r => r.source === "collaboration"))')
+  const reads = ui.calls.filter(({ url }) => url.endsWith('/read')).length
+  sync.resolve({ messages: [{ id: 2, body: 'Late sync' }] })
+  send.resolve({ id: 3, body: 'Late sent message' })
+  await Promise.all([polling, sending])
+  assert.equal(ui.run('messages.value.length'), 0)
+  assert.equal(ui.run('draft.value'), '')
+  assert.equal(ui.run('sending.value'), false)
+  assert.equal(ui.calls.filter(({ url }) => url.endsWith('/read')).length, reads)
+})
+
+test('switching tenants clears visible content immediately and ignores older room lists', async t => {
+  const stale = deferred(), fresh = deferred()
+  let lists = 0
+  const ui = setup(fixture(url => {
+    if (url === '/api/collaboration') return ++lists === 1 ? stale.promise : fresh.promise
+  }))
+  t.after(ui.close)
+  ui.mount()
+  ui.run('messages.value = [{ id: 1, body: "Previous tenant" }]; draft.value = "Private draft"')
+  ui.auth.activeTenant = '2'
+  assert.equal(ui.run('messages.value.length'), 0)
+  assert.equal(ui.run('collaborationRooms.value.length'), 0)
+  assert.equal(ui.run('draft.value'), '')
+  assert.equal(ui.run('session.value'), 'user-1:2')
+  fresh.resolve({ rooms: [{ id: 'tenant-2' }], invitations: [] })
+  await settle()
+  stale.resolve({ rooms: [{ id: 'tenant-1-secret' }], invitations: [{ id: 'private-invite' }] })
+  await settle()
+  assert.equal(ui.run('collaborationRooms.value[0].id'), 'tenant-2')
+  assert.equal(ui.run('invitations.value.length'), 0)
+})
+
+test('collaboration and internal service failures do not block the other room type', async t => {
+  const ui = setup(fixture(url => {
+    if (url === '/api/collaboration') throw { statusCode: 503, data: { message: 'Unterräume nicht erreichbar' } }
+  }))
+  t.after(ui.close)
+  ui.mount()
+  await settle()
+  assert.equal(ui.run('isInternal.value'), true)
+  assert.equal(ui.run('messages.value.length'), 1)
+  assert.equal(ui.run('collaborationError.value'), 'Unterräume nicht erreichbar')
+  const other = setup(fixture(url => {
+    if (url === '/api/communication/chat/rooms') throw { statusCode: 409, data: { message: 'Chat nicht verfügbar' } }
+  }), { room: 'collaboration:shared-room' })
+  t.after(other.close)
+  other.mount()
+  await settle()
+  assert.equal(other.run('isCollaboration.value'), true)
+  assert.equal(other.run('listError.value'), 'Chat nicht verfügbar')
+})
+
+test('revoked membership removes the active collaboration room instead of exposing managed rooms', async t => {
+  let revoked = false
+  const ui = setup(fixture(url => {
+    if (url === '/api/collaboration' && revoked) return { rooms: [], invitations: [], managedRooms: [sharedRoom] }
+  }), { room: 'collaboration:shared-room' })
+  t.after(ui.close)
+  ui.mount()
+  await settle()
+  assert.equal(ui.run('isCollaboration.value'), true)
+  revoked = true
+  await ui.run('loadCollaboration()')
+  assert.equal(ui.run('activeRoom.value'), null)
+  assert.equal(ui.run('isCollaboration.value'), false)
+  assert.equal(ui.run('isInternal.value'), false)
+})
+
+test('logout clears the room and invitations without starting requests with the previous credentials', async t => {
+  const ui = setup(fixture(), { room: 'collaboration:shared-room' })
+  t.after(ui.close)
+  ui.mount()
+  await settle()
+  const calls = ui.calls.length
+  ui.auth.user = null
+  await settle()
+  await ui.run('refreshLists()')
+  assert.equal(ui.run('activeRoom.value'), null)
+  assert.equal(ui.run('invitations.value.length'), 0)
+  assert.equal(ui.calls.length, calls)
+})
+
+test('unmount cancels both polling timers and ignores pending lists', async () => {
+  const pending = deferred()
+  const ui = setup(fixture(url => url === '/api/collaboration' ? pending.promise : undefined))
+  ui.mount()
+  assert.equal(ui.timers.size, 2)
+  ui.close()
+  pending.resolve({ rooms: [sharedRoom], invitations: [] })
+  await settle()
+  assert.equal(ui.timers.size, 0)
+  assert.equal(ui.run('collaborationRooms.value.length'), 0)
+  assert.equal(ui.run('messages.value.length'), 0)
+})
+
+test('hiding the active room persists the preference, switches away and allows restoring it', async t => {
+  const ui = setup()
+  t.after(ui.close)
+  ui.mount()
+  await settle()
+  await ui.run('setRoomHidden(activeRoom.value, true)')
+  assert.equal(ui.run('hiddenRooms.value[0].key'), 'allgemein')
+  assert.equal(ui.run('visibleRooms.value.some(room => room.key === "allgemein")'), false)
+  assert.equal(ui.run('isCollaboration.value'), true)
+  assert.equal(ui.run('messages.value.length'), 0)
+  const save = ui.calls.find(call => call.url.endsWith('/room-preferences') && call.options?.method === 'PUT')
+  assert.equal(save.options.body.roomKey, 'allgemein')
+  assert.equal(save.options.body.hidden, true)
+  await ui.run('setRoomHidden(hiddenRooms.value[0], false)')
+  assert.equal(ui.run('hiddenRooms.value.length'), 0)
+  assert.equal(ui.run('activeRoomKey.value'), 'allgemein')
+  assert.equal(ui.run('messages.value[0].body'), 'Interne Nachricht')
+})
+
+test('saved hidden rooms stay hidden on reload, including federated room deep links', async t => {
+  const ui = setup(fixture(url => url.endsWith('/room-preferences') ? { hiddenRoomKeys: ['collaboration:shared-room', 'allgemein'] } : undefined), { room: 'collaboration:shared-room' })
+  t.after(ui.close)
+  ui.mount()
+  await settle()
+  assert.equal(ui.run('visibleRooms.value.length'), 0)
+  assert.equal(ui.run('activeRoom.value'), null)
+  assert.equal(ui.calls.some(({ url }) => /\/rooms\/.+\/(messages|read)/.test(url)), false)
+  await ui.run('selectRoom(decoratedRooms.value[0])')
+  assert.equal(ui.run('activeRoom.value'), null)
+  await ui.run('setRoomHidden(hiddenRooms.value.find(r => r.source === "collaboration"), false)')
+  assert.equal(ui.run('isCollaboration.value'), true)
+})
+
+test('preference save failure leaves the active conversation and list unchanged', async t => {
+  const ui = setup(fixture((url, options) => {
+    if (url.endsWith('/room-preferences') && options?.method === 'PUT') throw { data: { message: 'Speichern fehlgeschlagen' } }
+  }))
+  t.after(ui.close)
+  ui.mount()
+  await settle()
+  await ui.run('setRoomHidden(activeRoom.value, true)')
+  assert.equal(ui.run('hiddenRooms.value.length'), 0)
+  assert.equal(ui.run('activeRoomKey.value'), 'allgemein')
+  assert.equal(ui.run('messages.value[0].body'), 'Interne Nachricht')
+  assert.equal(ui.toasts.at(-1).title, 'Speichern fehlgeschlagen')
+})
+
+test('pending hide operations cannot change a new tenant, and hiding the last room clears its content', async t => {
+  const pending = deferred()
+  const ui = setup(fixture((url, options) => {
+    if (url.endsWith('/room-preferences') && options?.method === 'PUT') return pending.promise
+  }))
+  t.after(ui.close)
+  ui.mount()
+  await settle()
+  const hiding = ui.run('setRoomHidden(activeRoom.value, true)')
+  ui.auth.activeTenant = '2'
+  await settle()
+  pending.resolve({ hidden: true, roomKey: 'allgemein' })
+  await hiding
+  assert.equal(ui.run('hiddenRoomKeys.value.length'), 0)
+  assert.equal(ui.run('activeRoomKey.value'), 'allgemein')
+  const single = setup(fixture(url => url === '/api/collaboration' ? { rooms: [], invitations: [] } : undefined))
+  t.after(single.close)
+  single.mount()
+  await settle()
+  await single.run('setRoomHidden(activeRoom.value, true)')
+  await settle()
+  assert.equal(single.run('activeRoom.value'), null)
+  assert.equal(single.run('messages.value.length'), 0)
+  assert.equal(single.run('members.value.length'), 0)
+  assert.equal(single.run('visibleRooms.value.length'), 0)
+})
+
+test('removing an active project from the permitted room list clears its messages and members', async t => {
+  let disabled = false
+  const ui = setup(fixture(url => url.endsWith('/project-rooms') ? { rooms: disabled ? [] : [{ key: 'project_1', exists: true, type: 'project' }] } : undefined), { room: 'project_1' })
+  t.after(ui.close)
+  ui.mount()
+  await settle()
+  assert.equal(ui.run('messages.value.length'), 1)
+  disabled = true
+  await ui.run('loadRoomLists()')
+  await settle()
+  assert.equal(ui.run('activeRoom.value'), null)
+  assert.equal(ui.run('messages.value.length'), 0)
+  assert.equal(ui.run('members.value.length'), 0)
+})
--- a/push-server/apps/admin/pages/instances/[id].vue
+++ b/push-server/apps/admin/pages/instances/[id].vue
@@ -82,14 +82,14 @@ async function sendTestPush() {
    });
    await Promise.all([refreshInstance(), refreshJobs(), refreshDevices()]);
    toast.add({
-      title: "Test-Push gesendet",
-      description: `${result.sent ?? 0} gesendet, ${result.failed ?? 0} fehlgeschlagen`,
-      color: result.failed ? "warning" : "success",
+      title: result.failed ? (result.sent ? "Test-Push teilweise fehlgeschlagen" : "Test-Push fehlgeschlagen") : "Test-Push gesendet",
+      description: [`${result.sent ?? 0} gesendet, ${result.failed ?? 0} fehlgeschlagen`, result.lastErrorCode, result.lastErrorMessage].filter(Boolean).join(" · "),
+      color: result.failed ? (result.sent ? "warning" : "error") : "success",
    });
  } catch (error: any) {
    toast.add({
      title: "Test-Push fehlgeschlagen",
-      description: error?.data?.message || error?.message || "Die Testnachricht konnte nicht gesendet werden.",
+      description: error?.data?.message || error?.data?.error || error?.message || "Die Testnachricht konnte nicht gesendet werden.",
      color: "error",
    });
  } finally {
@@ -246,6 +246,7 @@ async function sendTestPush() {
                  <th>Angenommen</th>
                  <th>Gesendet</th>
                  <th>Fehler</th>
+                  <th>Letzter Fehler</th>
                  <th>Erstellt</th>
                </tr>
              </thead>
@@ -256,6 +257,10 @@ async function sendTestPush() {
                  <td>{{ job.acceptedCount }}</td>
                  <td>{{ job.sentCount }}</td>
                  <td>{{ job.failedCount }}</td>
+                  <td>
+                    <div>{{ job.lastErrorCode || "-" }}</div>
+                    <div v-if="job.lastErrorMessage" class="text-sm text-gray-500">{{ job.lastErrorMessage }}</div>
+                  </td>
                  <td>{{ new Date(job.createdAt).toLocaleString() }}</td>
                </tr>
              </tbody>