Add delete session functionality

- DELETE /api/v1/sessions/{id}: only closed sessions, user-scoped
- Returns 404 if not found/wrong user, 409 if session still open
- Deletes session_logs first, then session (no CASCADE)
- Frontend: trash button per session in SessionList (closed sessions only)
- Confirm dialog before delete, toast feedback, list reloads after

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

CLAUDE.md

@@ -55,7 +55,7 @@ Store-Methoden geben nach Mutationen immer **frisch aus der DB gelesene Objekte*
 - Nicht gefunden (`sql.ErrNoRows`) → 404
 - UNIQUE-Verletzung → 409
 
-Sentinel-Strings im Error-Message für Handler-Differenzierung: `"UNIQUE_VIOLATION:"`, `"SESSION_CLOSED"`. Diese werden mit `strings.Contains()` geprüft — kein custom error type.
+Sentinel-Strings im Error-Message für Handler-Differenzierung: `"UNIQUE_VIOLATION:"`, `"SESSION_CLOSED"`, `"SESSION_OPEN"`, `"SESSION_NOT_FOUND"`. Diese werden mit `strings.Contains()` geprüft — kein custom error type.
 
 ### Routing
 
@@ -74,6 +74,7 @@ Alle HTTP-Aufrufe gehen über `src/api/client.ts`. `ApiError` (extends Error) ha
 - `exercise_name` in `session_logs` **denormalisiert** gespeichert (damit gelöschte Übungen historische Daten nicht verwaisen lassen)
 - UNIQUE-Constraint auf `(session_id, exercise_id, set_number)`
 - Soft-Delete bei Übungen via `deleted_at` Timestamp
+- Hard-Delete bei Sessions: löscht zuerst explizit `session_logs`, dann `sessions` (kein ON DELETE CASCADE)
 
 ## Konventionen
 

backend/internal/handler/handler.go

@@ -42,6 +42,7 @@ func (h *Handler) RegisterRoutes(mux *http.ServeMux) {
 	mux.HandleFunc("GET /api/v1/sessions", h.handleListSessions)
 	mux.HandleFunc("GET /api/v1/sessions/{id}", h.handleGetSession)
 	mux.HandleFunc("PUT /api/v1/sessions/{id}/end", h.handleEndSession)
+	mux.HandleFunc("DELETE /api/v1/sessions/{id}", h.handleDeleteSession)
 
 	// Session Logs
 	mux.HandleFunc("POST /api/v1/sessions/{id}/logs", h.handleCreateLog)

backend/internal/handler/session.go

@@ -101,6 +101,38 @@ func (h *Handler) handleEndSession(w http.ResponseWriter, r *http.Request) {
 	writeJSON(w, http.StatusOK, session)
 }
 
+// handleDeleteSession handles DELETE /api/v1/sessions/{id}.
+// Löscht eine abgeschlossene Session samt aller Logs. Offene Sessions werden
+// mit 409 abgelehnt. Sessions anderer Nutzer oder nicht vorhandene Sessions
+// antworten mit 404.
+func (h *Handler) handleDeleteSession(w http.ResponseWriter, r *http.Request) {
+	uid, err := userID(r)
+	if err != nil {
+		writeError(w, http.StatusBadRequest, err.Error())
+		return
+	}
+	id, err := pathID(r, "id")
+	if err != nil {
+		writeError(w, http.StatusBadRequest, "Ungültige ID")
+		return
+	}
+
+	err = h.store.DeleteSession(id, uid)
+	if err != nil {
+		if strings.Contains(err.Error(), "SESSION_NOT_FOUND") {
+			writeError(w, http.StatusNotFound, "Session nicht gefunden")
+			return
+		}
+		if strings.Contains(err.Error(), "SESSION_OPEN") {
+			writeError(w, http.StatusConflict, "Nur abgeschlossene Sessions können gelöscht werden")
+			return
+		}
+		writeError(w, http.StatusInternalServerError, "Fehler beim Löschen der Session")
+		return
+	}
+	w.WriteHeader(http.StatusNoContent)
+}
+
 func (h *Handler) handleCreateLog(w http.ResponseWriter, r *http.Request) {
 	sessionID, err := pathID(r, "id")
 	if err != nil {

backend/internal/store/session_store.go

@@ -207,6 +207,37 @@ func (s *Store) GetLastLog(exerciseID, userID int64) (*model.LastLogResponse, er
 	return &resp, nil
 }
 
+// DeleteSession löscht eine abgeschlossene Session und alle zugehörigen Logs.
+// Gibt einen Fehler mit "SESSION_NOT_FOUND" zurück wenn die Session nicht existiert
+// oder nicht zum angegebenen Nutzer gehört. Gibt einen Fehler mit "SESSION_OPEN"
+// zurück wenn die Session noch nicht beendet wurde.
+func (s *Store) DeleteSession(id, userID int64) error {
+	var endedAt *string
+	err := s.db.QueryRow(
+		`SELECT ended_at FROM sessions WHERE id = ? AND user_id = ?`, id, userID,
+	).Scan(&endedAt)
+	if err == sql.ErrNoRows {
+		return fmt.Errorf("SESSION_NOT_FOUND: Session %d nicht gefunden", id)
+	}
+	if err != nil {
+		return fmt.Errorf("Session prüfen: %w", err)
+	}
+	if endedAt == nil {
+		return fmt.Errorf("SESSION_OPEN: Session ist noch nicht beendet")
+	}
+
+	// Logs zuerst löschen (kein ON DELETE CASCADE garantiert), dann Session
+	_, err = s.db.Exec(`DELETE FROM session_logs WHERE session_id = ?`, id)
+	if err != nil {
+		return fmt.Errorf("Session-Logs löschen: %w", err)
+	}
+	_, err = s.db.Exec(`DELETE FROM sessions WHERE id = ?`, id)
+	if err != nil {
+		return fmt.Errorf("Session löschen: %w", err)
+	}
+	return nil
+}
+
 // checkSessionOpen prüft ob eine Session offen ist.
 func (s *Store) checkSessionOpen(sessionID int64) error {
 	var endedAt *string

frontend/src/api/client.ts

@@ -189,6 +189,12 @@ export const api = {
         method: 'DELETE',
       });
     },
+
+    delete(id: number): Promise<void> {
+      return request<void>(`/api/v1/sessions/${id}`, {
+        method: 'DELETE',
+      });
+    },
   },
 
   stats: {

frontend/src/components/history/SessionList.tsx

@@ -2,12 +2,14 @@ import { useEffect, useState } from 'react';
 import { useHistoryStore } from '../../stores/historyStore';
 import { SessionDetail } from './SessionDetail';
 import type { Session } from '../../types';
-import { api } from '../../api/client';
+import { api, ApiError } from '../../api/client';
+import { useToastStore } from '../../stores/toastStore';
 
 export function SessionList() {
   const { sessions, loading, fetchSessions } = useHistoryStore();
   const [expandedId, setExpandedId] = useState<number | null>(null);
   const [expandedSession, setExpandedSession] = useState<Session | null>(null);
+  const [deletingId, setDeletingId] = useState<number | null>(null);
 
   useEffect(() => {
     fetchSessions(50);
@@ -38,6 +40,31 @@ export function SessionList() {
     });
   };
 
+  const handleDelete = async (e: React.MouseEvent, id: number) => {
+    e.stopPropagation();
+    if (!confirm('Session wirklich löschen? Alle Sätze werden unwiderruflich entfernt.')) return;
+
+    setDeletingId(id);
+    try {
+      await api.sessions.delete(id);
+      useToastStore.getState().addToast('success', 'Session erfolgreich gelöscht');
+      // Aufgeklappte Session schließen falls sie gerade gelöscht wurde
+      if (expandedId === id) {
+        setExpandedId(null);
+        setExpandedSession(null);
+      }
+      fetchSessions(50);
+    } catch (err) {
+      const message =
+        err instanceof ApiError
+          ? err.message
+          : 'Session konnte nicht gelöscht werden';
+      useToastStore.getState().addToast('error', message);
+    } finally {
+      setDeletingId(null);
+    }
+  };
+
   const formatDuration = (start: string, end?: string) => {
     if (!end) return 'laufend';
     const ms = new Date(end).getTime() - new Date(start).getTime();
@@ -68,9 +95,10 @@ export function SessionList() {
           key={session.id}
           className="bg-gray-900 border border-gray-800 rounded-xl overflow-hidden"
         >
+          <div className="flex items-stretch">
             <button
               onClick={() => toggleSession(session.id)}
-            className="w-full px-4 py-3 min-h-[44px] text-left hover:bg-gray-800/50"
+              className="flex-1 px-4 py-3 min-h-[44px] text-left hover:bg-gray-800/50"
             >
               <div className="flex items-center justify-between">
                 <div>
@@ -95,6 +123,27 @@ export function SessionList() {
                 </div>
               </div>
             </button>
+            {session.ended_at && (
+              <button
+                onClick={(e) => handleDelete(e, session.id)}
+                disabled={deletingId === session.id}
+                className="flex items-center justify-center w-11 min-h-[44px] text-gray-500 hover:text-red-400 hover:bg-gray-800/50 disabled:opacity-50 disabled:cursor-not-allowed transition-colors border-l border-gray-800"
+                title="Session löschen"
+                aria-label="Session löschen"
+              >
+                {deletingId === session.id ? (
+                  <svg className="w-4 h-4 animate-spin" fill="none" viewBox="0 0 24 24">
+                    <circle className="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" strokeWidth="4" />
+                    <path className="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8v8H4z" />
+                  </svg>
+                ) : (
+                  <svg className="w-4 h-4" fill="none" viewBox="0 0 24 24" stroke="currentColor" strokeWidth={2}>
+                    <path strokeLinecap="round" strokeLinejoin="round" d="M19 7l-.867 12.142A2 2 0 0116.138 21H7.862a2 2 0 01-1.995-1.858L5 7m5 4v6m4-6v6m1-10V4a1 1 0 00-1-1h-4a1 1 0 00-1 1v3M4 7h16" />
+                  </svg>
+                )}
+              </button>
+            )}
+          </div>
           {expandedId === session.id && expandedSession && (
             <div className="px-4 pb-4 border-t border-gray-800 pt-3">
               <SessionDetail logs={expandedSession.logs || []} />