Budgetsperre sichtbar machen (#608), Gedaechtnisabruf kuerzt statt wegzulassen (#607)

#608: Ein wegen erschoepften Budgets abgelehnter Lauf hinterlaesst jetzt einen Beleg (Status BudgetExceeded) an Aufgabe und Verlauf; die Log-Warnung kommt einmal je Agent, Grenze und Tag. Die Kostenprognose zaehlt Ablehnungen nicht als Lauf und warnt, wenn die geplanten Aufgaben eines Agenten sein Tagesbudget uebersteigen (API + Verbrauchsansicht). #607: Passt schon der erste Treffer nicht in den Abruf, wird er gekuerzt (Anfang und Ende bleiben) statt ganz zu fehlen. remember weist auf gleichnamige Eintraege ohne Schluessel und auf Eintraege nahe der Abrufgrenze hin. Version 0.1.9. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-15 18:59:14 +02:00
parent b0997b5334
commit f5731c50f8
12 changed files with 408 additions and 22 deletions
@@ -1,6 +1,7 @@
 using ClawdDotNet.Core.Api;
 using ClawdDotNet.Core.Audit;
 using ClawdDotNet.Core.Config;
+using ClawdDotNet.Core.Engine;
 using ClawdDotNet.Core.Tasks;

 namespace ClawdDotNet.Core.Accounting;
@@ -34,6 +35,12 @@ public sealed record AufgabenPrognose(
    int Stichprobe,
    decimal KostenProTag);

+/// <summary>
+/// Ein Agent, dessen Aufgaben laut Prognose mehr kosten, als sein Tagesbudget erlaubt (#608).
+/// Die spaeten Laeufe eines solchen Tages lehnt die Engine ab.
+/// </summary>
+public sealed record BudgetWarnung(string AgentId, decimal KostenProTag, decimal BudgetProTag);
+
 /// <summary>Die Prognose der ganzen Instanz.</summary>
 public sealed record InstanzPrognose(
    IReadOnlyList<AufgabenPrognose> Aufgaben,
@@ -42,7 +49,8 @@ public sealed record InstanzPrognose(
    decimal SummeProTag,
    decimal SummeProMonat,
    decimal EinmaligOffen,
-    int OhneKostenbasis);
+    int OhneKostenbasis,
+    IReadOnlyList<BudgetWarnung> Budgetwarnungen);

 /// <summary>
 /// Rechnet aus Terminen und bisherigen Laeufen hoch, was eine Instanz kuenftig kostet (#595).
@@ -81,6 +89,11 @@ public static class KostenPrognose
        jetztUtc = DateTime.SpecifyKind(jetztUtc, DateTimeKind.Utc);
        var seit = jetztUtc.AddDays(-TageRueckblick);

+        // #608: Eine Ablehnung wegen erschoepften Budgets hinterlaesst einen Beleg ueber 0 USD.
+        // Sie ist kein Lauf und darf den Schnitt nicht druecken.
+        belegeJeAufgabe = belegeJeAufgabe.ToDictionary(
+            e => e.Key, e => (IReadOnlyList<RunReceipt>)e.Value.Where(IstLauf).ToList());
+
        var agentNachId = agenten
            .GroupBy(a => a.AgentId, StringComparer.OrdinalIgnoreCase)
            .ToDictionary(g => g.Key, g => g.First(), StringComparer.OrdinalIgnoreCase);
@@ -139,9 +152,26 @@ public static class KostenPrognose
            Runde(summeProTag),
            Runde(summeProTag * TageJeMonat),
            Runde(zeilen.Where(z => z.EinmaligOffen).Sum(z => z.KostenJeLauf ?? 0m)),
-            zeilen.Count(z => z.Grundlage == PrognoseGrundlage.Unbekannt && (z.LaeufeProTag > 0 || z.EinmaligOffen)));
+            zeilen.Count(z => z.Grundlage == PrognoseGrundlage.Unbekannt && (z.LaeufeProTag > 0 || z.EinmaligOffen)),
+            Budgetwarnungen(zeilen, agentNachId));
    }

+    /// <summary>
+    /// #608: Reicht das Tagesbudget eines Agenten fuer seine geplanten Aufgaben nicht, soll das
+    /// vorher auffallen - nicht erst am Abend, wenn die ersten Laeufe abgelehnt werden.
+    /// Gezaehlt werden nur die Aufgaben; sonstige Laeufe lassen sich keinem Agenten sicher
+    /// zuordnen und kaemen noch hinzu.
+    /// </summary>
+    private static List<BudgetWarnung> Budgetwarnungen(
+        IEnumerable<AufgabenPrognose> zeilen, IReadOnlyDictionary<string, AgentConfig> agentNachId)
+        => zeilen
+            .GroupBy(z => z.AgentId, StringComparer.OrdinalIgnoreCase)
+            .Select(g => (Agent: agentNachId.GetValueOrDefault(g.Key), Summe: g.Sum(z => z.KostenProTag)))
+            .Where(x => x.Agent is { Budget.DailyCostUsd: > 0 } a && x.Summe > a.Budget.DailyCostUsd)
+            .Select(x => new BudgetWarnung(x.Agent!.AgentId, Runde(x.Summe), x.Agent.Budget.DailyCostUsd))
+            .OrderByDescending(w => w.KostenProTag - w.BudgetProTag)
+            .ToList();
+
    private static AufgabenPrognose Arbeit(
        TaskItem aufgabe, string agentId, AgentConfig? agent, IReadOnlyList<RunReceipt> belege,
        IReadOnlyDictionary<string, List<RunReceipt>> bekannteJeAgent,
@@ -215,6 +245,9 @@ public static class KostenPrognose
        return jeSchritt * AnnahmeSchritte;
    }

+    private static bool IstLauf(RunReceipt beleg)
+        => beleg.Status != nameof(AgentRunStatus.BudgetExceeded);
+
    private static DateTime Utc(DateTime wert)
        => wert.Kind == DateTimeKind.Utc ? wert : wert.ToUniversalTime();

@@ -154,7 +154,7 @@ public sealed class AgentEngine : IAgentMessageRouter, Staging.IFrozenCallExecut
            return zu;

        // Vor der ersten Anfrage prüfen — ein erschöpftes Budget soll gar nichts kosten.
-        if (await CheckBudgetAsync(agentConfig, externalCt) is { } denied)
+        if (await CheckBudgetAsync(agentConfig, source ?? AuditSource.Direct, taskId, externalCt) is { } denied)
            return denied;

        using var lauf = TrackRun();
@@ -425,7 +425,7 @@ public sealed class AgentEngine : IAgentMessageRouter, Staging.IFrozenCallExecut
        if (RefuseWhileShuttingDown(agentConfig) is { } zu)
            return zu;

-        if (await CheckBudgetAsync(agentConfig, externalCt) is { } denied)
+        if (await CheckBudgetAsync(agentConfig, source, taskId, externalCt) is { } denied)
            return denied;

        using var lauf = TrackRun();
@@ -1600,7 +1600,8 @@ public sealed class AgentEngine : IAgentMessageRouter, Staging.IFrozenCallExecut
    /// Prüft das Tagesbudget. Gibt ein Ergebnis zurück, wenn der Lauf nicht stattfinden
    /// darf — sonst null.
    /// </summary>
-    private async Task<AgentRunResult?> CheckBudgetAsync(AgentConfig agentConfig, CancellationToken ct)
+    private async Task<AgentRunResult?> CheckBudgetAsync(
+        AgentConfig agentConfig, string? source, string? taskId, CancellationToken ct)
    {
        if (_budgetGuard is null)
            return null;
@@ -1609,17 +1610,38 @@ public sealed class AgentEngine : IAgentMessageRouter, Staging.IFrozenCallExecut
        if (status.IsAllowed)
            return null;

+        // #608: Ist ein Budget erschoepft, lehnt es jeden weiteren Lauf des Tages ab. Einmal je
+        // Agent, Grenze und Tag als Warnung genuegt - danach steht jede Ablehnung als Beleg da.
        var logger = _loggerFactory.CreateLogger("ClawdDotNet.Core.Engine.Budget");
-        logger.LogWarning("Lauf abgelehnt für {AgentId}: {Reason}", agentConfig.AgentId, status.Reason);
+        var heute = DateOnly.FromDateTime(_clock.GetLocalNow().DateTime);
+        var schluessel = agentConfig.AgentId + "|" + status.Limit;
+        if (_budgetGewarnt.TryGetValue(schluessel, out var gewarnt) && gewarnt == heute)
+        {
+            logger.LogInformation("Lauf abgelehnt für {AgentId} (Aufgabe {TaskId}): {Reason}",
+                agentConfig.AgentId, taskId ?? "-", status.Reason);
+        }
+        else
+        {
+            _budgetGewarnt[schluessel] = heute;
+            logger.LogWarning("Lauf abgelehnt für {AgentId} (Aufgabe {TaskId}): {Reason} Weitere Ablehnungen heute stehen als Beleg im Verlauf.",
+                agentConfig.AgentId, taskId ?? "-", status.Reason);
+        }

        var result = new AgentRunResult(
            agentConfig.AgentId, AgentRunStatus.BudgetExceeded,
            $"[Budget erschöpft] {status.Reason}", 0, 0, TimeSpan.Zero);

+        // #608: Ohne Beleg blieb die Ablehnung unsichtbar - Aufgabenkarte und Verlauf zeigten
+        // weiter den letzten erfolgreichen Lauf, die Luecke fiel nur im Log auf.
+        await RecordReceiptAsync(Guid.NewGuid().ToString("N"), agentConfig, result, source, taskId);
+
        OnRunCompleted?.Invoke(agentConfig.Model, result);
        return result;
    }

+    /// <summary>Welche Budgetgrenze je Agent zuletzt an welchem Tag als Warnung gemeldet wurde.</summary>
+    private readonly System.Collections.Concurrent.ConcurrentDictionary<string, DateOnly> _budgetGewarnt = new();
+
    /// <summary>
    /// Schreibt den Verbrauch eines Laufs fort. Fehler hierbei dürfen den Lauf nicht
    /// nachträglich scheitern lassen — die eigentliche Arbeit ist bereits getan.
@@ -190,6 +190,13 @@ async function erstellePrognoseKarte() {
  );

  const hinweise = [];
+  for (const w of p.budgetWarnings || []) {
+    hinweise.push(erstelleElement("div", {
+      klasse: "hinweis-box warnung",
+      text: `${w.agentId}: Die geplanten Aufgaben kosten laut Prognose ${formatiereKosten(w.costPerDay)} am Tag, `
+        + `das Tagesbudget erlaubt ${formatiereKosten(w.budgetPerDay)}. Die späten Läufe eines Tages werden abgelehnt.`
+    }));
+  }
  if (p.withoutBasis > 0) {
    hinweise.push(erstelleElement("p", {
      klasse: "gedaempft text-klein",
@@ -165,7 +165,47 @@ public sealed class MemoryTool : IAgentTool

        return ToolResult.Ok(
            $"Gemerkt (#{saved.Id}, {scopeLabel}){keyHint}\n" +
-            $"Betreff: {saved.Subject} | Art: {saved.Category} | Wichtigkeit: {saved.Importance}");
+            $"Betreff: {saved.Subject} | Art: {saved.Category} | Wichtigkeit: {saved.Importance}" +
+            await HinweiseAsync(saved, scope, repository, context, ct));
+    }
+
+    /// <summary>
+    /// #607: Ein Agent merkte sich bei jedem Lauf dieselbe, wachsende Liste ohne Schlüssel -
+    /// sieben Einträge mit zusammen 23.000 Zeichen, bis der neueste allein nicht mehr in einen
+    /// Abruf passte. Beides soll er erfahren, solange er es noch ändern kann.
+    /// </summary>
+    private static async Task<string> HinweiseAsync(
+        MemoryEntry saved, MemoryScope scope, IMemoryRepository repository, AgentToolContext context, CancellationToken ct)
+    {
+        var sb = new StringBuilder();
+
+        if (string.IsNullOrWhiteSpace(saved.Key))
+        {
+            var gleicherBetreff = await repository.RecallAsync(new MemoryQuery
+            {
+                Scope = scope,
+                OwnerId = context.AgentId,
+                Subject = saved.Subject,
+                Limit = 50,
+                MinImportance = 1
+            }, ct);
+
+            var ohneSchluessel = gleicherBetreff.Count(e => string.IsNullOrWhiteSpace(e.Key));
+            if (ohneSchluessel > 1)
+            {
+                sb.Append($"\nHinweis: Unter dem Betreff '{saved.Subject}' liegen jetzt {ohneSchluessel} Einträge " +
+                          "ohne Schlüssel. Ersetzt dieser Eintrag einen früheren, merke ihn mit 'key' – dann wird " +
+                          "er fortgeschrieben statt verdoppelt. Überholte Einträge entfernst du mit forget (id).");
+            }
+        }
+
+        if (saved.Content.Length > MaxResultChars / 2)
+        {
+            sb.Append($"\nHinweis: Der Eintrag ist {saved.Content.Length} Zeichen lang, ein Abruf zeigt höchstens " +
+                      $"{MaxResultChars} Zeichen. Halte ihn kürzer oder teile ihn auf, sonst wird er beim Abruf gekürzt.");
+        }
+
+        return sb.ToString();
    }

    private static async Task<ToolResult> RecallAsync(
@@ -252,8 +292,21 @@ public sealed class MemoryTool : IAgentTool
            // Lieber weniger Treffer als ein gesprengter Kontext.
            if (sb.Length + block.Length > MaxResultChars)
            {
-                sb.AppendLine($"[… {entries.Count - shown} weitere Treffer ausgelassen. " +
-                              "Grenze die Suche ein, um sie zu sehen.]");
+                // #607: Passte schon der erste Treffer nicht, fiel er frueher ganz weg - der
+                // Agent sah keinen einzigen Inhalt und hielt alles fuer neu. Jetzt wird er
+                // gekuerzt; Anfang und Ende bleiben stehen, weil wachsende Listen hinten
+                // anhaengen und Notizen vorne beginnen.
+                if (shown == 0)
+                {
+                    sb.Append(FormatEntry(entry, scope, MaxResultChars - sb.Length - FooterReserve));
+                    shown++;
+                }
+
+                if (entries.Count > shown)
+                {
+                    sb.AppendLine($"[… {entries.Count - shown} weitere Treffer ausgelassen. " +
+                                  "Grenze die Suche ein, um sie zu sehen.]");
+                }
                break;
            }

@@ -264,29 +317,56 @@ public sealed class MemoryTool : IAgentTool
        return sb.ToString().TrimEnd();
    }

-    private static string FormatEntry(MemoryEntry entry, MemoryScope scope)
+    /// <summary>Platz, der nach einem gekuerzten Treffer fuer den Auslassungshinweis bleibt.</summary>
+    private const int FooterReserve = 200;
+
+    private static string FormatEntry(MemoryEntry entry, MemoryScope scope, int? maxChars = null)
    {
-        var sb = new StringBuilder();
-
-        sb.Append($"#{entry.Id} [{entry.Subject}] {entry.Category}, Wichtigkeit {entry.Importance}");
+        var header = new StringBuilder();
+        header.Append($"#{entry.Id} [{entry.Subject}] {entry.Category}, Wichtigkeit {entry.Importance}");
        if (!string.IsNullOrWhiteSpace(entry.Key))
-            sb.Append($", Schlüssel: {entry.Key}");
-        sb.AppendLine();
-
-        sb.AppendLine($"  {entry.Content}");
+            header.Append($", Schlüssel: {entry.Key}");

        var meta = new List<string> { $"aktualisiert {entry.UpdatedAt:yyyy-MM-dd HH:mm} UTC" };
        if (entry.Tags.Count > 0)
            meta.Add("Schlagworte: " + string.Join(", ", entry.Tags));
        if (scope == MemoryScope.Shared && !string.IsNullOrWhiteSpace(entry.CreatedBy))
            meta.Add($"von {entry.CreatedBy}");
+        var metaLine = $"  ({string.Join(" | ", meta)})";

-        sb.AppendLine($"  ({string.Join(" | ", meta)})");
+        var content = entry.Content;
+        if (maxChars is { } max)
+            content = Kuerze(content, max - header.Length - metaLine.Length - 16);
+
+        var sb = new StringBuilder();
+        sb.Append(header).AppendLine();
+        sb.AppendLine($"  {content}");
+        sb.AppendLine(metaLine);
        sb.AppendLine();

        return sb.ToString();
    }

+    /// <summary>Kuerzt einen Inhalt auf etwa <paramref name="platz"/> Zeichen, Anfang und Ende bleiben.</summary>
+    internal static string Kuerze(string content, int platz)
+    {
+        const int Mindestens = 400;
+
+        var marke = $"\n  [… gekürzt: {{0}} von {content.Length} Zeichen ausgelassen – der Eintrag ist zu groß " +
+                    "für einen Abruf. Teile ihn auf oder halte ihn kürzer.]\n  ";
+
+        if (content.Length <= platz)
+            return content;
+
+        var haelfte = Math.Max(Mindestens, platz - marke.Length) / 2;
+        if (2 * haelfte >= content.Length)
+            return content;
+
+        return content[..haelfte]
+               + string.Format(marke, content.Length - 2 * haelfte)
+               + content[^haelfte..];
+    }
+
    // ─── Eingabe lesen ───

    private static string? GetString(JsonElement input, string name)
@@ -140,7 +140,11 @@ public sealed record ForecastDto(
    decimal TotalPerDay,
    decimal TotalPerMonth,
    decimal OneOffOpen,
-    int WithoutBasis);
+    int WithoutBasis,
+    IReadOnlyList<ForecastBudgetDto> BudgetWarnings);
+
+/// <summary>Ein Agent, dessen geplante Aufgaben laut Prognose sein Tagesbudget uebersteigen (#608).</summary>
+public sealed record ForecastBudgetDto(string AgentId, decimal CostPerDay, decimal BudgetPerDay);

 /// <summary>Eine Zeile der Kostenprognose. <c>Basis</c>: Laeufe, Agent, Schaetzung oder Unbekannt.</summary>
 public sealed record ForecastTaskDto(
@@ -100,7 +100,8 @@ internal static class Mapping
            prognose.SummeProTag,
            prognose.SummeProMonat,
            prognose.EinmaligOffen,
-            prognose.OhneKostenbasis);
+            prognose.OhneKostenbasis,
+            prognose.Budgetwarnungen.Select(w => new ForecastBudgetDto(w.AgentId, w.KostenProTag, w.BudgetProTag)).ToList());

    public static ServiceDto ToDto(this ServiceConfig service)
        => new(