@dst-justin/relay 2.2.6 → 2.3.0

package/README.md

@@ -166,6 +166,10 @@ Prefix commands with `!` to run them inline:
 | `relay autoswitch stop` | Stop and remove daemon |
 | `relay autoswitch status` | Daemon state and per-account thresholds |
 | `relay autoswitch log` | Recent auto-switch history |
+| `relay warmup add <account> <HH:MM>` | Schedule an account warmup time |
+| `relay warmup remove <account> [HH:MM]` | Remove one or all warmup times for an account |
+| `relay warmup list` | Show configured warmup schedules |
+| `relay warmup pause` / `relay warmup resume` | Temporarily pause or resume warmups |
 
 ## Autoswitch
 
@@ -194,6 +198,34 @@ relay autoswitch status   # verify it's running
 - Manual switches (`!relay work`) are respected until that account hits its threshold.
 - If all accounts are over threshold, relay switches to the least-used one.
 
+## Warmup
+
+Warmup runs a real, non-interactive `claude -p ping` call to Anthropic's API on your machine in the background at the scheduled time — it does not send your credentials anywhere, and it does not increase your weekly usage cap. It only starts your rolling 5-hour usage window earlier.
+
+Use warmup when you want an account's 5-hour usage window to start before you sit down to work.
+
+```bash
+relay warmup add <account> <HH:MM>     # e.g. relay warmup add work 06:00
+relay warmup remove <account> [HH:MM]
+relay warmup list
+relay warmup pause
+relay warmup resume
+```
+
+Warmup requires the autoswitch daemon to be running (`relay autoswitch start`) to actually fire. `relay warmup add` warns if the daemon is not running.
+
+**Config shape** (`~/.claude-relay/autoswitch.json`):
+
+```json
+{
+  "warmup_enabled": true,
+  "warmup": [
+    { "account": "work", "time": "06:00" },
+    { "account": "personal", "time": "08:30" }
+  ]
+}
+```
+
 ## How It Works
 
 relay stores a snapshot of each account's OAuth credentials in `~/.claude-relay/credentials/`. Switching writes the target account's credentials back into the store that Claude Code reads from.
@@ -223,6 +255,21 @@ Sessions live in `~/.claude/projects/` and are shared across all accounts — af
 
 ## Changelog
 
+### v2.3.0 — 2026-07-10
+- Add scheduled warmup: `relay warmup add/remove/list/pause/resume` to pre-warm a 5hr session at set times
+- Daemon warmup engine (`check_warmup`/`do_warmup`) fires scheduled warmups; always pings (`claude -p ping`) on fire rather than skipping when the account looks "already active" — an idle-overnight account was silently missing its pre-warm
+- Daemon now records the resolved `claude` binary path at autoswitch start, so it can find it regardless of the daemon's runtime PATH
+- Add warmup health warning to `relay status`
+- Fix: unify the cross-process credential lock across bash and Python — the bash mkdir-based fallback (used on macOS, which lacks `flock(1)`) never actually synchronized against the daemon's `fcntl.flock()`, defeating the lock's purpose; also fixes a TOCTOU race in token refresh where the current-account file was read before the lock was acquired
+- Refactor: atomic JSON writes for the daemon usage cache, preventing corruption from concurrent writes
+
+### v2.2.7 — 2026-07-05
+- `relay lock <name>` / `relay unlock <name>`: lock an account so it won't be cycled back to when over its usage threshold
+- `relay lock` (no args): show locked accounts
+- Autoswitch daemon now auto-enables with default 80% threshold when 2+ accounts exist — no config required
+- Cycling follows `order` sequence; locked+over-threshold accounts are skipped; if all candidates are blocked, stays on current account and notifies
+- Lock badge (🔒) shown in `relay list` and `relay autoswitch status`
+
 ### v2.2.6 — 2026-07-04
 - `relay status -f` / `relay status --follow`: live-refresh current account status, same 30-second interval as `relay list -f`
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dst-justin/relay",
-  "version": "2.2.6",
+  "version": "2.3.0",
   "description": "Multi-account switcher for Claude Code — instant credential swap across macOS, Linux, and Windows",
   "bin": {
     "relay": "./relay.js"

package/relay

@@ -12,6 +12,7 @@ RELAY_DIR="${HOME}/.claude-relay"
 CREDS_STORE="${RELAY_DIR}/credentials"
 META_STORE="${RELAY_DIR}/meta"
 CURRENT_FILE="${RELAY_DIR}/current"
+ORDER_FILE="${RELAY_DIR}/order"
 UPDATE_CACHE="${RELAY_DIR}/.update_cache"
 CLAUDE_DIR="${HOME}/.claude"
 CLAUDE_JSON="${HOME}/.claude.json"
@@ -59,6 +60,36 @@ warn() { printf "  ${YL}⚠${R} %s\n" "$*"; }
 err()  { printf "  ${RD}✗${R} %s\n" "$*" >&2; }
 hdr()  { printf "\n${B}${MG}  %s${R}\n  ${D}─────────────────────────────────────${R}\n" "$*"; }
 
+with_credential_lock() {
+  local lockfile="${RELAY_DIR}/credential.lock"
+  local ready_fifo="${TMPDIR:-/tmp}/relay-lock-ready.$$"
+  local release_fifo="${TMPDIR:-/tmp}/relay-lock-release.$$"
+  if ! mkfifo "${ready_fifo}" "${release_fifo}" 2>/dev/null; then
+    "$@"
+    return $?
+  fi
+
+  "${PY}" -c '
+import fcntl, sys
+lockfile, ready_fifo, release_fifo = sys.argv[1], sys.argv[2], sys.argv[3]
+with open(lockfile, "a") as f:
+    fcntl.flock(f, fcntl.LOCK_EX)
+    open(ready_fifo, "w").close()
+    open(release_fifo, "r").read()
+' "${lockfile}" "${ready_fifo}" "${release_fifo}" &
+  local holder_pid=$!
+
+  : < "${ready_fifo}"
+
+  "$@"
+  local status=$?
+
+  : > "${release_fifo}"
+  wait "${holder_pid}" 2>/dev/null
+  rm -f "${ready_fifo}" "${release_fifo}"
+  return "${status}"
+}
+
 mkdir -p "${CREDS_STORE}" "${META_STORE}" "${CLAUDE_DIR}"
 chmod 700 "${RELAY_DIR}" "${CREDS_STORE}" 2>/dev/null || true
 
@@ -69,13 +100,45 @@ account_creds()  { echo "${CREDS_STORE}/$1.json"; }
 account_meta()   { echo "${META_STORE}/$1"; }
 account_exists() { [[ -f "$(account_creds "$1")" ]]; }
 
-# list accounts sorted, one per line (bash 3.2 compatible)
+# list accounts in canonical add-order, one per line (bash 3.2 compatible).
+# Self-healing: drops names whose credential file is gone, appends any
+# credential file not yet tracked (alphabetically), and rewrites ORDER_FILE.
 list_account_names() {
-  local f
-  for f in "${CREDS_STORE}"/*.json; do
-    [[ -f "${f}" ]] || continue
-    basename "${f}" .json
-  done | sort
+  local on_disk=() name f
+
+  while IFS= read -r name; do
+    on_disk+=("${name}")
+  done < <(for f in "${CREDS_STORE}"/*.json; do [[ -f "${f}" ]] || continue; basename "${f}" .json; done | sort)
+
+  local ordered=()
+  if [[ -f "${ORDER_FILE}" ]]; then
+    local existing already
+    while IFS= read -r name; do
+      [[ -z "${name}" ]] && continue
+      account_exists "${name}" || continue
+      already=0
+      for existing in ${ordered[@]+"${ordered[@]}"}; do
+        [[ "${existing}" == "${name}" ]] && { already=1; break; }
+      done
+      [[ "${already}" -eq 0 ]] && ordered+=("${name}")
+    done < "${ORDER_FILE}"
+  fi
+
+  local acct tracked
+  for acct in ${on_disk[@]+"${on_disk[@]}"}; do
+    tracked=0
+    for name in ${ordered[@]+"${ordered[@]}"}; do
+      [[ "${name}" == "${acct}" ]] && { tracked=1; break; }
+    done
+    [[ "${tracked}" -eq 0 ]] && ordered+=("${acct}")
+  done
+
+  if [[ ${#ordered[@]} -gt 0 ]]; then
+    printf '%s\n' "${ordered[@]}" > "${ORDER_FILE}"
+    printf '%s\n' "${ordered[@]}"
+  else
+    : > "${ORDER_FILE}"
+  fi
 }
 
 account_by_index() {
@@ -136,6 +199,14 @@ mode, creds_dir, meta_dir, current = sys.argv[1], sys.argv[2], sys.argv[3], sys.
 no_usage = '--no-usage' in sys.argv
 relay_dir = os.path.dirname(creds_dir)
 cache_file = os.path.join(relay_dir, 'usage_cache.json')
+
+# Load locks from autoswitch config (best-effort, no error if missing)
+_locks = []
+try:
+    _as_cfg = json.load(open(os.path.join(relay_dir, 'autoswitch.json')))
+    _locks = _as_cfg.get('locks', [])
+except Exception:
+    pass
 CACHE_TTL = 120  # seconds
 
 R='\033[0m'; B='\033[1m'; D='\033[2m'
@@ -316,7 +387,8 @@ if mode == 'quick':
         ncol = GR + B if cur else B
         email = get_email(name)
         u = u5_str(usage.get(name)) if not no_usage else ''
-        print(f'  {marker}  {ncol}{name:<12}{R}  {D}{email:<26}{R}  {u}')
+        lock_badge = f' {YL}🔒{R}' if name in _locks else ''
+        print(f'  {marker}  {ncol}{name:<12}{R}  {D}{email:<26}{R}  {u}{lock_badge}')
     print()
     print(f'  {D}switch:{R} {CY}!relay <index or name>{R}   {D}details:{R} {CY}!relay status{R}')
     print()
@@ -331,8 +403,9 @@ else:
         d = usage.get(name)
         u5 = u5_str(d) if not no_usage else '—'
         u7 = u7_str(d, name) if not no_usage else '—'
+        lock_badge = f' {YL}🔒{R}' if name in _locks else ''
         # ANSI codes don't consume display width — pad manually for alignment
-        print(f'  {marker} {D}{i:<2}{R}{ncol}{name:<12}{R} {email:<28} {u5:<52} {u7}')
+        print(f'  {marker} {D}{i:<2}{R}{ncol}{name:<12}{R} {email:<28} {u5:<52} {u7}{lock_badge}')
     print()
     n_warn = sum(1 for d in usage.values() if isinstance(d, dict) and (d.get('five_hour') or {}).get('utilization', 0) >= 80)
     if n_warn:
@@ -344,6 +417,10 @@ EOF
 # Core switch logic
 # ══════════════════════════════════════════════════════════════════
 do_switch() {
+  with_credential_lock _do_switch_locked "$@"
+}
+
+_do_switch_locked() {
   local name="$1"
   local current; current=$(current_name)
 
@@ -558,6 +635,56 @@ cmd_status() {
   _cmd_status_once
   _check_update_bg
   _show_update_notice
+
+  # Warmup health (only prints when relevant — silent otherwise)
+  if [[ -f "${RELAY_DIR}/autoswitch.json" ]] && [[ -f "${RELAY_DIR}/autoswitch.log" ]]; then
+    "${PY}" - "${RELAY_DIR}/autoswitch.json" "${RELAY_DIR}/autoswitch.log" <<'PYEOF'
+import json, sys
+from collections import defaultdict
+
+cfg_path, log_path = sys.argv[1], sys.argv[2]
+try:
+    cfg = json.load(open(cfg_path))
+except Exception:
+    sys.exit(0)
+entries = cfg.get('warmup', [])
+if not entries:
+    sys.exit(0)
+
+counts = defaultdict(lambda: {'total': 0, 'bad': 0})
+try:
+    with open(log_path) as f:
+        lines = f.readlines()[-2000:]
+except Exception:
+    lines = []
+
+for line in lines:
+    try:
+        rec = json.loads(line)
+    except Exception:
+        continue
+    ev = rec.get('event')
+    if ev == 'warmup_missed':
+        key = f"{rec.get('account')}|{rec.get('time')}"
+        counts[key]['total'] += 1
+        counts[key]['bad'] += 1
+    elif ev == 'warmup_ping':
+        acct = rec.get('account')
+        for e in entries:
+            if e.get('account') == acct:
+                key = f"{acct}|{e.get('time')}"
+                counts[key]['total'] += 1
+                if not rec.get('ok'):
+                    counts[key]['bad'] += 1
+
+R='\033[0m'; YL='\033[33m'
+for e in entries:
+    key = f"{e.get('account')}|{e.get('time')}"
+    c = counts.get(key)
+    if c and c['total'] >= 3 and c['bad'] >= 3:
+        print(f"  {YL}⚠ warmup: {e.get('account')} {e.get('time')} missed {c['bad']}/{c['total']} recent{R}")
+PYEOF
+  fi
 }
 
 cmd_add() {
@@ -818,17 +945,20 @@ _extract_daemon() {
   cat > "${AUTOSWITCH_DAEMON}" <<'DAEMON_EOF'
 #!/usr/bin/env python3
 """relay autoswitch daemon — runs in background, switches accounts by usage threshold."""
-import json, os, sys, time, datetime, urllib.request, urllib.error, platform, subprocess, signal
+import fcntl, json, os, sys, time, datetime, urllib.request, urllib.error, platform, subprocess, signal, shutil
+from contextlib import contextmanager
 
 RELAY_DIR    = os.path.expanduser('~/.claude-relay')
 CONFIG_FILE  = os.path.join(RELAY_DIR, 'autoswitch.json')
 LOCK_FILE    = os.path.join(RELAY_DIR, 'autoswitch.lock')
+CREDENTIAL_LOCK_FILE = os.path.join(RELAY_DIR, 'credential.lock')
 LOG_FILE     = os.path.join(RELAY_DIR, 'autoswitch.log')
 MANUAL_FILE  = os.path.join(RELAY_DIR, 'manual_switch')
 CURRENT_FILE = os.path.join(RELAY_DIR, 'current')
 CREDS_DIR    = os.path.join(RELAY_DIR, 'credentials')
 CACHE_FILE   = os.path.join(RELAY_DIR, 'usage_cache.json')
 CACHE_TTL    = 120  # seconds — same as render_table
+WARMUP_STATE_FILE = os.path.join(RELAY_DIR, 'warmup_state.json')
 
 # ── lock ──────────────────────────────────────────────────────────
 def write_lock():
@@ -907,27 +1037,107 @@ def kc_write(content):
         with open(live, 'w') as f: f.write(content)
         os.chmod(live, 0o600)
 
+@contextmanager
+def credential_lock():
+    os.makedirs(RELAY_DIR, exist_ok=True)
+    with open(CREDENTIAL_LOCK_FILE, 'w') as f:
+        fcntl.flock(f, fcntl.LOCK_EX)
+        try:
+            yield
+        finally:
+            fcntl.flock(f, fcntl.LOCK_UN)
+
 def do_switch(name):
-    cred = os.path.join(CREDS_DIR, name + '.json')
-    current = open(CURRENT_FILE).read().strip() if os.path.exists(CURRENT_FILE) else ''
-    if current and os.path.exists(os.path.join(CREDS_DIR, current + '.json')):
-        live = kc_read()
-        if live:
-            with open(os.path.join(CREDS_DIR, current + '.json'), 'w') as f: f.write(live)
-    with open(CURRENT_FILE, 'w') as f: f.write(name)
-    content = open(cred).read()
-    kc_write(content)
+    with credential_lock():
+        cred = os.path.join(CREDS_DIR, name + '.json')
+        current = open(CURRENT_FILE).read().strip() if os.path.exists(CURRENT_FILE) else ''
+        if current and os.path.exists(os.path.join(CREDS_DIR, current + '.json')):
+            live = kc_read()
+            if live:
+                with open(os.path.join(CREDS_DIR, current + '.json'), 'w') as f: f.write(live)
+        with open(CURRENT_FILE, 'w') as f: f.write(name)
+        content = open(cred).read()
+        kc_write(content)
+
+def load_warmup_state():
+    try: return json.load(open(WARMUP_STATE_FILE))
+    except: return {}
+
+def save_warmup_state(s):
+    save_json_atomic(WARMUP_STATE_FILE, s)
+
+def get_claude_bin():
+    try:
+        p = open(os.path.join(RELAY_DIR, 'claude_bin')).read().strip()
+        if p and os.path.exists(p): return p
+    except: pass
+    return shutil.which('claude') or 'claude'
+
+def do_warmup(acct):
+    current_before = open(CURRENT_FILE).read().strip() if os.path.exists(CURRENT_FILE) else ''
+    do_switch(acct)
+    log_event('warmup_switch', account=acct)
+    try:
+        r = subprocess.run([get_claude_bin(), '-p', 'ping', '--output-format', 'text'],
+                            capture_output=True, timeout=30)
+        ok = (r.returncode == 0)
+        log_event('warmup_ping', account=acct, ok=ok)
+        notify('relay', f'warmup: {acct} 已完成 5hr session 預熱' if ok
+                         else f'warmup: {acct} ping 失敗')
+        return ok
+    except Exception as e:
+        log_event('warmup_ping', account=acct, ok=False, err=str(e))
+        return False
+    finally:
+        if current_before and current_before != acct and os.path.exists(os.path.join(CREDS_DIR, current_before + '.json')):
+            do_switch(current_before)
+            log_event('warmup_restore', account=current_before)
+
+def check_warmup(entries):
+    if not entries: return
+    state = load_warmup_state()
+    now = datetime.datetime.now()
+    today = now.strftime('%Y-%m-%d')
+    changed = False
+    for entry in entries:
+        acct, hhmm = entry.get('account'), entry.get('time')
+        if not acct or not hhmm: continue
+        key = f'{acct}|{hhmm}'
+        if (state.get(key) or {}).get('date') == today:
+            continue
+        try:
+            h, m = map(int, hhmm.split(':'))
+            scheduled = now.replace(hour=h, minute=m, second=0, microsecond=0)
+        except: continue
+        if now < scheduled:
+            continue
+        if (now - scheduled).total_seconds() > 900:  # 15 min grace window
+            state[key] = {'date': today, 'status': 'missed'}
+            log_event('warmup_missed', account=acct, time=hhmm)
+            changed = True; continue
+        if not os.path.exists(os.path.join(CREDS_DIR, acct + '.json')):
+            log_event('warmup_pending', account=acct, reason='missing_account')
+            continue
+        ok = do_warmup(acct)
+        state[key] = {'date': today, 'status': 'ok' if ok else 'ping_failed'}
+        changed = True
+    if changed: save_warmup_state(state)
 
 # ── usage fetch ───────────────────────────────────────────────────
 def load_cache():
     try: return json.load(open(CACHE_FILE))
     except: return {}
 
-def save_cache(c):
+def save_json_atomic(path, data):
     try:
-        with open(CACHE_FILE, 'w') as f: json.dump(c, f)
+        tmp = path + '.tmp'
+        with open(tmp, 'w') as f: json.dump(data, f)
+        os.replace(tmp, path)
     except: pass
 
+def save_cache(c):
+    save_json_atomic(CACHE_FILE, c)
+
 # ponytail: intentional copy of try_refresh() — daemon is a standalone extracted script
 def try_refresh_daemon(name, cred_path):
     try:
@@ -950,9 +1160,10 @@ def try_refresh_daemon(name, cred_path):
         content = json.dumps(d)
         open(cred_path, 'w').write(content)
         os.chmod(cred_path, 0o600)
-        current = open(CURRENT_FILE).read().strip() if os.path.exists(CURRENT_FILE) else ''
-        if name == current:
-            kc_write(content)  # critical: update keychain so do_switch() doesn't clobber
+        with credential_lock():
+            current = open(CURRENT_FILE).read().strip() if os.path.exists(CURRENT_FILE) else ''
+            if name == current:
+                kc_write(content)  # critical: update keychain so do_switch() doesn't clobber
         return oauth['accessToken']
     except Exception:
         return None
@@ -998,6 +1209,14 @@ def get_utilization(usage_data):
     u = fh.get('utilization')
     return int(u) if u is not None else None
 
+def is_blocked(name, thr_map, locks_list, usage_map):
+    """True if account is locked AND at or over its threshold — skip as switch target."""
+    if name not in locks_list:
+        return False
+    util = get_utilization(usage_map.get(name))
+    threshold = thr_map.get(name, 80)
+    return util is not None and util >= threshold
+
 # ── manual switch protection ───────────────────────────────────────
 def get_manual_switch():
     try: return json.load(open(MANUAL_FILE))
@@ -1008,9 +1227,34 @@ def clear_manual_switch():
     except: pass
 
 # ── main loop ─────────────────────────────────────────────────────
+def load_raw_config():
+    """Read autoswitch.json's raw contents, or {} if missing/corrupt. Used so
+    'warmup' entries work even when load_config()'s auto-default path (which
+    omits 'warmup') would otherwise apply."""
+    try:
+        return json.load(open(CONFIG_FILE))
+    except FileNotFoundError:
+        return {}
+    except Exception as e:
+        log_event('config_parse_error', error=str(e))
+        return {}
+
 def load_config():
-    try: return json.load(open(CONFIG_FILE))
-    except: return None
+    try:
+        return json.load(open(CONFIG_FILE))
+    except:
+        # Auto-default: 2+ accounts → enable with 80% threshold, no explicit config needed
+        if not os.path.isdir(CREDS_DIR):
+            return None
+        accounts = sorted(f[:-5] for f in os.listdir(CREDS_DIR) if f.endswith('.json'))
+        if len(accounts) < 2:
+            return None
+        return {
+            'order': accounts,
+            'thresholds': {a: 80 for a in accounts},
+            'locks': [],
+            'poll': {'low_minutes': 10, 'high_minutes': 2, 'high_threshold': 50}
+        }
 
 def main():
     check_single_instance()
@@ -1029,11 +1273,15 @@ def main():
             last_refresh_ts = time.time()
 
         cfg = load_config()
+        raw_cfg = load_raw_config()
+        if raw_cfg.get('warmup_enabled', True):
+            check_warmup(raw_cfg.get('warmup', []))
         if not cfg:
             time.sleep(60); continue
 
         order = cfg.get('order', [])
         thresholds = cfg.get('thresholds', {})
+        locks = cfg.get('locks', [])
         poll = cfg.get('poll', {})
         low_min   = int(poll.get('low_minutes', 10))
         high_min  = int(poll.get('high_minutes', 2))
@@ -1061,21 +1309,23 @@ def main():
         if cur_threshold is None or cur_util is None or cur_util < cur_threshold:
             time.sleep(sleep_sec); continue
 
-        candidates = [(n, get_utilization(usage.get(n))) for n in order if n != current]
-        under = [(n, u) for n, u in candidates if u is not None and thresholds.get(n) is not None and u < thresholds[n]]
-
-        if under:
-            target, target_util = under[0]
-        else:
-            measured = [(n, u) for n, u in candidates if u is not None]
-            if not measured:
-                time.sleep(sleep_sec); continue
-            target, target_util = min(measured, key=lambda x: x[1])
-            log_event('all_over_threshold', selected=target, usage=target_util)
-            notify('relay', f'All accounts over threshold — switching to {target} ({target_util}%)')
-            do_switch(target)
-            time.sleep(sleep_sec); continue
-
+        # Ordered cycling: walk order[] from current position, skip blocked accounts
+        idx = order.index(current) if current in order else 0
+        target = None
+        for i in range(1, len(order)):
+            candidate = order[(idx + i) % len(order)]
+            if not is_blocked(candidate, thresholds, locks, usage):
+                target = candidate
+                break
+
+        if target is None:
+            # All candidates are locked + over threshold — stay put
+            log_event('all_blocked', current=current)
+            notify('relay', 'All accounts at limit — staying on current account')
+            time.sleep(sleep_sec)
+            continue
+
+        target_util = get_utilization(usage.get(target))
         log_event('switch', frm=current, to=target, usage=cur_util)
         notify('relay', f'switched {current} → {target} ({current} at {cur_util}%)')
         do_switch(target)
@@ -1199,6 +1449,14 @@ cmd_autoswitch_start() {
   }
 
   hdr "autoswitch — start"
+  if [[ -n "${REAL_CLAUDE}" && "${REAL_CLAUDE}" != "$0" ]]; then
+    echo "${REAL_CLAUDE}" > "${RELAY_DIR}/claude_bin"
+  elif [[ -z "${REAL_CLAUDE}" ]]; then
+    warn "claude not found; warmup will fall back to daemon PATH lookup and may fail"
+  else
+    warn "claude resolves to relay wrapper; warmup will fall back to daemon PATH lookup and may fail"
+  fi
+
   _extract_daemon
   log "Daemon extracted to ${AUTOSWITCH_DAEMON}"
 
@@ -1314,6 +1572,7 @@ cfg = json.load(open(sys.argv[1]))
 current = sys.argv[2]
 order = cfg.get('order', [])
 thresholds = cfg.get('thresholds', {})
+locks = cfg.get('locks', [])
 relay_dir = os.path.expanduser('~/.claude-relay')
 cache_file = os.path.join(relay_dir, 'usage_cache.json')
 
@@ -1332,8 +1591,8 @@ def get_util(name):
     u = fh.get('utilization')
     return int(u) if u is not None else None
 
-print(f'  {B}{"order":<4} {"account":<14} {"threshold":<12} {"cached usage":<14}{R}')
-print(f'  {D}{"─"*52}{R}')
+print(f'  {B}{"order":<4} {"account":<14} {"threshold":<12} {"cached usage":<14} {"lock":<6}{R}')
+print(f'  {D}{"─"*58}{R}')
 for i, name in enumerate(order, 1):
     cur = name == current
     marker = f'{GR}●{R}' if cur else ' '
@@ -1353,7 +1612,8 @@ for i, name in enumerate(order, 1):
             for j in range(i-1)
         )
         if prev_over: next_s = f' {CY}← next{R}'
-    print(f'  {marker} {D}{i:<2}{R}{ncol}{name:<14}{R} {thr_s:<12} {util_s}{next_s}')
+    lock_s = f' {YL}🔒{R}' if name in locks else ''
+    print(f'  {marker} {D}{i:<2}{R}{ncol}{name:<14}{R} {thr_s:<12} {util_s}{next_s}{lock_s}')
 
 log_file = os.path.join(os.path.dirname(sys.argv[1]), 'autoswitch.log')
 try:
@@ -1372,6 +1632,8 @@ EOF
   printf "  %-34s %s\n" "  ${CY}relay autoswitch stop${R}"   "stop daemon"
   printf "  %-34s %s\n" "  ${CY}relay autoswitch config${R}" "edit settings"
   printf "  %-34s %s\n" "  ${CY}relay autoswitch log${R}"    "switch history"
+  printf "  %-34s %s\n" "  ${CY}relay lock <name>${R}"       "lock account (skip when over threshold)"
+  printf "  %-34s %s\n" "  ${CY}relay unlock <name>${R}"     "remove lock"
   _show_update_notice
 }
 
@@ -1422,6 +1684,283 @@ cmd_autoswitch() {
   esac
 }
 
+cmd_lock() {
+  local name="${1:-}"
+  local cfg="${RELAY_DIR}/autoswitch.json"
+
+  # No argument: show lock status
+  if [[ -z "${name}" ]]; then
+    hdr "Account locks"
+    if [[ ! -f "${cfg}" ]]; then
+      warn "No autoswitch config. Run: relay autoswitch config"
+      return 0
+    fi
+    "${PY}" - "${cfg}" <<'PYEOF'
+import json, sys
+cfg = json.load(open(sys.argv[1]))
+locks = cfg.get('locks', [])
+R='\033[0m'; B='\033[1m'; D='\033[2m'; YL='\033[33m'
+if not locks:
+    print(f'  {D}No accounts locked.{R}')
+else:
+    for name in locks:
+        print(f'  {YL}🔒{R}  {B}{name}{R}')
+print()
+PYEOF
+    return 0
+  fi
+
+  account_exists "${name}" || { err "Account '${name}' not found"; exit 1; }
+
+  # Ensure config file exists (create auto-default if missing)
+  if [[ ! -f "${cfg}" ]]; then
+    "${PY}" - "${CREDS_STORE}" "${cfg}" <<'PYEOF'
+import json, sys, os
+creds_dir, cfg_path = sys.argv[1], sys.argv[2]
+accounts = sorted(f[:-5] for f in os.listdir(creds_dir) if f.endswith('.json'))
+config = {
+    'order': accounts,
+    'thresholds': {a: 80 for a in accounts},
+    'locks': [],
+    'poll': {'low_minutes': 10, 'high_minutes': 2, 'high_threshold': 50}
+}
+json.dump(config, open(cfg_path, 'w'), indent=2)
+PYEOF
+    ok "Created default autoswitch config: ${cfg}"
+  fi
+
+  "${PY}" - "${cfg}" "${name}" <<'PYEOF'
+import json, sys
+cfg_path, name = sys.argv[1], sys.argv[2]
+cfg = json.load(open(cfg_path))
+locks = cfg.get('locks', [])
+if name in locks:
+    print(f'  already locked: {name}')
+    sys.exit(0)
+locks.append(name)
+cfg['locks'] = locks
+json.dump(cfg, open(cfg_path, 'w'), indent=2)
+PYEOF
+  ok "Locked '${B}${name}${R}' — won't be switched back to when over threshold"
+}
+
+cmd_unlock() {
+  local name="${1:-}"
+  [[ -z "${name}" ]] && { err "usage: relay unlock <name>"; exit 1; }
+  local cfg="${RELAY_DIR}/autoswitch.json"
+  [[ ! -f "${cfg}" ]] && { warn "No autoswitch config — nothing to unlock"; return 0; }
+
+  "${PY}" - "${cfg}" "${name}" <<'PYEOF'
+import json, sys
+cfg_path, name = sys.argv[1], sys.argv[2]
+cfg = json.load(open(cfg_path))
+locks = cfg.get('locks', [])
+if name not in locks:
+    print(f'  not locked: {name}')
+    sys.exit(0)
+locks.remove(name)
+cfg['locks'] = locks
+json.dump(cfg, open(cfg_path, 'w'), indent=2)
+PYEOF
+  ok "Unlocked '${B}${name}${R}'"
+}
+
+cmd_warmup() {
+  local sub="${1:-}"; [[ $# -gt 0 ]] && shift
+  case "${sub}" in
+    add)     cmd_warmup_add "$@" ;;
+    remove|rm) cmd_warmup_remove "$@" ;;
+    list|ls) cmd_warmup_list ;;
+    pause)   cmd_warmup_pause ;;
+    resume)  cmd_warmup_resume ;;
+    test)    cmd_warmup_test "$@" ;;
+    *)       cmd_warmup_list ;;
+  esac
+}
+
+_warmup_ensure_config() {
+  local cfg="${RELAY_DIR}/autoswitch.json"
+  if [[ ! -f "${cfg}" ]]; then
+    "${PY}" - "${CREDS_STORE}" "${cfg}" <<'PYEOF'
+import json, sys, os
+creds_dir, cfg_path = sys.argv[1], sys.argv[2]
+accounts = sorted(f[:-5] for f in os.listdir(creds_dir) if f.endswith('.json')) if os.path.isdir(creds_dir) else []
+config = {
+    'order': accounts,
+    'thresholds': {a: 80 for a in accounts},
+    'locks': [],
+    'poll': {'low_minutes': 10, 'high_minutes': 2, 'high_threshold': 50},
+    'warmup': []
+}
+json.dump(config, open(cfg_path, 'w'), indent=2)
+PYEOF
+  fi
+}
+
+_warmup_daemon_running() {
+  local pid; pid=$(cat "${RELAY_DIR}/autoswitch.lock" 2>/dev/null || echo "")
+  [[ -n "${pid}" ]] && kill -0 "${pid}" 2>/dev/null
+}
+
+_warmup_valid_time() {
+  [[ "$1" =~ ^([0-1][0-9]|2[0-3]):[0-5][0-9]$ ]]
+}
+
+cmd_warmup_add() {
+  local name="${1:-}" hhmm="${2:-}"
+  if [[ -z "${name}" || -z "${hhmm}" ]]; then
+    err "usage: relay warmup add <account> <HH:MM>"
+    exit 1
+  fi
+  account_exists "${name}" || {
+    err "Account '${name}' not found — run 'relay list' to see accounts, or 'relay add ${name}' first"
+    exit 1
+  }
+  _warmup_valid_time "${hhmm}" || {
+    err "Invalid time '${hhmm}' — expected HH:MM, 00:00–23:59 (e.g. 06:00)"
+    exit 1
+  }
+
+  _warmup_ensure_config
+  local cfg="${RELAY_DIR}/autoswitch.json"
+
+  "${PY}" - "${cfg}" "${name}" "${hhmm}" <<'PYEOF'
+import json, sys
+cfg_path, name, hhmm = sys.argv[1], sys.argv[2], sys.argv[3]
+cfg = json.load(open(cfg_path))
+entries = cfg.get('warmup', [])
+if not any(e.get('account') == name and e.get('time') == hhmm for e in entries):
+    entries.append({'account': name, 'time': hhmm})
+cfg['warmup'] = entries
+json.dump(cfg, open(cfg_path, 'w'), indent=2)
+PYEOF
+
+  ok "warmup: ${name} will fire at ${hhmm}"
+  echo "  Warmup runs a real, non-interactive 'claude -p ping' call to Anthropic's API"
+  echo "  on your machine in the background at the scheduled time — it does not send"
+  echo "  your credentials anywhere, and it does not increase your weekly usage cap."
+  echo "  It only starts your rolling 5-hour usage window earlier."
+  if ! _warmup_daemon_running; then
+    warn "background daemon isn't running — this won't fire until you run: relay autoswitch start"
+  fi
+}
+
+cmd_warmup_remove() {
+  local name="${1:-}" hhmm="${2:-}"
+  if [[ -z "${name}" ]]; then
+    err "usage: relay warmup remove <account> [HH:MM]"
+    exit 1
+  fi
+  local cfg="${RELAY_DIR}/autoswitch.json"
+  [[ -f "${cfg}" ]] || { warn "No warmup entries for '${name}'"; return 0; }
+
+  local removed
+  if ! removed=$("${PY}" - "${cfg}" "${name}" "${hhmm}" <<'PYEOF'
+import json, sys
+cfg_path, name, hhmm = sys.argv[1], sys.argv[2], (sys.argv[3] or None)
+cfg = json.load(open(cfg_path))
+entries = cfg.get('warmup', [])
+if hhmm:
+    remaining = [e for e in entries if not (e.get('account') == name and e.get('time') == hhmm)]
+else:
+    remaining = [e for e in entries if e.get('account') != name]
+removed = len(entries) - len(remaining)
+cfg['warmup'] = remaining
+json.dump(cfg, open(cfg_path, 'w'), indent=2)
+print(removed)
+PYEOF
+); then
+    err "Failed to remove warmup entries for '${name}'"
+    return 1
+  fi
+  if [[ "${removed}" -eq 0 ]]; then
+    if [[ -n "${hhmm}" ]]; then
+      warn "No warmup entries for '${name}' at ${hhmm}"
+    else
+      warn "No warmup entries for '${name}'"
+    fi
+    return 0
+  fi
+  ok "Removed warmup entries for '${name}'"
+}
+
+cmd_warmup_list() {
+  local cfg="${RELAY_DIR}/autoswitch.json"
+  hdr "warmup"
+
+  if _warmup_daemon_running; then :; else
+    printf "  ${YL}daemon: not running${R} — run 'relay autoswitch start'\n"
+  fi
+
+  [[ -f "${cfg}" ]] || { warn "No warmup entries. Run: relay warmup add <account> <HH:MM>"; return 0; }
+
+  "${PY}" - "${cfg}" "${RELAY_DIR}/warmup_state.json" <<'PYEOF'
+import json, sys
+cfg = json.load(open(sys.argv[1]))
+if not cfg.get('warmup_enabled', True):
+    print('  \033[33m⏸ warmup paused\033[0m — run \'relay warmup resume\' to re-enable')
+entries = cfg.get('warmup', [])
+if not entries:
+    print('  No warmup entries. Run: relay warmup add <account> <HH:MM>')
+    sys.exit(0)
+try:
+    state = json.load(open(sys.argv[2]))
+except Exception:
+    state = {}
+labels = {
+    'ok': '成功', 'ping_failed': 'ping 失敗', 'missed': '錯過',
+    'missing_account': '帳號不存在',
+}
+for e in entries:
+    acct, hhmm = e.get('account'), e.get('time')
+    rec = state.get(f'{acct}|{hhmm}')
+    if rec:
+        status = labels.get(rec.get('status'), rec.get('status'))
+        print(f"  {acct:<12} {hhmm}   最後: {rec.get('date')} {status}")
+    else:
+        print(f"  {acct:<12} {hhmm}   尚未觸發")
+PYEOF
+}
+
+cmd_warmup_pause() {
+  _warmup_ensure_config
+  local cfg="${RELAY_DIR}/autoswitch.json"
+  "${PY}" - "${cfg}" <<'PYEOF'
+import json, sys
+cfg_path = sys.argv[1]
+cfg = json.load(open(cfg_path))
+cfg['warmup_enabled'] = False
+json.dump(cfg, open(cfg_path, 'w'), indent=2)
+PYEOF
+  ok "warmup paused — entries kept, run 'relay warmup resume' to re-enable"
+}
+
+cmd_warmup_resume() {
+  local cfg="${RELAY_DIR}/autoswitch.json"
+  [[ -f "${cfg}" ]] || { err "No warmup config. Run: relay warmup add <account> <HH:MM> first"; exit 1; }
+  "${PY}" - "${cfg}" <<'PYEOF'
+import json, sys
+cfg_path = sys.argv[1]
+cfg = json.load(open(cfg_path))
+cfg['warmup_enabled'] = True
+json.dump(cfg, open(cfg_path, 'w'), indent=2)
+PYEOF
+  ok "warmup resumed"
+}
+
+cmd_warmup_test() {
+  local name="${1:-}"
+  [[ -z "${name}" ]] && { err "usage: relay warmup test <account>"; exit 1; }
+  account_exists "${name}" || { err "Account '${name}' not found"; exit 1; }
+  hdr "warmup — test"
+  log "Switching to '${name}', pinging, then restoring your current account..."
+  "${PY}" - "${name}" <<'PYEOF'
+import sys, os
+sys.path.insert(0, os.path.expanduser('~/.claude-relay'))
+PYEOF
+  warn "relay warmup test requires the daemon module — run this from an environment where the daemon has been extracted (relay autoswitch start at least once), then re-run this command."
+}
+
 _script_dir() {
   # Resolve symlinks so we find package.json even when installed via npm/symlink
   local src="$0"
@@ -1640,6 +2179,15 @@ cmd_help() {
   printf "  %-32s %s\n" "  relay autoswitch start/stop" "manage background daemon"
   printf "  %-32s %s\n" "  relay autoswitch status"   "daemon state + thresholds"
   echo ""
+  printf "  ${B}Warmup${R}\n"
+  printf "  %-32s %s\n" "  relay warmup add <acct> <HH:MM>" "pre-warm an account's 5hr window daily"
+  printf "  %-32s %s\n" "  relay warmup remove <acct> [HH:MM]" "remove a warmup schedule"
+  printf "  %-32s %s\n" "  relay warmup list"         "show scheduled warmups + last result"
+  printf "  %-32s %s\n" "  relay warmup pause/resume" "suspend/re-enable without deleting"
+  printf "  %-32s %s\n" "  relay lock <name>"         "prevent account from cycling back when over limit"
+  printf "  %-32s %s\n" "  relay unlock <name>"       "remove lock"
+  printf "  %-32s %s\n" "  relay lock"                "show locked accounts"
+  echo ""
   printf "  ${D}switches the OAuth credential (macOS Keychain / Linux ~/.claude/.credentials.json); sessions are shared${R}\n"
   printf "  ${D}after switching: claude -c to resume, claude --resume <id> for a specific session${R}\n\n"
   _check_update_bg
@@ -1676,6 +2224,9 @@ case "${CMD}" in
   rename|mv)        cmd_rename "$@" ;;
   sessions|sess)    cmd_sessions ;;
   autoswitch|as)    cmd_autoswitch "$@" ;;
+  lock)             cmd_lock "$@" ;;
+  unlock)           cmd_unlock "$@" ;;
+  warmup)           cmd_warmup "$@" ;;
   version|--version|-V) cmd_version ;;
   update)           cmd_update ;;
   install)          cmd_install ;;