Freigaben buendeln statt Weckflut (#643), Freigabemodell ueber Werkzeugrechte (#641)

#643: Entscheidungen wecken den Agenten nur noch bei Ablehnung oder gescheiterter
Ausfuehrung, gesammelt in einer Aufgabe je Agent (5 min Ruhefenster), frisch per
@new:agent statt im fortgefuehrten Chatverlauf. Eine einmalige Aufgabe, deren Lauf
wegen Budget oder Herunterfahren gar nicht stattfand, bleibt faellig (Wiedervorlage
nach 30 min) statt mit gesetztem Marker liegenzubleiben.

#641: Rechte stehen in der Werkzeugkonfiguration des Agenten (erlaubt/verboten).
Erlaubtes laeuft, Nicht-Erlaubtes wird einzeln vorgelegt statt verweigert, Verbotenes
gar nicht erst. "Gleichartiges kuenftig erlauben" erteilt eine widerrufbare
Dauerfreigabe je Agent/Werkzeug/Operation; nach drei gleichartigen Freigaben schlaegt
die Oberflaeche sie vor. Aenderungen an Agenten bleiben ausnahmslos freigabepflichtig.
Database: Operation ist das SQL-Schluesselwort; die eigene Zugriffspruefung greift nur
noch ohne Freigabestelle (AgentToolContext.FreigabeGeprueft). WebUI: Rechte-Tabelle je
Werkzeug, Dauerfreigaben mit Widerruf.

Version 0.1.11.

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

src/ClawdDotNet.Core/Tasks/TaskScanner.cs

@@ -2,14 +2,30 @@ using Microsoft.Extensions.Logging;
 
 namespace ClawdDotNet.Core.Tasks;
 
+/// <summary>Wie ein Dispatch ausging.</summary>
+public enum TaskLauf
+{
+    /// <summary>Der Lauf schloss regulär ab.</summary>
+    Erledigt,
+
+    /// <summary>Der Lauf fand statt und scheiterte.</summary>
+    Gescheitert,
+
+    /// <summary>
+    /// Der Lauf fand gar nicht statt — Budget erschöpft, Instanz im Herunterfahren (#643).
+    /// Eine einmalige Aufgabe bleibt dann fällig, statt als gelaufen liegenzubleiben.
+    /// </summary>
+    NichtGelaufen
+}
+
 /// <summary>
 /// Führt eine fällige Aufgabe aus. Kapselt, wie ein Assignee zu einem Lauf wird — der
 /// Scanner selbst kennt die Engine nicht und bleibt so ohne sie testbar.
 /// </summary>
 public interface ITaskDispatcher
 {
-    /// <summary>Führt die Aufgabe aus. Gibt zurück, ob der Lauf regulär abschloss.</summary>
-    Task<bool> DispatchAsync(TaskItem task, CancellationToken ct);
+    /// <summary>Führt die Aufgabe aus und meldet, wie der Lauf ausging.</summary>
+    Task<TaskLauf> DispatchAsync(TaskItem task, CancellationToken ct);
 }
 
 /// <summary>
@@ -58,6 +74,16 @@ public sealed class TaskScanner : IAsyncDisposable
     /// <summary>Wiederkehrende @agent-Aufgaben, deren wachsender Kontext bereits gemeldet wurde (#598).</summary>
     private readonly HashSet<string> _warnedContext = [];
 
+    /// <summary>
+    /// #643: Einmalige Aufgaben, deren Lauf nicht stattfand, und ab wann sie wieder dran sind.
+    /// Ohne diese Pause würde eine wegen Budget abgewiesene Aufgabe jede Minute erneut
+    /// anlaufen. Nur im Speicher — nach einem Neustart darf sie einmal sofort versuchen.
+    /// </summary>
+    private readonly System.Collections.Concurrent.ConcurrentDictionary<string, DateTime> _zurueckgestellt = new();
+
+    /// <summary>Pause, bevor eine nicht gelaufene einmalige Aufgabe erneut versucht wird.</summary>
+    public static readonly TimeSpan Wiedervorlage = TimeSpan.FromMinutes(30);
+
     private readonly CancellationTokenSource _cts = new();
     private Task? _loop;
 
@@ -196,6 +222,9 @@ public sealed class TaskScanner : IAsyncDisposable
                 _logger.LogWarning("Aufgabe {TaskId} ({Title}): {Hinweis}", task.Id, task.Title, hinweis);
             }
 
+            if (_zurueckgestellt.TryGetValue(task.Id, out var ab) && now < ab)
+                continue;
+
             var occ = TaskSchedule.DueOccurrence(task, now);
             if (occ is null)
                 continue;
@@ -257,10 +286,10 @@ public sealed class TaskScanner : IAsyncDisposable
 
     private async Task ProcessCoreAsync(TaskItem task, string token, CancellationToken ct)
     {
-        bool ok;
+        TaskLauf lauf;
         try
         {
-            ok = await _dispatcher.DispatchAsync(task, ct);
+            lauf = await _dispatcher.DispatchAsync(task, ct);
         }
         catch (OperationCanceledException) when (ct.IsCancellationRequested)
         {
@@ -269,10 +298,27 @@ public sealed class TaskScanner : IAsyncDisposable
         catch (Exception ex)
         {
             _logger.LogError(ex, "Dispatch für Aufgabe {TaskId} ist gescheitert", task.Id);
-            ok = false;
+            lauf = TaskLauf.Gescheitert;
         }
 
         var now = _clock.GetUtcNow().UtcDateTime;
+        var ok = lauf == TaskLauf.Erledigt;
+
+        // #643: Fand der Lauf einer einmaligen Aufgabe gar nicht statt, gilt ihr Termin als
+        // nicht verbraucht. Vorher blieb sie mit gesetztem Marker für immer auf todo liegen.
+        if (lauf == TaskLauf.NichtGelaufen && !task.IsRecurring)
+        {
+            if (await _repo.ReleaseClaimAsync(task.Id, token, task.LastOccurrence, now, ct))
+            {
+                _zurueckgestellt[task.Id] = now + Wiedervorlage;
+                _logger.LogInformation(
+                    "Aufgabe {TaskId} lief nicht (Budget/Herunterfahren) — erneut fällig ab {Ab:HH:mm} UTC",
+                    task.Id, now + Wiedervorlage);
+            }
+            return;
+        }
+
+        _zurueckgestellt.TryRemove(task.Id, out _);
 
         // Endstatus:
         // - Fehlschlag → zurück auf todo (der Marker steht schon beim Claim, derselbe Termin