Maison

Skill

Productivité et flux de travail

stay-within-limits

BuilderIO/skills

Maintenez le travail des agents à long terme dans les limites de 5 heures et d’utilisation hebdomadaire en vérifiant l’utilisation entre les vagues, en mettant en pause près du plafond, et en ne reprenant que lorsque la fenêtre est libre.

...Développer tout

Heure mise à jour 6 septembre 2026

# Claude Code # rate limiting # agent orchestration # budget management # ccusage # pause resume # usage limits

Rester dans les limites

Confiner le travail des agents de longue durée dans les fenêtres d'utilisation actuelles de 5 heures et hebdomadaires. Vérifier l'utilisation avant de lancer des travaux substantiels et entre les vagues d'agents subordonnés parallèles. Si une limite de 5 heures ou hebdomadaire active est à 95 % ou plus, suspendre les nouveaux travaux jusqu'à ce que la fenêtre soit suffisamment dégagée pour continuer en toute sécurité.

Boucle principale

Exécuter une vague de travail bornée. Par défaut, utiliser au maximum 3 agents subordonnés parallèles, sauf si l'utilisateur ou l'hôte impose un autre taux de throttling.
Attendre que la vague se termine. Ne pas interrompre les agents subordonnés en cours d'exécution uniquement pour économiser le budget ; cela entraîne généralement une perte de travail.
Vérifier l'utilisation actuelle des fenêtres de 5 heures et hebdomadaires avec l'outil d'utilisation/budget de l'hôte.
Si l'une des fenêtres est à 95 % ou plus, arrêter de lancer des travaux et planifier une reprise autonome lorsque la fenêtre concernée devrait être dégagée.
Lors de la reprise, revérifier la fenêtre réelle ou le bloc avant de continuer. Ne pas se fier uniquement au temps écoulé sur l'horloge murale.

Signaux d'utilisation

Préférer un outil d'utilisation de l'hôte de première partie lorsqu'il est disponible. Dans Claude Code, utiliser :

npx -y ccusage@latest blocks --active --json

Utiliser le JSON pour identifier le début du bloc actif, le coût ou le pourcentage actuel, et le temps restant. Au réveil, comparer l'horodatage de début du bloc actif avec le précédent ; un nouvel horodatage constitue une preuve plus solide que « suffisamment de temps s'est écoulé ».

Si l'outil signale un coût au lieu d'un pourcentage direct, convertir via la limite de compte actuelle lorsqu'elle est connue. Pour les blocs de 5 heures de style Claude Max, certains utilisateurs préfèrent un seuil d'alerte précoce autour de 500-550 $ ; considérer cela comme une garde-fou configurée par l'utilisateur, et non comme une règle universelle. La règle d'arrêt par défaut reste 95 % de la limite active de 5 heures ou hebdomadaire.

Suspension et reprise

Lorsqu'un outil de réveil/reprise est disponible, planifier un réveil pour :

min(3600, secondesAvantDégagementDeLaFenêtre)

Si le runtime limite les délais de réveil à 60-3600 secondes, enchaîner les réveils pour les attentes plus longues. Chaque réveil doit revérifier l'utilisation, reprogrammer si le budget est toujours dépassé, et ne continuer que lorsque la fenêtre est sûrement en dessous du seuil.

Rendre les invites de réveil autonomes. Inclure :

Le plan restant.
La règle de vérification puis de reprogrammation.
Le seuil de 95 % et le throttling de vague.
La commande d'utilisation exacte ou l'outil d'utilisation de l'hôte à exécuter.
L'identifiant du bloc/fenêtre précédent, lorsque disponible.
Les prochaines étapes de vérification.
Les paquets de passation de la prochaine vague, y compris la portée, les commandes de vérification et les conditions d'arrêt, si la délégation doit reprendre.

Choix du mécanisme d'attente

Utiliser un outil de réveil/reprise lorsque l'agent a besoin d'instructions attachées à la reprise future.
Utiliser une mise en veille en arrière-plan ou un observateur pour les minuteries fixes et les éléments qu'un processus peut observer directement.
Utiliser cron ou des horaires récurrents uniquement pour les travaux de session fraîche récurrents.

Éviter le sondage à intervalles courts pour les éléments dont l'hôte vous notifiera, tels que la tâche en arrière-plan ou la fin d'un agent subordonné. Pour les suspensions budgétaires, un manque de cache d'invite après une longue mise en veille est acceptable ; préserver la limite est plus important.

Rapport

Si vous suspendez, informer l'utilisateur de la fenêtre dépassant le seuil, de l'utilisation observée, de la planification ou de l'attente de la prochaine vérification, et des travaux restants. Conserver suffisamment d'état dans l'invite de réveil pour que le tour suivant puisse reprendre sans dépendre de l'élan de la conversation.

Voir sur GitHub

---
name: stay-within-limits
description: Keep long-running agent work within 5-hour and weekly usage limits by checking usage between waves, pausing near the cap, and resuming only when the window is clear.
---

# Stay Within Limits

Keep long-running agent work inside the current 5-hour and weekly usage windows.
Check usage before launching substantial work and between waves of parallel
subagents. If an active 5-hour or weekly limit is at or above 95%, pause new
work until the window is clear enough to continue safely.

## Core Loop

1. Run a bounded wave of work. Default to at most 3 parallel subagents unless
   the user or host gives a different throttle.
2. Wait for the wave to finish. Do not interrupt in-flight subagents just to
   save budget; that usually loses work.
3. Check current 5-hour and weekly usage with the host's usage/budget tool.
4. If either window is at or above 95%, stop launching work and schedule a
   self-contained resume when the relevant window should clear.
5. On resume, re-check the real window or block before continuing. Do not trust
   elapsed wall-clock time alone.

## Usage Signals

Prefer a first-party host usage tool when available. In Claude Code, use:

```sh
npx -y ccusage@latest blocks --active --json
```

Use the JSON to identify the active block start, current cost or percentage, and
time remaining. On wake, compare the active block start timestamp with the
previous one; a new timestamp is stronger evidence than "enough time passed."

If the tool reports cost instead of a direct percentage, convert through the
current account limit when known. For Claude Max-style 5-hour blocks, some users
prefer an earlier caution threshold around $500-550; treat that as a
user-configured guardrail, not a universal rule. The default stop rule is still
95% of the active 5-hour or weekly limit.

## Pausing And Resuming

When a wake/resume tool is available, schedule a wakeup for:

```txt
min(3600, secondsUntilWindowClears)
```

If the runtime clamps wake delays to 60-3600 seconds, chain wakeups for longer
waits. Each wakeup should re-check usage, reschedule if still over budget, and
continue only when the window is safely below the threshold.

Make wake prompts self-contained. Include:

- The remaining plan.
- The check-then-reschedule rule.
- The 95% threshold and wave throttle.
- The exact usage command or host usage tool to run.
- The previous block/window identifier when available.
- The next verification steps.
- The next wave's handoff packets, including scope, verification commands, and
  stop conditions, if delegation will resume.

## Choosing The Wait Mechanism

- Use a wake/resume tool when the agent needs instructions attached to the
  future resume.
- Use a background sleep or watcher for fixed timers and things a process can
  observe directly.
- Use cron or recurring schedules only for recurring fresh-session work.

Avoid short-interval polling for things the host will notify you about, such as
background task or subagent completion. For budget pauses, a prompt-cache miss
after a long sleep is acceptable; preserving the limit matters more.

## Reporting

If you pause, tell the user which window is over threshold, the observed usage,
when you scheduled or expect the next check, and what work remains. Keep enough
state in the wake prompt that the next turn can resume without relying on
conversation momentum.