Merge feat/711-lagebild: Teamuebersicht, Stufe 0 (#711)

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

.gitattributes

@@ -24,3 +24,6 @@
 *.jpg     binary
 *.zip     binary
 *.dll     binary
+
+# Vendored third-party files stay byte for byte as published (checksums in vendor/README.md)
+src/ClawdDotNet.Manager.Web/wwwroot/vendor/** -text

docs/Organisation-Konzept.md

@@ -1,6 +1,6 @@
 # Organisation — 50 bis 100 Agenten geordnet zusammenarbeiten lassen
 
-*Stand: 21. September 2026. Konzept, noch nicht gebaut.*
+*Stand: 24. September 2026 (ergänzt um 7a, 9a, 10a, Einstellungen an der Einheit, Budgetende, Füllarbeit). Konzept, noch nicht gebaut.*
 
 > Herkunft: Richtungsentscheidung des Nutzers am 2026-09-21. Die bisherige Regel im
 > [InstanceSetupGuide](InstanceSetupGuide.md) („mehr als 5 Agenten kritisch
@@ -123,6 +123,47 @@ Instanz „Onlinehandel"
 | **Freigaben** | ein Mensch | die Leitung innerhalb ihrer Grenzen, der Mensch für alles darüber (Geld, Außenwirkung) |
 | **Parallelität** | unbegrenzt | je Einheit und je Instanz eine Zahl gleichzeitiger Läufe, der Rest wartet |
 
+### Einstellungen an der Einheit: nie zwei Werte, die sich übertrumpfen
+
+*Festgelegt am 2026-09-24 durch den Nutzer, in zwei Schritten.*
+
+Einstellungen lassen sich an der Einheit speichern und bearbeiten. **Aber es gibt nie
+zwei Werte für dieselbe Sache, von denen einer den anderen zur Laufzeit übertrumpft.**
+Daraus folgen genau zwei Arten von Einheiten-Einstellungen:
+
+**1. Sammelwerte, die in die Agenten geschrieben werden.** Alles, was es auch am Agenten
+gibt: Tagesbudget, Modell, Verhalten beim Budgetende (#716). Wer für das Marketing das
+Tagesbudget setzt, schreibt den Wert in jeden Agenten darunter. Die Einheit merkt sich den
+Wert nur als **Vorgabe für Agenten, die neu hinzukommen**, nie als Grenze, die im
+Hintergrund gilt. Danach steht am Agenten, was gilt, und nur dort.
+
+- **Vorschau** vor dem Schreiben: welche Agenten sich wie ändern, Audit-Eintrag je Agent.
+- **Warnung bei Ausreißern:** Weicht der bisherige Wert eines Agenten massiv von denen
+  seiner Kollegen ab, wird er in der Vorschau hervorgehoben und ist standardmäßig
+  **nicht** angehakt. Gemeint ist der Spezialist, der bewusst viele Tokens verbraucht und
+  sonst mit dem Wert seiner Kollegen kaputtkonfiguriert würde. Der Mensch entscheidet je
+  Ausreißer, ob er mit überschrieben wird.
+- Die Vorschau bietet zwei Rechenwege: **ein Wert je Agent** („jeder bekommt 10 $") oder
+  **ein Gesamtbetrag, verteilt** („das Marketing bekommt 100 $"). Beim Verteilen
+  vorgeschlagen: im Verhältnis der bisherigen Werte, damit ein Spezialist seinen
+  größeren Anteil behält.
+
+**2. Regeln, die es nur an der Einheit gibt.** Sie haben kein Gegenstück am Agenten und
+können deshalb mit nichts konkurrieren:
+
+- **Rechte-Obergrenze.** „Was die Einheit nicht darf, kann ein Mitglied nicht bekommen"
+  bleibt, weil sie eine Sicherheitsgrenze ist. Sie wird **beim Schreiben** geprüft, nicht
+  zur Laufzeit darübergelegt: Eine Rechteänderung am Agenten, die über die Obergrenze
+  hinausginge, wird abgewiesen. Senkt man die Obergrenze, zeigt die Vorschau, welchen
+  Agenten dadurch Rechte entzogen werden, und schreibt es in sie hinein. Damit gilt auch
+  hier: Was am Agenten steht, gilt.
+- **Parallelität je Einheit** (#685). Ein Agent läuft ohnehin nur einmal gleichzeitig,
+  die Zahl gehört also nur der Einheit. Bis #685 gebaut ist, gilt sie instanzweit
+  (`maxParallelTaskRuns`, #682).
+
+**Grenzen der Leitung** (Abschnitt 12) sind ein Sammelwert: Sie stehen am
+Leitungsagenten. Beim Wechsel der Leitung zeigt die Vorschau, was mit umzieht.
+
 ### Beliebig tief, und beweglich
 
 Eine Einheit enthält Einheiten, und die wieder Einheiten — **ohne feste Grenze**.
@@ -609,6 +650,76 @@ Und quer dazu: Jedes Werkzeug bringt seine Eignungsproben mit
 das angenehm; bei fünfzig ist es die einzige Art, den Überblick zu behalten, welches
 Modell womit umgehen kann.
 
+---
+
+## 7a — Fremde Laufzeiten
+
+*Ergänzt am 2026-09-24, angeregt durch Paperclip. Items #712, #713.*
+
+Der vorige Abschnitt legt fest, dass nur die Entwicklungsabteilung Code hervorbringt.
+Daraus folgt eine Frage, die bisher offen war: **Womit programmiert sie?** Ein
+nachgebautes Schreib-und-Ausführ-Werkzeug von uns wird nie so gut wie Claude Code, das
+auf nichts anderes ausgelegt ist. Und mit einem Abo kann es billiger sein als Tokens über
+OpenRouter.
+
+Also bekommt jeder Agent eine **Laufzeit**:
+
+| Laufzeit | Was läuft | Wofür |
+|---|---|---|
+| `native` | unsere Engine mit OpenRouter, wie heute | Voreinstellung, alles außer Programmieren |
+| `claude-code` | Claude Code im Kopflos-Modus | die Entwicklungsabteilung |
+| `codex` | OpenAI Codex CLI | dasselbe, anderer Anbieter |
+| `command` | ein Befehl, dessen Ausgabe das Ergebnis ist | Sonderfälle |
+| `http` | ein Aufruf an einen fremden Dienst | Agenten, die woanders laufen |
+
+**Was die Instanz behält:** Organisation, Taskboard, Budget, Audit, Freigaben. **Was die
+fremde Laufzeit übernimmt:** die Arbeit innerhalb eines einzelnen Laufs. Paperclip trennt
+das vollständig: *„control plane, not execution plane"*. Wir tun das nicht, und das ist
+Absicht. Unsere Sicherheit liegt in der Ausführung (StagingGate, Werkzeugrechte,
+UntrustedContent). Eine fremde Laufzeit ist deshalb die Ausnahme für einen bestimmten
+Zweck, nicht das Modell für alles.
+
+### Eine fremde Laufzeit gilt als weniger vertrauenswürdig
+
+Was innerhalb von Claude Code geschieht, sieht keine unserer Prüfstellen. Daraus folgen
+vier Regeln:
+
+1. **Eigener Arbeitsplatz.** Ein Worktree oder eine Sandbox (#654), nie der
+   Arbeitsbereich der Instanz selbst.
+2. **Freigabelisten statt Rechte-Umgehung.** `--allowedTools` und `--max-turns`, nie
+   `--dangerously-skip-permissions`. Bei Paperclip ist die Umgehung die Voreinstellung;
+   bei uns ist sie ausgeschlossen.
+3. **Das Ergebnis ist ein Vorschlag.** Ein Diff oder ein fertiges Skript zur Abnahme, nie
+   ein direkter Einsatz. Ob es eingesetzt wird, entscheidet die Lieferkette aus
+   Abschnitt 7 (#695). Dass es Claude Code geschrieben hat, erspart keine Prüfung.
+4. **Nach außen nur über uns.** Mit Taskboard, Leitung und Ablage spricht die fremde
+   Laufzeit über einen **MCP-Server, den die Instanz je Lauf bereitstellt** (#713). Jeder
+   Aufruf dort durchläuft dieselbe Kette wie ein nativer Werkzeugaufruf. Der Server
+   bietet nur an, was der Agent laut Konfiguration hat, und ist damit kein zweiter Weg
+   an den Rechten vorbei. Das Token gilt einen Lauf lang und wird nie in der
+   Befehlszeile übergeben.
+
+### Kosten, die nichts kosten
+
+Mit einem Abo kostet ein Lauf 0 $ und verbraucht trotzdem etwas: Kontingent. Die
+Token-Zahlen aus `--output-format stream-json` gehen deshalb wie jeder andere Lauf in
+RunUsage. In der Kostenanalyse (Abschnitt 8a) erscheinen sie als Kontingentverbrauch, nicht
+als „kostenlos". Sonst wird genau die Abteilung unsichtbar, die am meisten Tokens
+verbraucht.
+
+### Zwei Vorbehalte vor dem Bau
+
+- **Das Kontingent teilt der Mensch mit sich selbst.** Ein Pro-Plan, auf dem die
+  Entwicklungsabteilung läuft, ist derselbe, mit dem der Mensch arbeitet. Entweder ein
+  eigener Account oder eine Vorfahrtsregel, die die Abteilung anhält, bevor der Mensch
+  an die Grenze stößt.
+- **Die Nutzungsbedingungen sind nicht geprüft.** Ob der automatisierte Dauerbetrieb
+  eines Verbraucher-Abos durch ein Agentensystem gedeckt ist, ist offen. Deshalb werden
+  beide Anmeldewege gebaut, Abo und API-Schlüssel, und die Entscheidung bleibt eine
+  Frage der Konfiguration statt eine des Umbaus.
+
+---
+
 ## 8 — Kontrolle: eine Leitung delegiert nicht nur
 
 Modelle machen Fehler. Das ist keine Randbedingung, sondern die Arbeitsgrundlage — vier
@@ -818,6 +929,93 @@ muss. Also:
 Erkennen ist auch hier Code, nicht Modell: Ein Mittelwert und ein Schwellwert sind eine
 Abfrage. Ob die Abweichung ein Problem ist, deutet die Aufsicht (#680).
 
+### Was liegen bleibt, wenn das Budget endet
+
+*Ergänzt am 2026-09-24 auf Hinweis des Nutzers. Item #716.*
+
+Um 22:30 ist das Tagesbudget aufgebraucht, und für den Rest des Tages stehen noch 100
+Läufe an. Lässt man sie verfallen, fehlt Arbeit. Holt man sie nach, fressen sie das
+Budget des nächsten Tages.
+
+**Heute gibt es dafür schon ein Verhalten. Nur hat es niemand entschieden.** Der Ausfall
+wird vermerkt (seit #608 als RunReceipt mit `BudgetExceeded`), aber nicht an der Aufgabe
+und nicht zusammengefasst. Einmalige Aufgaben werden alle 30 Minuten erneut versucht und
+laufen nach Mitternacht still zu Lasten des neuen Tages. Wiederkehrende verfallen still,
+weil ihr Termin schon beim Beanspruchen verbraucht ist. Beides kann richtig sein, aber
+nicht, ohne dass es jemand festlegt. Die Tagesgrenze ist die lokale Mitternacht.
+
+Der Vorschlag ist eine Einstellung je Agent, was mit einem Lauf geschieht, der am Budget
+scheitert:
+
+| Regel | Was geschieht | Voreinstellung für |
+|---|---|---|
+| `expire` | verfällt, wird an der Aufgabe vermerkt | wiederkehrende Aufgaben: Der nächste Termin kommt ohnehin, ein verpasster Stundenbericht ist vom nächsten überholt |
+| `catch_up_once` | alle verfallenen Termine werden zu **einem** Nachholauf zusammengefasst | — (sinnvoll für den Tagesbericht, dessen nächster Termin erst in 24 Stunden käme) |
+| `carry_over` | wird mitgenommen | einmalige Aufgaben: echte Arbeit, die nicht verschwinden darf |
+
+Dazu gilt: **Der neue Tag hat Vorfahrt.** Nachholläufe kommen nach den regulär fälligen,
+unterhalb jeder Priorität, und sie nutzen nur den **Spielraum**, den der Rest des Tages
+nicht braucht: Grenze minus Verbrauch, minus die Reservierung laufender Läufe, minus der
+Bedarf der noch geplanten Läufe bis Mitternacht, minus 10 % Reserve. Ohne diese Regel
+schiebt ein einziger überzogener Tag seinen Ausfall Tag für Tag vor sich her, statt ihn
+aufzulösen. *Beim Bau am 2026-09-24 geändert:* Das Konzept sah hier zunächst einen
+pauschalen Anteil von 25 % vor. Ein fester Anteil ist an einem vollen Tag zu viel und an
+einem ruhigen unnötig wenig; der Spielraum folgt dem tatsächlichen Plan, und dieselbe
+Rechnung trägt später die Füllarbeit. Eine einmalige Aufgabe, die
+nach einigen Tagen immer noch nicht drankam, geht an den Menschen: Was nie läuft, darf
+nicht unbemerkt liegen bleiben.
+
+**Vermerkt wird zweimal:** an der Aufgabe („ausgefallen: Budget erschöpft, 22:30" bzw.
+„nachgeholt am …") und in einer Tageszusammenfassung („Budget Marketing um 22:30
+erschöpft, 100 Läufe ausgefallen, 12 zum Nachholen vorgemerkt"). Die Zusammenfassung
+geht in die Abweichungsmeldung oben und ins Lagebild (Abschnitt 10a).
+
+**Besser als jede Nachholregel ist Vorbeugen.** Die Kostenprognose aus #608 weiß schon
+heute, ob das Budget für die geplanten Aufgaben reicht. Sie sollte vormittags melden,
+dass bei diesem Verbrauch um 22:30 Schluss ist. Dann kann der Mensch rechtzeitig
+nachlegen oder entscheiden, was entfällt.
+
+Zur selben Baustelle gehört die **Budgetreservierung**, der offene Rest aus #682: Noch
+prüft jeder Lauf das Budget einzeln vor dem Start, und bis zu `maxParallelTaskRuns` Läufe
+können es gemeinsam überschreiten. Erst mit einer Reservierung vor dem Lauf ist der
+Ausfall vorhersagbar statt eine Frage, welcher Lauf zuerst zugreift.
+
+### Füllarbeit und Großaufgaben
+
+*Ergänzt am 2026-09-24 auf Vorschlag des Nutzers. Item #717.*
+
+Der vorige Abschnitt regelt, was liegen bleibt, wenn das Budget nicht reicht. Die
+Kehrseite: An den meisten Tagen bleibt Budget übrig, und das verfällt.
+
+**Füllarbeit** ist Arbeit, die umfangreich, aber nicht eilig ist. Ob sie heute, morgen
+oder übermorgen läuft, ist gleich. Sie bekommt statt eines Termins eine **Frist
+„spätestens bis"** und läuft, wenn Platz ist. Rechenzentren machen das seit Jahrzehnten
+so und nennen es *Backfilling*. Ob Platz ist, entscheidet der Code:
+
+- Keine regulär fällige Aufgabe des Agenten wartet.
+- Das Restbudget des Tages, abzüglich der Prognose für die noch geplanten Läufe (#608) und
+  eines Sicherheitsaufschlags, reicht für die Schätzung der Füllarbeit.
+- Bevorzugt spät am Tag, weil die Prognose dann am wenigsten Unsicherheit hat.
+
+Rückt die Frist näher und es fand sich nie Platz, wird der Mensch gefragt: Budget
+erhöhen oder Frist verschieben. Eine Füllarbeit überschreitet ihre Frist nie still.
+
+**Großaufgaben** sind Aufgaben, deren Schätzung einen großen Teil des Tagesbudgets
+übersteigt (Vorgabe etwa 50 %). Sie werden nicht einfach angefangen. Der Agent schlägt
+einen von zwei Wegen vor:
+
+1. **Teilen.** Unteraufgaben, jede ein eigener Lauf, verbunden über die Elternaufgabe
+   (Zielkette, Abschnitt 9a). Die Teile können dann Füllarbeit sein.
+2. **Sonderbudget.** Ein Betrag für genau diese Aufgabe samt Unteraufgaben, vom Menschen
+   freigegeben. Es ist ein eigener Topf: Es hebt die Tagesgrenze des Agenten nicht an und
+   ist in der Kostenanalyse gesondert sichtbar. Damit ist es die einzige Ausnahme von
+   „Budgets bleiben am Agenten", gebunden an eine Aufgabe und nie still.
+
+**Ehrlich schätzen.** Kosten lassen sich vorab nicht genau wissen, und Modelle schätzen
+ihren eigenen Aufwand schlecht. Wo es Verlauf gibt, schätzt der Code aus dem Verlauf.
+Sonst schätzt der Agent, und die Zahl ist als Schätzung gekennzeichnet. Nach dem ersten
+Teillauf ersetzt der gemessene Wert die Schätzung.
+
 ### Was die Auswertung dafür braucht
 
 - **Die Einheit als Dimension** in Filtern und Zeitverlauf der Verbrauchsansicht (#660) —
@@ -889,6 +1087,87 @@ Daraus drei Festlegungen:
 
 ---
 
+## 9a — Von Paperclip gelernt
+
+*Ergänzt am 2026-09-24 nach Durchsicht des Paperclip-Quellcodes. Items #714, #715.*
+
+[Paperclip](https://github.com/paperclipai/paperclip) ist das Projekt, das diesem Konzept
+am nächsten kommt: Firma, Organigramm, Budgets, der Mensch als „Board" mit Vetorecht.
+Einiges davon lohnt sich zu übernehmen, anderes bewusst nicht.
+
+### Übernommen: die Zielkette (#714)
+
+Jede Aufgabe hat eine **Elternaufgabe**, ganz oben steht das Ziel der Einheit. Damit kann
+jeder Agent beantworten, *warum* er etwas tut. Die Kette geht als kurzer Absatz in den
+Lauf mit. Das ist etwas anderes als `blocked_by`: Die Elternaufgabe ist der Zweck
+(„wofür"), der Blocker die Voraussetzung („wann"). Heute kennt `TaskItem` nur den Blocker.
+
+Daraus folgt eine zweite Fähigkeit, Paperclips *Task Watchdog*: **Kommt ein ganzer
+Teilbaum zur Ruhe**, alle Blätter erledigt, abgebrochen, blockiert oder in Prüfung, und
+es gibt keinen Weg mehr, auf dem er weiterläuft, dann prüft jemand, ob der Stillstand
+berechtigt ist. Denn Agenten hören aus falschen Gründen auf: „erledigt" ohne Beleg, eine
+Prüfung ohne Prüfer, ein falsch gelesener Blocker. Ohne Prüfung liegt der Baum einfach
+still, und niemand merkt es. Die Aufteilung ist dieselbe wie überall: Ob der Baum ruht,
+erkennt eine Abfrage (#646). Ob das in Ordnung ist, deutet die Aufsicht (#680) oder die
+Leitung. Der Prüfer gibt zurück, er bessert nicht selbst nach.
+
+### Übernommen: Rückmeldung nach Vertrauensstufe (#715)
+
+Das ist der wertvollste Gedanke aus Paperclip, und er schließt eine Lücke, die dieses
+Konzept bisher hatte. Ein Agent, der Rezensionen, Mails oder Webseiten liest, hat fremden
+Text im Kontext. UntrustedContent (K2) rahmt diesen Text beim Lesen. Schreibt der Agent
+seiner Leitung aber einen Kommentar in eigenen Worten, trägt er den fremden Text eine
+Ebene höher, in einen Kontext mit mehr Rechten, und dort ist er nicht mehr gerahmt.
+**Prompt-Injection über die Hierarchie.**
+
+Nach oben gibt es deshalb genau drei Wege:
+
+1. **Das Erledigt-Signal.** Immer an. Die Leitung wird geweckt und liest das Ergebnis im
+   Vorgang selbst.
+2. **Ein Kommentar genau eine Ebene nach oben.** Nur ein Kommentar, keine Status- oder
+   Feldänderung, nie an die übernächste Ebene oder an Geschwister. **Nur für die
+   Standardstufe.**
+3. **Für Agenten, die fremde Inhalte lesen: kein Freitext nach oben.** Stattdessen
+   verfasst der Code eine Systemmeldung „blockiert" oder „abgebrochen". Sie löst keine
+   weitere Meldung aus und geht je Zustand nur einmal hinaus.
+
+**Woher die Stufe kommt:** aus den Werkzeugen, nicht aus einer Einstellung. Wer WebFetch,
+Mail, Rocket.Chat oder ein Skript mit Außenkontakt hat, liest fremde Inhalte. Das weiß
+der Code aus der Konfiguration, eine Selbstauskunft des Agenten ist dafür nicht nötig.
+Eine Einstellung darf die Stufe nur verschärfen, nie lockern.
+
+Für Querverbindungen gilt das **„Courier Pattern"**: Wer seitlich etwas braucht, schreibt
+nicht in fremde Vorgänge, sondern legt beim Ziel eine vollständige, in sich geschlossene
+Aufgabe an. Das ist die Adressbuchregel aus Abschnitt 3 und die Stille-Post-Regel aus
+Abschnitt 5, nur zu Ende gedacht: Der Empfänger darf die Vorgänge des Absenders womöglich
+gar nicht lesen, also muss alles Nötige in der Aufgabe selbst stehen.
+
+**Reihenfolge:** vor der Freigabe durch die Leitung (#687). Eine Leitung, die Freigaben
+erteilt, darf keinen Kontext haben, in den ein Untergebener fremden Text schreiben kann.
+
+### Übernommen, im Kleinen
+
+- **Budget in zwei Stufen.** Die harte Grenze gibt es schon (`BudgetGuard`, Tagesbudget
+  je Agent und Instanz). Dazu kommt eine Warnung bei 80 % an die Leitung, damit das
+  Anhalten keine Überraschung ist. Gehört zu #699.
+- **Gestaffelte Anzeige.** Oben die lesbare Zusammenfassung, darunter die Schritte, ganz
+  unten das Rohprotokoll. Gilt für die Teamübersicht (Abschnitt 10a) und die
+  Laufansichten aus #660.
+
+### Bewusst nicht übernommen
+
+- **Rechte-Umgehung als Voreinstellung.** Der Claude-Code-Adapter startet mit
+  `dangerouslySkipPermissions = true`, und Skills sind „open by default". Das ist das
+  Gegenteil unserer Linie, jedem Agenten nur die Rechte zu geben, die er braucht.
+- **Die ganze Firma sieht alle Arbeit.** Bei Paperclip ist das ausdrücklich gewollt.
+  Hier trennen die gemeinsamen Bereiche je Einheit bewusst (Abschnitt 3).
+- **Die reine Steuerungsebene.** Siehe Abschnitt 7a.
+- **Als Warnsignal: die Komplexität.** Allein die Regeln zur Ausführung umfassen dort
+  über 1.400 Zeilen, bei knapp 5.000 offenen Issues und im Wesentlichen einem einzigen
+  Hauptentwickler. Das mahnt, nur zu übernehmen, was eine Lücke schließt.
+
+---
+
 ## 10 — Was sich am Menschen ändert
 
 Bei fünf Agenten ist der Mensch der Koordinator. Bei fünfzig kann er es nicht sein, und
@@ -906,6 +1185,91 @@ der Versuch macht ihn zum Flaschenhals.
 
 ---
 
+## 10a — Das Lagebild
+
+*Ergänzt am 2026-09-24 auf Vorschlag des Nutzers. Item #711, baut auf #688 auf.*
+
+Die **Teamübersicht**: eine grafische Ansicht wie über ein Büro. Nodes für Agenten, Kanten
+für ihre Beziehungen. Auf einen Blick sieht man, wer gerade arbeitet, wer mit wem in den
+letzten Sekunden gesprochen hat und wo es klemmt. Ein Klick führt zum Agenten.
+
+Bei fünf Agenten ist das eine Annehmlichkeit. Bei fünfzig ist es die einzige Art, ein
+Problem zu bemerken, bevor die Rechnung kommt oder ein Ergebnis fehlt. Abschnitt 10 sagt,
+bei fünfzig Agenten müsse etwas anderes dem Menschen sagen, wo er hinsehen soll. Das
+Lagebild ist dieses Etwas, zum Hinsehen, neben der Aufsicht (#680) zum Nachlesen.
+
+### Drei Festlegungen
+
+1. **Die Anordnung kommt aus der Struktur, nicht aus der Hand.** In n8n oder Node-RED ist
+   der Graph das Programm, dort zieht man Nodes, und das soll so sein. Hier zeigt der
+   Graph eine Wahrheit, die woanders liegt: Einheiten, Leitung, Adressbuch. Sind die
+   Nodes frei platzierbar und verbindbar, zeigt das Bild bald etwas anderes als die
+   Organisation. Verschieben per Drag & Drop kommt später als Bedienung für den Umzug
+   (Abschnitt 3), mit gestoppter Instanz, Bestätigung und Audit-Eintrag, nicht als
+   Zeichenwerkzeug.
+2. **Einheiten sind aufklappbare Container, Probleme wandern nach oben.** Hundert Nodes
+   mit wechselnden Kanten sind ein Knäuel. Standardansicht sind die Abteilungen mit einer
+   Zusammenfassung: „4 arbeiten · 1 Problem · 2 Freigaben offen". Eine Markierung am
+   Container heißt „irgendwo darin", und man klappt auf, bis man den Agenten findet.
+   Kanten zwischen Einheiten werden gebündelt, mit Zähler.
+3. **„Problem" stellt der Code fest, nicht das Modell.** Die Zustände:
+
+   | Zustand | Woher |
+   |---|---|
+   | arbeitet | aktiver Lauf |
+   | wartet auf Freigabe | offene StagedCalls |
+   | wartet auf Kollegen | laufende Delegation |
+   | Problem | letzter Lauf gescheitert, LoopGuard-Abbruch, Eskalation über Frist, Budget erschöpft |
+   | hängt | Lauf deutlich länger als bei diesem Agenten üblich |
+   | pausiert / aus | Konfiguration |
+
+   Immer Farbe **und** Symbol.
+
+### Der Klick führt in die Seitenleiste, nicht direkt in den Chat
+
+Die meisten Probleme löst man nicht im Gespräch: Oft wartet eine Freigabe, oder ein
+Werkzeug ist dreimal gescheitert. Die Seitenleiste zeigt den laufenden Lauf, den letzten
+Fehler im Wortlaut, offene Aufgaben und Freigaben (dort bestätigbar), die Kosten von heute
+gegen den Durchschnitt und den Knopf „Chat öffnen". Das ist ein Klick mehr, dafür ist
+der richtige Handgriff meist schon da.
+
+### Technik
+
+- **Datenquelle** ist der vorhandene Ereignisstrom (`MergedEventStream`). Neu sind
+  Ereignistypen mit Absender und Empfänger: Delegation, Task-Zuweisung, später Besprechung
+  und Eskalation, jeweils mit eigener Linienart. Das Verblassen nach einigen Sekunden
+  geschieht im Browser.
+- **Bibliothek:** Cytoscape.js mit ELK-Layout. Es kann verschachtelte Container und
+  hierarchisches Layout und bleibt bei Hunderten Nodes flüssig, ohne React. Als Datei im
+  `wwwroot`, nicht über ein CDN.
+- **Nur in der WebUI.** Ein zweiter Graph-Renderer in Avalonia wäre doppelte Arbeit, die
+  auseinanderläuft. Der Desktop bettet die Ansicht ein oder verlinkt sie.
+- Englisch, Texte über Sprachpakete (#661).
+
+### Stufen
+
+- **Stufe 0**, ohne Einheiten: die vorhandenen Agenten mit Delegationskanten und
+  Zuständen. Das nützt sofort, auf der Test-VM mit sieben Agenten.
+- **Stufe 1**, mit #683: Container und nach oben gereichte Probleme. Ab hier fällt das
+  Lagebild mit dem Organigramm aus #688 zusammen; es gibt nicht zwei Ansichten der
+  Organisation.
+- **Später: die Zeitleiste.** „Wie sah das Büro um 3:12 Uhr aus?" Das kostet wenig, weil
+  nichts gelöscht wird (Abschnitt 8a): Das AuditLog wird nur neu abgespielt. Für die Frage,
+  wie ein Projekt gescheitert ist, ist das vielleicht das wertvollste Werkzeug überhaupt.
+
+### Wie andere es machen
+
+Paperclip hat ein statisches Organigramm mit einem Statuspunkt je Agent und daneben eine
+Liste der laufenden Läufe, aber keine Ansicht der Kommunikation. LangGraph Studio zeigt den
+laufenden Node eines *Ablaufgraphen*, also eines Programms, nicht einer Organisation.
+AutoGen Studio, Flowise und Langflow sind Baukästen („Nodes ziehen = Programm"), gut zum
+Bauen, schwach als Lagebild. ChatDev und AI Town zeigen das Büro wörtlich als
+Pixelgrafik: charmant, aber mit wenig Information. Die Verbindung aus aufklappbarer
+Organisation, Live-Zuständen und nach oben gereichten Problemen mit Direktzugriff hat
+keines davon.
+
+---
+
 ## 11 — Reihenfolge
 
 Nichts davon muss auf einmal entstehen. Die Reihenfolge ist so gewählt, dass jede Stufe
@@ -914,10 +1278,11 @@ für sich schon nützt und keine die nächste blockiert.
 | Stufe | Inhalt | Nutzen für sich |
 |---|---|---|
 | **0** | Parallelität deckeln, stille Kappung bei 500 beseitigen (#682) | Fehler, unabhängig von der Größe |
+| **0a** | Lagebild ohne Einheiten (#711, Stufe 0) | Der Mensch sieht auf der Test-VM sofort, wer arbeitet und wo es klemmt |
 | **1** | Einheiten als Struktur: Baum, Zugehörigkeit, vererbte Rechte, Adressbuch nach Einheit | Der Schnitt, der alles Weitere trägt |
 | **2** | Ablage und Brett je Einheit | Buchhaltung und Einkauf treten sich nicht mehr auf die Füße |
 | **3** | Budget und Parallelität je Einheit | Eine ausufernde Abteilung legt nicht die Instanz lahm |
-| **4** | Ursprungsverweis in jedem Vorgang (#697) | Entscheidungen stützen sich auf das Original, nicht auf die vierte Nacherzählung |
+| **4** | Ursprungsverweis in jedem Vorgang (#697); Zielkette (#714); Rückmeldung nach Vertrauensstufe (#715) | Entscheidungen stützen sich auf das Original, jede Aufgabe kennt ihren Zweck, und fremder Text steigt nicht in der Hierarchie auf |
 | **5** | Eskalation, Konflikt und Beschluss (#689) | Eine Frage, die niemand beantworten kann, versandet nicht mehr |
 | **6** | Besprechung als Mittel, mit Protokoll | Leitungen können sich abstimmen, ohne *n²* Nachrichten |
 | **7** | Entscheidungsinstanz an der Spitze (#690) | Der Betrieb läuft weiter, wenn der Mensch schläft |
@@ -925,11 +1290,11 @@ für sich schon nützt und keine die nächste blockiert.
 | **9** | Kontrollpflicht der Leitung, abgestufte personelle Mittel (#693); Doctrine (#698) | Fehler findet die Leitung, nicht erst der Mensch — und sie kann steuern |
 | **9a** | Kosten je Einheit, Abweichungsmeldung (#699), Archiv (#700) | Ineffizienz wird sichtbar, bevor sie einen Monat lang läuft |
 | **9b** | Abstimmung als dritte Freigabeform (#702) | Vier Blickwinkel statt einer Unterschrift, wo es sich lohnt |
-| **10** | Oberfläche: Organigramm statt Agentenliste, Lage je Abteilung | Bei fünfzig Agenten ist eine flache Liste keine Übersicht |
+| **10** | Oberfläche: Organigramm und Lagebild in einem (#688, #711 Stufe 1) | Bei fünfzig Agenten ist eine flache Liste keine Übersicht |
 | **11** | Organisationsvorlagen (#691) | Ein Haus lässt sich weitergeben statt nachbauen |
 
 Quer dazu, unabhängig von der Reihenfolge: der Werkzeugkasten (#692), der A/B-Vergleich
-von Modellen (#694) und die Schemaauskunft (#676) — letztere ist Vorbedingung für
+von Modellen (#694), die fremden Laufzeiten samt MCP-Server (#712, #713; nach der Sandbox #654) und die Schemaauskunft (#676) — letztere ist Vorbedingung für
 Stufe 5, weil eine Eskalation einen belastbaren Negativbefund braucht.
 
 **Zum Umzug (Abschnitt 3):** Er gehört zu Stufe 1. Eine Struktur, die sich nach dem
@@ -979,11 +1344,18 @@ Gegenlesen am 2026-09-22 als zu grob aufgefallen:
 - **Was ist eine „Grenze" der Leitung?** Das Konzept sagt „die Leitung gibt frei, was
   innerhalb ihrer Grenzen liegt", ohne zu sagen, woraus eine Grenze besteht. Vorschlag:
   Betrag je Vorgang, Betrag je Tag, erlaubte Werkzeugklassen, Außenwirkung ja/nein — und
-  alles davon an der Einheit, nicht an der Person der Leitung (Stufe 8).
+  alles davon an der Einheit, nicht an der Person der Leitung (Stufe 8). *Überholt am
+  2026-09-24: Grenzen sind ein Sammelwert und stehen am Leitungsagenten (Abschnitt 3,
+  „Einstellungen an der Einheit").*
 - **Wie wird ein Beschluss wirksam?** „Bindend für alles unterhalb" ist ein Wort ohne
   Maschinerie, solange niemand nachsieht. Vorschlag: Das Eskalationswerkzeug sucht von
   sich aus, bevor es einen Vorgang anlegt — genau wie `task_find` vor `task_create`
   (#674). Ein Beschluss, den man aktiv lesen müsste, wird nicht gelesen (Stufe 5).
+- **Auf welchem Account läuft eine fremde Laufzeit?** (Abschnitt 7a, vor #712.) Ein
+  Pro-Plan teilt sein Kontingent mit dem Menschen, und ob der automatisierte
+  Dauerbetrieb eines Verbraucher-Abos von den Nutzungsbedingungen gedeckt ist, ist
+  ungeprüft. Vorschlag: beide Anmeldewege bauen, als Voreinstellung den API-Schlüssel
+  nehmen und das Abo erst nach Prüfung der Bedingungen freigeben.
 - ~~**Was passiert, wenn die Eskalationsgrenze erreicht ist?**~~ **Entschieden am
   2026-09-22, und schärfer als vorgeschlagen: Eine Eskalation, die nicht gelöst werden
   kann, darf es nicht geben.** Finden die Agenten binnen einer einstellbaren Frist keine
@@ -1024,3 +1396,10 @@ nur nicht selbst an.
 | #654, #196, #657 | Sandbox, Shell, Skriptprüfung — der eigentliche Werkzeugkasten |
 | #687 | Freigabe durch die Leitung innerhalb von Grenzen |
 | #688 | Organigramm in Oberfläche und WebUI |
+| #716 | Was liegen bleibt, wenn das Budget endet (Ausfall, Nachholen, Reservierung) |
+| #717 | Füllarbeit und Großaufgaben: ungenutztes Budget füllen, teilen oder Sonderbudget |
+| #711 | Lagebild (Teamübersicht): wer arbeitet, wer spricht mit wem, wo klemmt es |
+| #712 | Fremde Laufzeiten: Claude Code, Codex, Befehl, HTTP |
+| #713 | ClawdDotNet als MCP-Server für fremde Laufzeiten |
+| #714 | Zielkette und Prüfung ruhender Aufgabenbäume |
+| #715 | Rückmeldung nach Vertrauensstufe, Courier Pattern |

src/ClawdDotNet.App/AppHost.cs

@@ -3,6 +3,7 @@ using ClawdDotNet.App.Settings;
 using ClawdDotNet.Core.Accounting;
 using ClawdDotNet.Core.Api;
 using ClawdDotNet.Core.Audit;
+using ClawdDotNet.Core.Budget;
 using ClawdDotNet.Core.Config;
 using ClawdDotNet.Core.Engine;
 using ClawdDotNet.Core.Logging;
@@ -112,6 +113,9 @@ public sealed class AppHost : IAsyncDisposable
         Board, AuditRepository, Scanner, Usage, Pricing, () => Instance.Agents,
         LoggerFactory.CreateLogger("ClawdDotNet.App.Tasks"));
 
+    /// <summary>#711: The team overview. Stateless, like <see cref="TaskAdmin"/>.</summary>
+    public TeamOverview Team => new(Engine, Staging, AuditRepository, Usage, () => Instance.Agents);
+
     public TelegramClientManager? TelegramClient { get; private init; }
     public OpenRouterStatusService? Status { get; private init; }
 
@@ -725,7 +729,24 @@ public sealed class AppHost : IAsyncDisposable
         var dispatcher = new EngineTaskDispatcher(
             engine, () => instance.Agents, instance.InstanceId, tools, stateStore, loggerFactory);
 
-        var scanner = new TaskScanner(taskRepository, dispatcher, loggerFactory);
+        var headroom = engine.BudgetGuard is { } guard
+            ? new BudgetHeadroom(guard, () => instance.Agents, () => engine.InstanceBudget)
+            : null;
+
+        var scanner = new TaskScanner(taskRepository, dispatcher, loggerFactory,
+            maxParallelRuns: instance.MaxParallelTaskRuns,
+            budgetMissPolicy: task =>
+            {
+                // #716: The agent's rule. Bare '@new' names no agent — then the default applies.
+                var agentId = TaskAssignee.AgentId(task.Assignee);
+                return instance.Agents
+                    .FirstOrDefault(a => string.Equals(a.AgentId, agentId, StringComparison.OrdinalIgnoreCase))
+                    ?.Budget.MissPolicy ?? BudgetMissPolicy.Expire;
+            },
+            // #716: Late work waits for headroom the rest of the day does not need, and a
+            // day the budget will not last is named while there is still time to act.
+            lateRunGate: headroom,
+            budgetOutlook: headroom);
 
         // Reconciliation nicht blockierend: Der Start soll nicht auf das Dateisystem warten.
         _ = Task.Run(async () =>

src/ClawdDotNet.App/Services/TaskAdministration.cs

@@ -187,7 +187,8 @@ public sealed class TaskAdministration(
         if (board is null)
             return null;
 
-        var aufgaben = await board.ListAsync(new TaskQuery { Limit = 500 }, ct);
+        // #716: ungekappt - vorher fehlten ab 500 Aufgaben die übrigen in der Prognose.
+        var aufgaben = await board.ListAllAsync(ct);
 
         var belege = new Dictionary<string, IReadOnlyList<RunReceipt>>(StringComparer.Ordinal);
         if (audit is not null)

src/ClawdDotNet.App/Services/TeamOverview.cs

@@ -0,0 +1,170 @@
+using ClawdDotNet.Core.Accounting;
+using ClawdDotNet.Core.Activity;
+using ClawdDotNet.Core.Audit;
+using ClawdDotNet.Core.Config;
+using ClawdDotNet.Core.Engine;
+using ClawdDotNet.Core.Staging;
+
+namespace ClawdDotNet.App.Services;
+
+/// <summary>What an agent is doing, as the team overview shows it (#711).</summary>
+public enum TeamState
+{
+    /// <summary>Nothing running, nothing open, the last run went fine (or there was none).</summary>
+    Idle,
+
+    /// <summary>At least one run in progress.</summary>
+    Working,
+
+    /// <summary>A run has taken much longer than this agent's runs usually take.</summary>
+    Stuck,
+
+    /// <summary>Tool calls of this agent wait for a human decision.</summary>
+    WaitingForApproval,
+
+    /// <summary>The last run failed, hit a limit or found the target busy.</summary>
+    Problem,
+
+    /// <summary>The last run was refused because the budget is used up.</summary>
+    BudgetExhausted
+}
+
+/// <summary>One agent in the team overview.</summary>
+public sealed record TeamMember(
+    string AgentId,
+    string DisplayName,
+    string Model,
+    TeamState State,
+    IReadOnlyList<ActiveRun> Runs,
+    int PendingApprovals,
+    string? LastRunStatus,
+    DateTime? LastRunAtUtc,
+    string? LastRunResult,
+    long TypicalRunMs);
+
+/// <summary>The whole picture at one moment: every agent, and who reached whom recently.</summary>
+public sealed record TeamSnapshot(IReadOnlyList<TeamMember> Members, IReadOnlyList<AgentLink> RecentLinks, DateTime AtUtc);
+
+/// <summary>
+/// #711: The team overview — who is working, who reached whom, where something is stuck.
+///
+/// <para><b>Detecting is code, interpreting is model</b> (Organisation-Konzept, 10a). Every
+/// state here comes from a fact the instance recorded: a run in progress, an open staged
+/// call, the status of the last receipt. Nothing is judged by a model, so the picture is
+/// the same for everyone who looks and costs nothing to draw.</para>
+///
+/// <para><b>Order of states.</b> When several apply, the one that needs someone first wins:
+/// stuck, then waiting for approval, then working; a problem or an exhausted budget only
+/// shows while nothing new is running — a new run is the attempt to get past it.</para>
+/// </summary>
+public sealed class TeamOverview(
+    AgentEngine? engine,
+    StagingService? staging,
+    IAuditRepository? audit,
+    IUsageRepository? usage,
+    Func<IReadOnlyList<AgentConfig>> agents,
+    TimeProvider? clock = null)
+{
+    /// <summary>How far back the last receipt of each agent is looked for.</summary>
+    public static readonly TimeSpan ReceiptWindow = TimeSpan.FromDays(3);
+
+    /// <summary>How long recent links stay in the snapshot — the overview fades them out.</summary>
+    public static readonly TimeSpan LinkWindow = TimeSpan.FromMinutes(10);
+
+    /// <summary>A run counts as stuck after this many times the agent's typical duration…</summary>
+    public const int StuckFactor = 3;
+
+    /// <summary>…but never before this — short runs vary a lot in relative terms.</summary>
+    public static readonly TimeSpan StuckFloor = TimeSpan.FromMinutes(5);
+
+    /// <summary>Without history, a run counts as stuck after this long.</summary>
+    public static readonly TimeSpan StuckWithoutHistory = TimeSpan.FromMinutes(15);
+
+    private readonly TimeProvider _clock = clock ?? TimeProvider.System;
+
+    public async Task<TeamSnapshot> SnapshotAsync(CancellationToken ct)
+    {
+        var now = _clock.GetUtcNow().UtcDateTime;
+        var configured = agents();
+
+        var active = engine?.Activity.ActiveRuns() ?? [];
+        var links = engine?.Activity.RecentLinks(LinkWindow) ?? [];
+
+        var pending = staging is null ? [] : await staging.ListPendingAsync(ct);
+        var pendingByAgent = pending
+            .GroupBy(c => c.AgentId, StringComparer.OrdinalIgnoreCase)
+            .ToDictionary(g => g.Key, g => g.Count(), StringComparer.OrdinalIgnoreCase);
+
+        var lastReceipt = new Dictionary<string, RunReceipt>(StringComparer.OrdinalIgnoreCase);
+        if (audit is not null)
+        {
+            var receipts = await audit.ListReceiptsAsync(now - ReceiptWindow, now, 5_000, ct);
+            foreach (var receipt in receipts)
+            {
+                if (!lastReceipt.TryGetValue(receipt.AgentId, out var known) || receipt.OccurredAt > known.OccurredAt)
+                    lastReceipt[receipt.AgentId] = receipt;
+            }
+        }
+
+        var members = new List<TeamMember>();
+        foreach (var agent in configured)
+        {
+            var runs = active
+                .Where(r => string.Equals(r.AgentId, agent.AgentId, StringComparison.OrdinalIgnoreCase))
+                .OrderBy(r => r.StartedAtUtc)
+                .ToList();
+            var approvals = pendingByAgent.GetValueOrDefault(agent.AgentId);
+            lastReceipt.TryGetValue(agent.AgentId, out var last);
+            var typical = await TypicalRunAsync(agent.AgentId, ct);
+
+            var state = Classify(runs, approvals, last?.Status, typical, now);
+            members.Add(new TeamMember(
+                agent.AgentId, agent.DisplayName, agent.Model, state, runs, approvals,
+                last?.Status, last?.OccurredAt, last?.ResultRef, (long)typical.TotalMilliseconds));
+        }
+
+        return new TeamSnapshot(members, links, now);
+    }
+
+    /// <summary>
+    /// The state from the facts. Pure, so the rules can be tested without an instance.
+    /// </summary>
+    public static TeamState Classify(
+        IReadOnlyList<ActiveRun> runs, int pendingApprovals, string? lastRunStatus, TimeSpan typicalRun, DateTime nowUtc)
+    {
+        if (runs.Count > 0)
+        {
+            var limit = typicalRun > TimeSpan.Zero
+                ? TimeSpan.FromTicks(Math.Max(typicalRun.Ticks * StuckFactor, StuckFloor.Ticks))
+                : StuckWithoutHistory;
+            if (runs.Any(r => nowUtc - r.StartedAtUtc > limit))
+                return TeamState.Stuck;
+        }
+
+        if (pendingApprovals > 0)
+            return TeamState.WaitingForApproval;
+
+        if (runs.Count > 0)
+            return TeamState.Working;
+
+        return lastRunStatus switch
+        {
+            nameof(AgentRunStatus.BudgetExceeded) => TeamState.BudgetExhausted,
+            nameof(AgentRunStatus.Failed)
+                or nameof(AgentRunStatus.LoopLimitExceeded)
+                or nameof(AgentRunStatus.TargetBusy) => TeamState.Problem,
+            _ => TeamState.Idle
+        };
+    }
+
+    /// <summary>The agent's typical run duration — the median of its recent runs.</summary>
+    private async Task<TimeSpan> TypicalRunAsync(string agentId, CancellationToken ct)
+    {
+        if (usage is null)
+            return TimeSpan.Zero;
+
+        var recent = await usage.GetRecentForAgentAsync(agentId, 20, ct);
+        var durations = recent.Where(r => r.DurationMs > 0).Select(r => r.DurationMs).Order().ToList();
+        return durations.Count == 0 ? TimeSpan.Zero : TimeSpan.FromMilliseconds(durations[durations.Count / 2]);
+    }
+}

src/ClawdDotNet.Core/Accounting/SqliteUsageRepository.cs

@@ -125,6 +125,29 @@ public sealed class SqliteUsageRepository : IUsageRepository
         return results;
     }
 
+    public async Task<IReadOnlyList<RunUsage>> GetRecentForAgentAsync(string agentId, int limit, CancellationToken ct)
+    {
+        await using var conn = await _storage.OpenConnectionAsync(ct);
+        using var cmd = conn.CreateCommand();
+        cmd.CommandText = """
+            SELECT Id, AgentId, Model, PromptTokens, CompletionTokens, CachedTokens,
+                   CostUsd, CostIsKnown, Status, StepCount, DurationMs, OccurredAt
+              FROM RunUsage
+             WHERE AgentId = @agent COLLATE NOCASE
+             ORDER BY OccurredAt DESC
+             LIMIT @limit
+            """;
+        cmd.Parameters.AddWithValue("@agent", agentId);
+        cmd.Parameters.AddWithValue("@limit", Math.Clamp(limit, 1, 1000));
+
+        var results = new List<RunUsage>();
+        await using var reader = await cmd.ExecuteReaderAsync(ct);
+        while (await reader.ReadAsync(ct))
+            results.Add(Read(reader));
+
+        return results;
+    }
+
     public Task<int> PurgeBeforeAsync(DateOnly date, CancellationToken ct)
         => _storage.WriteAsync(async conn =>
         {

src/ClawdDotNet.Core/Accounting/UsageModels.cs

@@ -53,6 +53,14 @@ public interface IUsageRepository
 
     Task<IReadOnlyList<RunUsage>> GetRecentAsync(int limit, CancellationToken ct);
 
+    /// <summary>
+    /// #716: The most recent runs of one agent — the basis for estimating what a run of
+    /// it will cost. Without an implementation there is no estimate, and a reservation
+    /// counts nothing.
+    /// </summary>
+    Task<IReadOnlyList<RunUsage>> GetRecentForAgentAsync(string agentId, int limit, CancellationToken ct)
+        => Task.FromResult<IReadOnlyList<RunUsage>>([]);
+
     /// <summary>Entfernt Einträge älter als das angegebene Datum. Gibt die Anzahl zurück.</summary>
     Task<int> PurgeBeforeAsync(DateOnly date, CancellationToken ct);
 }

src/ClawdDotNet.Core/Activity/AgentActivity.cs

@@ -0,0 +1,132 @@
+using ClawdDotNet.Core.Tools;
+
+namespace ClawdDotNet.Core.Activity;
+
+/// <summary>A run that is in progress right now.</summary>
+public sealed record ActiveRun(
+    string RunId,
+    string AgentId,
+    string Source,
+    string? TaskId,
+    string? CalledBy,
+    DateTime StartedAtUtc);
+
+/// <summary>
+/// One agent reaching another — for now a delegated run (<see cref="Kind"/> =
+/// <c>delegation</c>). Meetings and escalations will add their own kinds.
+/// </summary>
+public sealed record AgentLink(string From, string To, string Kind, DateTime AtUtc);
+
+/// <summary>
+/// #711: Who is working right now, and who reached whom — the live side of the team overview.
+///
+/// <para><b>Why a component of its own.</b> The engine already tracked running chats, but
+/// only those that went through <c>ChatAsync</c>; a fresh run (<c>@new</c>) was invisible to
+/// <c>IsRunning</c>. And nothing recorded that agent A had called agent B — the delegation
+/// chain knew it for the length of the call and then forgot. Here both are kept and
+/// announced, independent of which engine path a run takes.</para>
+///
+/// <para><b>Memory only, and bounded.</b> This is the view of "now". What happened
+/// yesterday is in the audit log; the time line (#711, later) replays it from there.</para>
+/// </summary>
+public sealed class AgentActivity
+{
+    /// <summary>How many recent links are kept for a page that connects late.</summary>
+    public const int RecentLinkCapacity = 500;
+
+    private readonly Lock _lock = new();
+    private readonly Dictionary<string, ActiveRun> _active = new(StringComparer.Ordinal);
+    private readonly Queue<AgentLink> _recentLinks = new();
+    private readonly TimeProvider _clock;
+
+    public AgentActivity(TimeProvider? clock = null) => _clock = clock ?? TimeProvider.System;
+
+    public event Action<ActiveRun>? RunStarted;
+
+    /// <summary>A run ended — with the <c>AgentRunStatus</c> name, or <c>Aborted</c>.</summary>
+    public event Action<ActiveRun, string>? RunFinished;
+
+    public event Action<AgentLink>? LinkObserved;
+
+    /// <summary>
+    /// Announces a run. Dispose the handle when it ends; call <see cref="RunHandle.Complete"/>
+    /// first to report how. A delegated run (<paramref name="chain"/> deeper than its root)
+    /// also records the link from the caller.
+    /// </summary>
+    public RunHandle Begin(string runId, string agentId, string source, string? taskId, DelegationChain? chain)
+    {
+        var now = _clock.GetUtcNow().UtcDateTime;
+        var calledBy = chain is { Depth: > 0 } ? chain.Agents[^2] : null;
+        var run = new ActiveRun(runId, agentId, source, taskId, calledBy, now);
+
+        AgentLink? link = calledBy is null ? null : new AgentLink(calledBy, agentId, "delegation", now);
+
+        lock (_lock)
+        {
+            _active[runId] = run;
+            if (link is not null)
+            {
+                _recentLinks.Enqueue(link);
+                while (_recentLinks.Count > RecentLinkCapacity)
+                    _recentLinks.Dequeue();
+            }
+        }
+
+        Raise(() => RunStarted?.Invoke(run));
+        if (link is not null)
+            Raise(() => LinkObserved?.Invoke(link));
+
+        return new RunHandle(this, run);
+    }
+
+    /// <summary>The runs in progress right now.</summary>
+    public IReadOnlyList<ActiveRun> ActiveRuns()
+    {
+        lock (_lock)
+            return [.. _active.Values];
+    }
+
+    /// <summary>Links observed within <paramref name="window"/>, oldest first.</summary>
+    public IReadOnlyList<AgentLink> RecentLinks(TimeSpan window)
+    {
+        var since = _clock.GetUtcNow().UtcDateTime - window;
+        lock (_lock)
+            return [.. _recentLinks.Where(l => l.AtUtc >= since)];
+    }
+
+    private void End(ActiveRun run, string status)
+    {
+        lock (_lock)
+        {
+            if (!_active.Remove(run.RunId))
+                return;
+        }
+
+        Raise(() => RunFinished?.Invoke(run, status));
+    }
+
+    /// <summary>A subscriber that throws must not break the run it is watching.</summary>
+    private static void Raise(Action raise)
+    {
+        try { raise(); }
+        catch { /* observers are best effort */ }
+    }
+
+    public sealed class RunHandle : IDisposable
+    {
+        private readonly AgentActivity _owner;
+        private readonly ActiveRun _run;
+        private string _status = "Aborted";
+
+        internal RunHandle(AgentActivity owner, ActiveRun run)
+        {
+            _owner = owner;
+            _run = run;
+        }
+
+        /// <summary>How the run ended. Without it, disposal reports <c>Aborted</c>.</summary>
+        public void Complete(string status) => _status = status;
+
+        public void Dispose() => _owner.End(_run, _status);
+    }
+}

src/ClawdDotNet.Core/Budget/BudgetGuard.cs

@@ -13,6 +13,13 @@ public enum BudgetLimit
     InstanceTokens
 }
 
+/// <summary>#716: What a run is expected to use — the agent's average over recent runs.</summary>
+public readonly record struct RunEstimate(decimal CostUsd, long Tokens)
+{
+    public static RunEstimate operator +(RunEstimate a, RunEstimate b) => new(a.CostUsd + b.CostUsd, a.Tokens + b.Tokens);
+    public static RunEstimate operator -(RunEstimate a, RunEstimate b) => new(a.CostUsd - b.CostUsd, a.Tokens - b.Tokens);
+}
+
 public sealed record BudgetStatus(bool IsAllowed, BudgetLimit Limit, string? Reason)
 {
     public static BudgetStatus Allowed { get; } = new(true, BudgetLimit.None, null);
@@ -34,6 +41,19 @@ public sealed class BudgetGuard
     private readonly IUsageRepository _usage;
     private readonly Func<DateTime> _now;
 
+    /// <summary>How many recent runs of an agent make up its per-run estimate (#716).</summary>
+    public const int EstimateSample = 20;
+
+    /// <summary>
+    /// #716: Check and reserve happen under this lock. Without it, two runs starting at
+    /// the same moment would both read the same "used" figure and both pass.
+    /// </summary>
+    private readonly SemaphoreSlim _reserveGate = new(1, 1);
+
+    private readonly Lock _reservedLock = new();
+    private readonly Dictionary<string, RunEstimate> _reservedByAgent = new(StringComparer.OrdinalIgnoreCase);
+    private RunEstimate _reservedInstance;
+
     public BudgetGuard(IUsageRepository usage, Func<DateTime>? now = null)
     {
         _usage = usage;
@@ -43,8 +63,116 @@ public sealed class BudgetGuard
     /// <summary>
     /// Prüft, ob der Agent heute noch laufen darf.
     /// </summary>
-    public async Task<BudgetStatus> CheckAsync(
+    public Task<BudgetStatus> CheckAsync(
         AgentConfig agent, InstanceBudget instanceBudget, CancellationToken ct)
+        => CheckCoreAsync(agent, instanceBudget, default, default, ct);
+
+    /// <summary>
+    /// #716: Checks like <see cref="CheckAsync"/> and, if the run may start, reserves its
+    /// estimated usage until the returned handle is disposed — i.e. until the run's usage
+    /// is recorded.
+    ///
+    /// <para><b>What changes.</b> Before, each run was checked on its own against what was
+    /// already recorded. Runs in flight were invisible, so several starting together all
+    /// passed and exceeded the budget together (#682 capped how many; this closes it).
+    /// Now the runs in flight count with their estimate.</para>
+    ///
+    /// <para><b>What does not change.</b> A single run is still refused only when the
+    /// budget is already used up — its own estimate is not added. Otherwise a small task
+    /// would be refused because the agent's average run is large.</para>
+    /// </summary>
+    public async Task<(BudgetStatus Status, IDisposable? Reservation)> ReserveAsync(
+        AgentConfig agent, InstanceBudget instanceBudget, CancellationToken ct)
+    {
+        if (!agent.Budget.HasAnyLimit && !instanceBudget.HasAnyLimit)
+            return (BudgetStatus.Allowed, null);
+
+        var estimate = await EstimateRunAsync(agent.AgentId, ct);
+
+        await _reserveGate.WaitAsync(ct);
+        try
+        {
+            RunEstimate agentReserved, instanceReserved;
+            lock (_reservedLock)
+            {
+                agentReserved = _reservedByAgent.GetValueOrDefault(agent.AgentId);
+                instanceReserved = _reservedInstance;
+            }
+
+            var status = await CheckCoreAsync(agent, instanceBudget, agentReserved, instanceReserved, ct);
+            if (!status.IsAllowed)
+                return (status, null);
+
+            lock (_reservedLock)
+            {
+                _reservedByAgent[agent.AgentId] = _reservedByAgent.GetValueOrDefault(agent.AgentId) + estimate;
+                _reservedInstance += estimate;
+            }
+
+            return (status, new Reservation(this, agent.AgentId, estimate));
+        }
+        finally
+        {
+            _reserveGate.Release();
+        }
+    }
+
+    /// <summary>Today's usage of an agent, or with an empty id of the whole instance.</summary>
+    public Task<DailyUsage> GetUsedTodayAsync(string agentId, CancellationToken ct)
+        => _usage.GetDailyAsync(DateOnly.FromDateTime(_now()), agentId, ct);
+
+    /// <summary>What is currently reserved by runs in flight — for the agent, or with an
+    /// empty id for the whole instance.</summary>
+    public RunEstimate Reserved(string agentId)
+    {
+        lock (_reservedLock)
+            return agentId.Length == 0 ? _reservedInstance : _reservedByAgent.GetValueOrDefault(agentId);
+    }
+
+    /// <summary>
+    /// The average of the agent's recent runs. Runs without usage (refusals, aborted
+    /// before the first call) do not count — they would drag the estimate towards zero.
+    /// </summary>
+    public async Task<RunEstimate> EstimateRunAsync(string agentId, CancellationToken ct)
+    {
+        var recent = await _usage.GetRecentForAgentAsync(agentId, EstimateSample, ct);
+        var runs = recent.Where(r => r.TotalTokens > 0).ToList();
+        if (runs.Count == 0)
+            return default;
+
+        return new RunEstimate(
+            runs.Average(r => r.CostUsd),
+            (long)Math.Ceiling(runs.Average(r => (double)r.TotalTokens)));
+    }
+
+    private void Release(string agentId, RunEstimate estimate)
+    {
+        lock (_reservedLock)
+        {
+            var left = _reservedByAgent.GetValueOrDefault(agentId) - estimate;
+            if (left.CostUsd <= 0 && left.Tokens <= 0)
+                _reservedByAgent.Remove(agentId);
+            else
+                _reservedByAgent[agentId] = left;
+
+            _reservedInstance -= estimate;
+        }
+    }
+
+    private sealed class Reservation(BudgetGuard guard, string agentId, RunEstimate estimate) : IDisposable
+    {
+        private int _disposed;
+
+        public void Dispose()
+        {
+            if (Interlocked.Exchange(ref _disposed, 1) == 0)
+                guard.Release(agentId, estimate);
+        }
+    }
+
+    private async Task<BudgetStatus> CheckCoreAsync(
+        AgentConfig agent, InstanceBudget instanceBudget,
+        RunEstimate agentReserved, RunEstimate instanceReserved, CancellationToken ct)
     {
         var today = DateOnly.FromDateTime(_now());
 
@@ -54,19 +182,21 @@ public sealed class BudgetGuard
         {
             var used = await _usage.GetDailyAsync(today, agent.AgentId, ct);
 
-            if (Exceeds(agentBudget.DailyCostUsd, used.CostUsd))
+            if (Exceeds(agentBudget.DailyCostUsd, used.CostUsd + agentReserved.CostUsd))
             {
                 return new BudgetStatus(false, BudgetLimit.AgentCost,
                     $"Tagesbudget des Agenten erschöpft: {used.CostUsd:F4} von maximal " +
                     $"{agentBudget.DailyCostUsd:F2} USD verbraucht." +
+                    ReservedHint(agentReserved.CostUsd) +
                     UnpricedHint(used));
             }
 
-            if (Exceeds(agentBudget.DailyTokens, used.TotalTokens))
+            if (Exceeds(agentBudget.DailyTokens, used.TotalTokens + agentReserved.Tokens))
             {
                 return new BudgetStatus(false, BudgetLimit.AgentTokens,
                     $"Token-Tageslimit des Agenten erschöpft: {used.TotalTokens:N0} von maximal " +
-                    $"{agentBudget.DailyTokens:N0}.");
+                    $"{agentBudget.DailyTokens:N0}." +
+                    ReservedTokensHint(agentReserved.Tokens));
             }
         }
 
@@ -75,19 +205,21 @@ public sealed class BudgetGuard
         {
             var used = await _usage.GetDailyAsync(today, agentId: "", ct);
 
-            if (Exceeds(instanceBudget.DailyCostUsd, used.CostUsd))
+            if (Exceeds(instanceBudget.DailyCostUsd, used.CostUsd + instanceReserved.CostUsd))
             {
                 return new BudgetStatus(false, BudgetLimit.InstanceCost,
                     $"Tagesbudget der Instanz erschöpft: {used.CostUsd:F4} von maximal " +
                     $"{instanceBudget.DailyCostUsd:F2} USD verbraucht." +
+                    ReservedHint(instanceReserved.CostUsd) +
                     UnpricedHint(used));
             }
 
-            if (Exceeds(instanceBudget.DailyTokens, used.TotalTokens))
+            if (Exceeds(instanceBudget.DailyTokens, used.TotalTokens + instanceReserved.Tokens))
             {
                 return new BudgetStatus(false, BudgetLimit.InstanceTokens,
                     $"Token-Tageslimit der Instanz erschöpft: {used.TotalTokens:N0} von maximal " +
-                    $"{instanceBudget.DailyTokens:N0}.");
+                    $"{instanceBudget.DailyTokens:N0}." +
+                    ReservedTokensHint(instanceReserved.Tokens));
             }
         }
 
@@ -109,6 +241,13 @@ public sealed class BudgetGuard
 
     private static bool Exceeds(long limit, long used) => limit > 0 && used >= limit;
 
+    /// <summary>#716: Without this, a refusal at "3.20 of 5.00 USD used" would look wrong.</summary>
+    private static string ReservedHint(decimal reserved)
+        => reserved > 0 ? $" Weitere {reserved:F4} USD sind für laufende Läufe reserviert." : "";
+
+    private static string ReservedTokensHint(long reserved)
+        => reserved > 0 ? $" Weitere {reserved:N0} Tokens sind für laufende Läufe reserviert." : "";
+
     /// <summary>
     /// Ohne Preisangaben ist die verbrauchte Summe unvollständig — sonst wirkte ein
     /// niedriger Wert wie ein noch offener Spielraum.

src/ClawdDotNet.Core/Budget/BudgetHeadroom.cs

@@ -0,0 +1,220 @@
+using ClawdDotNet.Core.Config;
+using ClawdDotNet.Core.Tasks;
+
+namespace ClawdDotNet.Core.Budget;
+
+/// <summary>
+/// #716: Decides whether a late run — carried-over work or a catch-up — may start now,
+/// without taking budget the rest of the day still needs.
+///
+/// <para><b>The rule: the new day has right of way.</b> Headroom is the limit minus what
+/// was used, minus what runs in flight have reserved, minus what the day's remaining
+/// scheduled runs will need, minus a safety margin. A late run starts only if its
+/// estimate fits into that. Otherwise one overdrawn day would push its shortfall into the
+/// next, and the next, instead of resolving it.</para>
+///
+/// <para>This replaces the flat "at most 25 % of the new day" from the concept: a fixed
+/// share is either too much on a busy day or needlessly little on a quiet one. The same
+/// calculation is what fill work (#717) will run on.</para>
+///
+/// <para><b>Estimates, honestly.</b> A run is estimated from the agent's recent runs
+/// (<see cref="BudgetGuard.EstimateRunAsync"/>). Without history the estimate is zero —
+/// then only the margin keeps a reserve. That errs towards letting late work through;
+/// the budget check at the start of the run still refuses once the limit is reached.</para>
+/// </summary>
+public sealed class BudgetHeadroom : ILateRunGate, IBudgetOutlook
+{
+    /// <summary>Share of each limit kept free as a reserve for surprises.</summary>
+    public const decimal SafetyShare = 0.10m;
+
+    private readonly BudgetGuard _guard;
+    private readonly Func<IReadOnlyList<AgentConfig>> _agents;
+    private readonly Func<InstanceBudget> _instanceBudget;
+    private readonly TimeProvider _clock;
+
+    public BudgetHeadroom(
+        BudgetGuard guard,
+        Func<IReadOnlyList<AgentConfig>> agents,
+        Func<InstanceBudget> instanceBudget,
+        TimeProvider? clock = null)
+    {
+        _guard = guard;
+        _agents = agents;
+        _instanceBudget = instanceBudget;
+        _clock = clock ?? TimeProvider.System;
+    }
+
+    public async Task<bool> HasRoomAsync(
+        TaskItem lateTask, IReadOnlyList<TaskItem> runnable, DateTime nowUtc, CancellationToken ct)
+    {
+        var agents = _agents();
+        var agent = FindAgent(agents, lateTask);
+        var instanceBudget = _instanceBudget();
+
+        // Without a known agent there is nothing to calculate against; the budget check at
+        // the start of the run still applies.
+        if (agent is null || (!agent.Budget.HasAnyLimit && !instanceBudget.HasAnyLimit))
+            return true;
+
+        var endOfDay = StartOfNextLocalDay(nowUtc);
+        var estimates = new Dictionary<string, RunEstimate>(StringComparer.OrdinalIgnoreCase);
+
+        async Task<RunEstimate> EstimateFor(string agentId)
+        {
+            if (!estimates.TryGetValue(agentId, out var estimate))
+                estimates[agentId] = estimate = await _guard.EstimateRunAsync(agentId, ct);
+            return estimate;
+        }
+
+        var ownEstimate = await EstimateFor(agent.AgentId);
+
+        // Regular work of the rest of the day: everything scheduled except late work
+        // itself — that is what has to wait for headroom, not what headroom is kept for.
+        var regular = runnable.Where(t => t.Id != lateTask.Id && !IsLate(t)).ToList();
+
+        if (agent.Budget.HasAnyLimit)
+        {
+            var demand = default(RunEstimate);
+            foreach (var task in regular.Where(t => IsOf(t, agent.AgentId)))
+                demand += Times(ownEstimate, TaskSchedule.OccurrencesBetween(task, nowUtc, endOfDay));
+
+            var used = await _guard.GetUsedTodayAsync(agent.AgentId, ct);
+            var reserved = _guard.Reserved(agent.AgentId);
+
+            if (!Fits(agent.Budget.DailyCostUsd, used.CostUsd, reserved.CostUsd, demand.CostUsd, ownEstimate.CostUsd)
+                || !Fits(agent.Budget.DailyTokens, used.TotalTokens, reserved.Tokens, demand.Tokens, ownEstimate.Tokens))
+                return false;
+        }
+
+        if (instanceBudget.HasAnyLimit)
+        {
+            var demand = default(RunEstimate);
+            foreach (var task in regular)
+            {
+                var agentId = TaskAssignee.AgentId(task.Assignee);
+                if (agentId.Length == 0)
+                    continue;
+                demand += Times(await EstimateFor(agentId), TaskSchedule.OccurrencesBetween(task, nowUtc, endOfDay));
+            }
+
+            var used = await _guard.GetUsedTodayAsync("", ct);
+            var reserved = _guard.Reserved("");
+
+            if (!Fits(instanceBudget.DailyCostUsd, used.CostUsd, reserved.CostUsd, demand.CostUsd, ownEstimate.CostUsd)
+                || !Fits(instanceBudget.DailyTokens, used.TotalTokens, reserved.Tokens, demand.Tokens, ownEstimate.Tokens))
+                return false;
+        }
+
+        return true;
+    }
+
+    /// <summary>
+    /// #716: Walks through the rest of today's schedule in time order and finds, per agent
+    /// with a limit and for the instance, the first run the budget would no longer cover.
+    /// Late work is left out: it only ever runs in headroom, so it cannot be what makes the
+    /// day's own runs fail.
+    /// </summary>
+    public async Task<IReadOnlyList<BudgetShortfall>> ShortfallsAsync(
+        IReadOnlyList<TaskItem> runnable, DateTime nowUtc, CancellationToken ct)
+    {
+        var agents = _agents();
+        var instanceBudget = _instanceBudget();
+        var endOfDay = StartOfNextLocalDay(nowUtc);
+        var result = new List<BudgetShortfall>();
+
+        // Every planned run until midnight, with whose it is.
+        var planned = new List<(DateTime At, string AgentId)>();
+        foreach (var task in runnable.Where(t => !IsLate(t)))
+        {
+            var agent = FindAgent(agents, task);
+            if (agent is null)
+                continue;
+            foreach (var at in TaskSchedule.OccurrenceTimesBetween(task, nowUtc, endOfDay))
+                planned.Add((at, agent.AgentId));
+        }
+
+        planned.Sort((a, b) => a.At.CompareTo(b.At));
+
+        var estimates = new Dictionary<string, RunEstimate>(StringComparer.OrdinalIgnoreCase);
+        foreach (var agentId in planned.Select(p => p.AgentId).Distinct(StringComparer.OrdinalIgnoreCase))
+            estimates[agentId] = await _guard.EstimateRunAsync(agentId, ct);
+
+        foreach (var agent in agents.Where(a => a.Budget.HasAnyLimit))
+        {
+            var runs = planned.Where(p => string.Equals(p.AgentId, agent.AgentId, StringComparison.OrdinalIgnoreCase)).ToList();
+            var used = await _guard.GetUsedTodayAsync(agent.AgentId, ct);
+            var reserved = _guard.Reserved(agent.AgentId);
+            if (FirstRefused(runs, estimates, agent.Budget.DailyCostUsd, agent.Budget.DailyTokens, used, reserved) is { } index)
+                result.Add(new BudgetShortfall(agent.AgentId, runs[index].At, runs.Count - index, runs.Count));
+        }
+
+        if (instanceBudget.HasAnyLimit)
+        {
+            var used = await _guard.GetUsedTodayAsync("", ct);
+            var reserved = _guard.Reserved("");
+            if (FirstRefused(planned, estimates, instanceBudget.DailyCostUsd, instanceBudget.DailyTokens, used, reserved) is { } index)
+                result.Add(new BudgetShortfall("", planned[index].At, planned.Count - index, planned.Count));
+        }
+
+        return result;
+    }
+
+    /// <summary>
+    /// The index of the first run that would find the budget used up, or <c>null</c>.
+    /// Mirrors the check at the start of a run: a run is refused once usage has reached
+    /// the limit, not merely because its own estimate would overshoot.
+    /// </summary>
+    private static int? FirstRefused(
+        List<(DateTime At, string AgentId)> runs, Dictionary<string, RunEstimate> estimates,
+        decimal costLimit, long tokenLimit, Accounting.DailyUsage used, RunEstimate reserved)
+    {
+        var cost = used.CostUsd + reserved.CostUsd;
+        long tokens = used.TotalTokens + reserved.Tokens;
+
+        for (var i = 0; i < runs.Count; i++)
+        {
+            if ((costLimit > 0 && cost >= costLimit) || (tokenLimit > 0 && tokens >= tokenLimit))
+                return i;
+
+            var estimate = estimates.GetValueOrDefault(runs[i].AgentId);
+            cost += estimate.CostUsd;
+            tokens += estimate.Tokens;
+        }
+
+        return null;
+    }
+
+    /// <summary>Carried-over work and pending catch-ups are the late runs.</summary>
+    public static bool IsLate(TaskItem task) => task.IsCarriedOver || task.CatchUpPending;
+
+    /// <summary>0 or less means: no limit of this kind.</summary>
+    private static bool Fits(decimal limit, decimal used, decimal reserved, decimal demand, decimal estimate)
+        => limit <= 0 || limit - used - reserved - demand - limit * SafetyShare >= estimate;
+
+    private static bool Fits(long limit, long used, long reserved, long demand, long estimate)
+        => limit <= 0 || limit - used - reserved - demand - (long)(limit * SafetyShare) >= estimate;
+
+    private static RunEstimate Times(RunEstimate estimate, int runs)
+        => new(estimate.CostUsd * runs, estimate.Tokens * runs);
+
+    private static bool IsOf(TaskItem task, string agentId)
+        => string.Equals(TaskAssignee.AgentId(task.Assignee), agentId, StringComparison.OrdinalIgnoreCase);
+
+    private static AgentConfig? FindAgent(IReadOnlyList<AgentConfig> agents, TaskItem task)
+    {
+        var agentId = TaskAssignee.AgentId(task.Assignee);
+        return agentId.Length == 0
+            ? (agents.Count == 1 ? agents[0] : null)
+            : agents.FirstOrDefault(a => string.Equals(a.AgentId, agentId, StringComparison.OrdinalIgnoreCase));
+    }
+
+    private DateTime StartOfNextLocalDay(DateTime nowUtc)
+    {
+        var zone = _clock.LocalTimeZone;
+        var local = TimeZoneInfo.ConvertTimeFromUtc(DateTime.SpecifyKind(nowUtc, DateTimeKind.Utc), zone);
+        var midnight = DateTime.SpecifyKind(local.Date.AddDays(1), DateTimeKind.Unspecified);
+        while (zone.IsInvalidTime(midnight))
+            midnight = midnight.AddMinutes(1);
+        return TimeZoneInfo.ConvertTimeToUtc(midnight, zone);
+    }
+}

src/ClawdDotNet.Core/Config/AgentConfig.cs

@@ -183,6 +183,21 @@ public sealed class AgentBudget
     [JsonPropertyName("dailyTokens")]
     public long DailyTokens { get; set; }
 
+    /// <summary>
+    /// #716: What happens to a run of a recurring task when the budget is exhausted —
+    /// <c>expire</c> (default) or <c>catchUpOnce</c>. One-time tasks are always carried
+    /// over to the next day. Kept as text so an unknown value falls back instead of
+    /// failing the whole configuration.
+    /// </summary>
+    [JsonPropertyName("whenExhausted")]
+    public string WhenExhausted { get; set; } = "expire";
+
+    [JsonIgnore]
+    public Tasks.BudgetMissPolicy MissPolicy
+        => string.Equals(WhenExhausted?.Trim(), "catchUpOnce", StringComparison.OrdinalIgnoreCase)
+            ? Tasks.BudgetMissPolicy.CatchUpOnce
+            : Tasks.BudgetMissPolicy.Expire;
+
     [JsonIgnore]
     public bool HasAnyLimit => DailyCostUsd > 0 || DailyTokens > 0;
 }

src/ClawdDotNet.Core/Config/InstanceConfig.cs

@@ -152,6 +152,23 @@ public sealed class InstanceConfig
     [JsonPropertyName("delegationGateTimeoutSeconds")]
     public int DelegationGateTimeoutSeconds { get; set; } = 120;
 
+    /// <summary>
+    /// #682: How many scheduled task runs may be in flight at the same time. Due tasks
+    /// beyond this wait in order of priority and due time and start as soon as a run
+    /// finishes.
+    ///
+    /// <para><b>Why a cap at all.</b> Cron expressions pile up on round times. Without a
+    /// cap, fifty due tasks meant fifty simultaneous model calls — provider rate limits,
+    /// a cost spike, and all fifty passing the instance budget check together, because
+    /// that check runs per run before it starts.</para>
+    ///
+    /// <para>Per instance for now; per unit comes with #685. Values below 1 count as 1.
+    /// A run the human starts by hand does not wait for a free slot, but it occupies one
+    /// while it runs.</para>
+    /// </summary>
+    [JsonPropertyName("maxParallelTaskRuns")]
+    public int MaxParallelTaskRuns { get; set; } = 4;
+
     [JsonPropertyName("agents")]
     public List<AgentConfig> Agents { get; set; } = new();
 

src/ClawdDotNet.Core/Engine/AgentEngine.cs

@@ -35,6 +35,15 @@ public sealed class AgentEngine : IAgentMessageRouter, Staging.IFrozenCallExecut
     /// <summary>Tagesgrenzen der Instanz. Wird vom Host gesetzt.</summary>
     public InstanceBudget InstanceBudget { get; set; } = InstanceBudget.Unlimited;
 
+    /// <summary>
+    /// #716: The guard that checks and reserves every run — the scanner's headroom
+    /// calculation has to see the same reservations. <c>null</c> without usage recording.
+    /// </summary>
+    public BudgetGuard? BudgetGuard => _budgetGuard;
+
+    /// <summary>#711: Who is working right now and who reached whom — for the team overview.</summary>
+    public Activity.AgentActivity Activity { get; } = new();
+
     /// <summary>
     /// Wie viele Weitergaben eine Delegationskette höchstens haben darf (B8).
     /// A→B ist die Tiefe 1, A→B→C die Tiefe 2.
@@ -163,15 +172,20 @@ 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, source ?? AuditSource.Direct, taskId, externalCt) is { } denied)
+        // #716: Die Reservierung gilt, bis der Verbrauch erfasst ist (Ende der Methode).
+        var (denied, reservation) = await CheckBudgetAsync(agentConfig, source ?? AuditSource.Direct, taskId, externalCt);
+        if (denied is not null)
             return denied;
+        using var budgetReservation = reservation;
 
         using var lauf = TrackRun();
 
         var runId = Guid.NewGuid().ToString("N");
         var chain = delegation ?? DelegationChain.Root(agentConfig.AgentId);
+        using var activity = Activity.Begin(runId, agentConfig.AgentId, source ?? AuditSource.Direct, taskId, chain);
         var recorder = CreateRecorder(agentConfig);
         var result = await RunCoreAsync(agentConfig, userMessage, instanceId, externalCt, runId, source, chain, recorder);
+        activity.Complete(result.Status.ToString());
         await RecordUsageAsync(agentConfig, result);
         await RecordReceiptAsync(runId, agentConfig, result, source ?? AuditSource.Direct, taskId);
         await SaveTranscriptAsync(recorder, runId, agentConfig, result, source ?? AuditSource.Direct, taskId);
@@ -444,8 +458,10 @@ public sealed class AgentEngine : IAgentMessageRouter, Staging.IFrozenCallExecut
         if (RefuseWhileShuttingDown(agentConfig) is { } zu)
             return zu;
 
-        if (await CheckBudgetAsync(agentConfig, source, taskId, externalCt) is { } denied)
+        var (denied, reservation) = await CheckBudgetAsync(agentConfig, source, taskId, externalCt);
+        if (denied is not null)
             return denied;
+        using var budgetReservation = reservation;
 
         using var lauf = TrackRun();
 
@@ -487,8 +503,11 @@ public sealed class AgentEngine : IAgentMessageRouter, Staging.IFrozenCallExecut
 
         try
         {
+            // #711: "working" starts past the gate — waiting for it is not working.
+            using var activity = Activity.Begin(runId, agentConfig.AgentId, source ?? AuditSource.Direct, taskId, chain);
             var recorder = CreateRecorder(agentConfig);
             var result = await ChatCoreAsync(agentConfig, userMessage, instanceId, runCts.Token, source, runId, chain, recorder);
+            activity.Complete(result.Status.ToString());
             await RecordUsageAsync(agentConfig, result);
             await RecordReceiptAsync(runId, agentConfig, result, source, taskId);
             await SaveTranscriptAsync(recorder, runId, agentConfig, result, source ?? AuditSource.Direct, taskId);
@@ -1638,17 +1657,17 @@ public sealed class AgentEngine : IAgentMessageRouter, Staging.IFrozenCallExecut
 
     /// <summary>
     /// Prüft das Tagesbudget. Gibt ein Ergebnis zurück, wenn der Lauf nicht stattfinden
-    /// darf — sonst null.
+    /// darf — sonst null und, bei gesetzter Grenze, die Reservierung des Laufs (#716).
     /// </summary>
-    private async Task<AgentRunResult?> CheckBudgetAsync(
+    private async Task<(AgentRunResult? Denied, IDisposable? Reservation)> CheckBudgetAsync(
         AgentConfig agentConfig, string? source, string? taskId, CancellationToken ct)
     {
         if (_budgetGuard is null)
-            return null;
+            return (null, null);
 
-        var status = await _budgetGuard.CheckAsync(agentConfig, InstanceBudget, ct);
+        var (status, reservation) = await _budgetGuard.ReserveAsync(agentConfig, InstanceBudget, ct);
         if (status.IsAllowed)
-            return null;
+            return (null, reservation);
 
         // #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.
@@ -1676,7 +1695,7 @@ public sealed class AgentEngine : IAgentMessageRouter, Staging.IFrozenCallExecut
         await RecordReceiptAsync(Guid.NewGuid().ToString("N"), agentConfig, result, source, taskId);
 
         OnRunCompleted?.Invoke(agentConfig.Model, result);
-        return result;
+        return (result, null);
     }
 
     /// <summary>Welche Budgetgrenze je Agent zuletzt an welchem Tag als Warnung gemeldet wurde.</summary>

src/ClawdDotNet.Core/Storage/SqliteStorage.cs

@@ -339,6 +339,12 @@ public sealed class SqliteStorage
         // #554: Paart den "angefangen"-Eintrag mit seinem Abschluss.
         SpalteErgaenzen(connection, "AuditLog", "CallId", "TEXT NOT NULL DEFAULT ''");
 
+        // #716: What happened when the budget refused a run.
+        SpalteErgaenzen(connection, "Tasks", "BudgetMissCount", "INTEGER NOT NULL DEFAULT 0");
+        SpalteErgaenzen(connection, "Tasks", "LastBudgetMissAt", "TEXT NULL");
+        SpalteErgaenzen(connection, "Tasks", "DeferredUntil", "TEXT NULL");
+        SpalteErgaenzen(connection, "Tasks", "CatchUpPending", "INTEGER NOT NULL DEFAULT 0");
+
         // Findet offene Aufrufe beim Start, ohne die ganze Tabelle zu lesen.
         using var index = connection.CreateCommand();
         index.CommandText = """

src/ClawdDotNet.Core/Tasks/EngineTaskDispatcher.cs

@@ -98,7 +98,8 @@ public sealed class EngineTaskDispatcher : ITaskDispatcher
         return result.Status switch
         {
             AgentRunStatus.Completed => TaskLauf.Erledigt,
-            AgentRunStatus.BudgetExceeded or AgentRunStatus.ShuttingDown => TaskLauf.NichtGelaufen,
+            AgentRunStatus.BudgetExceeded => TaskLauf.KeinBudget,
+            AgentRunStatus.ShuttingDown => TaskLauf.NichtGelaufen,
             _ => TaskLauf.Gescheitert
         };
     }

src/ClawdDotNet.Core/Tasks/ITaskRepository.cs

@@ -19,6 +19,23 @@ public interface ITaskRepository
 
     Task<IReadOnlyList<TaskItem>> ListAsync(TaskQuery query, CancellationToken ct);
 
+    /// <summary>
+    /// #682: Every task in status <c>todo</c> — the scanner's candidates, without a cap.
+    ///
+    /// <para><see cref="ListAsync"/> clamps to 500 because it serves views and tools. The
+    /// scanner used it too, so beyond 500 tasks schedules silently fell out of the tick.
+    /// Only <c>todo</c> can be claimed, so this list is bounded by the work that is
+    /// actually waiting, not by the size of the board.</para>
+    /// </summary>
+    Task<IReadOnlyList<TaskItem>> ListRunnableAsync(CancellationToken ct);
+
+    /// <summary>
+    /// Every task, without a cap — for the few callers that must see the whole board: the
+    /// cost forecast, duplicate detection, the import's orphan sweep. Before #716 they used
+    /// <see cref="ListAsync"/> with its limit of 500 and silently saw only part of it.
+    /// </summary>
+    Task<IReadOnlyList<TaskItem>> ListAllAsync(bool includeArchived, CancellationToken ct);
+
     /// <summary>
     /// Beansprucht einen fälligen Termin atomar. Genau ein gleichzeitiger Aufruf gewinnt;
     /// jeder weitere erhält <c>false</c>. Setzt den Marker (<paramref name="occurrenceKey"/>)
@@ -55,6 +72,28 @@ public interface ITaskRepository
     /// <summary>Ändert den Status direkt (Tool-Aktionen, Auto-Dispatch, Eskalation).</summary>
     Task<bool> SetStatusAsync(string id, TaskItemStatus status, DateTime now, CancellationToken ct);
 
+    /// <summary>
+    /// #716: The budget refused a run of a one-time task. Releases the claim, restores the
+    /// occurrence (the task is still due) and defers it to <paramref name="deferredUntil"/>.
+    /// </summary>
+    Task<bool> CarryOverAsync(
+        string id, string claimToken, string? previousOccurrence, DateTime deferredUntil,
+        DateTime now, CancellationToken ct);
+
+    /// <summary>
+    /// #716: The budget refused a run of a recurring task. Releases the claim back to
+    /// <c>todo</c>; the occurrence stays consumed. With <paramref name="catchUpUntil"/> a
+    /// single catch-up run is scheduled for then — an already pending one is kept.
+    /// </summary>
+    Task<bool> RecordBudgetMissAsync(
+        string id, string claimToken, DateTime? catchUpUntil, DateTime now, CancellationToken ct);
+
+    /// <summary>
+    /// #716: A run took place — clears the miss counter, a pending catch-up and the
+    /// deferral. <see cref="TaskItem.LastBudgetMissAt"/> stays as history.
+    /// </summary>
+    Task<bool> ClearBudgetMissAsync(string id, DateTime now, CancellationToken ct);
+
     /// <summary>
     /// Reconciliation beim Start: verwaiste Claims (älter als <paramref name="leaseCutoff"/>)
     /// lösen und die betroffenen Aufgaben von <see cref="TaskItemStatus.InProgress"/> zurück

src/ClawdDotNet.Core/Tasks/SqliteTaskRepository.cs

@@ -193,6 +193,68 @@ public sealed class SqliteTaskRepository : ITaskRepository
             return await cmd.ExecuteNonQueryAsync(ct) > 0;
         }, ct);
 
+    public Task<bool> CarryOverAsync(
+        string id, string claimToken, string? previousOccurrence, DateTime deferredUntil,
+        DateTime now, CancellationToken ct)
+        => _storage.WriteAsync(async conn =>
+        {
+            using var cmd = conn.CreateCommand();
+            cmd.CommandText = """
+                UPDATE Tasks
+                   SET Status = 'todo', ClaimToken = NULL, ClaimedAt = NULL,
+                       LastOccurrence = @occ, UpdatedAt = @now,
+                       BudgetMissCount = BudgetMissCount + 1, LastBudgetMissAt = @now,
+                       DeferredUntil = @deferred
+                 WHERE Id = @id AND ClaimToken = @token
+                """;
+            cmd.Parameters.AddWithValue("@occ", (object?)previousOccurrence ?? DBNull.Value);
+            cmd.Parameters.AddWithValue("@now", Format(now));
+            cmd.Parameters.AddWithValue("@deferred", Format(deferredUntil));
+            cmd.Parameters.AddWithValue("@id", id);
+            cmd.Parameters.AddWithValue("@token", claimToken);
+
+            return await cmd.ExecuteNonQueryAsync(ct) > 0;
+        }, ct);
+
+    public Task<bool> RecordBudgetMissAsync(
+        string id, string claimToken, DateTime? catchUpUntil, DateTime now, CancellationToken ct)
+        => _storage.WriteAsync(async conn =>
+        {
+            using var cmd = conn.CreateCommand();
+            // A pending catch-up keeps its date: several misses still mean one catch-up run.
+            cmd.CommandText = """
+                UPDATE Tasks
+                   SET Status = 'todo', ClaimToken = NULL, ClaimedAt = NULL, UpdatedAt = @now,
+                       BudgetMissCount = BudgetMissCount + 1, LastBudgetMissAt = @now,
+                       CatchUpPending = CASE WHEN @catchUp = 1 THEN 1 ELSE CatchUpPending END,
+                       DeferredUntil = CASE WHEN @catchUp = 1 AND CatchUpPending = 0 THEN @deferred
+                                            ELSE DeferredUntil END
+                 WHERE Id = @id AND ClaimToken = @token
+                """;
+            cmd.Parameters.AddWithValue("@now", Format(now));
+            cmd.Parameters.AddWithValue("@catchUp", catchUpUntil is null ? 0 : 1);
+            cmd.Parameters.AddWithValue("@deferred", catchUpUntil is { } until ? Format(until) : DBNull.Value);
+            cmd.Parameters.AddWithValue("@id", id);
+            cmd.Parameters.AddWithValue("@token", claimToken);
+
+            return await cmd.ExecuteNonQueryAsync(ct) > 0;
+        }, ct);
+
+    public Task<bool> ClearBudgetMissAsync(string id, DateTime now, CancellationToken ct)
+        => _storage.WriteAsync(async conn =>
+        {
+            using var cmd = conn.CreateCommand();
+            cmd.CommandText = """
+                UPDATE Tasks
+                   SET BudgetMissCount = 0, CatchUpPending = 0, DeferredUntil = NULL, UpdatedAt = @now
+                 WHERE Id = @id
+                """;
+            cmd.Parameters.AddWithValue("@now", Format(now));
+            cmd.Parameters.AddWithValue("@id", id);
+
+            return await cmd.ExecuteNonQueryAsync(ct) > 0;
+        }, ct);
+
     public Task<int> ReleaseStaleClaimsAsync(DateTime leaseCutoff, DateTime now, CancellationToken ct)
         => _storage.WriteAsync(async conn =>
         {
@@ -208,6 +270,37 @@ public sealed class SqliteTaskRepository : ITaskRepository
             return await cmd.ExecuteNonQueryAsync(ct);
         }, ct);
 
+    public async Task<IReadOnlyList<TaskItem>> ListAllAsync(bool includeArchived, CancellationToken ct)
+    {
+        await using var conn = await _storage.OpenConnectionAsync(ct);
+        using var cmd = conn.CreateCommand();
+        cmd.CommandText = "SELECT " + Columns + " FROM Tasks"
+            + (includeArchived ? "" : " WHERE Status <> 'archived'")
+            + " ORDER BY Priority DESC, UpdatedAt DESC";
+
+        var results = new List<TaskItem>();
+        await using var reader = await cmd.ExecuteReaderAsync(ct);
+        while (await reader.ReadAsync(ct))
+            results.Add(Read(reader));
+
+        return results;
+    }
+
+    public async Task<IReadOnlyList<TaskItem>> ListRunnableAsync(CancellationToken ct)
+    {
+        await using var conn = await _storage.OpenConnectionAsync(ct);
+        using var cmd = conn.CreateCommand();
+        cmd.CommandText = "SELECT " + Columns + " FROM Tasks WHERE Status = @status";
+        cmd.Parameters.AddWithValue("@status", TaskText.Of(TaskItemStatus.Todo));
+
+        var results = new List<TaskItem>();
+        await using var reader = await cmd.ExecuteReaderAsync(ct);
+        while (await reader.ReadAsync(ct))
+            results.Add(Read(reader));
+
+        return results;
+    }
+
     public async Task<IReadOnlyList<TaskItem>> ListBlockedByAsync(string blockerId, CancellationToken ct)
     {
         await using var conn = await _storage.OpenConnectionAsync(ct);
@@ -237,7 +330,8 @@ public sealed class SqliteTaskRepository : ITaskRepository
     private const string Columns =
         "Id, Title, Status, Type, Priority, Assignee, WhenKind, WhenValue, WhenTz, " +
         "RequireApproval, Acceptance, BlockedBy, OnlyWhenMarketOpen, Body, FileName, " +
-        "ToolName, JobTypeId, LastOccurrence, ClaimToken, ClaimedAt, CreatedAt, UpdatedAt";
+        "ToolName, JobTypeId, LastOccurrence, ClaimToken, ClaimedAt, CreatedAt, UpdatedAt, "
+        + "BudgetMissCount, LastBudgetMissAt, DeferredUntil, CatchUpPending";
 
     private static void BindDefinition(SqliteCommand cmd, TaskItem task)
     {
@@ -303,7 +397,11 @@ public sealed class SqliteTaskRepository : ITaskRepository
             ClaimToken = r.IsDBNull(18) ? null : r.GetString(18),
             ClaimedAt = r.IsDBNull(19) ? null : Parse(r.GetString(19)),
             CreatedAt = Parse(r.GetString(20)),
-            UpdatedAt = Parse(r.GetString(21))
+            UpdatedAt = Parse(r.GetString(21)),
+            BudgetMissCount = r.GetInt32(22),
+            LastBudgetMissAt = r.IsDBNull(23) ? null : Parse(r.GetString(23)),
+            DeferredUntil = r.IsDBNull(24) ? null : Parse(r.GetString(24)),
+            CatchUpPending = r.GetInt32(25) != 0
         };
     }
 

src/ClawdDotNet.Core/Tasks/TaskModels.cs

@@ -205,6 +205,32 @@ public sealed record TaskItem
     public DateTime CreatedAt { get; init; }
     public DateTime UpdatedAt { get; init; }
 
+    // ─── Budget misses (#716) ───
+
+    /// <summary>
+    /// How many times in a row a run of this task was refused because the budget was
+    /// exhausted. Reset by the next run that actually takes place.
+    /// </summary>
+    public int BudgetMissCount { get; init; }
+
+    /// <summary>When the last budget refusal happened (UTC). Kept after a reset, as history.</summary>
+    public DateTime? LastBudgetMissAt { get; init; }
+
+    /// <summary>
+    /// Not before this point (UTC). Set after a budget refusal to the start of the next
+    /// local day: retrying within the same day only produces further refusals.
+    /// </summary>
+    public DateTime? DeferredUntil { get; init; }
+
+    /// <summary>
+    /// A recurring task under <see cref="BudgetMissPolicy.CatchUpOnce"/> missed at least
+    /// one occurrence; all of them are caught up by a single run.
+    /// </summary>
+    public bool CatchUpPending { get; init; }
+
+    /// <summary>A one-time task that was refused for lack of budget and carried over.</summary>
+    public bool IsCarriedOver => !IsRecurring && BudgetMissCount > 0;
+
     /// <summary>
     /// Wiederkehrend? Solche Tasks kehren nach dem Feuern auf <c>todo</c> zurück statt auf
     /// <c>done</c> — sonst würde ein Cron-Task nur ein einziges Mal laufen. Ein
@@ -215,6 +241,19 @@ public sealed record TaskItem
            || When is { Kind: TaskWhenKind.Cron or TaskWhenKind.Every };
 }
 
+/// <summary>
+/// #716: What happens to a run of a recurring task that the budget refused. One-time
+/// tasks are always carried over — they are real work that must not disappear.
+/// </summary>
+public enum BudgetMissPolicy
+{
+    /// <summary>The occurrence lapses and is recorded; the next regular one comes anyway.</summary>
+    Expire,
+
+    /// <summary>All missed occurrences are caught up by one run on the next day.</summary>
+    CatchUpOnce
+}
+
 /// <summary>Suchkriterien für <see cref="ITaskRepository.ListAsync"/>.</summary>
 public sealed record TaskQuery
 {

src/ClawdDotNet.Core/Tasks/TaskScanner.cs

@@ -12,10 +12,17 @@ public enum TaskLauf
     Gescheitert,
 
     /// <summary>
-    /// Der Lauf fand gar nicht statt — Budget erschöpft, Instanz im Herunterfahren (#643).
+    /// Der Lauf fand gar nicht statt — Instanz im Herunterfahren (#643).
     /// Eine einmalige Aufgabe bleibt dann fällig, statt als gelaufen liegenzubleiben.
     /// </summary>
-    NichtGelaufen
+    NichtGelaufen,
+
+    /// <summary>
+    /// #716: The run did not take place because the budget is exhausted. Unlike a
+    /// shutdown, retrying the same day is pointless — the scanner defers to the next day
+    /// and applies the agent's <see cref="BudgetMissPolicy"/>.
+    /// </summary>
+    KeinBudget
 }
 
 /// <summary>
@@ -37,6 +44,30 @@ public interface IMarketCalendar
     bool IsOpen(DateTime nowUtc);
 }
 
+/// <summary>
+/// #716: Decides whether a late run — carried-over work or a catch-up — may start now.
+/// Without one, late runs only wait for the regular ones of the same tick.
+/// </summary>
+public interface ILateRunGate
+{
+    Task<bool> HasRoomAsync(TaskItem lateTask, IReadOnlyList<TaskItem> runnable, DateTime nowUtc, CancellationToken ct);
+}
+
+/// <summary>
+/// #716: The day ahead — where the budget will not reach the end of today's schedule.
+/// </summary>
+public interface IBudgetOutlook
+{
+    Task<IReadOnlyList<BudgetShortfall>> ShortfallsAsync(IReadOnlyList<TaskItem> runnable, DateTime nowUtc, CancellationToken ct);
+}
+
+/// <summary>
+/// #716: An agent whose budget runs out before today's schedule does — from when on, and
+/// how many planned runs will be refused. <see cref="AgentId"/> is empty for the instance
+/// limit.
+/// </summary>
+public sealed record BudgetShortfall(string AgentId, DateTime ExhaustsAtUtc, int RunsRefused, int RunsPlanned);
+
 /// <summary>Bis C1 kommt: der Markt gilt als immer offen.</summary>
 public sealed class AlwaysOpenMarketCalendar : IMarketCalendar
 {
@@ -84,6 +115,40 @@ public sealed class TaskScanner : IAsyncDisposable
     /// <summary>Pause, bevor eine nicht gelaufene einmalige Aufgabe erneut versucht wird.</summary>
     public static readonly TimeSpan Wiedervorlage = TimeSpan.FromMinutes(30);
 
+    /// <summary>#682: Default for <see cref="Config.InstanceConfig.MaxParallelTaskRuns"/>.</summary>
+    public const int DefaultMaxParallelRuns = 4;
+
+    private readonly int _maxParallelRuns;
+
+    /// <summary>
+    /// Runs started by the tick loop that have not finished yet. The loop no longer waits
+    /// for them (#682), so disposal has to.
+    /// </summary>
+    private readonly HashSet<Task> _inFlight = [];
+
+    /// <summary>How many due tasks had to wait at the last tick — logged only on change.</summary>
+    private int _lastWaiting;
+
+    /// <summary>#716: What the budget refused, per agent, for the day summary.</summary>
+    private readonly Func<TaskItem, BudgetMissPolicy> _missPolicy;
+    private readonly Dictionary<string, (int Misses, int CarriedOver, int CatchUps)> _missesToday = new(StringComparer.OrdinalIgnoreCase);
+    private DateOnly? _missDay;
+
+    private readonly ILateRunGate? _lateRunGate;
+
+    private readonly IBudgetOutlook? _outlook;
+
+    /// <summary>How often the day ahead is looked at — a forecast, not a watchdog.</summary>
+    public static readonly TimeSpan OutlookInterval = TimeSpan.FromMinutes(30);
+
+    private DateTime _lastOutlookAt = DateTime.MinValue;
+
+    /// <summary>Agents already warned about today, with the day — once per agent and day.</summary>
+    private readonly Dictionary<string, DateOnly> _shortfallWarned = new(StringComparer.OrdinalIgnoreCase);
+
+    /// <summary>How many late runs waited for budget headroom at the last tick.</summary>
+    private int _lastWaitingForHeadroom;
+
     private readonly CancellationTokenSource _cts = new();
     private Task? _loop;
 
@@ -94,7 +159,11 @@ public sealed class TaskScanner : IAsyncDisposable
         IMarketCalendar? market = null,
         TimeProvider? clock = null,
         TimeSpan? tick = null,
-        TimeSpan? lease = null)
+        TimeSpan? lease = null,
+        int maxParallelRuns = DefaultMaxParallelRuns,
+        Func<TaskItem, BudgetMissPolicy>? budgetMissPolicy = null,
+        ILateRunGate? lateRunGate = null,
+        IBudgetOutlook? budgetOutlook = null)
     {
         _repo = repo;
         _dispatcher = dispatcher;
@@ -103,8 +172,15 @@ public sealed class TaskScanner : IAsyncDisposable
         _logger = loggerFactory.CreateLogger("ClawdDotNet.Core.Tasks.Scanner");
         _tick = tick ?? TimeSpan.FromSeconds(60);
         _lease = lease ?? TimeSpan.FromMinutes(15);
+        _maxParallelRuns = Math.Max(1, maxParallelRuns);
+        _missPolicy = budgetMissPolicy ?? (_ => BudgetMissPolicy.Expire);
+        _lateRunGate = lateRunGate;
+        _outlook = budgetOutlook;
     }
 
+    /// <summary>How many scheduled runs may be in flight at once (#682).</summary>
+    public int MaxParallelRuns => _maxParallelRuns;
+
     public void Start()
     {
         _loop ??= RunLoopAsync(_cts.Token);
@@ -158,7 +234,10 @@ public sealed class TaskScanner : IAsyncDisposable
 
             try
             {
-                await ScanOnceAsync(ct);
+                // #682: Start, don't wait. Before, the tick awaited every run it started,
+                // so one ten-minute run held back every other schedule for ten minutes.
+                // Now a finished run frees its slot and the next tick fills it.
+                await LaunchDueAsync(ct);
             }
             catch (Exception ex) when (ex is not OperationCanceledException)
             {
@@ -169,20 +248,45 @@ public sealed class TaskScanner : IAsyncDisposable
 
     /// <summary>
     /// Ein Durchlauf: fällige Aufgaben beanspruchen und ausführen. Gibt die Zahl der
-    /// tatsächlich angestoßenen Läufe zurück. Öffentlich, damit Tests einen Takt
-    /// deterministisch auslösen können.
+    /// tatsächlich angestoßenen Läufe zurück und kehrt erst zurück, wenn sie fertig sind.
+    /// Öffentlich, damit Tests einen Takt deterministisch auslösen können — die
+    /// Taktschleife selbst wartet nicht auf die Läufe (#682).
     /// </summary>
     public async Task<int> ScanOnceAsync(CancellationToken ct)
+    {
+        var launched = await LaunchDueAsync(ct);
+        await Task.WhenAll(launched);
+        return launched.Count;
+    }
+
+    /// <summary>
+    /// Claims due tasks while a slot is free and starts them without waiting.
+    ///
+    /// <para><b>Claim only what can start now (#682).</b> A claim sets the task to
+    /// <c>running</c> with a lease. Claiming everything and queueing it in memory would
+    /// let a waiting task outlive its lease and be claimed a second time. So tasks beyond
+    /// the free slots stay <c>todo</c> and are picked up by a later tick — a cron occurrence
+    /// is not lost by that, <see cref="TaskSchedule.DueOccurrence"/> searches back to the
+    /// last run.</para>
+    ///
+    /// <para><b>Order:</b> priority first, then the oldest due occurrence — when slots are
+    /// short, what matters and what has waited longest goes first.</para>
+    /// </summary>
+    private async Task<IReadOnlyList<Task>> LaunchDueAsync(CancellationToken ct)
     {
         if (!IsAcceptingWork)
-            return 0;
+            return [];
 
         var now = _clock.GetUtcNow().UtcDateTime;
         var leaseCutoff = now - _lease;
 
-        var candidates = await _repo.ListAsync(new TaskQuery { Limit = 500 }, ct);
+        // #682: ungekappt. Vorher ListAsync mit Limit 500 — darüber fielen Termine lautlos aus.
+        var candidates = await _repo.ListRunnableAsync(ct);
 
-        var claimed = new List<(TaskItem Task, string Token)>();
+        SummarizeMissesIfNewDay(now);
+        await WarnAboutShortfallsAsync(candidates, now, ct);
+
+        var due = new List<(TaskItem Task, string Occurrence, bool Late)>();
         foreach (var task in candidates)
         {
             if (task.Status != TaskItemStatus.Todo)
@@ -225,23 +329,122 @@ public sealed class TaskScanner : IAsyncDisposable
             if (_zurueckgestellt.TryGetValue(task.Id, out var ab) && now < ab)
                 continue;
 
-            var occ = TaskSchedule.DueOccurrence(task, now);
-            if (occ is null)
+            // #716: Refused for lack of budget — not before the next day. For a recurring
+            // task this only holds back the catch-up; its regular occurrences keep coming.
+            var deferred = task.DeferredUntil is { } until && now < until;
+            if (deferred && !task.IsRecurring)
                 continue;
 
             if (task.OnlyWhenMarketOpen && !_market.IsOpen(now))
                 continue;
 
-            var token = Guid.NewGuid().ToString("N");
-            if (await _repo.TryClaimAsync(task.Id, occ, token, now, leaseCutoff, ct))
-                claimed.Add((task, token));
+            var occ = TaskSchedule.DueOccurrence(task, now);
+            if (occ is not null)
+            {
+                // A regular occurrence also covers a pending catch-up: one run, not two.
+                due.Add((task, occ, Late: task.IsCarriedOver));
+                continue;
+            }
+
+            if (task.CatchUpPending && !deferred)
+                due.Add((task, Iso(now), Late: true));
         }
 
-        // Gleichzeitig anstoßen — Läufe desselben Agenten serialisiert ohnehin das
-        // Agent-Gate der Engine; verschiedene Agenten laufen echt parallel.
-        await Task.WhenAll(claimed.Select(c => ProcessAsync(c.Task, c.Token, ct)));
+        // #716: The new day has right of way — carried-over and catch-up runs come after
+        // everything regularly due. Within each group: priority, then the oldest occurrence.
+        // Occurrence keys are ISO-8601 UTC ("O"), so ordinal order is time order.
+        due.Sort((a, b) =>
+        {
+            if (a.Late != b.Late)
+                return a.Late ? 1 : -1;
+            var byPriority = b.Task.Priority.CompareTo(a.Task.Priority);
+            return byPriority != 0 ? byPriority : string.CompareOrdinal(a.Occurrence, b.Occurrence);
+        });
 
-        return claimed.Count;
+        var launched = new List<Task>();
+        var waiting = 0;
+        var waitingForHeadroom = 0;
+        foreach (var (task, occ, late) in due)
+        {
+            // OpenCount also counts runs started by hand (RunTaskNowAsync) — they take a
+            // slot, even though they did not wait for one.
+            if (OpenCount >= _maxParallelRuns)
+            {
+                waiting++;
+                continue;
+            }
+
+            // #716: Late work only uses what the rest of the day does not need.
+            if (late && _lateRunGate is not null
+                && !await _lateRunGate.HasRoomAsync(task, candidates, now, ct))
+            {
+                waitingForHeadroom++;
+                continue;
+            }
+
+            var token = Guid.NewGuid().ToString("N");
+            if (await _repo.TryClaimAsync(task.Id, occ, token, now, leaseCutoff, ct))
+                launched.Add(Track(RunLoggedAsync(task, token, ct)));
+        }
+
+        // A cap that hides its effect is worse than none (the lesson of #673): say when
+        // due work had to wait, but only when that changes — the tick runs every minute.
+        if (waiting != _lastWaiting)
+        {
+            if (waiting > 0)
+                _logger.LogInformation(
+                    "{Waiting} due task(s) waiting for a free slot — {Max} run(s) at a time (maxParallelTaskRuns)",
+                    waiting, _maxParallelRuns);
+            else
+                _logger.LogInformation("No due tasks waiting for a slot anymore");
+            _lastWaiting = waiting;
+        }
+
+        if (waitingForHeadroom != _lastWaitingForHeadroom)
+        {
+            if (waitingForHeadroom > 0)
+                _logger.LogInformation(
+                    "{Waiting} carried-over or catch-up run(s) waiting for budget headroom — "
+                    + "the rest of today's schedule comes first",
+                    waitingForHeadroom);
+            _lastWaitingForHeadroom = waitingForHeadroom;
+        }
+
+        return launched;
+    }
+
+    /// <summary>
+    /// Runs a claimed task and logs what escapes it. The tick loop does not await its runs,
+    /// so an exception here would otherwise go unobserved.
+    /// </summary>
+    private async Task RunLoggedAsync(TaskItem task, string token, CancellationToken ct)
+    {
+        try
+        {
+            await ProcessAsync(task, token, ct);
+        }
+        catch (OperationCanceledException) when (ct.IsCancellationRequested)
+        {
+            // Shutdown. The claim is released by the lease or the next start's reconciliation.
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Run of task {TaskId} failed outside the dispatch", task.Id);
+        }
+    }
+
+    private Task Track(Task run)
+    {
+        lock (_inFlight)
+            _inFlight.Add(run);
+
+        _ = run.ContinueWith(t =>
+        {
+            lock (_inFlight)
+                _inFlight.Remove(t);
+        }, TaskScheduler.Default);
+
+        return run;
     }
 
     /// <summary>
@@ -304,6 +507,12 @@ public sealed class TaskScanner : IAsyncDisposable
         var now = _clock.GetUtcNow().UtcDateTime;
         var ok = lauf == TaskLauf.Erledigt;
 
+        if (lauf == TaskLauf.KeinBudget)
+        {
+            await HandleBudgetMissAsync(task, token, now, ct);
+            return;
+        }
+
         // #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)
@@ -334,10 +543,148 @@ public sealed class TaskScanner : IAsyncDisposable
 
         await _repo.CompleteClaimAsync(task.Id, token, final, now, ct);
 
+        // #716: A run took place — earlier budget misses are settled.
+        if (lauf != TaskLauf.NichtGelaufen
+            && (task.BudgetMissCount > 0 || task.CatchUpPending || task.DeferredUntil is not null))
+            await _repo.ClearBudgetMissAsync(task.Id, now, ct);
+
         if (ok && final == TaskItemStatus.Done)
             await UnblockDependentsAsync(task.Id, now, ct);
     }
 
+    /// <summary>
+    /// #716: The budget refused the run. A one-time task is carried over to the next day
+    /// with its occurrence intact; a recurring one follows the agent's policy — the
+    /// occurrence lapses, and under <see cref="BudgetMissPolicy.CatchUpOnce"/> one
+    /// catch-up run is scheduled for the next day.
+    /// </summary>
+    private async Task HandleBudgetMissAsync(TaskItem task, string token, DateTime now, CancellationToken ct)
+    {
+        var nextDay = StartOfNextLocalDay(now);
+        var agent = TaskAssignee.AgentId(task.Assignee);
+        var carried = false;
+        var catchUp = false;
+
+        if (!task.IsRecurring)
+        {
+            carried = await _repo.CarryOverAsync(task.Id, token, task.LastOccurrence, nextDay, now, ct);
+        }
+        else
+        {
+            catchUp = _missPolicy(task) == BudgetMissPolicy.CatchUpOnce;
+            await _repo.RecordBudgetMissAsync(task.Id, token, catchUp ? nextDay : null, now, ct);
+        }
+
+        lock (_missesToday)
+        {
+            var entry = _missesToday.GetValueOrDefault(agent);
+            _missesToday[agent] = (entry.Misses + 1,
+                entry.CarriedOver + (carried ? 1 : 0),
+                entry.CatchUps + (catchUp && !task.CatchUpPending ? 1 : 0));
+        }
+
+        _logger.LogInformation(
+            "Task {TaskId} refused for lack of budget — {Outcome}",
+            task.Id,
+            carried ? $"carried over, due again from {nextDay:yyyy-MM-dd HH:mm} UTC"
+                : catchUp ? "occurrence lapsed, one catch-up run scheduled for the next day"
+                : "occurrence lapsed (policy: expire)");
+    }
+
+    /// <summary>
+    /// #716: Prevent rather than catch up. Every half hour the day ahead is checked; an
+    /// agent whose budget will not last until midnight is named once a day — with the time
+    /// it runs out and how many planned runs that costs — while there is still time to
+    /// raise the budget or decide what can go.
+    /// </summary>
+    private async Task WarnAboutShortfallsAsync(IReadOnlyList<TaskItem> runnable, DateTime nowUtc, CancellationToken ct)
+    {
+        if (_outlook is null || nowUtc - _lastOutlookAt < OutlookInterval)
+            return;
+        _lastOutlookAt = nowUtc;
+
+        IReadOnlyList<BudgetShortfall> shortfalls;
+        try
+        {
+            shortfalls = await _outlook.ShortfallsAsync(runnable, nowUtc, ct);
+        }
+        catch (Exception ex) when (ex is not OperationCanceledException)
+        {
+            _logger.LogWarning(ex, "Budget outlook failed — no forecast this time");
+            return;
+        }
+
+        var today = DateOnly.FromDateTime(TimeZoneInfo.ConvertTimeFromUtc(nowUtc, _clock.LocalTimeZone));
+        foreach (var shortfall in shortfalls)
+        {
+            if (_shortfallWarned.TryGetValue(shortfall.AgentId, out var warnedOn) && warnedOn == today)
+                continue;
+            _shortfallWarned[shortfall.AgentId] = today;
+
+            var local = TimeZoneInfo.ConvertTimeFromUtc(shortfall.ExhaustsAtUtc, _clock.LocalTimeZone);
+            _logger.LogWarning(
+                "Budget forecast: the daily budget of {Who} will run out around {Time:HH:mm} — "
+                + "{Refused} of {Planned} runs planned for the rest of today would be refused. "
+                + "Raise the budget or decide what can wait.",
+                shortfall.AgentId.Length == 0 ? "the instance" : $"agent '{shortfall.AgentId}'",
+                local, shortfall.RunsRefused, shortfall.RunsPlanned);
+        }
+    }
+
+    /// <summary>
+    /// #716: On the first tick of a new local day, one line per agent about what the
+    /// budget refused the day before. The details are on the tasks themselves.
+    /// </summary>
+    private void SummarizeMissesIfNewDay(DateTime nowUtc)
+    {
+        var today = DateOnly.FromDateTime(TimeZoneInfo.ConvertTimeFromUtc(nowUtc, _clock.LocalTimeZone));
+
+        List<KeyValuePair<string, (int Misses, int CarriedOver, int CatchUps)>> summary;
+        DateOnly? day;
+        lock (_missesToday)
+        {
+            if (_missDay is null)
+            {
+                _missDay = today;
+                return;
+            }
+            if (_missDay == today)
+                return;
+
+            day = _missDay;
+            summary = [.. _missesToday];
+            _missesToday.Clear();
+            _missDay = today;
+        }
+
+        foreach (var (agent, counts) in summary)
+        {
+            _logger.LogWarning(
+                "Budget summary {Day:yyyy-MM-dd} for agent {AgentId}: {Misses} run(s) refused for lack of "
+                + "budget, {Carried} task(s) carried over, {CatchUps} catch-up run(s) scheduled",
+                day, agent.Length == 0 ? "-" : agent, counts.Misses, counts.CarriedOver, counts.CatchUps);
+        }
+    }
+
+    /// <summary>
+    /// Local midnight after <paramref name="nowUtc"/>, in UTC. The budget day follows the
+    /// machine's local date, like <see cref="Budget.BudgetGuard"/>.
+    /// </summary>
+    private DateTime StartOfNextLocalDay(DateTime nowUtc)
+    {
+        var zone = _clock.LocalTimeZone;
+        var local = TimeZoneInfo.ConvertTimeFromUtc(nowUtc, zone);
+        var midnight = DateTime.SpecifyKind(local.Date.AddDays(1), DateTimeKind.Unspecified);
+
+        // A midnight skipped by a DST change does not exist; take the next valid minute.
+        while (zone.IsInvalidTime(midnight))
+            midnight = midnight.AddMinutes(1);
+
+        return TimeZoneInfo.ConvertTimeToUtc(midnight, zone);
+    }
+
+    private static string Iso(DateTime utc) => utc.ToUniversalTime().ToString("O");
+
     /// <summary>
     /// Auto-Dispatch: Wird eine Aufgabe fertig, werden die auf sie wartenden Aufgaben
     /// freigegeben, sobald <b>alle</b> ihre Blocker erledigt sind.
@@ -378,6 +725,14 @@ public sealed class TaskScanner : IAsyncDisposable
             try { await _loop; }
             catch (OperationCanceledException) { }
         }
+
+        // #682: The loop no longer waits for its runs, so wait for them here — otherwise
+        // a run could still write to the repository after the scanner is gone.
+        Task[] inFlight;
+        lock (_inFlight)
+            inFlight = [.. _inFlight];
+        await Task.WhenAll(inFlight);
+
         _cts.Dispose();
     }
 }

src/ClawdDotNet.Core/Tasks/TaskSchedule.cs

@@ -201,6 +201,79 @@ public static class TaskSchedule
         }
     }
 
+    /// <summary>
+    /// #716: How many runs the task will still trigger from <paramref name="fromUtc"/> up to
+    /// (excluding) <paramref name="toUtc"/> — including one that is due right now. The
+    /// basis for "how much budget does the rest of the day still need".
+    /// </summary>
+    public static int OccurrencesBetween(TaskItem task, DateTime fromUtc, DateTime toUtc, int cap = 1_440)
+        => OccurrenceTimesBetween(task, fromUtc, toUtc, cap).Count;
+
+    /// <summary>
+    /// #716: When the task will run from <paramref name="fromUtc"/> up to (excluding)
+    /// <paramref name="toUtc"/>. A run due right now is listed at <paramref name="fromUtc"/>.
+    /// </summary>
+    public static IReadOnlyList<DateTime> OccurrenceTimesBetween(TaskItem task, DateTime fromUtc, DateTime toUtc, int cap = 1_440)
+    {
+        fromUtc = DateTime.SpecifyKind(fromUtc, DateTimeKind.Utc);
+        toUtc = DateTime.SpecifyKind(toUtc, DateTimeKind.Utc);
+        var times = new List<DateTime>();
+        if (toUtc <= fromUtc)
+            return times;
+
+        var dueNow = DueOccurrence(task, fromUtc) is not null;
+        if (dueNow)
+            times.Add(fromUtc);
+
+        if (task.When is not { } when)
+            return times; // one-time without a schedule: due until it ran
+
+        switch (when.Kind)
+        {
+            case TaskWhenKind.At:
+            {
+                if (!dueNow && task.LastOccurrence is null
+                    && TryResolveInstant(when.Value, when.TimeZone, out var at) && at < toUtc)
+                    times.Add(at);
+                return times;
+            }
+
+            case TaskWhenKind.Every:
+            {
+                if (!TryParseInterval(when.Value, out var interval) || interval <= TimeSpan.Zero)
+                    return times;
+
+                var next = dueNow
+                    ? fromUtc + interval
+                    : NextOccurrenceUtc(task, fromUtc) ?? toUtc;
+                while (times.Count < cap && next < toUtc)
+                {
+                    times.Add(next);
+                    next += interval;
+                }
+                return times;
+            }
+
+            case TaskWhenKind.Cron:
+            {
+                if (!TryPrepareCron(when, out var cron, out var tz))
+                    return times;
+
+                var cursor = fromUtc;
+                while (times.Count < cap && NextCronUtc(cron, tz, cursor) is { } next && next < toUtc)
+                {
+                    if (next > fromUtc)
+                        times.Add(next);
+                    cursor = next;
+                }
+                return times;
+            }
+
+            default:
+                return times;
+        }
+    }
+
     private static bool TryPrepareCron(TaskWhen when, out CronExpression cron, out TimeZoneInfo tz)
     {
         cron = null!;

src/ClawdDotNet.Core/Tasks/TaskboardService.cs

@@ -31,6 +31,10 @@ public sealed class TaskboardService
     public Task<IReadOnlyList<TaskItem>> ListAsync(TaskQuery query, CancellationToken ct)
         => _repo.ListAsync(query, ct);
 
+    /// <summary>The whole board, without the cap of <see cref="ListAsync"/>.</summary>
+    public Task<IReadOnlyList<TaskItem>> ListAllAsync(CancellationToken ct, bool includeArchived = false)
+        => _repo.ListAllAsync(includeArchived, ct);
+
     // ─── Anlegen ───
 
     /// <summary>
@@ -104,9 +108,9 @@ public sealed class TaskboardService
             if (task is not null) { seen.Add(task.Id); imported++; }
         }
 
-        // Verwaiste Zeilen archivieren. Der Deckel von 500 ist für den Start unkritisch;
-        // wächst das Board darüber hinaus, gehört ohnehin das Aufräumen (siehe Konzept) her.
-        var known = await _repo.ListAsync(new TaskQuery { IncludeArchived = true, Limit = 500 }, ct);
+        // Verwaiste Zeilen archivieren. Ungekappt (#716): Vorher sah dieser Abgleich nur die
+        // ersten 500 Zeilen, und darüber blieben verwaiste Zeilen still stehen.
+        var known = await _repo.ListAllAsync(includeArchived: true, ct);
         foreach (var task in known)
             if (task.Status != TaskItemStatus.Archived && !seen.Contains(task.Id))
                 await _repo.SetStatusAsync(task.Id, TaskItemStatus.Archived, DateTime.UtcNow, ct);

src/ClawdDotNet.Desktop/ViewModels/AgentsPageViewModel.cs

@@ -1,3 +1,4 @@
+using ClawdDotNet.Core.Tasks;
 using System.Collections.ObjectModel;
 using Avalonia.Threading;
 using ClawdDotNet.App;
@@ -77,6 +78,13 @@ public sealed partial class AgentItemViewModel : ViewModelBase
     [ObservableProperty]
     private long _dailyTokens;
 
+    /// <summary>#716: What happens to a recurring task's run when the budget is exhausted.</summary>
+    [ObservableProperty]
+    private string _whenExhausted = "expire";
+
+    /// <summary>The values <see cref="AgentBudget.WhenExhausted"/> understands.</summary>
+    public IReadOnlyList<string> WhenExhaustedOptions { get; } = ["expire", "catchUpOnce"];
+
     public ObservableCollection<ToolItemViewModel> AvailableTools { get; } = [];
 
     /// <summary>
@@ -101,6 +109,7 @@ public sealed partial class AgentItemViewModel : ViewModelBase
         _timeoutSeconds = config.LoopGuard.TimeoutSeconds;
         _dailyCostUsd = config.Budget.DailyCostUsd;
         _dailyTokens = config.Budget.DailyTokens;
+        _whenExhausted = config.Budget.MissPolicy == BudgetMissPolicy.CatchUpOnce ? "catchUpOnce" : "expire";
 
         foreach (var tool in KnownTools)
         {
@@ -137,6 +146,7 @@ public sealed partial class AgentItemViewModel : ViewModelBase
         Config.LoopGuard.TimeoutSeconds = TimeoutSeconds;
         Config.Budget.DailyCostUsd = DailyCostUsd;
         Config.Budget.DailyTokens = DailyTokens;
+        Config.Budget.WhenExhausted = WhenExhausted;
     }
 }
 

src/ClawdDotNet.Desktop/Views/AgentsPageView.axaml

@@ -208,6 +208,15 @@
                         <TextBox Text="{Binding DailyTokens}" />
                       </StackPanel>
                     </Grid>
+
+                    <StackPanel>
+                      <TextBlock Classes="label" Text="{Binding L[desktop.agents.whenExhausted]}" />
+                      <ComboBox HorizontalAlignment="Stretch"
+                                ItemsSource="{Binding WhenExhaustedOptions}"
+                                SelectedItem="{Binding WhenExhausted}" />
+                      <TextBlock Classes="caption" TextWrapping="Wrap"
+                                 Text="{Binding L[desktop.agents.whenExhaustedHint]}" />
+                    </StackPanel>
                   </StackPanel>
 
                 </StackPanel>

src/ClawdDotNet.Desktop/i18n/de.json

@@ -64,6 +64,8 @@
   "desktop.agents.maxToolResultChars": "Max. Tool-Ergebnis (Zeichen)",
   "desktop.agents.dailyCost": "Tagesbudget ($ USD)",
   "desktop.agents.dailyTokens": "Tagesbudget (Tokens)",
+  "desktop.agents.whenExhausted": "Wenn das Budget erschöpft ist (wiederkehrende Aufgaben)",
+  "desktop.agents.whenExhaustedHint": "expire: Der verpasste Lauf verfällt und wird an der Aufgabe vermerkt. catchUpOnce: Alle verpassten Läufe werden am nächsten Tag durch einen Lauf nachgeholt, nach der regulären Arbeit des Tages. Einmalige Aufgaben werden immer auf den nächsten Tag mitgenommen.",
   "desktop.agents.allowedToolsFor": "ZUGELASSENE WERKZEUGE FÜR {0}",
   "desktop.agents.thTool": "WERKZEUG",
   "desktop.agents.thDescription": "BESCHREIBUNG",

src/ClawdDotNet.Desktop/i18n/en.json

@@ -64,6 +64,8 @@
   "desktop.agents.maxToolResultChars": "Max Tool Result (chars)",
   "desktop.agents.dailyCost": "Daily Budget ($ USD)",
   "desktop.agents.dailyTokens": "Daily Budget (Tokens)",
+  "desktop.agents.whenExhausted": "When the budget is exhausted (recurring tasks)",
+  "desktop.agents.whenExhaustedHint": "expire: the missed run lapses and is recorded on the task. catchUpOnce: all missed runs are caught up by one run the next day, after the day's regular work. One-time tasks are always carried over to the next day.",
   "desktop.agents.allowedToolsFor": "ALLOWED TOOLS FOR {0}",
   "desktop.agents.thTool": "TOOL",
   "desktop.agents.thDescription": "DESCRIPTION",

src/ClawdDotNet.Manager.Web/wwwroot/app.css

@@ -1721,3 +1721,77 @@ div.klein,
 td.klein {
   font-size: 12px;
 }
+
+/* ─── Team overview (#711) ─── */
+
+.team-ansicht {
+  display: flex;
+  flex-direction: column;
+  gap: 12px;
+  height: 100%;
+}
+
+.team-zusammenfassung {
+  flex-wrap: wrap;
+  min-height: 24px;
+}
+
+.team-flaeche {
+  display: flex;
+  gap: 12px;
+  flex: 1;
+  min-height: 420px;
+}
+
+.team-graph {
+  flex: 1;
+  min-width: 0;
+  min-height: 420px;
+  background: var(--surface-subtil);
+  border: 1px solid var(--divider);
+}
+
+.team-seitenleiste {
+  width: 320px;
+  flex-shrink: 0;
+  padding: 14px;
+  background: var(--surface);
+  border: 1px solid var(--divider);
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+  overflow-y: auto;
+}
+
+.team-seitenleiste-kopf {
+  justify-content: space-between;
+}
+
+.team-seitenleiste h3 {
+  margin: 8px 0 0;
+}
+
+.team-ergebnis {
+  white-space: pre-wrap;
+  word-break: break-word;
+  max-height: 160px;
+  overflow-y: auto;
+  font-family: var(--schrift-mono);
+}
+
+.team-aktionen {
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+  margin-top: 8px;
+}
+
+.team-legende {
+  flex-wrap: wrap;
+  gap: 16px;
+}
+
+@media (max-width: 800px) {
+  .team-flaeche { flex-direction: column; }
+  .team-seitenleiste { width: auto; }
+}

src/ClawdDotNet.Manager.Web/wwwroot/app.js

@@ -35,10 +35,12 @@ import { renderUsageRuns } from "./views/usage-runs.js";
 import { renderUsageTimeline } from "./views/usage-timeline.js";
 import { renderRunDetail } from "./views/run-detail.js";
 import { renderPromptHistory } from "./views/prompt-history.js";
+import { renderTeam, leaveTeam } from "./views/team.js";
 
 // ─── 1. Routen registrieren ───
 
 function verlasseAnsicht() {
+  leaveTeam();
   trenneLogStream();
   trenneAgentenChatsStream();
   stoppeInstanzenPolling();
@@ -50,6 +52,7 @@ registriereRoute("/chat/:agentId", (p) => { verlasseAnsicht(); return rendereCha
 registriereRoute("/agenten", () => { verlasseAnsicht(); return rendereAgenten(); });
 registriereRoute("/agenten/:agentId", (p) => { verlasseAnsicht(); return rendereAgenten(p); });
 registriereRoute("/aufgaben", () => { verlasseAnsicht(); return rendereAufgaben(); });
+registriereRoute("/team", () => { verlasseAnsicht(); return renderTeam(); });
 registriereRoute("/dienste", () => { verlasseAnsicht(); return rendereDienste(); });
 registriereRoute("/staging", () => { verlasseAnsicht(); return rendereStaging(); });
 registriereRoute("/verbrauch", () => { verlasseAnsicht(); return rendereVerbrauch(); });

src/ClawdDotNet.Manager.Web/wwwroot/i18n/de.json

@@ -67,6 +67,28 @@
   "nav.chat": "Chat",
   "nav.agents": "Agenten",
   "nav.tasks": "Aufgaben",
+  "nav.team": "Teamübersicht",
+  "team.title": "Teamübersicht",
+  "team.subtitle": "Wer arbeitet, wer hat in den letzten Sekunden wen erreicht, und wo klemmt es. Ein Klick auf einen Agenten zeigt Einzelheiten.",
+  "team.noInstance": "Keine Instanz ausgewählt. Oben eine aktive Instanz wählen.",
+  "team.empty": "Diese Instanz hat keine Agenten.",
+  "team.legendLink": "hat erreicht (verblasst nach 30 s)",
+  "team.state.Idle": "bereit",
+  "team.state.Working": "arbeitet",
+  "team.state.Stuck": "hängt",
+  "team.state.WaitingForApproval": "wartet auf Freigabe",
+  "team.state.Problem": "Problem",
+  "team.state.BudgetExhausted": "Budget erschöpft",
+  "team.running": "Läuft gerade",
+  "team.since": "seit {time}",
+  "team.task": "Aufgabe {id}",
+  "team.calledBy": "gerufen von {agent}",
+  "team.stuckHint": "Läufe dieses Agenten dauern sonst etwa {minutes} Min.",
+  "team.approvals": "{n} Werkzeugaufruf/-aufrufe warten auf Freigabe",
+  "team.lastRun": "Letzter Lauf",
+  "team.openApprovals": "Freigaben öffnen",
+  "team.openChat": "Chat öffnen",
+  "team.openRuns": "Läufe anzeigen",
   "nav.services": "Dienste",
   "nav.group.analytics": "Analyse",
   "nav.usage": "Tokennutzung",
@@ -192,6 +214,12 @@
   "tasks.saved": "Aufgabe gespeichert.",
   "tasks.deleted": "Aufgabe gelöscht.",
   "tasks.runTriggered": "Lauf ausgelöst.",
+  "tasks.nextRun": "Nächster",
+  "tasks.lastRun": "Letzter",
+  "tasks.budgetMissed": "Budget erschöpft: {n} Lauf/Läufe abgelehnt",
+  "tasks.budgetMissedLast": "zuletzt {time}",
+  "tasks.budgetCarriedOver": "mitgenommen, wieder fällig ab {time}",
+  "tasks.budgetCatchUp": "ein Nachholauf ab {time}",
 
   "services.title": "Dienste",
   "services.newService": "Neuer Dienst",

src/ClawdDotNet.Manager.Web/wwwroot/i18n/en.json

@@ -67,6 +67,28 @@
   "nav.chat": "Chat",
   "nav.agents": "Agents",
   "nav.tasks": "Tasks",
+  "nav.team": "Team overview",
+  "team.title": "Team overview",
+  "team.subtitle": "Who is working, who reached whom in the last seconds, and where something is stuck. Click an agent for details.",
+  "team.noInstance": "No instance selected. Choose an active instance in the header.",
+  "team.empty": "No agents in this instance.",
+  "team.legendLink": "reached (fades after 30 s)",
+  "team.state.Idle": "idle",
+  "team.state.Working": "working",
+  "team.state.Stuck": "stuck",
+  "team.state.WaitingForApproval": "waiting for approval",
+  "team.state.Problem": "problem",
+  "team.state.BudgetExhausted": "budget exhausted",
+  "team.running": "Running now",
+  "team.since": "since {time}",
+  "team.task": "task {id}",
+  "team.calledBy": "called by {agent}",
+  "team.stuckHint": "Runs of this agent usually take about {minutes} min.",
+  "team.approvals": "{n} tool call(s) waiting for approval",
+  "team.lastRun": "Last run",
+  "team.openApprovals": "Open approvals",
+  "team.openChat": "Open chat",
+  "team.openRuns": "Show runs",
   "nav.services": "Services",
   "nav.group.analytics": "Analytics",
   "nav.usage": "Token Usage",
@@ -192,6 +214,12 @@
   "tasks.saved": "Task saved.",
   "tasks.deleted": "Task deleted.",
   "tasks.runTriggered": "Run triggered.",
+  "tasks.nextRun": "Next",
+  "tasks.lastRun": "Last",
+  "tasks.budgetMissed": "Budget exhausted: {n} run(s) refused",
+  "tasks.budgetMissedLast": "last at {time}",
+  "tasks.budgetCarriedOver": "carried over, due again from {time}",
+  "tasks.budgetCatchUp": "one catch-up run from {time}",
 
   "services.title": "Services",
   "services.newService": "New Service",

src/ClawdDotNet.Manager.Web/wwwroot/index.html

@@ -55,6 +55,12 @@
           </svg>
           <span class="nav-label" data-i18n="nav.agents">Agents</span>
         </a>
+        <a href="#/team" class="nav-link" title="Team overview" data-i18n-title="nav.team">
+          <svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.75">
+            <path d="M3 3h6v6H3z M15 3h6v6h-6z M9 15h6v6H9z M6 9v3h12V9 M12 12v3"/>
+          </svg>
+          <span class="nav-label" data-i18n="nav.team">Team overview</span>
+        </a>
         <a href="#/aufgaben" class="nav-link" title="Tasks" data-i18n-title="nav.tasks">
           <svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.75">
             <path d="M9 11l3 3L22 4 M21 12v7a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h11"/>

src/ClawdDotNet.Manager.Web/wwwroot/modules/events.js

@@ -93,7 +93,7 @@ export function verbindeStrom() {
     meldeStatus(false);
   };
 
-  const bekannteEreignisse = ["chat", "step", "run", "instance", "status"];
+  const bekannteEreignisse = ["chat", "step", "run", "instance", "status", "activity"];
   for (const art of bekannteEreignisse) {
     strom.addEventListener(art, (e) => verteileEreignis(art, e.data));
   }

src/ClawdDotNet.Manager.Web/wwwroot/vendor/README.md

@@ -0,0 +1,23 @@
+# Vendored libraries
+
+Third-party files the WebUI ships as-is. They live here instead of being loaded from a CDN
+because the target machine may have no internet access (WebUI-Leitfaden). Do not edit them;
+to update, replace the file and this table together.
+
+Downloaded 2026-09-24 from the npm registry. Each tarball was checked against the
+`dist.integrity` (SHA-512) the registry publishes before extracting.
+
+| Package | Version | File | License | SHA-256 of the file |
+|---|---|---|---|---|
+| [cytoscape](https://www.npmjs.com/package/cytoscape) | 3.34.3 | `cytoscape/cytoscape.min.js` | MIT | `5f3b5b529546d5af1fc5628590af033b74511a5b6f789f5f4682845863228b91` |
+| [elkjs](https://www.npmjs.com/package/elkjs) | 0.9.3 | `elkjs/elk.bundled.js` | EPL-2.0 | `b0745abd7f23cd91690a1587e377edbe19fd7233c783300290936720546216d4` |
+| [cytoscape-elk](https://www.npmjs.com/package/cytoscape-elk) | 2.3.0 | `cytoscape-elk/cytoscape-elk.js` | MIT | `25acbb9dea9b0dc6fef0e79b697547ee56e579f0e1c22ae4353131e72c7e140a` |
+
+**Why elkjs 0.9.3 and not the newest.** cytoscape-elk 2.3.0 declares `elkjs ^0.9.3`. A newer
+elkjs would be untested with the adapter.
+
+**How they are loaded.** All three are UMD bundles and, loaded as classic scripts in this
+order, register the globals `cytoscape`, `ELK` and `cytoscapeElk`. The team overview (#711)
+loads them on demand, so pages that do not draw a graph do not pay for ~2 MB of script.
+
+The license texts sit next to each file.

src/ClawdDotNet.Manager.Web/wwwroot/vendor/cytoscape-elk/LICENSE

@@ -0,0 +1,21 @@
+
+
+Copyright (c) 2016-2018, 2020, The Cytoscape Consortium.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the “Software”), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

src/ClawdDotNet.Manager.Web/wwwroot/vendor/cytoscape-elk/cytoscape-elk.js

@@ -0,0 +1,356 @@
+(function webpackUniversalModuleDefinition(root, factory) {
+	if(typeof exports === 'object' && typeof module === 'object')
+		module.exports = factory(require("elkjs/lib/elk.bundled.js"));
+	else if(typeof define === 'function' && define.amd)
+		define(["elkjs"], factory);
+	else if(typeof exports === 'object')
+		exports["cytoscapeElk"] = factory(require("elkjs/lib/elk.bundled.js"));
+	else
+		root["cytoscapeElk"] = factory(root["ELK"]);
+})(this, function(__WEBPACK_EXTERNAL_MODULE__632__) {
+return /******/ (function() { // webpackBootstrap
+/******/ 	"use strict";
+/******/ 	var __webpack_modules__ = ({
+
+/***/ 632:
+/***/ (function(module) {
+
+module.exports = __WEBPACK_EXTERNAL_MODULE__632__;
+
+/***/ })
+
+/******/ 	});
+/************************************************************************/
+/******/ 	// The module cache
+/******/ 	var __webpack_module_cache__ = {};
+/******/ 	
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/ 		// Check if module is in cache
+/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
+/******/ 		if (cachedModule !== undefined) {
+/******/ 			return cachedModule.exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = __webpack_module_cache__[moduleId] = {
+/******/ 			// no module.id needed
+/******/ 			// no module.loaded needed
+/******/ 			exports: {}
+/******/ 		};
+/******/ 	
+/******/ 		// Execute the module function
+/******/ 		__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+/******/ 	
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/ 	
+/************************************************************************/
+/******/ 	/* webpack/runtime/compat get default export */
+/******/ 	!function() {
+/******/ 		// getDefaultExport function for compatibility with non-harmony modules
+/******/ 		__webpack_require__.n = function(module) {
+/******/ 			var getter = module && module.__esModule ?
+/******/ 				function() { return module['default']; } :
+/******/ 				function() { return module; };
+/******/ 			__webpack_require__.d(getter, { a: getter });
+/******/ 			return getter;
+/******/ 		};
+/******/ 	}();
+/******/ 	
+/******/ 	/* webpack/runtime/define property getters */
+/******/ 	!function() {
+/******/ 		// define getter functions for harmony exports
+/******/ 		__webpack_require__.d = function(exports, definition) {
+/******/ 			for(var key in definition) {
+/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+/******/ 				}
+/******/ 			}
+/******/ 		};
+/******/ 	}();
+/******/ 	
+/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
+/******/ 	!function() {
+/******/ 		__webpack_require__.o = function(obj, prop) { return Object.prototype.hasOwnProperty.call(obj, prop); }
+/******/ 	}();
+/******/ 	
+/************************************************************************/
+var __webpack_exports__ = {};
+// This entry need to be wrapped in an IIFE because it need to be isolated against other modules in the chunk.
+!function() {
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  "default": function() { return /* binding */ src; }
+});
+
+// EXTERNAL MODULE: external {"commonjs":"elkjs/lib/elk.bundled.js","commonjs2":"elkjs/lib/elk.bundled.js","amd":"elkjs","root":"ELK"}
+var elk_bundled_js_amd_elkjs_root_ELK_ = __webpack_require__(632);
+var elk_bundled_js_amd_elkjs_root_ELK_default = /*#__PURE__*/__webpack_require__.n(elk_bundled_js_amd_elkjs_root_ELK_);
+;// CONCATENATED MODULE: ./src/assign.js
+// Simple, internal Object.assign() polyfill for options objects etc.
+function assign_assign(tgt) {
+  for (var _len = arguments.length, srcs = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    srcs[_key - 1] = arguments[_key];
+  }
+
+  srcs.forEach(function (src) {
+    Object.keys(src).forEach(function (k) {
+      return tgt[k] = src[k];
+    });
+  });
+  return tgt;
+}
+
+/* harmony default export */ var src_assign = (Object.assign != null ? Object.assign.bind(Object) : assign_assign);
+;// CONCATENATED MODULE: ./src/defaults.js
+var defaults = {
+  nodeDimensionsIncludeLabels: false,
+  // Boolean which changes whether label dimensions are included when calculating node dimensions
+  fit: true,
+  // Whether to fit
+  padding: 20,
+  // Padding on fit
+  animate: false,
+  // Whether to transition the node positions
+  animateFilter: function animateFilter() {
+    return true;
+  },
+  // Whether to animate specific nodes when animation is on; non-animated nodes immediately go to their final positions
+  animationDuration: 500,
+  // Duration of animation in ms if enabled
+  animationEasing: undefined,
+  // Easing of animation if enabled
+  transform: function transform(node, pos) {
+    return pos;
+  },
+  // A function that applies a transform to the final node position
+  ready: undefined,
+  // Callback on layoutready
+  stop: undefined,
+  // Callback on layoutstop
+  nodeLayoutOptions: undefined,
+  // Special options for only the nodes
+  elk: {
+    // Options to pass directly to ELK `layoutOptions`. The subsequent identifier has to be used as property key in quotes.
+    // E.g. for 'org.eclipse.elk.direction' use:
+    // 'elk.direction'
+    // Primary/mandatory, the elk algorithm to use
+    // one of 'box', 'disco', 'force', 'layered', 'mrtree', 'radial', 'random', 'stress'
+    // (see https://www.eclipse.org/elk/reference/algorithms.html)
+    algorithm: undefined
+  },
+  priority: function priority() {
+    return null;
+  } // Edges with a non-nil value are skipped when geedy edge cycle breaking is enabled
+
+};
+/* harmony default export */ var src_defaults = (defaults);
+;// CONCATENATED MODULE: ./src/layout.js
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+
+
+
+var elkOverrides = {};
+
+var getPos = function getPos(ele, options) {
+  var dims = ele.layoutDimensions(options);
+  var parent = ele.parent();
+  var k = ele.scratch('elk');
+  var p = {
+    x: k.x,
+    y: k.y
+  };
+
+  while (parent.nonempty()) {
+    var kp = parent.scratch('elk');
+    p.x += kp.x;
+    p.y += kp.y;
+    parent = parent.parent();
+  } // elk considers a node position to be its top-left corner, while cy is the centre
+
+
+  p.x += dims.w / 2;
+  p.y += dims.h / 2;
+  return p;
+};
+
+var makeNode = function makeNode(node, options) {
+  var k = {
+    _cyEle: node,
+    id: node.id()
+  }; // Apply nodeLayoutOptions per user-specified function
+  // e.g. nodeLayoutOptions => n.scratch('layoutOptions')
+
+  if (options.nodeLayoutOptions) {
+    k.layoutOptions = options.nodeLayoutOptions(node);
+  }
+
+  if (!node.isParent()) {
+    var dims = node.layoutDimensions(options);
+    var p = node.position(); // the elk position is the top-left corner, cy is the centre
+
+    k.x = p.x - dims.w / 2;
+    k.y = p.y - dims.h / 2;
+    k.width = dims.w;
+    k.height = dims.h;
+  }
+
+  node.scratch('elk', k);
+  return k;
+};
+
+var makeEdge = function makeEdge(edge
+/*, options*/
+) {
+  var k = {
+    _cyEle: edge,
+    id: edge.id(),
+    source: edge.data('source'),
+    target: edge.data('target')
+  };
+  edge.scratch('elk', k);
+  return k;
+};
+
+var makeGraph = function makeGraph(nodes, edges, options) {
+  var elkNodes = [];
+  var elkEdges = [];
+  var elkEleLookup = {};
+  var graph = {
+    id: 'root',
+    children: [],
+    edges: []
+  }; // map all nodes
+
+  for (var i = 0; i < nodes.length; i++) {
+    var n = nodes[i];
+    var k = makeNode(n, options);
+    elkNodes.push(k);
+    elkEleLookup[n.id()] = k;
+  } // map all edges
+
+
+  for (var _i = 0; _i < edges.length; _i++) {
+    var e = edges[_i];
+
+    var _k = makeEdge(e, options);
+
+    elkEdges.push(_k);
+    elkEleLookup[e.id()] = _k;
+  } // make hierarchy
+
+
+  for (var _i2 = 0; _i2 < elkNodes.length; _i2++) {
+    var _k2 = elkNodes[_i2];
+    var _n = _k2._cyEle;
+
+    if (!_n.isChild()) {
+      graph.children.push(_k2);
+    } else {
+      var parent = _n.parent();
+
+      var parentK = elkEleLookup[parent.id()];
+      var children = parentK.children = parentK.children || [];
+      children.push(_k2);
+    }
+  }
+
+  for (var _i3 = 0; _i3 < elkEdges.length; _i3++) {
+    var _k3 = elkEdges[_i3]; // put all edges in the top level for now
+    // TODO does this cause issues in certain edgecases?
+
+    /*let e = k._cyEle;
+    let parentSrc = e.source().parent();
+    let parentTgt = e.target().parent();
+    if ( false && parentSrc.nonempty() && parentTgt.nonempty() && parentSrc.same( parentTgt ) ){
+      let kp = elkEleLookup[ parentSrc.id() ];
+       kp.edges = kp.edges || [];
+       kp.edges.push( k );
+    } else {*/
+
+    graph.edges.push(_k3); //}
+  }
+
+  return graph;
+};
+
+var Layout = /*#__PURE__*/function () {
+  function Layout(options) {
+    _classCallCheck(this, Layout);
+
+    var elkOptions = options.elk;
+    var cy = options.cy;
+    this.options = src_assign({}, src_defaults, options);
+    this.options.elk = src_assign({
+      aspectRatio: cy.width() / cy.height()
+    }, src_defaults.elk, elkOptions, elkOverrides);
+  }
+
+  _createClass(Layout, [{
+    key: "run",
+    value: function run() {
+      var layout = this;
+      var options = this.options;
+      var eles = options.eles;
+      var nodes = eles.nodes();
+      var edges = eles.edges();
+      var elk = new (elk_bundled_js_amd_elkjs_root_ELK_default())();
+      var graph = makeGraph(nodes, edges, options);
+      graph['layoutOptions'] = options.elk;
+      elk.layout(graph).then(function () {
+        nodes.filter(function (n) {
+          return !n.isParent();
+        }).layoutPositions(layout, options, function (n) {
+          return getPos(n, options);
+        });
+      });
+      return this;
+    }
+  }, {
+    key: "stop",
+    value: function stop() {
+      return this; // chaining
+    }
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      return this; // chaining
+    }
+  }]);
+
+  return Layout;
+}();
+
+/* harmony default export */ var layout = (Layout);
+;// CONCATENATED MODULE: ./src/index.js
+ // registers the extension on a cytoscape lib ref
+
+var register = function register(cytoscape) {
+  if (!cytoscape) {
+    return;
+  } // can't register if cytoscape unspecified
+
+
+  cytoscape('layout', 'elk', layout); // register with cytoscape.js
+};
+
+if (typeof cytoscape !== 'undefined') {
+  // expose to global cytoscape (i.e. window.cytoscape)
+  // eslint-disable-next-line no-undef
+  register(cytoscape);
+}
+
+/* harmony default export */ var src = (register);
+}();
+__webpack_exports__ = __webpack_exports__["default"];
+/******/ 	return __webpack_exports__;
+/******/ })()
+;
+});

src/ClawdDotNet.Manager.Web/wwwroot/vendor/cytoscape/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2016-2026, The Cytoscape Consortium.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the “Software”), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

src/ClawdDotNet.Manager.Web/wwwroot/vendor/elkjs/LICENSE.md

@@ -0,0 +1,264 @@
+# Eclipse Public License - v 2.0
+
+THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
+PUBLIC LICENSE (“AGREEMENT”). ANY USE, REPRODUCTION OR DISTRIBUTION OF
+THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT.
+
+## 1. DEFINITIONS
+
+“Contribution” means:
+
+-   a\) in the case of the initial Contributor, the initial content
+    Distributed under this Agreement, and
+-   b\) in the case of each subsequent Contributor:
+    -   i\) changes to the Program, and
+    -   ii\) additions to the Program;
+
+    where such changes and/or additions to the Program originate from
+    and are Distributed by that particular Contributor. A Contribution
+    “originates” from a Contributor if it was added to the Program by
+    such Contributor itself or anyone acting on such Contributor's
+    behalf. Contributions do not include changes or additions to the
+    Program that are not Modified Works.
+
+“Contributor” means any person or entity that Distributes the Program.
+
+“Licensed Patents” mean patent claims licensable by a Contributor which
+are necessarily infringed by the use or sale of its Contribution alone
+or when combined with the Program.
+
+“Program” means the Contributions Distributed in accordance with this
+Agreement.
+
+“Recipient” means anyone who receives the Program under this Agreement
+or any Secondary License (as applicable), including Contributors.
+
+“Derivative Works” shall mean any work, whether in Source Code or other
+form, that is based on (or derived from) the Program and for which the
+editorial revisions, annotations, elaborations, or other modifications
+represent, as a whole, an original work of authorship.
+
+“Modified Works” shall mean any work in Source Code or other form that
+results from an addition to, deletion from, or modification of the
+contents of the Program, including, for purposes of clarity any new file
+in Source Code form that contains any contents of the Program. Modified
+Works shall not include works that contain only declarations,
+interfaces, types, classes, structures, or files of the Program solely
+in each case in order to link to, bind by name, or subclass the Program
+or Modified Works thereof.
+
+“Distribute” means the acts of a) distributing or b) making available in
+any manner that enables the transfer of a copy.
+
+“Source Code” means the form of a Program preferred for making
+modifications, including but not limited to software source code,
+documentation source, and configuration files.
+
+“Secondary License” means either the GNU General Public License, Version
+2.0, or any later versions of that license, including any exceptions or
+additional permissions as identified by the initial Contributor.
+
+## 2. GRANT OF RIGHTS
+
+-   a\) Subject to the terms of this Agreement, each Contributor hereby
+    grants Recipient a non-exclusive, worldwide, royalty-free copyright
+    license to reproduce, prepare Derivative Works of, publicly display,
+    publicly perform, Distribute and sublicense the Contribution of such
+    Contributor, if any, and such Derivative Works.
+-   b\) Subject to the terms of this Agreement, each Contributor hereby
+    grants Recipient a non-exclusive, worldwide, royalty-free patent license
+    under Licensed Patents to make, use, sell, offer to sell, import and
+    otherwise transfer the Contribution of such Contributor, if any, in
+    Source Code or other form. This patent license shall apply to the
+    combination of the Contribution and the Program if, at the time the
+    Contribution is added by the Contributor, such addition of the
+    Contribution causes such combination to be covered by the
+    Licensed Patents. The patent license shall not apply to any other
+    combinations which include the Contribution. No hardware per se is
+    licensed hereunder.
+-   c\) Recipient understands that although each Contributor grants the
+    licenses to its Contributions set forth herein, no assurances are
+    provided by any Contributor that the Program does not infringe the
+    patent or other intellectual property rights of any other entity. Each
+    Contributor disclaims any liability to Recipient for claims brought by
+    any other entity based on infringement of intellectual property rights
+    or otherwise. As a condition to exercising the rights and licenses
+    granted hereunder, each Recipient hereby assumes sole responsibility to
+    secure any other intellectual property rights needed, if any. For
+    example, if a third party patent license is required to allow Recipient
+    to Distribute the Program, it is Recipient's responsibility to acquire
+    that license before distributing the Program.
+-   d\) Each Contributor represents that to its knowledge it has sufficient
+    copyright rights in its Contribution, if any, to grant the copyright
+    license set forth in this Agreement.
+-   e\) Notwithstanding the terms of any Secondary License, no Contributor
+    makes additional grants to any Recipient (other than those set forth in
+    this Agreement) as a result of such Recipient's receipt of the Program
+    under the terms of a Secondary License (if permitted under the terms of
+    Section 3).
+
+## 3. REQUIREMENTS
+
+3.1 If a Contributor Distributes the Program in any form, then:
+
+-   a\) the Program must also be made available as Source Code, in accordance
+    with section 3.2, and the Contributor must accompany the Program with a
+    statement that the Source Code for the Program is available under this
+    Agreement, and informs Recipients how to obtain it in a reasonable
+    manner on or through a medium customarily used for software exchange;
+    and
+-   b\) the Contributor may Distribute the Program under a license different
+    than this Agreement, provided that such license:
+    -   i\) effectively disclaims on behalf of all other Contributors all
+        warranties and conditions, express and implied, including warranties or
+        conditions of title and non-infringement, and implied warranties or
+        conditions of merchantability and fitness for a particular purpose;
+    -   ii\) effectively excludes on behalf of all other Contributors all
+        liability for damages, including direct, indirect, special, incidental
+        and consequential damages, such as lost profits;
+    -   iii\) does not attempt to limit or alter the recipients' rights in the
+        Source Code under section 3.2; and
+    -   iv\) requires any subsequent distribution of the Program by any party to
+        be under a license that satisfies the requirements of this section 3.
+
+3.2 When the Program is Distributed as Source Code:
+
+-   a\) it must be made available under this Agreement, or if the Program (i)
+    is combined with other material in a separate file or files made
+    available under a Secondary License, and (ii) the initial Contributor
+    attached to the Source Code the notice described in Exhibit A of this
+    Agreement, then the Program may be made available under the terms of
+    such Secondary Licenses, and
+-   b\) a copy of this Agreement must be included with each copy of
+    the Program.
+
+3.3 Contributors may not remove or alter any copyright, patent,
+trademark, attribution notices, disclaimers of warranty, or limitations
+of liability (‘notices’) contained within the Program from any copy of
+the Program which they Distribute, provided that Contributors may add
+their own appropriate notices.
+
+## 4. COMMERCIAL DISTRIBUTION
+
+Commercial distributors of software may accept certain responsibilities
+with respect to end users, business partners and the like. While this
+license is intended to facilitate the commercial use of the Program, the
+Contributor who includes the Program in a commercial product offering
+should do so in a manner which does not create potential liability for
+other Contributors. Therefore, if a Contributor includes the Program in
+a commercial product offering, such Contributor (“Commercial
+Contributor”) hereby agrees to defend and indemnify every other
+Contributor (“Indemnified Contributor”) against any losses, damages and
+costs (collectively “Losses”) arising from claims, lawsuits and other
+legal actions brought by a third party against the Indemnified
+Contributor to the extent caused by the acts or omissions of such
+Commercial Contributor in connection with its distribution of the
+Program in a commercial product offering. The obligations in this
+section do not apply to any claims or Losses relating to any actual or
+alleged intellectual property infringement. In order to qualify, an
+Indemnified Contributor must: a) promptly notify the Commercial
+Contributor in writing of such claim, and b) allow the Commercial
+Contributor to control, and cooperate with the Commercial Contributor
+in, the defense and any related settlement negotiations. The Indemnified
+Contributor may participate in any such claim at its own expense.
+
+For example, a Contributor might include the Program in a commercial
+product offering, Product X. That Contributor is then a Commercial
+Contributor. If that Commercial Contributor then makes performance
+claims, or offers warranties related to Product X, those performance
+claims and warranties are such Commercial Contributor's responsibility
+alone. Under this section, the Commercial Contributor would have to
+defend claims against the other Contributors related to those
+performance claims and warranties, and if a court requires any other
+Contributor to pay any damages as a result, the Commercial Contributor
+must pay those damages.
+
+## 5. NO WARRANTY {#warranty}
+
+EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT
+PERMITTED BY APPLICABLE LAW, THE PROGRAM IS PROVIDED ON AN “AS IS”
+BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR
+IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF
+TITLE, NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR
+PURPOSE. Each Recipient is solely responsible for determining the
+appropriateness of using and distributing the Program and assumes all
+risks associated with its exercise of rights under this Agreement,
+including but not limited to the risks and costs of program errors,
+compliance with applicable laws, damage to or loss of data, programs or
+equipment, and unavailability or interruption of operations.
+
+## 6. DISCLAIMER OF LIABILITY {#disclaimer}
+
+EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT
+PERMITTED BY APPLICABLE LAW, NEITHER RECIPIENT NOR ANY CONTRIBUTORS
+SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST
+PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE
+EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+## 7. GENERAL
+
+If any provision of this Agreement is invalid or unenforceable under
+applicable law, it shall not affect the validity or enforceability of
+the remainder of the terms of this Agreement, and without further action
+by the parties hereto, such provision shall be reformed to the minimum
+extent necessary to make such provision valid and enforceable.
+
+If Recipient institutes patent litigation against any entity (including
+a cross-claim or counterclaim in a lawsuit) alleging that the Program
+itself (excluding combinations of the Program with other software or
+hardware) infringes such Recipient's patent(s), then such Recipient's
+rights granted under Section 2(b) shall terminate as of the date such
+litigation is filed.
+
+All Recipient's rights under this Agreement shall terminate if it fails
+to comply with any of the material terms or conditions of this Agreement
+and does not cure such failure in a reasonable period of time after
+becoming aware of such noncompliance. If all Recipient's rights under
+this Agreement terminate, Recipient agrees to cease use and distribution
+of the Program as soon as reasonably practicable. However, Recipient's
+obligations under this Agreement and any licenses granted by Recipient
+relating to the Program shall continue and survive.
+
+Everyone is permitted to copy and distribute copies of this Agreement,
+but in order to avoid inconsistency the Agreement is copyrighted and may
+only be modified in the following manner. The Agreement Steward reserves
+the right to publish new versions (including revisions) of this
+Agreement from time to time. No one other than the Agreement Steward has
+the right to modify this Agreement. The Eclipse Foundation is the
+initial Agreement Steward. The Eclipse Foundation may assign the
+responsibility to serve as the Agreement Steward to a suitable separate
+entity. Each new version of the Agreement will be given a distinguishing
+version number. The Program (including Contributions) may always be
+Distributed subject to the version of the Agreement under which it was
+received. In addition, after a new version of the Agreement is
+published, Contributor may elect to Distribute the Program (including
+its Contributions) under the new version.
+
+Except as expressly stated in Sections 2(a) and 2(b) above, Recipient
+receives no rights or licenses to the intellectual property of any
+Contributor under this Agreement, whether expressly, by implication,
+estoppel or otherwise. All rights in the Program not expressly granted
+under this Agreement are reserved. Nothing in this Agreement is intended
+to be enforceable by any entity that is not a Contributor or Recipient.
+No third-party beneficiary rights are created under this Agreement.
+
+## Exhibit A – Form of Secondary Licenses Notice {#exhibit-a}
+
+“This Source Code may also be made available under the following
+Secondary Licenses when the conditions for such availability set forth
+in the Eclipse Public License, v. 2.0 are satisfied: {name license(s),
+version(s), and exceptions or additional permissions here}.”
+
+> Simply including a copy of this Agreement, including this Exhibit A is
+> not sufficient to license the Source Code under Secondary Licenses.
+>
+> If it is not possible or desirable to put the notice in a particular
+> file, then You may include the notice in a location (such as a LICENSE
+> file in a relevant directory) where a recipient would be likely to
+> look for such a notice.
+>
+> You may add additional accurate notices of copyright ownership.

src/ClawdDotNet.Manager.Web/wwwroot/views/tasks.js

@@ -163,11 +163,11 @@ function erstelleAufgabenKarte(task) {
   zeilen.push(
     erstelleElement("p", {
       klasse: "gedaempft text-klein",
-      text: `Next: ${task.nextRunUtc ? formatiereDatumZeit(task.nextRunUtc) : "—"}`
+      text: `${t("tasks.nextRun")}: ${task.nextRunUtc ? formatiereDatumZeit(task.nextRunUtc) : "—"}`
     })
   );
 
-  const letzter = erstelleElement("p", { klasse: "gedaempft text-klein" }, "Last: ");
+  const letzter = erstelleElement("p", { klasse: "gedaempft text-klein" }, `${t("tasks.lastRun")}: `);
   if (task.lastRun) {
     letzter.append(
       `${formatiereDatumZeit(task.lastRun.occurredAt)} `,
@@ -184,6 +184,19 @@ function erstelleAufgabenKarte(task) {
     zeilen.push(erstelleElement("p", { klasse: "text-klein", text: `⚠ ${task.hinweis}` }));
   }
 
+  // #716: What the budget refused, and what happens next.
+  const ausfall = task.budgetMiss;
+  if (ausfall) {
+    const teile = [t("tasks.budgetMissed", { n: ausfall.count })];
+    if (ausfall.lastAt) teile.push(t("tasks.budgetMissedLast", { time: formatiereDatumZeit(ausfall.lastAt) }));
+    if (ausfall.carriedOver && ausfall.deferredUntil) {
+      teile.push(t("tasks.budgetCarriedOver", { time: formatiereDatumZeit(ausfall.deferredUntil) }));
+    } else if (ausfall.catchUpPending) {
+      teile.push(t("tasks.budgetCatchUp", { time: ausfall.deferredUntil ? formatiereDatumZeit(ausfall.deferredUntil) : "—" }));
+    }
+    zeilen.push(erstelleElement("p", { klasse: "text-klein", text: `⚠ ${teile.join(" · ")}` }));
+  }
+
   const aktionen = erstelleElement("div", {
     klasse: "gruppe-horizontal",
     stil: "margin-top: 8px; justify-content: flex-end;"

src/ClawdDotNet.Manager.Web/wwwroot/views/team.js

@@ -0,0 +1,429 @@
+// ClawdDotNet — Team overview (#711)
+//
+// Who is working, who reached whom in the last seconds, and where something is stuck — at a
+// glance, like looking across an office. Stage 0: the agents of the active instance and the
+// live links between them. With units (#683) they become collapsible containers.
+//
+// Three rules from the concept (Organisation-Konzept, 10a):
+// - The layout comes from the structure, not from the hand: no free node editor.
+// - The state is decided by the instance (code), the page only draws it.
+// - A click opens a side panel, not the chat — most problems are solved by an approval.
+
+import { api, holeAktiveInstanz } from "../modules/api.js";
+import { erstelleElement, erstellePlakette, formatiereDatumZeit } from "../modules/dom.js";
+import { abonnieren } from "../modules/events.js";
+import { t } from "../modules/i18n.js";
+
+// Loaded on demand: pages without a graph do not pay for ~2 MB of script.
+const LIBRARIES = [
+  "vendor/cytoscape/cytoscape.min.js",
+  "vendor/elkjs/elk.bundled.js",
+  "vendor/cytoscape-elk/cytoscape-elk.js"
+];
+
+/** How long a link stays visible after it was observed; it fades out over this time. */
+const LINK_VISIBLE_MS = 30_000;
+
+/** How often the picture is refreshed without an event — for "stuck" and approvals. */
+const REFRESH_MS = 30_000;
+
+// Every state has a colour AND a symbol: colour alone is not enough.
+const STATES = {
+  Idle: { symbol: "○", tone: "neutral", colour: "--gedaempft" },
+  Working: { symbol: "▶", tone: "erfolg", colour: "--accent" },
+  Stuck: { symbol: "⧗", tone: "gefahr", colour: "--gefahr" },
+  WaitingForApproval: { symbol: "✋", tone: "warnung", colour: "--warnung" },
+  Problem: { symbol: "⚠", tone: "gefahr", colour: "--gefahr" },
+  BudgetExhausted: { symbol: "$", tone: "warnung", colour: "--warnung" }
+};
+
+let librariesLoaded = null;
+let cy = null;
+let snapshot = null;
+let selectedAgent = null;
+let panel = null;
+let summary = null;
+let unsubscribe = null;
+let refreshTimer = null;
+let fadeTimer = null;
+let refreshPending = null;
+let resizeObserver = null;
+
+/** Width the last layout was computed for — 0 means "not yet visible", see observeSize. */
+let layoutWidth = 0;
+
+// ─── Loading ───
+
+function loadScript(src) {
+  return new Promise((resolve, reject) => {
+    const script = document.createElement("script");
+    script.src = src;
+    script.onload = resolve;
+    script.onerror = () => reject(new Error(`Could not load ${src}`));
+    document.head.append(script);
+  });
+}
+
+function loadLibraries() {
+  librariesLoaded ??= (async () => {
+    // In order: cytoscape-elk registers against the globals of the two before it.
+    for (const src of LIBRARIES) await loadScript(src);
+    window.cytoscape.use(window.cytoscapeElk);
+  })();
+  return librariesLoaded;
+}
+
+function token(name) {
+  return getComputedStyle(document.documentElement).getPropertyValue(name).trim() || "#888";
+}
+
+// ─── View ───
+
+export async function renderTeam() {
+  const container = document.getElementById("ansicht-inhalt");
+  if (!container) return;
+  leaveTeam();
+
+  const layout = erstelleElement("div", { klasse: "team-ansicht" });
+  layout.append(
+    erstelleElement("h1", { text: t("team.title") }),
+    erstelleElement("p", { klasse: "gedaempft", text: t("team.subtitle") })
+  );
+
+  summary = erstelleElement("div", { klasse: "team-zusammenfassung gruppe-horizontal" });
+  const canvas = erstelleElement("div", { klasse: "team-graph", id: "team-graph" });
+  panel = erstelleElement("aside", { klasse: "team-seitenleiste" });
+  panel.hidden = true;
+
+  layout.append(summary, erstelleElement("div", { klasse: "team-flaeche" }, canvas, panel), buildLegend());
+  container.replaceChildren(layout);
+
+  if (!holeAktiveInstanz()) {
+    canvas.replaceChildren(erstelleElement("div", { klasse: "hinweis-zentriert", text: t("team.noInstance") }));
+    return;
+  }
+
+  canvas.replaceChildren(erstelleElement("div", { klasse: "hinweis-zentriert", text: t("common.loading") }));
+
+  try {
+    await loadLibraries();
+    snapshot = await api("/team");
+  } catch (err) {
+    canvas.replaceChildren(erstelleElement("div", { klasse: "fehler-zentriert", text: err.message }));
+    return;
+  }
+
+  canvas.replaceChildren();
+  drawGraph(canvas);
+
+  unsubscribe = abonnieren("activity", onActivity);
+  refreshTimer = setInterval(refresh, REFRESH_MS);
+  fadeTimer = setInterval(fadeLinks, 1_000);
+}
+
+/** Called when the route changes: stop listening, stop timers, free the graph. */
+export function leaveTeam() {
+  unsubscribe?.();
+  unsubscribe = null;
+  clearInterval(refreshTimer);
+  clearInterval(fadeTimer);
+  clearTimeout(refreshPending);
+  refreshTimer = fadeTimer = refreshPending = null;
+  resizeObserver?.disconnect();
+  resizeObserver = null;
+  cy?.destroy();
+  cy = null;
+  selectedAgent = null;
+}
+
+// ─── Graph ───
+
+function drawGraph(canvas) {
+  cy = window.cytoscape({
+    container: canvas,
+    elements: [],
+    wheelSensitivity: 0.2,
+    minZoom: 0.3,
+    maxZoom: 2.5,
+    // Nodes are not dragged: the layout comes from the structure, not the hand.
+    autoungrabify: true,
+    style: [
+      {
+        selector: "node",
+        style: {
+          shape: "rectangle",
+          width: 190,
+          height: 58,
+          "background-color": token("--surface"),
+          "border-width": 2,
+          "border-color": "data(colour)",
+          label: "data(label)",
+          "text-wrap": "wrap",
+          "text-max-width": 176,
+          "text-valign": "center",
+          "text-halign": "center",
+          "font-family": "Barlow, sans-serif",
+          "font-size": 13,
+          color: token("--text")
+        }
+      },
+      { selector: "node.aktiv", style: { "border-width": 4 } },
+      { selector: "node:selected", style: { "overlay-color": token("--accent"), "overlay-opacity": 0.15 } },
+      {
+        selector: "edge",
+        style: {
+          width: 3,
+          "line-color": token("--accent"),
+          "target-arrow-color": token("--accent"),
+          "target-arrow-shape": "triangle",
+          "curve-style": "bezier",
+          opacity: "data(opacity)"
+        }
+      }
+    ]
+  });
+
+  cy.on("tap", "node", (event) => openPanel(event.target.id()));
+  cy.on("tap", (event) => { if (event.target === cy) closePanel(); });
+
+  applySnapshot(true);
+  for (const link of snapshot.links ?? []) addLink(link);
+  observeSize(canvas);
+}
+
+/**
+ * The area can still be 0 px wide when the graph is first drawn — the page is being laid out
+ * around it. ELK then packs everything into one column, and nothing can be fitted. So: lay
+ * out again once the area has a width, and fit again whenever its size changes (the side
+ * panel opening, the window resizing).
+ */
+function observeSize(canvas) {
+  resizeObserver = new ResizeObserver(() => {
+    if (!cy) return;
+    cy.resize();
+    if (layoutWidth === 0 && canvas.clientWidth > 0) runLayout();
+    else cy.fit(undefined, 30);
+  });
+  resizeObserver.observe(canvas);
+}
+
+function runLayout() {
+  const area = cy.container();
+  layoutWidth = area.clientWidth;
+  const layout = cy.layout({
+    name: "elk",
+    fit: false,
+    // Stage 0 has no structure yet, so the agents are packed evenly into the shape of
+    // the area. rectpacking keeps their order, so a box does not jump around when a
+    // state changes. With units (#683) this becomes a layered layout of nested containers.
+    elk: {
+      algorithm: "rectpacking",
+      "elk.spacing.nodeNode": 40,
+      "elk.aspectRatio": area.clientWidth > 0 && area.clientHeight > 0
+        ? Math.max(0.5, area.clientWidth / area.clientHeight)
+        : 2
+    }
+  });
+  // ELK computes asynchronously; fit once the positions are there.
+  layout.one("layoutstop", () => cy?.fit(undefined, 30));
+  layout.run();
+}
+
+function nodeLabel(member) {
+  const state = STATES[member.state] ?? STATES.Idle;
+  const runs = member.runs.length > 1 ? ` ×${member.runs.length}` : "";
+  return `${state.symbol} ${member.displayName || member.agentId}${runs}\n${t(`team.state.${member.state}`)}`;
+}
+
+function applySnapshot(relayout) {
+  if (!cy || !snapshot) return;
+
+  const present = new Set();
+  for (const member of snapshot.members) {
+    present.add(member.agentId);
+    const state = STATES[member.state] ?? STATES.Idle;
+    const data = { id: member.agentId, label: nodeLabel(member), colour: token(state.colour) };
+    const node = cy.getElementById(member.agentId);
+    if (node.nonempty()) {
+      node.data(data);
+    } else {
+      cy.add({ group: "nodes", data });
+      relayout = true;
+    }
+    cy.getElementById(member.agentId).toggleClass("aktiv", member.runs.length > 0);
+  }
+
+  cy.nodes().filter((n) => !present.has(n.id())).remove();
+
+  if (relayout) runLayout();
+
+  renderSummary();
+  if (selectedAgent) openPanel(selectedAgent);
+}
+
+// ─── Live ───
+
+function forActiveInstance(data) {
+  // The manager merges the streams of all instances and stamps each event.
+  return !data?.instanz || data.instanz === holeAktiveInstanz();
+}
+
+function onActivity(data) {
+  if (!cy || !forActiveInstance(data)) return;
+
+  if (data.kind === "link" && data.link) addLink(data.link);
+
+  // Start and end change states; ask the instance instead of guessing here.
+  clearTimeout(refreshPending);
+  refreshPending = setTimeout(refresh, 400);
+}
+
+async function refresh() {
+  if (!cy) return;
+  try {
+    snapshot = await api("/team");
+    applySnapshot(false);
+  } catch {
+    // The next event or tick tries again; a failed refresh keeps the last picture.
+  }
+}
+
+function addLink(link) {
+  if (!cy) return;
+  const age = Date.now() - new Date(link.atUtc).getTime();
+  if (age > LINK_VISIBLE_MS) return;
+  if (cy.getElementById(link.from).empty() || cy.getElementById(link.to).empty()) return;
+
+  // One edge per pair; a new contact renews it.
+  const id = `link:${link.from}->${link.to}`;
+  const existing = cy.getElementById(id);
+  const data = { id, source: link.from, target: link.to, seenAt: new Date(link.atUtc).getTime(), opacity: 1 };
+  if (existing.nonempty()) existing.data(data);
+  else cy.add({ group: "edges", data });
+}
+
+function fadeLinks() {
+  if (!cy) return;
+  const now = Date.now();
+  cy.edges().forEach((edge) => {
+    const age = now - edge.data("seenAt");
+    if (age > LINK_VISIBLE_MS) edge.remove();
+    else edge.data("opacity", Math.max(0.15, 1 - age / LINK_VISIBLE_MS));
+  });
+}
+
+// ─── Summary and legend ───
+
+function renderSummary() {
+  if (!summary || !snapshot) return;
+  const counts = {};
+  for (const member of snapshot.members) counts[member.state] = (counts[member.state] ?? 0) + 1;
+
+  const parts = Object.keys(STATES)
+    .filter((state) => counts[state])
+    .map((state) => erstellePlakette(`${STATES[state].symbol} ${counts[state]} ${t(`team.state.${state}`)}`, STATES[state].tone));
+
+  summary.replaceChildren(
+    ...(parts.length ? parts : [erstelleElement("span", { klasse: "gedaempft", text: t("team.empty") })])
+  );
+}
+
+function buildLegend() {
+  return erstelleElement(
+    "div",
+    { klasse: "team-legende gruppe-horizontal gedaempft text-klein" },
+    ...Object.entries(STATES).map(([state, s]) =>
+      erstelleElement("span", { text: `${s.symbol} ${t(`team.state.${state}`)}` })),
+    erstelleElement("span", { text: `→ ${t("team.legendLink")}` })
+  );
+}
+
+// ─── Side panel ───
+
+function openPanel(agentId) {
+  const member = snapshot?.members.find((m) => m.agentId === agentId);
+  if (!member || !panel) return;
+  selectedAgent = agentId;
+  cy?.getElementById(agentId).select();
+
+  const state = STATES[member.state] ?? STATES.Idle;
+  const rows = [
+    erstelleElement("div", { klasse: "gruppe-horizontal team-seitenleiste-kopf" },
+      erstelleElement("h2", { text: member.displayName || member.agentId }),
+      erstelleElement("button", {
+        klasse: "schaltflaeche flach klein",
+        text: "×",
+        title: t("common.close"),
+        onclick: closePanel
+      })),
+    erstelleElement("p", { klasse: "gedaempft text-klein", text: `${member.agentId} · ${member.model}` }),
+    erstellePlakette(`${state.symbol} ${t(`team.state.${member.state}`)}`, state.tone)
+  ];
+
+  // Top layer: what is happening now.
+  if (member.runs.length) {
+    rows.push(erstelleElement("h3", { text: t("team.running") }));
+    for (const run of member.runs) {
+      const parts = [
+        t("team.since", { time: formatiereDatumZeit(run.startedAtUtc) }),
+        run.source,
+        run.taskId ? t("team.task", { id: run.taskId }) : null,
+        run.calledBy ? t("team.calledBy", { agent: run.calledBy }) : null
+      ].filter(Boolean);
+      rows.push(erstelleElement("p", { klasse: "text-klein", text: parts.join(" · ") }));
+    }
+    if (member.state === "Stuck" && member.typicalRunMs > 0) {
+      rows.push(erstelleElement("p", {
+        klasse: "text-klein",
+        text: `⚠ ${t("team.stuckHint", { minutes: Math.max(1, Math.round(member.typicalRunMs / 60_000)) })}`
+      }));
+    }
+  }
+
+  if (member.pendingApprovals > 0) {
+    rows.push(erstelleElement("p", { klasse: "text-klein", text: `✋ ${t("team.approvals", { n: member.pendingApprovals })}` }));
+  }
+
+  // Middle layer: how the last run ended.
+  rows.push(erstelleElement("h3", { text: t("team.lastRun") }));
+  if (member.lastRunStatus) {
+    rows.push(erstelleElement("p", { klasse: "text-klein" },
+      erstellePlakette(member.lastRunStatus, member.lastRunStatus === "Completed" ? "erfolg" : "warnung"),
+      ` ${formatiereDatumZeit(member.lastRunAtUtc)}`));
+    if (member.lastRunResult) {
+      rows.push(erstelleElement("p", { klasse: "text-klein team-ergebnis", text: member.lastRunResult }));
+    }
+  } else {
+    rows.push(erstelleElement("p", { klasse: "gedaempft text-klein", text: "—" }));
+  }
+
+  // The actions — the approval first, it is what most problems need.
+  const actions = erstelleElement("div", { klasse: "gruppe-vertikal team-aktionen" });
+  if (member.pendingApprovals > 0) {
+    actions.append(link(`#/staging`, t("team.openApprovals"), "primaer"));
+  }
+  actions.append(
+    link(`#/chat/${encodeURIComponent(member.agentId)}`, t("team.openChat")),
+    // Bottom layer: every run with its raw transcript.
+    link(`#/verbrauch/runs?agent=${encodeURIComponent(member.agentId)}`, t("team.openRuns"))
+  );
+  rows.push(actions);
+
+  panel.replaceChildren(...rows);
+  panel.hidden = false;
+}
+
+function link(href, text, style = "flach") {
+  return erstelleElement("button", {
+    type: "button",
+    klasse: `${style} klein`,
+    text,
+    onclick: () => { window.location.hash = href; }
+  });
+}
+
+function closePanel() {
+  selectedAgent = null;
+  cy?.elements().unselect();
+  if (panel) panel.hidden = true;
+}

src/ClawdDotNet.Tools.Taskboard/TaskboardTool.cs

@@ -210,7 +210,9 @@ public sealed class TaskboardTool : IAgentTool
     private static async Task<List<(TaskItem Task, TaskTitleMatch Match)>> SucheAehnlicheAsync(
         TaskboardService board, string title, string? exceptId, CancellationToken ct)
     {
-        var alle = await board.ListAsync(new TaskQuery { Limit = 500 }, ct);
+        // Uncapped (#716): with a limit of 500, a duplicate among older, low-priority tasks
+        // stayed invisible once the board grew beyond that.
+        var alle = await board.ListAllAsync(ct);
         return TaskSimilarity.FindOpen(alle, title, exceptId);
     }
 

src/ClawdDotNet.Web/Contracts/Dtos.cs

@@ -116,7 +116,39 @@ public sealed record TaskDto(
     TaskWhenDto? When = null,
     DateTime? NextRunUtc = null,
     TaskLastRunDto? LastRun = null,
-    string? Hinweis = null);
+    string? Hinweis = null,
+    TaskBudgetMissDto? BudgetMiss = null);
+
+/// <summary>
+/// #716: Runs of this task the budget refused — only present while something is open
+/// (misses since the last run that took place, a pending catch-up or a deferral).
+/// </summary>
+public sealed record TaskBudgetMissDto(int Count, DateTime? LastAt, DateTime? DeferredUntil, bool CatchUpPending, bool CarriedOver);
+
+/// <summary>#711: The team overview — every agent and who reached whom recently.</summary>
+public sealed record TeamSnapshotDto(IReadOnlyList<TeamMemberDto> Members, IReadOnlyList<AgentLinkDto> Links, DateTime AtUtc);
+
+/// <summary>
+/// #711: One agent in the team overview. <see cref="State"/> is one of Idle, Working, Stuck,
+/// WaitingForApproval, Problem, BudgetExhausted — decided by the instance, not the page.
+/// </summary>
+public sealed record TeamMemberDto(
+    string AgentId,
+    string DisplayName,
+    string Model,
+    string State,
+    IReadOnlyList<ActiveRunDto> Runs,
+    int PendingApprovals,
+    string? LastRunStatus,
+    DateTime? LastRunAtUtc,
+    string? LastRunResult,
+    long TypicalRunMs);
+
+/// <summary>#711: A run in progress.</summary>
+public sealed record ActiveRunDto(string RunId, string AgentId, string Source, string? TaskId, string? CalledBy, DateTime StartedAtUtc);
+
+/// <summary>#711: One agent reaching another.</summary>
+public sealed record AgentLinkDto(string From, string To, string Kind, DateTime AtUtc);
 
 /// <summary>Der letzte Lauf einer Aufgabe (#594) - aus dem Beleg, samt Kosten.</summary>
 public sealed record TaskLastRunDto(DateTime OccurredAt, string Status, decimal CostUsd, bool CostIsKnown, string ResultRef);

src/ClawdDotNet.Web/Contracts/Mapping.cs

@@ -69,6 +69,21 @@ internal static class Mapping
     public static ChatEntryDto ToDto(this ChatEntry entry)
         => new(entry.Role, entry.Content, entry.Timestamp, entry.Source);
 
+    public static TeamSnapshotDto ToDto(this App.Services.TeamSnapshot snapshot)
+        => new(
+            snapshot.Members.Select(m => new TeamMemberDto(
+                m.AgentId, m.DisplayName, m.Model, m.State.ToString(),
+                m.Runs.Select(ToDto).ToList(),
+                m.PendingApprovals, m.LastRunStatus, m.LastRunAtUtc, m.LastRunResult, m.TypicalRunMs)).ToList(),
+            snapshot.RecentLinks.Select(ToDto).ToList(),
+            snapshot.AtUtc);
+
+    public static ActiveRunDto ToDto(this Core.Activity.ActiveRun run)
+        => new(run.RunId, run.AgentId, run.Source, run.TaskId, run.CalledBy, run.StartedAtUtc);
+
+    public static AgentLinkDto ToDto(this Core.Activity.AgentLink link)
+        => new(link.From, link.To, link.Kind, link.AtUtc);
+
     public static TaskDto ToDto(this TaskOverview overview)
         => overview.Task.ToDto() with
         {
@@ -129,6 +144,10 @@ internal static class Mapping
             task.UpdatedAt,
             task.When is { } when
                 ? new TaskWhenDto(when.Kind.ToString().ToLowerInvariant(), when.Value, when.TimeZone)
+                : null,
+            BudgetMiss: task.BudgetMissCount > 0 || task.CatchUpPending || task.DeferredUntil is not null
+                ? new TaskBudgetMissDto(task.BudgetMissCount, task.LastBudgetMissAt, task.DeferredUntil,
+                    task.CatchUpPending, task.IsCarriedOver)
                 : null);
 
     /// <summary>

src/ClawdDotNet.Web/Endpoints/ApiEndpoints.cs

@@ -31,6 +31,7 @@ internal static class ApiEndpoints
         api.MapUsage();
         api.MapAnalytics();
         api.MapLogs();
+        api.MapGet("/team", async (AppHost host, CancellationToken ct) => (await host.Team.SnapshotAsync(ct)).ToDto());
 
         app.MapEvents();
         app.MapControl();

src/ClawdDotNet.Web/Endpoints/EventEndpoints.cs

@@ -71,12 +71,23 @@ internal static class EventEndpoints
         void OnRunCompleted(string model, Core.Engine.AgentRunResult result)
             => Publish("run", new
             {
+                agentId = result.AgentId,
                 model,
                 status = result.Status.ToString(),
                 steps = result.StepCount,
                 tokens = result.TokensUsed
             });
 
+        // #711: the team overview — who starts, who stops, who reached whom.
+        void OnRunStarted(Core.Activity.ActiveRun run)
+            => Publish("activity", new { kind = "started", run = run.ToDto() });
+
+        void OnRunFinished(Core.Activity.ActiveRun run, string status)
+            => Publish("activity", new { kind = "finished", run = run.ToDto(), status });
+
+        void OnLink(Core.Activity.AgentLink link)
+            => Publish("activity", new { kind = "link", link = link.ToDto() });
+
         void OnInstanceChanged(InstanceChange change)
             => Publish("instance", new { kind = change.Kind.ToString(), id = change.Id });
 
@@ -88,6 +99,9 @@ internal static class EventEndpoints
             engine.OnChatEntryAdded += OnChat;
             engine.OnStepCompleted += OnStep;
             engine.OnRunCompleted += OnRunCompleted;
+            engine.Activity.RunStarted += OnRunStarted;
+            engine.Activity.RunFinished += OnRunFinished;
+            engine.Activity.LinkObserved += OnLink;
         }
 
         host.InstanceChanged += OnInstanceChanged;
@@ -106,6 +120,9 @@ internal static class EventEndpoints
                 e.OnChatEntryAdded -= OnChat;
                 e.OnStepCompleted -= OnStep;
                 e.OnRunCompleted -= OnRunCompleted;
+                e.Activity.RunStarted -= OnRunStarted;
+                e.Activity.RunFinished -= OnRunFinished;
+                e.Activity.LinkObserved -= OnLink;
             }
 
             host.InstanceChanged -= OnInstanceChanged;

tests/ClawdDotNet.App.Tests/Services/TeamOverviewTests.cs

@@ -0,0 +1,82 @@
+using ClawdDotNet.App.Services;
+using ClawdDotNet.Core.Activity;
+using Shouldly;
+
+namespace ClawdDotNet.App.Tests.Services;
+
+/// <summary>
+/// #711: The rules that decide what the team overview shows for an agent. Every state comes
+/// from a recorded fact, never from a model's judgement.
+/// </summary>
+public sealed class TeamOverviewTests
+{
+    private static readonly DateTime Now = new(2027, 3, 10, 12, 0, 0, DateTimeKind.Utc);
+
+    private static ActiveRun RunningFor(TimeSpan duration)
+        => new("r", "worker", "task", null, null, Now - duration);
+
+    [Fact]
+    public void Nothing_running_and_a_good_last_run_is_idle()
+        => TeamOverview.Classify([], 0, "Completed", TimeSpan.FromMinutes(1), Now).ShouldBe(TeamState.Idle);
+
+    [Fact]
+    public void An_agent_without_any_run_yet_is_idle()
+        => TeamOverview.Classify([], 0, null, TimeSpan.Zero, Now).ShouldBe(TeamState.Idle);
+
+    [Fact]
+    public void A_run_in_progress_is_working()
+        => TeamOverview.Classify([RunningFor(TimeSpan.FromMinutes(1))], 0, null, TimeSpan.FromMinutes(1), Now)
+            .ShouldBe(TeamState.Working);
+
+    [Fact]
+    public void A_run_far_beyond_the_usual_duration_is_stuck()
+        // Usually 2 minutes: three times that is 6, running for 7.
+        => TeamOverview.Classify([RunningFor(TimeSpan.FromMinutes(7))], 0, null, TimeSpan.FromMinutes(2), Now)
+            .ShouldBe(TeamState.Stuck);
+
+    [Fact]
+    public void Short_runs_get_a_floor_before_they_count_as_stuck()
+        // Usually 20 seconds: three times is one minute, but the floor is five.
+        => TeamOverview.Classify([RunningFor(TimeSpan.FromMinutes(3))], 0, null, TimeSpan.FromSeconds(20), Now)
+            .ShouldBe(TeamState.Working);
+
+    [Fact]
+    public void Without_history_a_run_is_stuck_only_after_a_long_while()
+    {
+        TeamOverview.Classify([RunningFor(TimeSpan.FromMinutes(10))], 0, null, TimeSpan.Zero, Now).ShouldBe(TeamState.Working);
+        TeamOverview.Classify([RunningFor(TimeSpan.FromMinutes(16))], 0, null, TimeSpan.Zero, Now).ShouldBe(TeamState.Stuck);
+    }
+
+    [Fact]
+    public void An_open_approval_outranks_working()
+        // What the human can do something about comes first.
+        => TeamOverview.Classify([RunningFor(TimeSpan.FromMinutes(1))], 2, null, TimeSpan.FromMinutes(1), Now)
+            .ShouldBe(TeamState.WaitingForApproval);
+
+    [Fact]
+    public void Stuck_outranks_an_open_approval()
+        => TeamOverview.Classify([RunningFor(TimeSpan.FromHours(1))], 2, null, TimeSpan.FromMinutes(1), Now)
+            .ShouldBe(TeamState.Stuck);
+
+    [Theory]
+    [InlineData("Failed")]
+    [InlineData("LoopLimitExceeded")]
+    [InlineData("TargetBusy")]
+    public void A_failed_last_run_is_a_problem(string status)
+        => TeamOverview.Classify([], 0, status, TimeSpan.Zero, Now).ShouldBe(TeamState.Problem);
+
+    [Fact]
+    public void A_refused_last_run_shows_the_exhausted_budget()
+        => TeamOverview.Classify([], 0, "BudgetExceeded", TimeSpan.Zero, Now).ShouldBe(TeamState.BudgetExhausted);
+
+    [Fact]
+    public void A_new_run_hides_the_old_problem()
+        // A new run is the attempt to get past it; the problem shows again if it fails.
+        => TeamOverview.Classify([RunningFor(TimeSpan.FromMinutes(1))], 0, "Failed", TimeSpan.FromMinutes(1), Now)
+            .ShouldBe(TeamState.Working);
+
+    [Fact]
+    public void A_cancelled_run_is_not_a_problem()
+        // Cancelled means a human stopped it — that was a decision, not a fault.
+        => TeamOverview.Classify([], 0, "Cancelled", TimeSpan.Zero, Now).ShouldBe(TeamState.Idle);
+}

tests/ClawdDotNet.Core.Tests/Activity/AgentActivityTests.cs

@@ -0,0 +1,143 @@
+using ClawdDotNet.Core.Activity;
+using ClawdDotNet.Core.Tests.Infrastructure;
+using ClawdDotNet.Core.Tools;
+using Shouldly;
+
+namespace ClawdDotNet.Core.Tests.Activity;
+
+/// <summary>
+/// #711: Who is working right now and who reached whom — the live side of the team overview.
+/// </summary>
+public sealed class AgentActivityTests
+{
+    private readonly FakeTimeProvider _clock = new(new DateTimeOffset(2027, 3, 10, 12, 0, 0, TimeSpan.Zero));
+
+    [Fact]
+    public void A_run_is_active_until_its_handle_is_disposed()
+    {
+        var activity = new AgentActivity(_clock);
+
+        using (var run = activity.Begin("r1", "worker", "task", "t-1", null))
+        {
+            var active = activity.ActiveRuns().ShouldHaveSingleItem();
+            active.AgentId.ShouldBe("worker");
+            active.TaskId.ShouldBe("t-1");
+            active.CalledBy.ShouldBeNull();
+            run.Complete("Completed");
+        }
+
+        activity.ActiveRuns().ShouldBeEmpty();
+    }
+
+    [Fact]
+    public void Start_and_end_are_announced_with_the_status()
+    {
+        var activity = new AgentActivity(_clock);
+        var log = new List<string>();
+        activity.RunStarted += r => log.Add($"start {r.AgentId}");
+        activity.RunFinished += (r, status) => log.Add($"end {r.AgentId} {status}");
+
+        using (var run = activity.Begin("r1", "worker", "chat", null, null))
+            run.Complete("LoopLimitExceeded");
+        using (activity.Begin("r2", "worker", "chat", null, null)) { }
+
+        log.ShouldBe(["start worker", "end worker LoopLimitExceeded", "start worker", "end worker Aborted"]);
+    }
+
+    [Fact]
+    public void A_delegated_run_records_who_called_whom()
+    {
+        var activity = new AgentActivity(_clock);
+        AgentLink? seen = null;
+        activity.LinkObserved += l => seen = l;
+        var chain = DelegationChain.Root("lead").Append("buyer");
+
+        using (activity.Begin("r1", "buyer", "agent_comm", null, chain)) { }
+
+        seen.ShouldNotBeNull();
+        seen.From.ShouldBe("lead");
+        seen.To.ShouldBe("buyer");
+        seen.Kind.ShouldBe("delegation");
+        activity.RecentLinks(TimeSpan.FromMinutes(1)).ShouldHaveSingleItem().From.ShouldBe("lead");
+    }
+
+    [Fact]
+    public void Old_links_fall_out_of_the_recent_window()
+    {
+        var activity = new AgentActivity(_clock);
+        using (activity.Begin("r1", "buyer", "agent_comm", null, DelegationChain.Root("lead").Append("buyer"))) { }
+
+        _clock.Advance(TimeSpan.FromMinutes(11));
+
+        activity.RecentLinks(TimeSpan.FromMinutes(10)).ShouldBeEmpty();
+    }
+
+    [Fact]
+    public void The_memory_of_links_is_bounded()
+    {
+        var activity = new AgentActivity(_clock);
+        var chain = DelegationChain.Root("lead").Append("buyer");
+
+        for (var i = 0; i < AgentActivity.RecentLinkCapacity + 50; i++)
+            using (activity.Begin($"r{i}", "buyer", "agent_comm", null, chain)) { }
+
+        activity.RecentLinks(TimeSpan.FromDays(1)).Count.ShouldBe(AgentActivity.RecentLinkCapacity);
+    }
+
+    [Fact]
+    public void A_subscriber_that_throws_does_not_break_the_run()
+    {
+        var activity = new AgentActivity(_clock);
+        activity.RunStarted += _ => throw new InvalidOperationException("broken page");
+        activity.RunFinished += (_, _) => throw new InvalidOperationException("broken page");
+
+        Should.NotThrow(() =>
+        {
+            using var run = activity.Begin("r1", "worker", "chat", null, null);
+            run.Complete("Completed");
+        });
+        activity.ActiveRuns().ShouldBeEmpty();
+    }
+
+    // ─── through the engine ───
+
+    [Fact]
+    public async Task The_engine_announces_a_delegated_run_with_its_caller()
+    {
+        var fixture = new EngineFixture();
+        fixture.AddAgent("lead");
+        fixture.AddAgent("buyer");
+        fixture.Client.RespondsWithText("Erledigt.");
+
+        var started = new List<ActiveRun>();
+        var finished = new List<string>();
+        fixture.Engine.Activity.RunStarted += started.Add;
+        fixture.Engine.Activity.RunFinished += (_, status) => finished.Add(status);
+
+        var result = await fixture.Engine.SendMessageAsync("lead", "buyer", "Bitte pruefen", "inst", null, default);
+
+        result.Delivered.ShouldBeTrue(result.Error);
+        var run = started.ShouldHaveSingleItem();
+        run.AgentId.ShouldBe("buyer");
+        run.CalledBy.ShouldBe("lead");
+        finished.ShouldBe(["Completed"]);
+        fixture.Engine.Activity.ActiveRuns().ShouldBeEmpty();
+        fixture.Engine.Activity.RecentLinks(TimeSpan.FromMinutes(1)).ShouldHaveSingleItem().To.ShouldBe("buyer");
+    }
+
+    [Fact]
+    public async Task A_fresh_run_is_visible_too()
+    {
+        // Before #711 only runs through ChatAsync counted as "running"; RunAsync (@new) did not.
+        var fixture = new EngineFixture();
+        var agent = fixture.AddAgent("worker");
+        fixture.Client.RespondsWithText("Fertig.");
+
+        var started = new List<ActiveRun>();
+        fixture.Engine.Activity.RunStarted += started.Add;
+
+        await fixture.Engine.RunAsync(agent, "Los", "inst", CancellationToken.None);
+
+        started.ShouldHaveSingleItem().AgentId.ShouldBe("worker");
+    }
+}

tests/ClawdDotNet.Core.Tests/Budget/BudgetHeadroomTests.cs

@@ -0,0 +1,214 @@
+using ClawdDotNet.Core.Accounting;
+using ClawdDotNet.Core.Budget;
+using ClawdDotNet.Core.Config;
+using ClawdDotNet.Core.Tasks;
+using Shouldly;
+
+namespace ClawdDotNet.Core.Tests.Budget;
+
+/// <summary>
+/// #716, stage 3: late work — carried-over tasks and catch-ups — only uses budget the rest
+/// of the day does not need. The new day has right of way.
+/// </summary>
+public sealed class BudgetHeadroomTests
+{
+    // 2027-03-10 14:00 UTC; the test clock's local zone is UTC, so the day ends at 24:00 UTC.
+    private static readonly DateTime Now = new(2027, 3, 10, 14, 0, 0, DateTimeKind.Utc);
+    private static readonly DateTime CreatedEarlier = new(2027, 3, 1, 0, 0, 0, DateTimeKind.Utc);
+
+    private static AgentConfig Agent(decimal dailyCost = 1.00m)
+        => new() { AgentId = "worker", Budget = new AgentBudget { DailyCostUsd = dailyCost } };
+
+    /// <summary>Runs averaging 0.05 USD.</summary>
+    private static List<RunUsage> History(decimal cost = 0.05m)
+        => [.. Enumerable.Range(0, 5).Select(_ => new RunUsage { AgentId = "worker", PromptTokens = 1_000, CostUsd = cost, CostIsKnown = true })];
+
+    private static TaskItem Cron(string id, string expression, string? lastOccurrence = null) => new()
+    {
+        Id = id, Title = id, Assignee = "@worker", CreatedAt = CreatedEarlier, LastOccurrence = lastOccurrence,
+        When = new TaskWhen { Kind = TaskWhenKind.Cron, Value = expression, TimeZone = "UTC" }
+    };
+
+    private static TaskItem Carried(string id) => new()
+    {
+        Id = id, Title = id, Assignee = "@worker", CreatedAt = CreatedEarlier, BudgetMissCount = 1
+    };
+
+    private static BudgetHeadroom Headroom(decimal used, AgentConfig agent, InstanceBudget? instance = null, decimal perRun = 0.05m)
+        => new(new BudgetGuard(new FakeUsage(used, History(perRun))),
+            () => [agent], () => instance ?? InstanceBudget.Unlimited, new UtcClock(Now));
+
+    // ═══════════════════ counting the rest of the day ═══════════════════
+
+    [Fact]
+    public void Hourly_from_14_30_until_midnight_is_nine_more_runs()
+    {
+        // 15:00 … 23:00. The 14:00 run is done (marker), so nothing is due right now.
+        var task = Cron("t", "0 * * * *", lastOccurrence: "2027-03-10T14:00:00.0000000Z");
+
+        TaskSchedule.OccurrencesBetween(task, Now.AddMinutes(30), Now.Date.AddDays(1)).ShouldBe(9);
+    }
+
+    [Fact]
+    public void A_run_due_right_now_counts_as_well()
+    {
+        // Last run 13:00, so the 14:00 run is due now; then 15:00 … 23:00.
+        var task = Cron("t", "0 * * * *", lastOccurrence: "2027-03-10T13:00:00.0000000Z");
+
+        TaskSchedule.OccurrencesBetween(task, Now.AddMinutes(1), Now.Date.AddDays(1)).ShouldBe(10);
+    }
+
+    [Fact]
+    public void A_one_time_task_counts_once_until_it_ran()
+    {
+        var open = new TaskItem { Id = "t", CreatedAt = CreatedEarlier };
+        var done = open with { LastOccurrence = "2027-03-10T09:00:00.0000000Z" };
+
+        TaskSchedule.OccurrencesBetween(open, Now, Now.AddHours(1)).ShouldBe(1);
+        TaskSchedule.OccurrencesBetween(done, Now, Now.AddHours(1)).ShouldBe(0);
+    }
+
+    [Fact]
+    public void An_interval_counts_its_remaining_ticks()
+    {
+        var task = new TaskItem
+        {
+            Id = "t", CreatedAt = CreatedEarlier, LastOccurrence = "2027-03-10T13:45:00.0000000Z",
+            When = new TaskWhen { Kind = TaskWhenKind.Every, Value = "30m", TimeZone = "UTC" }
+        };
+
+        // 14:15, 14:45, 15:15, 15:45 before 16:00.
+        TaskSchedule.OccurrencesBetween(task, Now, Now.AddHours(2)).ShouldBe(4);
+    }
+
+    // ═══════════════════ headroom ═══════════════════
+
+    [Fact]
+    public async Task Late_work_fits_when_the_rest_of_the_day_leaves_room()
+    {
+        // Limit 1.00, used 0.30, margin 0.10. Rest of the day: 10 hourly runs à 0.05 = 0.50.
+        // Left: 1.00 - 0.30 - 0.50 - 0.10 = 0.10 ≥ 0.05 for the late run.
+        var hourly = Cron("t-hourly", "0 * * * *", lastOccurrence: "2027-03-10T13:00:00.0000000Z");
+        var late = Carried("t-late");
+
+        var room = await Headroom(used: 0.30m, Agent()).HasRoomAsync(late, [hourly, late], Now, default);
+
+        room.ShouldBeTrue();
+    }
+
+    [Fact]
+    public async Task Late_work_waits_when_the_rest_of_the_day_needs_the_budget()
+    {
+        // Same, but 0.40 used: 1.00 - 0.40 - 0.50 - 0.10 = 0.00 < 0.05.
+        var hourly = Cron("t-hourly", "0 * * * *", lastOccurrence: "2027-03-10T13:00:00.0000000Z");
+        var late = Carried("t-late");
+
+        var room = await Headroom(used: 0.40m, Agent()).HasRoomAsync(late, [hourly, late], Now, default);
+
+        room.ShouldBeFalse("the day's own schedule has right of way");
+    }
+
+    [Fact]
+    public async Task Other_late_work_does_not_count_as_the_days_demand()
+    {
+        // Ten carried-over tasks do not reserve budget against each other — they are what
+        // waits for headroom, not what headroom is kept for.
+        var late = Carried("t-late");
+        var others = Enumerable.Range(0, 10).Select(i => Carried($"t-other-{i}")).ToList();
+
+        var room = await Headroom(used: 0.50m, Agent()).HasRoomAsync(late, [late, .. others], Now, default);
+
+        room.ShouldBeTrue();
+    }
+
+    [Fact]
+    public async Task The_instance_limit_counts_the_schedules_of_all_agents()
+    {
+        var agent = Agent(dailyCost: 0); // no limit of its own
+        var instance = new InstanceBudget { DailyCostUsd = 1.00m };
+        var hourly = Cron("t-hourly", "0 * * * *", lastOccurrence: "2027-03-10T13:00:00.0000000Z");
+        var late = Carried("t-late");
+
+        (await Headroom(used: 0.30m, agent, instance).HasRoomAsync(late, [hourly, late], Now, default)).ShouldBeTrue();
+        (await Headroom(used: 0.40m, agent, instance).HasRoomAsync(late, [hourly, late], Now, default)).ShouldBeFalse();
+    }
+
+    [Fact]
+    public async Task Without_any_limit_there_is_always_room()
+    {
+        var late = Carried("t-late");
+
+        (await Headroom(used: 99m, Agent(dailyCost: 0)).HasRoomAsync(late, [late], Now, default)).ShouldBeTrue();
+    }
+
+    // ═══════════════════ the day ahead ═══════════════════
+
+    [Fact]
+    public async Task The_outlook_names_the_hour_the_budget_runs_out()
+    {
+        // Limit 1.00, used 0.60, runs at 14:00 (due now), 15:00 … 23:00 à 0.05. Before the
+        // 22:00 run 0.60 + 8 × 0.05 = 1.00 is used — from there on everything is refused.
+        var hourly = Cron("t-hourly", "0 * * * *", lastOccurrence: "2027-03-10T13:00:00.0000000Z");
+
+        var shortfalls = await Headroom(used: 0.60m, Agent()).ShortfallsAsync([hourly], Now, default);
+
+        var shortfall = shortfalls.ShouldHaveSingleItem();
+        shortfall.AgentId.ShouldBe("worker");
+        shortfall.ExhaustsAtUtc.ShouldBe(new DateTime(2027, 3, 10, 22, 0, 0, DateTimeKind.Utc));
+        shortfall.RunsRefused.ShouldBe(2);
+        shortfall.RunsPlanned.ShouldBe(10);
+    }
+
+    [Fact]
+    public async Task A_day_that_fits_has_no_shortfall()
+    {
+        var hourly = Cron("t-hourly", "0 * * * *", lastOccurrence: "2027-03-10T13:00:00.0000000Z");
+
+        (await Headroom(used: 0.30m, Agent()).ShortfallsAsync([hourly], Now, default)).ShouldBeEmpty();
+    }
+
+    [Fact]
+    public async Task Late_work_does_not_make_the_day_fall_short()
+    {
+        // Fifty carried-over tasks only ever run in headroom — they cannot be the reason the
+        // day's own runs are refused.
+        var hourly = Cron("t-hourly", "0 * * * *", lastOccurrence: "2027-03-10T13:00:00.0000000Z");
+        var late = Enumerable.Range(0, 50).Select(i => Carried($"t-late-{i}")).ToList();
+
+        (await Headroom(used: 0.30m, Agent()).ShortfallsAsync([hourly, .. late], Now, default)).ShouldBeEmpty();
+    }
+
+    [Fact]
+    public async Task The_instance_limit_gets_its_own_forecast()
+    {
+        var hourly = Cron("t-hourly", "0 * * * *", lastOccurrence: "2027-03-10T13:00:00.0000000Z");
+        var instance = new InstanceBudget { DailyCostUsd = 1.00m };
+
+        var shortfalls = await Headroom(used: 0.60m, Agent(dailyCost: 0), instance).ShortfallsAsync([hourly], Now, default);
+
+        shortfalls.ShouldHaveSingleItem().AgentId.ShouldBe("", "empty means: the instance");
+    }
+
+    // ═══════════════════ test doubles ═══════════════════
+
+    private sealed class UtcClock(DateTime now) : TimeProvider
+    {
+        public override DateTimeOffset GetUtcNow() => new(now, TimeSpan.Zero);
+        public override TimeZoneInfo LocalTimeZone => TimeZoneInfo.Utc;
+    }
+
+    private sealed class FakeUsage(decimal usedCost, IReadOnlyList<RunUsage> recent) : IUsageRepository
+    {
+        public Task RecordAsync(RunUsage usage, CancellationToken ct) => Task.CompletedTask;
+
+        public Task<DailyUsage> GetDailyAsync(DateOnly date, string agentId, CancellationToken ct)
+            => Task.FromResult(new DailyUsage(date, 0, 0, usedCost, true, 0));
+
+        public Task<IReadOnlyList<RunUsage>> GetRecentAsync(int limit, CancellationToken ct) => Task.FromResult(recent);
+
+        public Task<IReadOnlyList<RunUsage>> GetRecentForAgentAsync(string agentId, int limit, CancellationToken ct)
+            => Task.FromResult(recent);
+
+        public Task<int> PurgeBeforeAsync(DateOnly date, CancellationToken ct) => Task.FromResult(0);
+    }
+}

tests/ClawdDotNet.Core.Tests/Budget/BudgetReservationTests.cs

@@ -0,0 +1,173 @@
+using ClawdDotNet.Core.Accounting;
+using ClawdDotNet.Core.Budget;
+using ClawdDotNet.Core.Config;
+using Shouldly;
+
+namespace ClawdDotNet.Core.Tests.Budget;
+
+/// <summary>
+/// #716 (the rest of #682): Runs in flight count against the budget with their estimate.
+///
+/// Before, every run was checked on its own against what was already recorded, so runs
+/// starting together all saw the same figure and all passed. #682 capped how many could
+/// start at once; the reservation closes the gap.
+/// </summary>
+public sealed class BudgetReservationTests
+{
+    private static AgentConfig Agent(decimal dailyCost = 1.00m, long dailyTokens = 0)
+        => new() { AgentId = "worker", Budget = new AgentBudget { DailyCostUsd = dailyCost, DailyTokens = dailyTokens } };
+
+    /// <summary>Recent runs averaging 0.30 USD and 3,000 tokens.</summary>
+    private static List<RunUsage> History(decimal cost = 0.30m, int tokens = 3_000)
+        => [.. Enumerable.Range(0, 5).Select(_ => new RunUsage
+        {
+            AgentId = "worker", PromptTokens = tokens, CostUsd = cost, CostIsKnown = true, Status = "Completed"
+        })];
+
+    [Fact]
+    public async Task Runs_in_flight_count_against_the_budget()
+    {
+        var guard = new BudgetGuard(new FakeUsage(usedCost: 0.60m, History()));
+
+        var (first, a) = await guard.ReserveAsync(Agent(), InstanceBudget.Unlimited, default);
+        var (second, b) = await guard.ReserveAsync(Agent(), InstanceBudget.Unlimited, default);
+        var (third, c) = await guard.ReserveAsync(Agent(), InstanceBudget.Unlimited, default);
+
+        first.IsAllowed.ShouldBeTrue("0.60 used, nothing in flight");
+        second.IsAllowed.ShouldBeTrue("0.60 used + 0.30 in flight");
+        third.IsAllowed.ShouldBeFalse("0.60 used + 0.60 in flight — before #716 this one passed too");
+        third.Reason.ShouldNotBeNull().ShouldContain("reserviert");
+        c.ShouldBeNull();
+
+        a!.Dispose();
+        b!.Dispose();
+    }
+
+    [Fact]
+    public async Task A_finished_run_frees_its_reservation()
+    {
+        var guard = new BudgetGuard(new FakeUsage(usedCost: 0.60m, History()));
+
+        var (_, a) = await guard.ReserveAsync(Agent(), InstanceBudget.Unlimited, default);
+        var (_, b) = await guard.ReserveAsync(Agent(), InstanceBudget.Unlimited, default);
+        a!.Dispose();
+        a.Dispose(); // twice is harmless
+
+        var (again, c) = await guard.ReserveAsync(Agent(), InstanceBudget.Unlimited, default);
+        again.IsAllowed.ShouldBeTrue();
+
+        b!.Dispose();
+        c!.Dispose();
+        guard.Reserved("worker").ShouldBe(default(RunEstimate));
+        guard.Reserved("").ShouldBe(default(RunEstimate));
+    }
+
+    [Fact]
+    public async Task A_single_run_is_not_refused_because_of_its_own_estimate()
+    {
+        // 0.95 of 1.00 used, an average run costs 0.30: a small task may still fit, and
+        // refusing it on the average would be guessing.
+        var guard = new BudgetGuard(new FakeUsage(usedCost: 0.95m, History()));
+
+        var (status, reservation) = await guard.ReserveAsync(Agent(), InstanceBudget.Unlimited, default);
+
+        status.IsAllowed.ShouldBeTrue();
+        reservation!.Dispose();
+    }
+
+    [Fact]
+    public async Task Parallel_starts_cannot_all_pass_together()
+    {
+        var guard = new BudgetGuard(new FakeUsage(usedCost: 0m, History()));
+
+        var results = await Task.WhenAll(Enumerable.Range(0, 10)
+            .Select(_ => guard.ReserveAsync(Agent(), InstanceBudget.Unlimited, default)));
+
+        // 0.00, 0.30, 0.60, 0.90 in flight pass; from 1.20 on the budget is spoken for.
+        results.Count(r => r.Status.IsAllowed).ShouldBe(4);
+
+        foreach (var (_, reservation) in results)
+            reservation?.Dispose();
+    }
+
+    [Fact]
+    public async Task The_token_limit_counts_reservations_too()
+    {
+        var guard = new BudgetGuard(new FakeUsage(usedCost: 0m, History(cost: 0m, tokens: 4_000)));
+        var agent = Agent(dailyCost: 0, dailyTokens: 10_000);
+
+        var (a, ra) = await guard.ReserveAsync(agent, InstanceBudget.Unlimited, default);
+        var (b, rb) = await guard.ReserveAsync(agent, InstanceBudget.Unlimited, default);
+        var (c, _) = await guard.ReserveAsync(agent, InstanceBudget.Unlimited, default);
+        var (d, _) = await guard.ReserveAsync(agent, InstanceBudget.Unlimited, default);
+
+        a.IsAllowed.ShouldBeTrue();
+        b.IsAllowed.ShouldBeTrue();
+        c.IsAllowed.ShouldBeTrue("8,000 of 10,000 reserved");
+        d.IsAllowed.ShouldBeFalse("12,000 reserved");
+        d.Limit.ShouldBe(BudgetLimit.AgentTokens);
+
+        ra!.Dispose();
+        rb!.Dispose();
+    }
+
+    [Fact]
+    public async Task The_instance_limit_sees_the_runs_of_all_agents()
+    {
+        var guard = new BudgetGuard(new FakeUsage(usedCost: 0m, History()));
+        var instance = new InstanceBudget { DailyCostUsd = 0.50m };
+        var unlimitedAgent = Agent(dailyCost: 0);
+
+        var (a, _) = await guard.ReserveAsync(unlimitedAgent, instance, default);
+        var (b, _) = await guard.ReserveAsync(unlimitedAgent, instance, default);
+        var (c, _) = await guard.ReserveAsync(unlimitedAgent, instance, default);
+
+        a.IsAllowed.ShouldBeTrue();
+        b.IsAllowed.ShouldBeTrue("0.30 in flight");
+        c.IsAllowed.ShouldBeFalse("0.60 in flight over an instance limit of 0.50");
+        c.Limit.ShouldBe(BudgetLimit.InstanceCost);
+    }
+
+    [Fact]
+    public async Task Without_any_limit_nothing_is_reserved()
+    {
+        var guard = new BudgetGuard(new FakeUsage(usedCost: 0m, History()));
+
+        var (status, reservation) = await guard.ReserveAsync(Agent(dailyCost: 0), InstanceBudget.Unlimited, default);
+
+        status.IsAllowed.ShouldBeTrue();
+        reservation.ShouldBeNull();
+    }
+
+    [Fact]
+    public async Task Runs_without_usage_do_not_drag_the_estimate_down()
+    {
+        var history = History();
+        history.Add(new RunUsage { AgentId = "worker", Status = "BudgetExceeded" }); // 0 tokens
+        var guard = new BudgetGuard(new FakeUsage(usedCost: 0m, history));
+
+        var estimate = await guard.EstimateRunAsync("worker", default);
+
+        estimate.CostUsd.ShouldBe(0.30m);
+        estimate.Tokens.ShouldBe(3_000);
+    }
+
+    private sealed class FakeUsage(decimal usedCost, IReadOnlyList<RunUsage> recent) : IUsageRepository
+    {
+        public Task RecordAsync(RunUsage usage, CancellationToken ct) => Task.CompletedTask;
+
+        public async Task<DailyUsage> GetDailyAsync(DateOnly date, string agentId, CancellationToken ct)
+        {
+            await Task.Yield(); // like the database: the caller does not get the answer synchronously
+            return new DailyUsage(date, 0, 0, usedCost, true, 0);
+        }
+
+        public Task<IReadOnlyList<RunUsage>> GetRecentAsync(int limit, CancellationToken ct)
+            => Task.FromResult(recent);
+
+        public Task<IReadOnlyList<RunUsage>> GetRecentForAgentAsync(string agentId, int limit, CancellationToken ct)
+            => Task.FromResult(recent);
+
+        public Task<int> PurgeBeforeAsync(DateOnly date, CancellationToken ct) => Task.FromResult(0);
+    }
+}

tests/ClawdDotNet.Core.Tests/Engine/HarnessHaertungTests.cs

@@ -276,17 +276,16 @@ public class HarnessHaertungTests
                 ("ParallelTool", "{}", "c3"))
             .RespondsWithText("Fertig.");
 
-        var sw = Stopwatch.StartNew();
         await fixture.Engine.RunAsync(agent, "Los", "inst", CancellationToken.None);
-        sw.Stop();
 
         // Der belastbare Nachweis: Aufrufe haben sich überlappt.
+        //
+        // Hier stand zusätzlich eine Wanduhr-Prüfung (unter 750 ms, seriell wären es 900).
+        // Sie schlug am 2026-09-24 mit 927 ms fehl, als die Testprojekte parallel liefen —
+        // die Zeit misst die Last der Maschine, nicht das Verhalten der Engine. Der
+        // Höchststand gleichzeitiger Aufrufe beweist dasselbe, ohne zu wackeln.
         Assert.True(tool.MaxConcurrent > 1,
             $"Erwartet: überlappende Aufrufe. Höchststand war {tool.MaxConcurrent}.");
-
-        // Die Laufzeit als zweite, schwächere Bestätigung — seriell wären es 900 ms.
-        Assert.True(sw.ElapsedMilliseconds < 750,
-            $"Erwartet: deutlich unter 900 ms. Gemessen: {sw.ElapsedMilliseconds} ms.");
     }
 
     [Fact]

tests/ClawdDotNet.Core.Tests/Tasks/BudgetMissTests.cs

@@ -0,0 +1,293 @@
+using ClawdDotNet.Core.Storage;
+using ClawdDotNet.Core.Tasks;
+using ClawdDotNet.Core.Tests.Infrastructure;
+using Microsoft.Extensions.Logging.Abstractions;
+using Shouldly;
+
+namespace ClawdDotNet.Core.Tests.Tasks;
+
+/// <summary>
+/// #716: What the scanner does with a run the budget refused.
+///
+/// Before, a one-time task was retried every 30 minutes for the rest of the day — each
+/// attempt another refusal and another receipt — and then ran after midnight at the
+/// expense of the new day, without anyone having decided that. A recurring task's
+/// occurrence lapsed silently.
+/// </summary>
+public sealed class BudgetMissTests : IDisposable
+{
+    private readonly string _directory;
+    private readonly SqliteStorage _storage;
+    private readonly SqliteTaskRepository _repo;
+
+    // 2027: a cron schedule never looks back before the task's creation date.
+    private readonly FakeTimeProvider _clock = new(new DateTimeOffset(2027, 3, 10, 12, 0, 0, TimeSpan.Zero));
+
+    public BudgetMissTests()
+    {
+        _directory = Path.Combine(Path.GetTempPath(), "clawd-tests", Guid.NewGuid().ToString("N"));
+        _storage = new SqliteStorage(Path.Combine(_directory, "state.db"));
+        _repo = new SqliteTaskRepository(_storage);
+    }
+
+    public void Dispose()
+    {
+        Microsoft.Data.Sqlite.SqliteConnection.ClearAllPools();
+        try { Directory.Delete(_directory, recursive: true); }
+        catch { /* cleanup is secondary */ }
+    }
+
+    private TaskScanner Scanner(ITaskDispatcher dispatcher, BudgetMissPolicy policy = BudgetMissPolicy.Expire)
+        => new(_repo, dispatcher, NullLoggerFactory.Instance, clock: _clock, budgetMissPolicy: _ => policy);
+
+    private Task<TaskItem> SeedOneTime(string id, int priority = 3)
+        => _repo.UpsertAsync(new TaskItem { Id = id, Title = id, Assignee = "@worker", Priority = priority }, default);
+
+    private Task<TaskItem> SeedHourly(string id)
+        => _repo.UpsertAsync(new TaskItem
+        {
+            Id = id, Title = id, Assignee = "@worker",
+            When = new TaskWhen { Kind = TaskWhenKind.Cron, Value = "0 * * * *", TimeZone = "UTC" }
+        }, default);
+
+    private async Task<TaskItem> Get(string id) => (await _repo.GetAsync(id, default))!;
+
+    /// <summary>The next local midnight, in UTC — the budget day follows the local date.</summary>
+    private DateTime NextLocalMidnightUtc()
+    {
+        var zone = _clock.LocalTimeZone;
+        var local = TimeZoneInfo.ConvertTimeFromUtc(_clock.GetUtcNow().UtcDateTime, zone);
+        return TimeZoneInfo.ConvertTimeToUtc(DateTime.SpecifyKind(local.Date.AddDays(1), DateTimeKind.Unspecified), zone);
+    }
+
+    private void MoveTo(DateTime utc) => _clock.SetUtcNow(new DateTimeOffset(utc, TimeSpan.Zero));
+
+    // ═══════════════════ one-time tasks: carried over ═══════════════════
+
+    [Fact]
+    public async Task A_refused_one_time_task_is_carried_over_to_the_next_day()
+    {
+        await SeedOneTime("t-report");
+        var dispatcher = new BudgetDispatcher { HasBudget = false };
+        var scanner = Scanner(dispatcher);
+        var midnight = NextLocalMidnightUtc();
+
+        await scanner.ScanOnceAsync(default);
+
+        var task = await Get("t-report");
+        task.Status.ShouldBe(TaskItemStatus.Todo, "it is still work to be done");
+        task.BudgetMissCount.ShouldBe(1);
+        task.LastBudgetMissAt.ShouldNotBeNull();
+        task.DeferredUntil.ShouldBe(midnight);
+        task.IsCarriedOver.ShouldBeTrue();
+    }
+
+    [Fact]
+    public async Task A_carried_over_task_is_not_retried_the_same_day()
+    {
+        await SeedOneTime("t-report");
+        var dispatcher = new BudgetDispatcher { HasBudget = false };
+        var scanner = Scanner(dispatcher);
+        await scanner.ScanOnceAsync(default);
+
+        // Before #716: again after 30 minutes, and again, until midnight.
+        MoveTo(NextLocalMidnightUtc().AddMinutes(-1));
+        (await scanner.ScanOnceAsync(default)).ShouldBe(0);
+
+        dispatcher.Calls.ShouldBe(1, "one refusal, not one every half hour");
+    }
+
+    [Fact]
+    public async Task On_the_next_day_it_runs_and_the_miss_is_settled()
+    {
+        await SeedOneTime("t-report");
+        var dispatcher = new BudgetDispatcher { HasBudget = false };
+        var scanner = Scanner(dispatcher);
+        await scanner.ScanOnceAsync(default);
+
+        MoveTo(NextLocalMidnightUtc().AddMinutes(1));
+        dispatcher.HasBudget = true;
+        (await scanner.ScanOnceAsync(default)).ShouldBe(1);
+
+        var task = await Get("t-report");
+        task.Status.ShouldBe(TaskItemStatus.Done);
+        task.BudgetMissCount.ShouldBe(0);
+        task.DeferredUntil.ShouldBeNull();
+        task.LastBudgetMissAt.ShouldNotBeNull("kept as history");
+    }
+
+    [Fact]
+    public async Task The_new_day_has_right_of_way_over_carried_over_work()
+    {
+        await SeedOneTime("t-yesterday", priority: 5);
+        var dispatcher = new BudgetDispatcher { HasBudget = false };
+        var scanner = Scanner(dispatcher);
+        await scanner.ScanOnceAsync(default);
+
+        MoveTo(NextLocalMidnightUtc().AddMinutes(1));
+        await SeedOneTime("t-today", priority: 1);
+        dispatcher.HasBudget = true;
+        dispatcher.Started.Clear();
+        await scanner.ScanOnceAsync(default);
+
+        dispatcher.Started.ShouldBe(["t-today", "t-yesterday"],
+            "carried-over work comes after the day's own, even with a higher priority");
+    }
+
+    // ═══════════════════ recurring tasks: the agent's policy ═══════════════════
+
+    [Fact]
+    public async Task Under_expire_a_refused_occurrence_lapses_and_is_recorded()
+    {
+        await SeedHourly("t-hourly");
+        var dispatcher = new BudgetDispatcher { HasBudget = false };
+        var scanner = Scanner(dispatcher, BudgetMissPolicy.Expire);
+
+        await scanner.ScanOnceAsync(default);
+
+        var task = await Get("t-hourly");
+        task.Status.ShouldBe(TaskItemStatus.Todo);
+        task.BudgetMissCount.ShouldBe(1);
+        task.CatchUpPending.ShouldBeFalse();
+
+        // Nothing is caught up the next day beyond the regular occurrences.
+        MoveTo(NextLocalMidnightUtc().AddMinutes(30));
+        dispatcher.HasBudget = true;
+        dispatcher.Started.Clear();
+        (await scanner.ScanOnceAsync(default)).ShouldBe(1, "only the regular occurrence of this hour");
+    }
+
+    [Fact]
+    public async Task Under_catch_up_once_several_misses_leave_one_pending_catch_up()
+    {
+        await SeedHourly("t-hourly");
+        var dispatcher = new BudgetDispatcher { HasBudget = false };
+        var scanner = Scanner(dispatcher, BudgetMissPolicy.CatchUpOnce);
+        var midnight = NextLocalMidnightUtc();
+
+        // Three hours in a row refused.
+        for (var hour = 0; hour < 3; hour++)
+        {
+            await scanner.ScanOnceAsync(default);
+            _clock.Advance(TimeSpan.FromHours(1));
+        }
+
+        var task = await Get("t-hourly");
+        task.BudgetMissCount.ShouldBe(3);
+        task.CatchUpPending.ShouldBeTrue();
+        task.DeferredUntil.ShouldBe(midnight, "set by the first miss, not pushed on by the later ones");
+    }
+
+    [Fact]
+    public async Task The_catch_up_runs_exactly_once_on_the_next_day()
+    {
+        // A daily report at 22:30: its next regular occurrence is 24 hours away, so here
+        // the catch-up is the only run — the case catchUpOnce exists for.
+        MoveTo(new DateTime(2027, 3, 10, 22, 30, 0, DateTimeKind.Utc));
+        await _repo.UpsertAsync(new TaskItem
+        {
+            Id = "t-daily", Title = "t-daily", Assignee = "@worker",
+            When = new TaskWhen { Kind = TaskWhenKind.Cron, Value = "30 22 * * *", TimeZone = "UTC" }
+        }, default);
+
+        var dispatcher = new BudgetDispatcher { HasBudget = false };
+        var scanner = Scanner(dispatcher, BudgetMissPolicy.CatchUpOnce);
+        (await scanner.ScanOnceAsync(default)).ShouldBe(1, "the regular 22:30 run, refused");
+
+        MoveTo(NextLocalMidnightUtc().AddMinutes(1));
+        dispatcher.HasBudget = true;
+        dispatcher.Started.Clear();
+
+        (await scanner.ScanOnceAsync(default)).ShouldBe(1, "the catch-up");
+        _clock.Advance(TimeSpan.FromMinutes(1));
+        (await scanner.ScanOnceAsync(default)).ShouldBe(0, "once, not on every tick");
+
+        dispatcher.Started.ShouldBe(["t-daily"]);
+        var task = await Get("t-daily");
+        task.CatchUpPending.ShouldBeFalse();
+        task.BudgetMissCount.ShouldBe(0);
+        task.Status.ShouldBe(TaskItemStatus.Todo, "still recurring");
+    }
+
+    [Fact]
+    public async Task A_pending_catch_up_does_not_run_on_the_same_day()
+    {
+        await SeedHourly("t-hourly");
+        var dispatcher = new BudgetDispatcher { HasBudget = false };
+        var scanner = Scanner(dispatcher, BudgetMissPolicy.CatchUpOnce);
+        await scanner.ScanOnceAsync(default);
+
+        // Budget raised by the human in the evening: the regular occurrence runs, and it
+        // covers the pending catch-up — one run, not two.
+        dispatcher.HasBudget = true;
+        dispatcher.Started.Clear();
+        _clock.Advance(TimeSpan.FromHours(1));
+        (await scanner.ScanOnceAsync(default)).ShouldBe(1);
+        (await Get("t-hourly")).CatchUpPending.ShouldBeFalse();
+    }
+
+    [Fact]
+    public async Task A_shutdown_is_not_a_budget_miss()
+    {
+        await SeedOneTime("t-report");
+        var dispatcher = new BudgetDispatcher { Result = TaskLauf.NichtGelaufen };
+        await Scanner(dispatcher).ScanOnceAsync(default);
+
+        var task = await Get("t-report");
+        task.BudgetMissCount.ShouldBe(0);
+        task.DeferredUntil.ShouldBeNull("a shutdown keeps the old 30-minute retry");
+    }
+
+    [Fact]
+    public async Task Late_work_waits_while_the_headroom_gate_says_no()
+    {
+        await SeedOneTime("t-yesterday");
+        var dispatcher = new BudgetDispatcher { HasBudget = false };
+        var gate = new FixedGate { Room = false };
+        var scanner = new TaskScanner(_repo, dispatcher, NullLoggerFactory.Instance,
+            clock: _clock, lateRunGate: gate);
+        await scanner.ScanOnceAsync(default);
+
+        MoveTo(NextLocalMidnightUtc().AddMinutes(1));
+        await SeedOneTime("t-today");
+        dispatcher.HasBudget = true;
+        dispatcher.Started.Clear();
+
+        await scanner.ScanOnceAsync(default);
+        dispatcher.Started.ShouldBe(["t-today"], "regular work never asks the gate");
+        gate.Asked.ShouldBe(["t-yesterday"]);
+
+        gate.Room = true;
+        await scanner.ScanOnceAsync(default);
+        dispatcher.Started.ShouldBe(["t-today", "t-yesterday"]);
+    }
+
+    private sealed class FixedGate : ILateRunGate
+    {
+        public bool Room { get; set; }
+        public List<string> Asked { get; } = [];
+
+        public Task<bool> HasRoomAsync(TaskItem lateTask, IReadOnlyList<TaskItem> runnable, DateTime nowUtc, CancellationToken ct)
+        {
+            Asked.Add(lateTask.Id);
+            return Task.FromResult(Room);
+        }
+    }
+
+    // ═══════════════════ test double ═══════════════════
+
+    private sealed class BudgetDispatcher : ITaskDispatcher
+    {
+        public bool HasBudget { get; set; } = true;
+        public TaskLauf? Result { get; set; }
+        public int Calls { get; private set; }
+        public List<string> Started { get; } = [];
+
+        public Task<TaskLauf> DispatchAsync(TaskItem task, CancellationToken ct)
+        {
+            Calls++;
+            Started.Add(task.Id);
+            return Task.FromResult(Result ?? (HasBudget ? TaskLauf.Erledigt : TaskLauf.KeinBudget));
+        }
+    }
+}

tests/ClawdDotNet.Core.Tests/Tasks/ScannerCapacityTests.cs

@@ -0,0 +1,288 @@
+using ClawdDotNet.Core.Storage;
+using ClawdDotNet.Core.Tasks;
+using ClawdDotNet.Core.Tests.Infrastructure;
+using Microsoft.Extensions.Logging.Abstractions;
+using Shouldly;
+
+namespace ClawdDotNet.Core.Tests.Tasks;
+
+/// <summary>
+/// #682: The scanner caps parallel runs and no longer drops candidates beyond 500.
+///
+/// Before, every due task started at once — fifty agents on a round cron time meant fifty
+/// simultaneous model calls, all passing the instance budget check together. And the
+/// candidate list was clamped to 500 without a word, so schedules beyond that silently
+/// fell out of the tick.
+/// </summary>
+public sealed class ScannerCapacityTests : IDisposable
+{
+    private readonly string _directory;
+    private readonly SqliteStorage _storage;
+    private readonly SqliteTaskRepository _repo;
+    private readonly FakeTimeProvider _clock = new(new DateTimeOffset(2026, 7, 31, 12, 0, 0, TimeSpan.Zero));
+
+    public ScannerCapacityTests()
+    {
+        _directory = Path.Combine(Path.GetTempPath(), "clawd-tests", Guid.NewGuid().ToString("N"));
+        _storage = new SqliteStorage(Path.Combine(_directory, "state.db"));
+        _repo = new SqliteTaskRepository(_storage);
+    }
+
+    public void Dispose()
+    {
+        Microsoft.Data.Sqlite.SqliteConnection.ClearAllPools();
+        try { Directory.Delete(_directory, recursive: true); }
+        catch { /* cleanup is secondary */ }
+    }
+
+    private TaskScanner Scanner(ITaskDispatcher dispatcher, int maxParallelRuns)
+        => new(_repo, dispatcher, NullLoggerFactory.Instance, clock: _clock, maxParallelRuns: maxParallelRuns);
+
+    private Task<TaskItem> SeedDue(string id, int priority = 3, TaskWhen? when = null)
+        => _repo.UpsertAsync(new TaskItem
+        {
+            Id = id,
+            Title = id,
+            Assignee = "@new",
+            Status = TaskItemStatus.Todo,
+            Priority = priority,
+            When = when
+        }, default);
+
+    private static async Task WaitUntil(Func<bool> condition)
+    {
+        var deadline = DateTime.UtcNow.AddSeconds(10);
+        while (!condition())
+        {
+            if (DateTime.UtcNow > deadline)
+                throw new TimeoutException("condition not reached within 10 s");
+            await Task.Delay(10);
+        }
+    }
+
+    // ═══════════════════ the cap ═══════════════════
+
+    [Fact]
+    public async Task No_more_runs_than_the_cap_are_ever_in_flight()
+    {
+        for (var i = 0; i < 7; i++)
+            await SeedDue($"t-{i}");
+
+        var dispatcher = new TrackingDispatcher(holdFor: TimeSpan.FromMilliseconds(40));
+        var scanner = Scanner(dispatcher, maxParallelRuns: 2);
+
+        // Several ticks until everything has run — each tick fills only the free slots.
+        for (var tick = 0; tick < 20 && dispatcher.Started.Count < 7; tick++)
+            await scanner.ScanOnceAsync(default);
+
+        dispatcher.Started.Count.ShouldBe(7, "every due task runs eventually");
+        dispatcher.MaxConcurrent.ShouldBeLessThanOrEqualTo(2);
+    }
+
+    [Fact]
+    public async Task Tasks_beyond_the_cap_stay_todo_and_are_not_claimed()
+    {
+        await SeedDue("t-a", priority: 5);
+        await SeedDue("t-b");
+        await SeedDue("t-c");
+
+        var dispatcher = new TrackingDispatcher(gated: true);
+        var scanner = Scanner(dispatcher, maxParallelRuns: 1);
+
+        var scan = scanner.ScanOnceAsync(default);
+        await WaitUntil(() => dispatcher.Started.Count == 1);
+        await Task.Delay(100); // give a (wrong) second claim the chance to happen
+
+        dispatcher.Started.ShouldBe(["t-a"]);
+        (await _repo.GetAsync("t-b", default))!.Status.ShouldBe(TaskItemStatus.Todo,
+            "a waiting task must not be claimed — its lease would run out while it waits");
+        (await _repo.GetAsync("t-c", default))!.Status.ShouldBe(TaskItemStatus.Todo);
+
+        dispatcher.ReleaseAll();
+        (await scan).ShouldBe(1);
+    }
+
+    [Fact]
+    public async Task A_task_that_had_to_wait_keeps_its_occurrence()
+    {
+        var at = new TaskWhen { Kind = TaskWhenKind.At, Value = "2026-07-31T11:00:00Z", TimeZone = "UTC" };
+        await SeedDue("t-first", priority: 5);
+        await SeedDue("t-later", when: at);
+
+        var dispatcher = new TrackingDispatcher(gated: true);
+        var scanner = Scanner(dispatcher, maxParallelRuns: 1);
+
+        var first = scanner.ScanOnceAsync(default);
+        await WaitUntil(() => dispatcher.Started.Count == 1);
+        dispatcher.ReleaseAll();
+        await first;
+
+        // Ten minutes later, the one-time occurrence at 11:00 is still due.
+        _clock.Advance(TimeSpan.FromMinutes(10));
+        var second = scanner.ScanOnceAsync(default);
+        await WaitUntil(() => dispatcher.Started.Count == 2);
+        dispatcher.ReleaseAll();
+        await second;
+
+        dispatcher.Started.ShouldBe(["t-first", "t-later"]);
+    }
+
+    [Fact]
+    public async Task A_run_started_by_hand_occupies_a_slot()
+    {
+        await SeedDue("t-manual");
+        await SeedDue("t-scheduled");
+
+        var dispatcher = new TrackingDispatcher(gated: true);
+        var scanner = Scanner(dispatcher, maxParallelRuns: 1);
+
+        var manual = scanner.RunTaskNowAsync("t-manual", default);
+        await WaitUntil(() => dispatcher.Started.Count == 1);
+
+        (await scanner.ScanOnceAsync(default)).ShouldBe(0, "the only slot is taken by the manual run");
+
+        dispatcher.ReleaseAll();
+        (await manual).ShouldBeTrue();
+
+        // The slot is free again: the waiting task starts on the next tick.
+        var next = scanner.ScanOnceAsync(default);
+        await WaitUntil(() => dispatcher.Started.Count == 2);
+        dispatcher.ReleaseAll();
+        (await next).ShouldBe(1);
+    }
+
+    [Fact]
+    public async Task A_value_below_one_still_lets_work_through()
+    {
+        await SeedDue("t-1");
+        var scanner = Scanner(new TrackingDispatcher(), maxParallelRuns: 0);
+
+        scanner.MaxParallelRuns.ShouldBe(1);
+        (await scanner.ScanOnceAsync(default)).ShouldBe(1);
+    }
+
+    [Fact]
+    public async Task A_long_run_does_not_hold_back_the_next_tick()
+    {
+        // Real clock and a short tick: this is about the loop, not a single scan.
+        await SeedDue("t-slow");
+        var dispatcher = new TrackingDispatcher(gated: true);
+        await using var scanner = new TaskScanner(_repo, dispatcher, NullLoggerFactory.Instance,
+            tick: TimeSpan.FromMilliseconds(50), maxParallelRuns: 2);
+
+        scanner.Start();
+        await WaitUntil(() => dispatcher.Started.Count == 1);
+
+        // While t-slow still runs, new work arrives. Before #682 the loop awaited every
+        // run it started, so t-new would have waited for t-slow to finish.
+        await SeedDue("t-new");
+        await WaitUntil(() => dispatcher.Started.Count == 2);
+
+        dispatcher.Started.ShouldBe(["t-slow", "t-new"]);
+        scanner.OpenCount.ShouldBe(2);
+
+        scanner.StopAccepting();
+        dispatcher.ReleaseAll();
+        await WaitUntil(() => scanner.OpenCount == 0);
+    }
+
+    // ═══════════════════ order ═══════════════════
+
+    [Fact]
+    public async Task Higher_priority_goes_first()
+    {
+        await SeedDue("t-low", priority: 1);
+        await SeedDue("t-high", priority: 5);
+        await SeedDue("t-mid", priority: 3);
+
+        var dispatcher = new TrackingDispatcher();
+        await Scanner(dispatcher, maxParallelRuns: 1).ScanOnceAsync(default);
+
+        dispatcher.Started.ShouldBe(["t-high", "t-mid", "t-low"]);
+    }
+
+    [Fact]
+    public async Task At_equal_priority_the_longest_waiting_goes_first()
+    {
+        TaskWhen At(string utc) => new() { Kind = TaskWhenKind.At, Value = utc, TimeZone = "UTC" };
+        await SeedDue("t-1130", when: At("2026-07-31T11:30:00Z"));
+        await SeedDue("t-0900", when: At("2026-07-31T09:00:00Z"));
+        await SeedDue("t-1000", when: At("2026-07-31T10:00:00Z"));
+
+        var dispatcher = new TrackingDispatcher();
+        await Scanner(dispatcher, maxParallelRuns: 1).ScanOnceAsync(default);
+
+        dispatcher.Started.ShouldBe(["t-0900", "t-1000", "t-1130"]);
+    }
+
+    // ═══════════════════ no silent clamp ═══════════════════
+
+    [Fact]
+    public async Task More_than_500_due_tasks_are_all_considered()
+    {
+        for (var i = 0; i < 520; i++)
+            await SeedDue($"t-{i:000}");
+
+        var dispatcher = new TrackingDispatcher();
+        var dispatched = await Scanner(dispatcher, maxParallelRuns: 1000).ScanOnceAsync(default);
+
+        dispatched.ShouldBe(520, "before #682 the tick stopped at 500 without a word");
+    }
+
+    // ═══════════════════ test double ═══════════════════
+
+    /// <summary>
+    /// Records starts and the highest number of runs in flight at once. Either finishes
+    /// immediately, after <c>holdFor</c>, or — <c>gated</c> — only on <see cref="ReleaseAll"/>.
+    /// </summary>
+    private sealed class TrackingDispatcher(TimeSpan? holdFor = null, bool gated = false) : ITaskDispatcher
+    {
+        private readonly Lock _lock = new();
+        private readonly List<TaskCompletionSource> _gates = [];
+        private int _current;
+
+        public List<string> Started { get; } = [];
+        public int MaxConcurrent { get; private set; }
+
+        public async Task<TaskLauf> DispatchAsync(TaskItem task, CancellationToken ct)
+        {
+            TaskCompletionSource? gate = null;
+            lock (_lock)
+            {
+                Started.Add(task.Id);
+                _current++;
+                MaxConcurrent = Math.Max(MaxConcurrent, _current);
+                if (gated)
+                {
+                    gate = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+                    _gates.Add(gate);
+                }
+            }
+
+            try
+            {
+                if (gate is not null)
+                    await gate.Task;
+                else if (holdFor is { } delay)
+                    await Task.Delay(delay, ct);
+
+                return TaskLauf.Erledigt;
+            }
+            finally
+            {
+                lock (_lock)
+                    _current--;
+            }
+        }
+
+        public void ReleaseAll()
+        {
+            lock (_lock)
+            {
+                foreach (var gate in _gates)
+                    gate.TrySetResult();
+                _gates.Clear();
+            }
+        }
+    }
+}

tests/ClawdDotNet.Tools.Tests/Taskboard/DublettenTests.cs

@@ -143,6 +143,24 @@ public sealed class DublettenTests : IDisposable
         (await _board.ListAsync(new TaskQuery { Limit = 50 }, default)).Count.ShouldBe(2);
     }
 
+    [Fact]
+    public async Task Die_Dublette_wird_auch_hinter_500_anderen_Aufgaben_gefunden()
+    {
+        // #716: Die Suche las ListAsync mit Limit 500, sortiert nach Prioritaet. Eine alte
+        // Aufgabe mit niedriger Prioritaet fiel damit aus dem Blick, sobald das Brett wuchs.
+        var alt = await _board.CreateAsync(new TaskItem
+        {
+            Title = "Betriebsluecke: Eur Kurse nicht aktuell", Assignee = "@human", Priority = 1
+        }, default);
+        for (var i = 0; i < 510; i++)
+            await _repo.UpsertAsync(new TaskItem { Id = $"t-fill-{i}", Title = $"Anderes Thema {i}", Priority = 5 }, default);
+
+        var result = await Run("""{"action":"task_create","title":"Betriebsluecke: Kurse EUR nicht aktuell","assignee":"@human"}""");
+
+        result.Success.ShouldBeFalse("die alte Aufgabe meint dasselbe");
+        result.ErrorMessage.ShouldNotBeNull().ShouldContain(alt.Id);
+    }
+
     [Fact]
     public async Task Eine_erledigte_Aufgabe_blockiert_den_naechsten_Befund_nicht()
     {