Workflow resume и budget: повторный запуск и лимиты
📖 Теория
В этом уроке мы рассмотрим, как эффективно управлять рабочими процессами в Claude Code с помощью функции resume и budget. Эти инструменты помогут вам оптимизировать время выполнения задач и следить за ресурсами вашего проекта.
Что такое resume и budget?
- Resume: Позволяет вам перезапустить ранее выполненные процессы с использованием кэшированных данных. Это особенно полезно, когда необходимо повторно запустить задачи, не начиная все с нуля.
- Budget: Инструмент для контроля затрат, который позволяет установить лимиты на выполнение задач. Это помогает избежать перерасхода ресурсов и позволяет более рационально подходить к планированию.
Архитектура Resume
Resume работает на основе Anthropic Prompt Caching — технологии кэширования промптов, которая сохраняет обработанные части контекста и переиспользует их в последующих запросах.
Первый запуск:
User: "Analyze this 10,000 line file"
Claude: [Processes entire file] → 10,000 tokens input
Cost: $0.30 (10K tokens × $3/MTok)
С Resume (в течение 5 минут):
User: "/resume - now fix the bug on line 5234"
Claude: [Uses cached file analysis] → 100 tokens new input
Cost: $0.01 (100 tokens × $3/MTok + cache hit)
Savings: 97% cheaper!
Как работает кэширование
Anthropic Prompt Caching имеет 5-минутный TTL (Time To Live):
- 0-5 минут: Кэш активен, resume практически мгновенный
- 5+ минут: Кэш истёк, нужна полная обработка
- Размер кэша: До 200K токенов (примерно 150K слов)
Что кэшируется:
- System prompt (инструкции Claude Code)
- Содержимое прочитанных файлов
- Результаты выполненных команд
- История сообщений (conversation history)
Что НЕ кэшируется:
- Новые пользовательские сообщения
- Файлы, измененные после кэширования
- Real-time данные (WebFetch, API calls)
Budget Management
Budget в Claude Code контролирует три типа ресурсов:
| Ресурс | Метрика | Типичный лимит | Применение |
|---|---|---|---|
| Token Budget | Токены (input + output) | 200K - 2M | Ограничение стоимости API calls |
| Time Budget | Время выполнения | 30 min - 2 hours | Предотвращение бесконечных задач |
| Tool Call Budget | Количество вызовов инструментов | 50 - 500 | Контроль сложности задач |
Стратегии оптимизации
1. Cache-Friendly Workflow:
# Плохо: каждый раз читаем заново
User: "Check file.js"
Claude: [Reads file.js] 1000 tokens
User: "Now fix bug"
Claude: [Reads file.js again] 1000 tokens
# Хорошо: используем кэш
User: "Check file.js and fix bug"
Claude: [Reads file.js once] 1000 tokens
# Все последующие обращения к file.js используют кэш
2. Batch Operations:
# Плохо: множество мелких запросов
"Fix bug in auth.js"
"Fix bug in api.js"
"Fix bug in db.js"
# Хорошо: один запрос с batching
"Fix bugs in: auth.js, api.js, db.js"
3. Resume Checkpoints:
# Создавайте естественные точки resume
"Phase 1: Analyze all files" → /resume
"Phase 2: Generate refactoring plan" → /resume
"Phase 3: Execute refactoring"
🛠 Практика
Базовое использование Resume
Шаг 1. Чтобы запустить ранее сохранённый процесс, используйте команду /resume. Эта команда автоматически восстановит состояние вашего проекта на момент последнего завершения.
/resume
Шаг 2. Resume с продолжением задачи:
# Первая сессия (утро)
User: "Analyze the entire codebase and find performance issues"
Claude: [Анализирует 50K строк кода]
Claude: "Found 12 performance bottlenecks in..."
# Вторая сессия (после обеда, в течение 5 минут)
/resume - now fix the top 3 issues
# Claude использует кэшированный анализ
# Не нужно заново читать 50K строк!
Продвинутое использование Resume
Сценарий 1: Iterative Development
# Итерация 1
User: "Create REST API for user management"
Claude: [Creates 5 files: routes.js, controllers.js, models.js, ...]
# Итерация 2 (в течение 5 минут)
/resume - add authentication middleware
# Итерация 3
/resume - add input validation
# Каждый resume использует кэш предыдущей работы
Сценарий 2: Code Review с Resume
# Первый проход
User: "Review PR #456 for security issues"
Claude: [Reads 20 files, analyzes security]
Claude: "Found 3 security issues..."
# Второй проход (после исправлений)
/resume - re-review only the files that changed
# Claude помнит весь контекст PR из кэша
# Перечитывает только измененные файлы
Сценарий 3: Multi-Step Refactoring
# Step 1: Analysis
User: "Analyze opportunities to extract shared utilities"
Claude: "Found 5 patterns that can be extracted..."
# Step 2: Plan (resume)
/resume - create detailed refactoring plan
# Step 3: Execute (resume)
/resume - execute the plan
# Step 4: Verify (resume)
/resume - run tests and verify nothing broke
Budget Configuration
Создание конфигурации бюджета:
# .claude/budget.json
{
"version": "1.0",
"budgets": {
"default": {
"tokens": {
"max_input": 500000,
"max_output": 100000,
"max_total": 600000
},
"time": {
"max_duration_seconds": 3600,
"warn_at_seconds": 2700
},
"tools": {
"max_calls": 200,
"max_bash_calls": 50,
"max_edit_calls": 100
}
},
"ci": {
"tokens": {
"max_total": 100000
},
"time": {
"max_duration_seconds": 600
}
},
"production": {
"tokens": {
"max_total": 2000000
},
"time": {
"max_duration_seconds": 7200
}
}
},
"alerts": {
"email": "devops@example.com",
"slack_webhook": "https://hooks.slack.com/...",
"warn_at_percent": 80
}
}
Использование разных бюджетов:
# Использовать default бюджет
claude "your task"
# Использовать CI бюджет
CLAUDE_BUDGET=ci claude "run tests"
# Использовать production бюджет
CLAUDE_BUDGET=production claude "deploy to prod"
Production-Ready Budget Manager
#!/usr/bin/env python3
"""
Budget Manager - управление бюджетами для Claude Code
"""
import json
import time
from pathlib import Path
from dataclasses import dataclass
from typing import Optional, Dict
from datetime import datetime, timedelta
@dataclass
class BudgetUsage:
"""Использование бюджета"""
input_tokens: int = 0
output_tokens: int = 0
tool_calls: int = 0
bash_calls: int = 0
edit_calls: int = 0
start_time: float = None
def __post_init__(self):
if self.start_time is None:
self.start_time = time.time()
@property
def total_tokens(self):
return self.input_tokens + self.output_tokens
@property
def elapsed_seconds(self):
return time.time() - self.start_time
@property
def cost_estimate(self):
"""Примерная стоимость в USD"""
# Claude Sonnet pricing (примерно)
input_cost = self.input_tokens / 1_000_000 * 3.0
output_cost = self.output_tokens / 1_000_000 * 15.0
return input_cost + output_cost
class BudgetManager:
def __init__(self, config_path: str = ".claude/budget.json"):
self.config_path = Path(config_path)
self.usage_path = Path(".claude/budget-usage.json")
self.config = self._load_config()
self.usage = self._load_usage()
self.current_budget_name = "default"
def _load_config(self) -> Dict:
"""Загрузить конфигурацию бюджетов"""
if self.config_path.exists():
with open(self.config_path) as f:
return json.load(f)
return self._default_config()
def _default_config(self) -> Dict:
"""Конфигурация по умолчанию"""
return {
"version": "1.0",
"budgets": {
"default": {
"tokens": {"max_total": 600000},
"time": {"max_duration_seconds": 3600},
"tools": {"max_calls": 200}
}
}
}
def _load_usage(self) -> BudgetUsage:
"""Загрузить текущее использование"""
if self.usage_path.exists():
with open(self.usage_path) as f:
data = json.load(f)
return BudgetUsage(**data)
return BudgetUsage()
def _save_usage(self):
"""Сохранить использование"""
self.usage_path.parent.mkdir(parents=True, exist_ok=True)
with open(self.usage_path, 'w') as f:
json.dump({
'input_tokens': self.usage.input_tokens,
'output_tokens': self.usage.output_tokens,
'tool_calls': self.usage.tool_calls,
'bash_calls': self.usage.bash_calls,
'edit_calls': self.usage.edit_calls,
'start_time': self.usage.start_time
}, f, indent=2)
def set_budget(self, budget_name: str):
"""Установить активный бюджет"""
if budget_name not in self.config["budgets"]:
raise ValueError(f"Budget '{budget_name}' not found")
self.current_budget_name = budget_name
self.usage = BudgetUsage() # Reset usage
self._save_usage()
def get_current_budget(self) -> Dict:
"""Получить текущий бюджет"""
return self.config["budgets"][self.current_budget_name]
def track_tokens(self, input_tokens: int, output_tokens: int):
"""Отследить использование токенов"""
self.usage.input_tokens += input_tokens
self.usage.output_tokens += output_tokens
self._save_usage()
self._check_limits()
def track_tool_call(self, tool_name: str):
"""Отследить вызов инструмента"""
self.usage.tool_calls += 1
if tool_name == "Bash":
self.usage.bash_calls += 1
elif tool_name in ["Edit", "Write"]:
self.usage.edit_calls += 1
self._save_usage()
self._check_limits()
def _check_limits(self):
"""Проверить лимиты"""
budget = self.get_current_budget()
# Проверка токенов
if "tokens" in budget:
max_total = budget["tokens"].get("max_total")
if max_total and self.usage.total_tokens > max_total:
raise BudgetExceededError(
f"Token budget exceeded: {self.usage.total_tokens} > {max_total}"
)
# Проверка времени
if "time" in budget:
max_duration = budget["time"].get("max_duration_seconds")
if max_duration and self.usage.elapsed_seconds > max_duration:
raise BudgetExceededError(
f"Time budget exceeded: {self.usage.elapsed_seconds}s > {max_duration}s"
)
# Проверка tool calls
if "tools" in budget:
max_calls = budget["tools"].get("max_calls")
if max_calls and self.usage.tool_calls > max_calls:
raise BudgetExceededError(
f"Tool calls budget exceeded: {self.usage.tool_calls} > {max_calls}"
)
def get_status(self) -> Dict:
"""Получить статус бюджета"""
budget = self.get_current_budget()
status = {
"budget_name": self.current_budget_name,
"usage": {
"tokens": {
"input": self.usage.input_tokens,
"output": self.usage.output_tokens,
"total": self.usage.total_tokens
},
"time": {
"elapsed_seconds": int(self.usage.elapsed_seconds),
"elapsed_formatted": str(timedelta(seconds=int(self.usage.elapsed_seconds)))
},
"tools": {
"total_calls": self.usage.tool_calls,
"bash_calls": self.usage.bash_calls,
"edit_calls": self.usage.edit_calls
},
"cost_estimate_usd": round(self.usage.cost_estimate, 2)
},
"limits": budget,
"percentage_used": {}
}
# Вычислить проценты использования
if "tokens" in budget and "max_total" in budget["tokens"]:
max_tokens = budget["tokens"]["max_total"]
status["percentage_used"]["tokens"] = round(
(self.usage.total_tokens / max_tokens) * 100, 1
)
if "time" in budget and "max_duration_seconds" in budget["time"]:
max_time = budget["time"]["max_duration_seconds"]
status["percentage_used"]["time"] = round(
(self.usage.elapsed_seconds / max_time) * 100, 1
)
if "tools" in budget and "max_calls" in budget["tools"]:
max_calls = budget["tools"]["max_calls"]
status["percentage_used"]["tools"] = round(
(self.usage.tool_calls / max_calls) * 100, 1
)
return status
def reset(self):
"""Сбросить использование"""
self.usage = BudgetUsage()
self._save_usage()
def warn_if_approaching_limit(self, threshold_percent: float = 80.0):
"""Предупредить если приближаемся к лимиту"""
status = self.get_status()
for resource, percent in status["percentage_used"].items():
if percent >= threshold_percent:
print(f"⚠️ WARNING: {resource} budget at {percent}%")
class BudgetExceededError(Exception):
"""Исключение при превышении бюджета"""
pass
# Использование
if __name__ == "__main__":
manager = BudgetManager()
# Установить бюджет
manager.set_budget("default")
# Отследить использование
manager.track_tokens(input_tokens=1000, output_tokens=500)
manager.track_tool_call("Bash")
manager.track_tool_call("Edit")
# Проверить статус
status = manager.get_status()
print(json.dumps(status, indent=2))
# Предупредить если близко к лимиту
manager.warn_if_approaching_limit(threshold_percent=80)
Resume + Budget интеграция
#!/bin/bash
# claude-with-budget.sh
# Wrapper для запуска Claude с бюджетным контролем
BUDGET_NAME="${CLAUDE_BUDGET:-default}"
PROJECT_DIR="$(pwd)"
BUDGET_FILE="$PROJECT_DIR/.claude/budget-usage.json"
echo "🎯 Running with budget: $BUDGET_NAME"
# Проверить текущий статус
python3 - <
⚠️ Troubleshooting
Проблема 1: Resume не работает (кэш пропал)
Симптомы: /resume перечитывает все файлы заново.
Решение:
# Проверить время с последнего запроса
# Кэш живёт только 5 минут!
# Если прошло >5 минут - кэш истёк, это нормально
# Используйте resume чаще для максимальной экономии
# Оптимальная стратегия:
# 1. Большая задача (analysis)
# 2. Resume через 2-3 минуты (plan)
# 3. Resume через 2-3 минуты (execute)
# Итого: 3 запроса за 9 минут с 2 cache hits
Проблема 2: Budget exceeded неожиданно
Симптомы: Превышен бюджет хотя задача кажется простой.
Решение:
# Проверить логи
cat .claude/budget-usage.json
# Проверить что не включён debug mode
# Debug может генерировать много токенов
# Уменьшить размер контекста
# Не читайте большие файлы если не нужно
# Используйте более узкие запросы
# Вместо: "analyze entire codebase"
# Делайте: "analyze src/api/ directory"
Проблема 3: Resume возвращает устаревшие данные
Симптомы: Resume использует старую версию файла.
Решение:
# Кэш НЕ обновляется при изменении файлов
# Если файл изменился - нужно перечитать его явно
# Вариант 1: Не использовать resume после изменений
# Вариант 2: Явно указать "re-read modified files"
/resume - re-read files that changed and continue
# Вариант 3: Очистить кэш
# Подождите 5+ минут - кэш истечёт автоматически
Проблема 4: Budget tracking неточный
Симптомы: Показываемые токены не совпадают с реальностью.
Решение:
# Budget Manager использует approximation
# Точные данные доступны только в Anthropic Dashboard
# Для более точного трекинга:
# 1. Интегрируйте с Anthropic API
# 2. Читайте usage из response headers
# 3. Логируйте каждый API call
# Пример интеграции:
import anthropic
client = anthropic.Anthropic()
response = client.messages.create(...)
actual_tokens = response.usage.input_tokens + response.usage.output_tokens
manager.track_tokens(response.usage.input_tokens, response.usage.output_tokens)
Проблема 5: Resume работает медленно
Симптомы: Resume не даёт ожидаемого ускорения.
Решение:
# Resume ускоряет только token processing
# Не ускоряет:
# - Tool execution (bash, file I/O)
# - Network requests
# - Claude's thinking time
# Для реального ускорения нужно кэшировать и результаты:
# - Используйте BeforeToolCall hook для кэширования
# - Сохраняйте результаты bash команд
# - Избегайте повторных API calls
Проблема 6: Budget alerts не приходят
Симптомы: Настроены alerts, но уведомления не приходят.
Решение:
# Проверить конфигурацию
cat .claude/budget.json | jq '.alerts'
# Тест отправки в Slack
curl -X POST "$SLACK_WEBHOOK" \
-H 'Content-Type: application/json' \
-d '{"text":"Budget alert test"}'
# Добавить logging в BudgetManager
import logging
logging.basicConfig(level=logging.DEBUG)
# Проверить что alerts вызываются
manager.warn_if_approaching_limit(threshold_percent=0) # Должен всегда предупредить
Проблема 7: Разные сессии конфликтуют по бюджету
Симптомы: Запущено несколько сессий Claude, budget считается некорректно.
Решение:
# Используйте per-session budget files
SESSION_ID=$(uuidgen)
export CLAUDE_BUDGET_FILE=".claude/budget-$SESSION_ID.json"
# Или используйте file locking
import fcntl
with open(budget_file, 'r+') as f:
fcntl.flock(f.fileno(), fcntl.LOCK_EX)
# ... update budget ...
fcntl.flock(f.fileno(), fcntl.LOCK_UN)
# Или используйте shared state (Redis, database)
import redis
r = redis.Redis()
r.incr('claude:tokens:total')
📝 Домашнее задание
- Resume workflow: Создайте multi-step задачу (analysis → plan → execute) и используйте /resume между шагами. Измерьте экономию токенов.
- Budget configuration: Настройте файл budget.json с тремя профилями: development, ci, production. Каждый с разными лимитами.
- Budget tracking: Реализуйте BudgetManager и интегрируйте его в ваш проект. Логируйте все tool calls и считайте стоимость.
- Cache optimization: Проанализируйте ваш типичный workflow и определите оптимальные точки для /resume. Создайте cache-friendly checklist.
- Alerts system: Добавьте в BudgetManager интеграцию со Slack/Email для alerts при 80% использования бюджета.
- Monitoring: Создайте dashboard который показывает real-time budget usage: токены, время, стоимость, tool calls.
- Отчёт: Напишите краткий отчет о том, как использование resume и budget повлияло на ваш рабочий процесс. Сколько сэкономили токенов и денег?
🎓 После урока вы умеете
- Использовать команду /resume для восстановления предыдущих процессов
- Понимать как работает Anthropic Prompt Caching (5-min TTL, 200K tokens)
- Создавать cache-friendly workflows для максимальной экономии
- Настраивать budget в файле budget.json для контроля затрат на задачи
- Реализовывать production-ready BudgetManager с tracking и alerts
- Проверять статус бюджета и оптимизировать расходы
- Интегрировать resume и budget в CI/CD pipeline
- Диагностировать и решать проблемы с кэшированием и бюджетом
- Мониторить и анализировать использование ресурсов Claude Code
- Оптимизировать рабочие процессы, используя кэшированные данные и контроль ресурсов
🔗 Дополнительные ресурсы
Рекомендуемые курсы
Продолжите обучение по смежным темам
ИИ-наставник по этому уроку
Задайте вопрос по теме урока «Workflow resume и budget: повторный запуск и лимиты» — наставник ответит, опираясь на его содержание. Он помогает понять, но не делает домашку за вас.