@dst-justin/relay 2.2.7 → 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,14 @@ 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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dst-justin/relay",
-  "version": "2.2.7",
+  "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() {
@@ -354,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)
 
@@ -568,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() {
@@ -828,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():
@@ -917,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:
@@ -960,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
@@ -1026,6 +1227,18 @@ 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))
@@ -1060,6 +1273,9 @@ 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
 
@@ -1233,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}"
 
@@ -1541,6 +1765,202 @@ 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"
@@ -1758,6 +2178,12 @@ cmd_help() {
   printf "  %-32s %s\n" "  relay autoswitch config"   "set up auto-switching"
   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"
@@ -1800,6 +2226,7 @@ case "${CMD}" in
   autoswitch|as)    cmd_autoswitch "$@" ;;
   lock)             cmd_lock "$@" ;;
   unlock)           cmd_unlock "$@" ;;
+  warmup)           cmd_warmup "$@" ;;
   version|--version|-V) cmd_version ;;
   update)           cmd_update ;;
   install)          cmd_install ;;