---

name: self-arrest description: Session-limit self-protection for long-running solo sessions — arm a silent usage watcher that fires only when the 5h session window is ≥80% used AND projected to run out before its rollover; then checkpoint cleanly, lie flat, and auto-wake when the window resets. Use at the start of any long solo session, or invoke mid-session when limit pressure is suspected. NOT needed under /coordinate (the coordinator's autothrottle owns slot pressure there). argument-hint: [optional: path of the artifact file you update while working]

/self-arrest — checkpoint, lie flat, wake at the session reset

The account's REAL limits are queryable (no self-counting): .claude/tools/coordination/Get-AccountUsage.ps1 hits the OAuth usage endpoint and returns session (5h) + weekly utilization with reset times. This skill wraps it into a self-protection loop for a session with no coordinator watching over it.

Arm (once, at session start or on invocation)

1. Pick your activity file — a file you naturally keep updating while working (your plan/implementation artifact under plans/, or the file named in $ARGUMENTS). The watcher self-expires ~90 min after it goes stale, so it can never outlive your actual work.

2. Start the watcher as a persistent Monitor (silent until it matters):

   Monitor(command: "pwsh -NoProfile -File '.claude/tools/coordination/Watch-AccountUsage.ps1' -SelfArrestMode -ActivityFile '<your artifact>'",
           description: "self-arrest watch (session-limit projection)",
           persistent: true)
   

   It probes every 10 min and emits at most ONE line: SELF-ARREST session=X% projected=Y% resets=HH:mm (in N min) — only when usage is ≥80% AND the burn-rate projection says the window overshoots the account tier's landing target before its rollover (or usage hits the tier hard pause — landing target + 2, capped 97% — outright). Below 80% it never fires, whatever the burn rate. Landing targets are tier-resolved: 95% max_20x · 90% max_5x/premium team · 80% pro/normal team.

On the SELF-ARREST event

Work TO A SAFE POINT, never past it — the arrest exists to avoid the mid-flight limit hit and its rebuild cost:

1. Checkpoint: finish the current atomic step only. Commit WIP on your branch (checkpoint: <state> — self-arrest at <pct>%), then write SELF_ARREST_RESUME.md next to your plan artifact: what was in progress, exact next step, any volatile context a fresh read of the files would miss.

2. Announce: one short message to the user — arrested at X%, window resets HH:mm, auto-wake armed.

3. Arm the wake (single-notification background timer, +3 min buffer past reset):

   PowerShell(command: "$t=[DateTimeOffset]::Parse('<resets_at ISO from the event/state file>').AddMinutes(3); while([DateTimeOffset]::Now -lt $t){Start-Sleep 30}; 'SESSION WINDOW RESET — resume from SELF_ARREST_RESUME.md'",
              run_in_background: true)
   

4. Lie flat: no dispatches, no reads, no polling until the wake notification. The session limit fully resets at the rollover — waiting is free; hitting the wall is not.

On wake

Re-probe once (Get-AccountUsage.ps1) to confirm the fresh window, delete/absorb SELF_ARREST_RESUME.md into your normal artifact, re-arm the watcher, resume.

Boundaries

• Under /coordinate, do NOT arm this — the coordinator runs the slot-throttling variant of the same watcher and owns pacing; wave drivers never self-arrest (they are short-lived and the coordinator budgets for them).
• Weekly-limit pressure is deliberately NOT handled here (it moves slowly; it is a user/coordinator decision — see the bands in Get-ThrottleAdvice.ps1).
• Stop the watcher (TaskStop) when your task completes before any arrest — don't rely solely on the idle self-expiry.