Ablage je Einheit, Stufe 2: Verwaltung und Organisationsseite (#684)

- OrgAdministration: eine neue Einheit bekommt ihren Bereich (Mitglieder:
  die Einheit samt Untereinheiten, schreiben); reservierte Namen und belegte
  Bereichs-Ids werden als Einheiten-Id abgelehnt. Uebergreifende Bereiche
  anlegen (mit Eigentuemer), Name/Zweck/geschuetzte Ordner aendern,
  Mitgliederliste ersetzen, nur leere Bereiche loeschen, nie den eigenen
  einer Einheit. Eine geloeschte Einheit verlaesst alle Mitgliederlisten;
  ihr Bereich geht nur, wenn er leer ist, sonst bleibt er ohne Eigentuemer.
  Nachruesten des eigenen Bereichs fuer Einheiten von vor #684. Alles im
  AuditLog.
- API unter /api/organisation/workspaces; die Uebersicht liefert je Bereich
  Mitglieder, Dateizahl und - von der Instanz berechnet - wer hineinkommt.
- Organisationsseite: Bereiche unter der Struktur, Bearbeitung mit
  Mitglieder-Editor, "Wer hineinkommt", Bereichskarte an der Einheit,
  Bereiche am Agenten. Sprachschluessel en/de.
- Die Nachschau nach einem Absturz bekommt die Organisation mit, sonst
  fände sie einen Aufruf in einem benannten Bereich nicht.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

src/ClawdDotNet.Web/Endpoints/OrganisationEndpoints.cs

@@ -1,5 +1,6 @@
 using ClawdDotNet.App;
 using ClawdDotNet.App.Services;
+using ClawdDotNet.Core.Config;
 using ClawdDotNet.Web.Contracts;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Http;
@@ -38,7 +39,23 @@ internal static class OrganisationEndpoints
                     a.Budget.DailyCostUsd, a.Budget.DailyTokens, a.Model))
                 .ToList();
 
-            return new OrganisationDto(units, agents, chart.Problems(), AgentAdministration.KnownTools);
+            var workspaces = chart.Workspaces
+                .OrderBy(w => w.Id, StringComparer.OrdinalIgnoreCase)
+                .Select(w => new WorkspaceDto(
+                    w.Id, w.Name, w.Purpose, w.OwnerUnitId,
+                    ReferenceEquals(chart.UnitWorkspace(w.OwnerUnitId), w),
+                    w.Members.Select(m => new WorkspaceMemberDto(m.UnitId, m.AgentId, m.Access.ToString(), m.IncludeSubUnits)).ToList(),
+                    w.ProtectedPaths,
+                    host.Organisation.FileCount(w.Id),
+                    chart.Agents
+                        .Select(a => (a.AgentId, Access: chart.AccessTo(a.AgentId, w.Id)))
+                        .Where(x => x.Access > WorkspaceAccess.None)
+                        .OrderBy(x => x.AgentId, StringComparer.OrdinalIgnoreCase)
+                        .Select(x => new WorkspaceAccessDto(x.AgentId, x.Access.ToString()))
+                        .ToList()))
+                .ToList();
+
+            return new OrganisationDto(units, agents, chart.Problems(), AgentAdministration.KnownTools, workspaces);
         });
 
         org.MapPost("/units", (AppHost host, UnitInputDto input) =>
@@ -79,12 +96,51 @@ internal static class OrganisationEndpoints
                 .ToList());
         });
 
+        MapWorkspaces(org);
+
         org.MapPost("/units/{unitId}/settings", (AppHost host, string unitId, SettingApplyDto input) =>
             Enum.TryParse<UnitSetting>(input.Setting, ignoreCase: true, out var setting)
                 ? host.Organisation.ApplySetting(unitId, setting, input.Values, input.Reason, input.DefaultValue).ToResponse()
                 : Results.BadRequest(new OutcomeDto(false, "Unknown setting.")));
     }
 
+    // ─── workspaces (#684) ───
+
+    private static void MapWorkspaces(RouteGroupBuilder org)
+    {
+        org.MapPost("/workspaces", (AppHost host, WorkspaceInputDto input) =>
+            ToMembers(input.Members ?? []) is not { } members
+                ? Results.BadRequest(new OutcomeDto(false, "Unknown access level — Read, Write or Manage."))
+                : host.Organisation.CreateWorkspace(input.Id, input.Name, input.Purpose, input.OwnerUnitId, members, input.Reason).ToResponse());
+
+        org.MapPatch("/workspaces/{workspaceId}", (AppHost host, string workspaceId, WorkspaceUpdateDto input) =>
+            host.Organisation.UpdateWorkspace(workspaceId, input.Name, input.Purpose, input.ProtectedPaths, input.Reason).ToResponse());
+
+        org.MapPut("/workspaces/{workspaceId}/members", (AppHost host, string workspaceId, WorkspaceMembersInputDto input) =>
+            ToMembers(input.Members ?? []) is not { } members
+                ? Results.BadRequest(new OutcomeDto(false, "Unknown access level — Read, Write or Manage."))
+                : host.Organisation.SetWorkspaceMembers(workspaceId, members, input.Reason).ToResponse());
+
+        org.MapDelete("/workspaces/{workspaceId}", (AppHost host, string workspaceId, string? reason) =>
+            host.Organisation.DeleteWorkspace(workspaceId, reason ?? "").ToResponse());
+
+        org.MapPost("/units/{unitId}/workspace", (AppHost host, string unitId, ReasonInputDto? input) =>
+            host.Organisation.CreateUnitWorkspace(unitId, input?.Reason ?? "").ToResponse());
+    }
+
+    /// <summary><c>null</c> when a level is not one of Read, Write, Manage.</summary>
+    private static List<WorkspaceMemberInput>? ToMembers(IReadOnlyList<WorkspaceMemberDto> members)
+    {
+        var result = new List<WorkspaceMemberInput>();
+        foreach (var member in members)
+        {
+            if (!Enum.TryParse<WorkspaceAccess>(member.Access, ignoreCase: true, out var access) || !Enum.IsDefined(access))
+                return null;
+            result.Add(new WorkspaceMemberInput(member.UnitId, member.AgentId, access, member.IncludeSubUnits));
+        }
+        return result;
+    }
+
     private static StructurePreviewDto ToDto(StructurePreview preview)
         => new(preview.AffectedAgents, preview.ToolsLost, preview.Running, preview.Problems, preview.CanApply);
 }