[Feature Request] Scheduled Auto-Resume After Usage Limit — Zero-Interruption Agentic Workflows

Preflight Checklist

• [x] I have searched existing requests and this feature hasn't been requested yet
• [x] This is a single feature request (not multiple features)

Problem Statement

When Claude Code hits a usage limit (token/rate/plan), it stops completely and requires manual user input to resume. This contradicts the core value proposition of an agentic tool: autonomous operation.

What happens today:

1. Claude Code is running a complex, long-running task (refactor, test generation, codebase analysis)
2. Usage limit is reached mid-execution
3. A Retry / Cancel prompt appears
4. The task is frozen indefinitely until the user physically clicks Retry
5. If the user is asleep, in a meeting, or away — work stops completely

The core paradox: Claude Code is designed to reduce human intervention in repetitive or continuous tasks. But when a rate limit hits, the tool that was supposed to operate autonomously demands an immediate, non-deferrable manual action — exactly the opposite of its purpose.

For complex multi-step tasks spanning hours, this creates repeated interruptions that fragment the workflow and require costly context re-initialization on every resume.

Proposed Solution

When a usage limit is reached, instead of blocking on manual input, Claude Code should offer scheduled automatic resumption:

⚠ Usage limit reached. Resets at 06:00 AM.

Options:
  [1] Auto-resume at 06:00 AM  ← recommended
  [2] Set custom time: ___:___
  [3] Resume manually (current behavior)
  [4] Cancel task

> 1

✓ Scheduled for auto-resume at 06:00 AM.
  Task state saved. You can safely close this terminal.

Implementation path (MVP):

• Serialize current session state to ~/.claude/session_state.json
• Register an OS-level scheduled job (cron on Linux/macOS, Task Scheduler on Windows)
• At scheduled time, restart with claude --resume-session
• Reload context, notify user via desktop notification or log, continue execution

Advanced path:

• Background daemon that polls for limit reset and auto-resumes
• --auto-resume flag: claude --auto-resume "refactor auth module"
• Queue management for multiple scheduled tasks

Alternative Solutions

1. Notification-only approach: Send a desktop/push notification when limit resets — lower friction than current, no automation needed
2. --watch mode: Keep Claude Code alive in a wait state and auto-retry when limit clears
3. Persistent queue file: Write pending tasks to ~/.claude/queue processed automatically on next invocation

Priority

Medium - Would be very helpful

Feature Category

Configuration and settings

Use Case Example

Overnight development task:

1. Developer launches large task at 11:00 PM: claude "refactor auth module, add test coverage, update docs"
2. Claude Code works autonomously for ~2 hours
3. Usage limit reached at 01:00 AM — task 60% complete
4. Instead of freezing: Limit reached. Resets at 06:00 AM. Auto-resume? [Y/n]
5. Developer presses Y, closes laptop, goes to sleep
6. At 06:00 AM, Claude Code resumes with preserved context
7. Developer wakes up to a completed task and summary log

Without this feature: developer wakes up, finds everything frozen at 01:00 AM, manually resumes, waits another hour — 5 hours of potential autonomous work time lost.

Additional Context

This pattern is standard in async automation tools:

• GitHub Actions: retry-on-error with configurable backoff
• Make / n8n: built-in retry scheduling per node
• Celery: native retry with eta for future execution
• cron: fully async, zero-interruption by design

Claude Code is the first tool in the agentic AI category that presents itself as autonomous but doesn't handle temporary limits autonomously. This creates a perceived reliability gap.

UX Friction Score: 9/10

• Frequency: High — every power user hits this multiple times/day
• Workflow impact: Critical — completely halts execution
• Workaround: None available natively
• Gap from expectation: Very high — agentic tool requiring manual presence

Closing this gap would significantly improve trust, retention, and perceived quality for heavy users.