circuit-breaker（断路器）

Overview

The circuit-breaker skill is a safety mechanism that prevents infinite loops, resource exhaustion, and accidental destruction during autonomous development. It operates at the loop level (complementing resilient-execution which operates at the task level). Without circuit-breaker protection, autonomous loops can waste hours on stagnant problems, exhaust API limits, or accidentally destroy configuration files. This skill enforces hard boundaries that keep autonomous operations productive and safe.

Announce at start: "Circuit breaker is active — monitoring for stagnation, rate limits, and file protection."

Phase 1: Circuit State Check

Before each loop iteration, check the current circuit state:

+-----------+     threshold     +-----------+     cooldown     +------------+
|  CLOSED   |----exceeded----->|   OPEN    |----elapsed------>| HALF-OPEN  |
|  (normal) |                  |  (halted) |                  |  (probe)   |
+-----------+                  +-----------+                  +-----+------+
     ^                                                              |
     |                          success                             |
     +--------------------------------------------------------------+
     |                          failure                             |
     |                    +-----------+                              |
     +--------------------+   OPEN    |<----------------------------+
                          +-----------+

STOP: Check circuit state BEFORE executing any loop iteration. Do NOT execute if circuit is OPEN.

Phase 2: Stagnation Detection

Monitor these thresholds continuously during autonomous operation:

Stagnation Scoring

Each iteration, compute a progress score:

Threshold: If cumulative score across 3 iterations is negative, OPEN the circuit.

STOP: If any threshold is breached, OPEN the circuit immediately. Do NOT attempt "one more try."

Phase 3: Recovery Protocol

When the circuit opens, follow this recovery sequence:

Cooldown Period

• Default: 30 minutes before retry
• Purpose: Prevents rapid cycling through the same failing state
• After cooldown: Circuit enters HALF-OPEN state

HALF-OPEN Behavior

1. Allow exactly ONE iteration to execute
2. If successful (positive progress score): Close circuit, resume normal operation
3. If failed (same stagnation pattern): Re-open circuit, double the cooldown timer

Recovery Strategy Decision Table

STOP: After recovery, monitor the next 3 iterations closely. If stagnation recurs, escalate immediately.

Phase 4: Rate Limiting

Track and enforce API usage limits:

Rate Limit Behavior

1. Track API calls per rolling hour
2. At 80% of limit: display warning, prioritize remaining calls
3. At 100% of limit: pause execution, display countdown to reset
4. Never exceed limit — wait for reset window

Three-Layer Timeout Detection

For long-running operations (especially API calls with extended limits):

Phase 5: File Protection

Protected Paths

Protection Mechanisms

Pre-Destructive Operation Checklist

Before any rm, git clean, or git checkout.:

1. List all files that will be affected
2. Check each against the protected paths list
3. If ANY protected file would be affected: ABORT and report
4. If safe: proceed with caution
5. After operation: verify all protected files still exist

STOP: If a protected file is missing after any operation, halt immediately and restore it.

Phase 6: Monitoring and Metrics

Track these metrics across loop iterations:

Per-Iteration Status Log

## Iteration [N] — [timestamp]
- Circuit state: CLOSED / HALF-OPEN
- Tasks completed: [N]
- Files modified: [list]
- Tests: [X passed, Y failed, Z skipped]
- Errors encountered: [list]
- Progress score: [+/- N]
- API calls remaining: [N]
- Stagnation risk: LOW / MEDIUM / HIGH

Anti-Patterns / Common Mistakes

Anti-Rationalization Guards

Do NOT override an open circuit. Follow the recovery protocol.

Integration Points

Scope Clarification

The circuit breaker activates AFTER resilient-execution has exhausted its retries within individual tasks. If tasks keep failing despite 3 retries each, the circuit breaker detects the pattern.

Process Summary

1. Before each loop iteration: Check circuit state (CLOSED/HALF-OPEN/OPEN)
2. If OPEN: Report status, wait for cooldown, or escalate
3. If HALF-OPEN: Allow one probe iteration, evaluate result
4. If CLOSED: Execute normally, monitor all thresholds
5. After each iteration: Update metrics, compute progress score, evaluate thresholds
6. If threshold exceeded: Open circuit, report reason, begin cooldown
7. After cooldown: Enter HALF-OPEN, allow one probe
8. After probe: Close if successful, re-open with doubled cooldown if failed

Skill Type

RIGID — Thresholds and protection rules must be followed exactly. Do not relax circuit breaker conditions. Do not override open circuits. Do not skip file protection checks. Do not ignore stagnation signals.