@carjms/codexswitch 0.3.5 → 0.5.0

package/README.ko.md

@@ -205,13 +205,17 @@ cxs list                # 계정별 5h/week 사용량 % 확인
 | `cxs add-key <이름> [키]` | OpenAI API 키 계정 등록 (키 생략 시 `$OPENAI_API_KEY` 사용) |
 | `cxs list` | 계정 목록: 활성 표시, 이메일, 플랜, 우선순위, 한도 상태, 사용량 % |
 | `cxs usage [이름]` | 계정별 사용량 대시보드: 5시간/주간 게이지 바, 리셋 카운트다운, 다음 로테이션 계정 (별칭: `status`) |
+| `cxs chat` | **대화형 입력창 (Claude Code 스타일)**: 매 턴이 로테이션을 거치고 같은 codex 세션을 이어가므로, 계정이 바뀌어도 대화가 유지됨. 내부 명령: `/usage /use /next /model /new /quit` |
+| `cxs watch` | 실시간 인터랙티브 대시보드 — 5초마다 갱신; 키: `↑/↓` 선택, `s` 전환, `e` 활성/비활성, `p` 프로브, `q` 종료 |
+| `cxs probe [이름]` | 계정마다 최소 요청 1회를 보내 사용량 게이지 워밍업 (토큰 소량 소모) |
+| `cxs log [개수]` | 최근 활동 기록: 계정 전환, 한도 도달, 로테이션, 프로브 |
 | `cxs use <이름>` | 활성 계정 전환 |
 | `cxs current` | 현재 활성 계정 확인 |
 | `cxs next` | 설정된 순서의 다음 계정으로 전환 (끝에 오면 처음으로 순환) |
 | `cxs run [이름] [인자...]` | 전환 없이 특정 계정으로 codex 실행 (격리 환경) |
 | `cxs exec [인자...]` | `codex exec` + 한도 도달 시 순서대로 자동 로테이션 — 다음 계정이 같은 세션을 이어받음. git 저장소가 아닌 폴더에서도 동작 |
 | `cxs exec -a <이름> ...` | 특정 계정부터 exec 시작 (`--no-resume`: 이어받기 대신 처음부터 재시도) |
-| `cxs order [이름들...]` | 로테이션 순서를 한 번에 설정 (인자 없으면 현재 순서 표시) |
+| `cxs order [이름들...]` | 로테이션 순서 고정(pin); 나열하지 않은 계정은 **주간 리셋이 빠른 순**으로 자동 소진 (use-or-lose) |
 | `cxs model [모델명]` | `run`/`exec`에 자동 적용할 기본 모델 설정 (`default`로 초기화) |
 | `cxs threshold [5h%] [주간%]` | 사용량이 이 퍼센트에 도달하면 다음 계정으로 전환 (기본 95, 값 하나면 둘 다) |
 | `cxs patterns [add/remove]` | 한도 감지에 쓸 커스텀 정규식 패턴 추가/삭제 |
@@ -222,7 +226,7 @@ cxs list                # 계정별 5h/week 사용량 % 확인
 | `cxs remove <이름>` | 계정 삭제 |
 | `cxs rename <옛이름> <새이름>` | 계정 이름 변경 |
 | `cxs disable / enable <이름>` | 로테이션에서 임시 제외 / 복귀 |
-| `cxs priority <이름> <숫자>` | 계정 하나의 우선순위만 변경 (낮을수록 먼저, 기본 0) |
+| `cxs priority <이름> <숫자\|auto>` | 계정 하나의 순위 고정, `auto`면 고정 해제(리셋 빠른 순 자동 로테이션) |
 | `cxs clear-limit <이름>` | 기록된 한도 상태 수동 해제 |
 | `cxs cooldown [분]` | 한도 감지 시 기본 대기 시간 조회/설정 (기본 60분) |
 | `cxs sync` | codex가 갱신한 토큰을 저장소에 반영 |

package/README.md

@@ -207,13 +207,17 @@ cxs list                # per-account 5h/week usage columns
 | `cxs add-key <name> [key]` | Register an OpenAI API-key account (falls back to `$OPENAI_API_KEY`) |
 | `cxs list` | List accounts: active marker, email, plan, priority, limit status, usage % |
 | `cxs usage [name]` | Per-account usage dashboard: 5h/weekly gauge bars, reset countdowns, next rotation pick (alias: `status`) |
+| `cxs chat` | **Interactive prompt loop (Claude Code-style)**: each turn runs through rotation and resumes the same codex session, so the conversation survives account switches. Slash commands inside: `/usage /use /next /model /new /quit` |
+| `cxs watch` | Live interactive dashboard — refreshes every 5s; keys: `↑/↓` select, `s` switch, `e` enable/disable, `p` probe, `q` quit |
+| `cxs probe [name]` | Warm up the usage gauges with one minimal request per account (costs a few tokens) |
+| `cxs log [count]` | Recent activity: account switches, limits hit, rotations, probes |
 | `cxs use <name>` | Switch the active account |
 | `cxs current` | Show the active account |
 | `cxs next` | Switch to the next account in rotation order (wraps around) |
 | `cxs run [name] [args...]` | Run codex as a specific account without switching (isolated env) |
 | `cxs exec [args...]` | `codex exec` + automatic rotation on usage limits — the next account resumes the same session; works outside git repos |
 | `cxs exec -a <name> ...` | Start exec with a specific account (`--no-resume`: restart instead of resuming) |
-| `cxs order [names...]` | Set the rotation order in one command (no args: show it) |
+| `cxs order [names...]` | Pin the rotation order; unlisted accounts rotate by **soonest weekly reset** (use-or-lose) |
 | `cxs model [name]` | Set the default model injected into `run`/`exec` (`default` to reset) |
 | `cxs threshold [5h%] [wk%]` | Rotate to the next account when usage reaches these percents (default 95; one value sets both) |
 | `cxs patterns [add/remove]` | Custom regex patterns treated as rate-limit errors |
@@ -224,7 +228,7 @@ cxs list                # per-account 5h/week usage columns
 | `cxs remove <name>` | Delete an account |
 | `cxs rename <old> <new>` | Rename an account |
 | `cxs disable / enable <name>` | Temporarily exclude from / restore to rotation |
-| `cxs priority <name> <n>` | Change one account's priority (lower = preferred, default 0) |
+| `cxs priority <name> <n\|auto>` | Pin one account's priority, or `auto` to unpin (use-or-lose rotation) |
 | `cxs clear-limit <name>` | Manually clear a recorded rate-limit |
 | `cxs cooldown [minutes]` | Show/set the default cooldown after a limit is detected (default 60) |
 | `cxs sync` | Save tokens refreshed by codex back into the store |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@carjms/codexswitch",
-  "version": "0.3.5",
+  "version": "0.5.0",
   "description": "Multi-account manager for OpenAI Codex CLI with quota-based rotation (inspired by KarpelesLab/teamclaude)",
   "license": "MIT",
   "repository": {

package/src/cli.js

@@ -17,6 +17,10 @@ Accounts
   list                    list stored accounts (alias: accounts)
   usage [name]            per-account 5h/weekly usage gauges with reset times
                           (alias: status)
+  watch                   live usage dashboard, refreshes every 5s (q to quit)
+  probe [name]            warm up quota gauges with a minimal request per
+                          account (costs a few tokens; alias: warmup)
+  log [count]             recent activity: switches, limits, rotations
   use <name>              make <name> the active account in ~/.codex
   current                 show the active account
   next                    switch to the next account in rotation order (wraps around)
@@ -24,11 +28,16 @@ Accounts
   rename <old> <new>      rename a stored account
   enable <name>           re-enable a disabled account
   disable <name>          temporarily exclude an account from rotation
-  order [name...]         show or set the rotation order in one command
-  priority <name> <n>     set one account's priority (lower = preferred, default 0)
+  order [name...]         pin the rotation order in one command; accounts not
+                          listed rotate by soonest weekly reset (use-or-lose)
+  priority <name> <n|auto>  pin one account's priority, or "auto" to unpin
   clear-limit <name>      forget a recorded rate-limit for an account
 
 Running codex
+  chat                    interactive prompt loop (Claude Code-style): each turn
+                          runs through rotation and resumes the same session,
+                          so the conversation survives account switches
+                          (/usage /use /next /model /new /quit inside)
   run [name] [args...]    run codex as <name> (or active account) in an isolated
                           per-account CODEX_HOME; config/sessions are shared
   exec [args...]          run "codex exec ..." and auto-rotate through accounts in
@@ -86,7 +95,7 @@ function storeAccount(name, auth) {
   const existed = store.accountExists(name);
   store.writeAccountAuth(name, auth);
   const meta = store.loadMeta();
-  if (!meta.accounts[name]) meta.accounts[name] = { priority: 0, addedAt: Date.now() };
+  if (!meta.accounts[name]) meta.accounts[name] = { addedAt: Date.now() };
   // fresh credentials fix whatever got the account disabled or limited
   delete meta.accounts[name].disabled;
   delete meta.accounts[name].limitedUntil;
@@ -162,7 +171,7 @@ function cmdList() {
       a.active ? ui.bold(a.name) : a.name,
       ui.dim(a.email || '-'),
       a.plan,
-      a.priority,
+      a.priority == null ? ui.dim('auto') : a.priority,
       status,
       pct(a.usage && a.usage.p5h, meta.threshold5h),
       pct(a.usage && a.usage.weekly, meta.thresholdWeekly),
@@ -182,9 +191,10 @@ function cmdUse(args) {
   writeJSONAtomic(p.authPath, auth, 0o600);
   const meta = store.loadMeta();
   meta.active = name;
-  if (!meta.accounts[name]) meta.accounts[name] = { priority: 0 };
+  if (!meta.accounts[name]) meta.accounts[name] = {};
   meta.accounts[name].lastUsed = Date.now();
   store.saveMeta(meta);
+  store.logEvent('switch', `now using "${name}"`);
   const info = authInfo(auth);
   out(ui.ok(`now using ${ui.bold(`"${name}"`)}${info.email ? ui.dim(` (${info.email}, ${info.plan || 'unknown plan'})`) : ''}`));
 }
@@ -271,10 +281,18 @@ function setFlag(name, patch) {
 
 function cmdPriority(args) {
   const name = requireArg(args, 0, 'account name');
-  const n = parseInt(requireArg(args, 1, 'priority number'), 10);
-  if (Number.isNaN(n)) throw new Error('priority must be a number');
+  const value = requireArg(args, 1, 'priority number or "auto"');
+  if (value === 'auto') {
+    const meta = store.loadMeta();
+    if (meta.accounts[name]) delete meta.accounts[name].priority;
+    store.saveMeta(meta);
+    out(ui.ok(`"${name}" unpinned — rotates by soonest weekly reset (use-or-lose)`));
+    return;
+  }
+  const n = parseInt(value, 10);
+  if (Number.isNaN(n)) throw new Error('priority must be a number or "auto"');
   setFlag(name, { priority: n });
-  out(`priority of "${name}" set to ${n}`);
+  out(ui.ok(`priority of "${name}" pinned to ${n}`));
 }
 
 function cmdCooldown(args) {
@@ -317,13 +335,16 @@ function cmdOrder(args) {
   for (const name of args) {
     meta.accounts[name] = { ...(meta.accounts[name] || {}), priority: prio++ };
   }
+  // accounts not listed become "auto" and rotate by soonest weekly reset
   for (const a of accounts) {
     if (args.includes(a.name)) continue;
-    meta.accounts[a.name] = { ...(meta.accounts[a.name] || {}), priority: prio++ };
+    if (meta.accounts[a.name]) delete meta.accounts[a.name].priority;
   }
   store.saveMeta(meta);
-  out('rotation order set:');
-  store.listAccounts().forEach((a, i) => out(`${i + 1}. ${a.name}`));
+  out(ui.ok('rotation order set:'));
+  store.listAccounts().forEach((a, i) =>
+    out(`${i + 1}. ${a.name}${a.priority == null ? ui.dim(' (auto)') : ''}`)
+  );
 }
 
 function cmdModel(args) {
@@ -343,47 +364,195 @@ function cmdModel(args) {
   out(`default model set to "${meta.model}" (applied to run/exec)`);
 }
 
-// Per-account usage dashboard: gauge bars for the 5h / weekly windows with
-// reset countdowns, based on what codex recorded in its session files.
-function cmdUsage(args) {
-  const meta = store.loadMeta();
-  let accounts = store.listAccounts();
-  if (args[0]) {
-    accounts = accounts.filter((a) => a.name === args[0]);
-    if (accounts.length === 0) throw new Error(`no such account: ${args[0]}`);
-  }
-  if (accounts.length === 0) {
-    out('no accounts yet — add one with "codexswitch login" or "codexswitch import"');
-    return;
-  }
+// Render the per-account usage view (gauge bars for the 5h / weekly windows
+// with reset countdowns). `cursor` marks the selected row in watch mode.
+function usageLines(accounts, meta, { cursor = -1 } = {}) {
   const now = Date.now();
+  const lines = [];
   const bar = (pct, threshold) => {
     const width = 20;
     const filled = Math.max(0, Math.min(width, Math.round((pct / 100) * width)));
     const paint = pct >= threshold ? ui.red : pct >= 70 ? ui.yellow : ui.green;
     return `[${paint('█'.repeat(filled))}${ui.dim('░'.repeat(width - filled))}]`;
   };
-  const line = (label, win, threshold) => {
+  const gauge = (label, win, threshold) => {
     if (!win || typeof win.pct !== 'number') return `  ${label} ${ui.dim('no data')}`;
     const pct = Math.round(win.pct);
     const reset = win.resetAt && win.resetAt > now ? ` resets in ${fmtRemaining(win.resetAt)}` : '';
     const overMark = win.pct >= threshold ? ` ${ui.red(`≥ threshold ${threshold}%`)}` : '';
     return `  ${label} ${bar(win.pct, threshold)} ${String(pct).padStart(3)}%${ui.dim(reset)}${overMark}`;
   };
-  for (const a of accounts) {
+  accounts.forEach((a, i) => {
+    const sel = i === cursor ? ui.cyan('▶') : ' ';
     const mark = a.active ? ui.green('●') : ' ';
     const state = a.disabled ? ui.red(' [disabled]') : a.limitedUntil && a.limitedUntil > now ? ui.yellow(` [limited ${fmtRemaining(a.limitedUntil)}]`) : '';
-    out(`${mark} ${ui.bold(a.name)}${ui.dim(` (${a.plan || a.email || '-'})`)}${state}`);
+    lines.push(`${cursor >= 0 ? sel : ''}${mark} ${ui.bold(a.name)}${ui.dim(` (${a.plan || a.email || '-'})`)}${state}`);
     if (!a.usage) {
-      out(ui.dim('  no usage data yet — codex records it during runs (try "codexswitch run" once)'));
+      lines.push(ui.dim('  no usage data yet — codex records it during runs (try "codexswitch run" once)'));
     } else {
-      out(line('5h    ', a.usage.p5h, meta.threshold5h));
-      out(line('weekly', a.usage.weekly, meta.thresholdWeekly));
-      if (a.usage.at) out(ui.dim(`  measured ${fmtDate(a.usage.at)}`));
+      lines.push(gauge('5h    ', a.usage.p5h, meta.threshold5h));
+      lines.push(gauge('weekly', a.usage.weekly, meta.thresholdWeekly));
+      if (a.usage.at) lines.push(ui.dim(`  measured ${fmtDate(a.usage.at)}`));
     }
-  }
+  });
   const next = store.pickAccount();
-  out(ui.dim(`\nrotation would pick: ${next ? next.name : '(none usable)'} · threshold 5h ${meta.threshold5h}% / weekly ${meta.thresholdWeekly}%`));
+  lines.push(ui.dim(`\nrotation would pick: ${next ? next.name : '(none usable)'} · threshold 5h ${meta.threshold5h}% / weekly ${meta.thresholdWeekly}%`));
+  return lines;
+}
+
+function cmdUsage(args) {
+  const meta = store.loadMeta();
+  let accounts = store.listAccounts();
+  if (args[0]) {
+    accounts = accounts.filter((a) => a.name === args[0]);
+    if (accounts.length === 0) throw new Error(`no such account: ${args[0]}`);
+  }
+  if (accounts.length === 0) {
+    out('no accounts yet — add one with "codexswitch login" or "codexswitch import"');
+    return;
+  }
+  for (const l of usageLines(accounts, meta)) out(l);
+}
+
+// Warm up quota measurements: send a minimal request per account so the
+// usage gauges (and use-or-lose ordering) have data. Costs a few tokens.
+async function cmdProbe(args) {
+  runner.assertCodexAvailable();
+  const meta = store.loadMeta();
+  let accounts = store.listAccounts().filter((a) => !a.disabled);
+  if (args[0]) {
+    accounts = accounts.filter((a) => a.name === args[0]);
+    if (accounts.length === 0) throw new Error(`no such account: ${args[0]}`);
+  }
+  if (accounts.length === 0) throw new Error('no enabled accounts to probe');
+  out(ui.info(ui.dim(`probing ${accounts.length} account(s) with a minimal request...`)));
+  let failures = 0;
+  for (const a of accounts) {
+    const line = await probeOne(a, meta);
+    out(line.text);
+    if (!line.ok) failures++;
+  }
+  return failures > 0 ? 1 : 0;
+}
+
+// Probe a single account; returns a printable result line.
+async function probeOne(a, meta) {
+  const startTs = Date.now();
+  const res = await runner.runCodex(
+    a.name,
+    ['exec', ...buildExecArgs(['Reply with exactly: ok'], meta)],
+    { capture: true, silent: true }
+  );
+  const usage = runner.recordUsage(a.name, res.profile, startTs);
+  if (res.code !== 0) {
+    const why = runner.looksAuthFailed(res.output)
+      ? `login revoked — fix with "codexswitch login ${a.name}"`
+      : runner.looksRateLimited(res.output, meta.limitPatterns)
+        ? 'rate limited'
+        : `exit ${res.code}`;
+    store.logEvent('probe', `${a.name} failed: ${why}`);
+    return { ok: false, text: ui.fail(`${a.name}: ${why}`) };
+  }
+  store.logEvent('probe', `${a.name} measured`);
+  if (usage && usage.p5h) {
+    return { ok: true, text: ui.ok(`${a.name}: 5h ${Math.round(usage.p5h.pct)}%${usage.weekly ? ` / weekly ${Math.round(usage.weekly.pct)}%` : ''}`) };
+  }
+  return { ok: true, text: ui.warn(`${a.name}: reachable, but codex reported no usage data`) };
+}
+
+function cmdLog(args) {
+  const count = args[0] ? parseInt(args[0], 10) : 20;
+  if (Number.isNaN(count) || count < 1) throw new Error('usage: codexswitch log [count]');
+  const events = store.readEvents(count);
+  if (events.length === 0) {
+    out('no activity yet');
+    return;
+  }
+  const color = { limit: ui.yellow, auth: ui.red, probe: ui.cyan, switch: ui.green, exec: ui.green };
+  for (const e of events) {
+    const paint = color[e.type] || ((s) => s);
+    out(`${ui.dim(e.at.replace('T', ' ').slice(0, 19))}  ${paint(e.type.padEnd(6))} ${e.message}`);
+  }
+}
+
+// Live interactive dashboard: usage gauges + recent activity, refreshed
+// every 5s. Keyboard: up/down select, s switch, e enable/disable, p probe,
+// r refresh, q quit.
+async function cmdWatch() {
+  if (!process.stdout.isTTY) {
+    cmdUsage([]);
+    return 0;
+  }
+  let cursor = 0;
+  let message = '';
+  let busy = false;
+  const render = () => {
+    const meta = store.loadMeta();
+    const accounts = store.listAccounts();
+    if (cursor >= accounts.length) cursor = Math.max(0, accounts.length - 1);
+    process.stdout.write('\x1b[2J\x1b[H');
+    out(`${ui.bold('codexswitch watch')}${ui.dim(`  ${new Date().toLocaleTimeString()} \u00b7 refreshes every 5s`)}\n`);
+    if (accounts.length === 0) {
+      out('no accounts yet \u2014 add one with "codexswitch login"');
+    } else {
+      for (const l of usageLines(accounts, meta, { cursor })) out(l);
+    }
+    const events = store.readEvents(4);
+    if (events.length > 0) {
+      out(ui.dim('\nrecent activity:'));
+      for (const e of events) out(ui.dim(`  ${e.at.replace('T', ' ').slice(11, 19)}  ${e.type}: ${e.message}`));
+    }
+    out(`\n${ui.dim('keys:')} ${ui.cyan('\u2191/\u2193')} select  ${ui.cyan('s')} switch  ${ui.cyan('e')} enable/disable  ${ui.cyan('p')} probe  ${ui.cyan('r')} refresh  ${ui.cyan('q')} quit`);
+    if (message) out(message);
+  };
+  render();
+  const timer = setInterval(() => {
+    if (!busy) render();
+  }, 5000);
+  await new Promise((resolve) => {
+    if (process.stdin.isTTY) process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.on('data', async (b) => {
+      if (busy) return;
+      const s = b.toString();
+      const accounts = store.listAccounts();
+      const selected = accounts[cursor];
+      if (s === 'q' || s === '\u0003') {
+        clearInterval(timer);
+        if (process.stdin.isTTY) process.stdin.setRawMode(false);
+        process.stdin.pause();
+        resolve();
+        return;
+      }
+      if (s === '\x1b[A' || s === 'k') cursor = Math.max(0, cursor - 1);
+      else if (s === '\x1b[B' || s === 'j') cursor = Math.min(accounts.length - 1, cursor + 1);
+      else if (s === 'r') message = '';
+      else if (s === 's' && selected) {
+        try {
+          cmdUse([selected.name]);
+          message = ui.ok(`switched to "${selected.name}"`);
+        } catch (e) {
+          message = ui.fail(e.message);
+        }
+      } else if (s === 'e' && selected) {
+        setFlag(selected.name, { disabled: !selected.disabled });
+        message = selected.disabled ? ui.ok(`enabled "${selected.name}"`) : ui.warn(`disabled "${selected.name}"`);
+      } else if (s === 'p' && selected) {
+        busy = true;
+        message = ui.dim(`probing "${selected.name}"...`);
+        render();
+        try {
+          const result = await probeOne(selected, store.loadMeta());
+          message = result.text;
+        } catch (e) {
+          message = ui.fail(e.message);
+        }
+        busy = false;
+      }
+      render();
+    });
+  });
+  return 0;
 }
 
 // Rotate-early thresholds: how full the 5h / weekly window may get before
@@ -469,7 +638,7 @@ function cmdNames() {
 }
 
 const COMMANDS =
-  'login import add-key list usage use current next run exec order model remove rename ' +
+  'login import add-key list usage watch probe log chat use current next run exec order model remove rename ' +
   'enable disable priority clear-limit cooldown threshold patterns export restore sync completion help';
 
 function cmdCompletion(args) {
@@ -494,6 +663,18 @@ complete -F _codexswitch codexswitch cxs`;
 // non-git folders, and the configured default model — unless the user
 // already passed their own flags.
 function buildExecArgs(rest, meta) {
+  // "exec resume [--last|<id>] ..." — the subcommand and its target must
+  // stay in front; flags are injected after them.
+  if (rest[0] === 'resume') {
+    const head = ['resume'];
+    let i = 1;
+    if (rest[i] === '--last' || (rest[i] && /^[0-9a-f][0-9a-f-]{7,}$/i.test(rest[i]))) head.push(rest[i++]);
+    return [...head, ...injectExecFlags(rest.slice(i), meta)];
+  }
+  return injectExecFlags(rest, meta);
+}
+
+function injectExecFlags(rest, meta) {
   const args = [...rest];
   if (!args.includes('--skip-git-repo-check')) args.unshift('--skip-git-repo-check');
   const hasModel = args.some((a) => a === '-m' || a === '--model' || a.startsWith('--model='));
@@ -578,6 +759,7 @@ async function cmdExec(args) {
     if (res.code === 0) {
       store.clearLimited(name);
       console.error(ui.ok(`done as ${ui.bold(`"${name}"`)}`));
+      store.logEvent('exec', `done as "${name}"${useResume ? ' (resumed session)' : ''}`);
       warnIfOverThreshold(name);
       return 0;
     }
@@ -590,6 +772,7 @@ async function cmdExec(args) {
       console.error(
         ui.warn(`"${name}" hit a usage/rate limit (paused until ${fmtDate(until)}) — rotating${useResume ? ' and resuming the session' : ''}`)
       );
+      store.logEvent('limit', `"${name}" paused until ${fmtDate(until)}`);
       continue;
     }
     if (runner.looksAuthFailed(res.output)) {
@@ -599,6 +782,7 @@ async function cmdExec(args) {
       console.error(
         ui.fail(`"${name}" has a revoked/invalid login — disabled. Fix it with: ${ui.bold(`codexswitch login ${name}`)}`)
       );
+      store.logEvent('auth', `"${name}" disabled (revoked login)`);
       continue;
     }
     return res.code; // real failure, don't burn other accounts on it
@@ -607,6 +791,79 @@ async function cmdExec(args) {
   return 2;
 }
 
+// Interactive chat: a Claude Code-style prompt loop on top of exec.
+// Every turn goes through the rotation engine, and turns 2+ resume the same
+// codex session — so the conversation continues even when the account under
+// it changes between (or during) turns.
+async function cmdChat() {
+  const readline = require('readline');
+  runner.assertCodexAvailable();
+  if (store.listAccounts().length === 0) {
+    throw new Error('no accounts — add one with "codexswitch login"');
+  }
+  const meta = store.loadMeta();
+  out(`${ui.bold('codexswitch chat')} ${ui.dim(`· model ${meta.model || '(codex default)'} · rotation on limits`)}`);
+  out(ui.dim('type a prompt, or /help for commands (/quit to exit)\n'));
+
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  rl.setPrompt(ui.enabled ? `${ui.cyan('cxs')} ${ui.dim('›')} ` : 'cxs › ');
+  // Buffer lines ourselves: input can arrive while a turn is still running
+  // (type-ahead, piped input) and must not be dropped or hit a closed rl.
+  const pending = [];
+  const waiters = [];
+  let closed = false;
+  rl.on('line', (l) => {
+    const w = waiters.shift();
+    if (w) w(l);
+    else pending.push(l);
+  });
+  rl.on('close', () => {
+    closed = true;
+    for (const w of waiters.splice(0)) w(null);
+  });
+  const ask = () => {
+    if (pending.length > 0) return Promise.resolve(pending.shift());
+    if (closed) return Promise.resolve(null);
+    rl.prompt();
+    return new Promise((resolve) => waiters.push(resolve));
+  };
+
+  let inSession = false;
+  for (;;) {
+    const raw = await ask();
+    if (raw == null) break; // EOF (Ctrl-D or piped input ended)
+    const line = raw.trim();
+    if (!line) continue;
+
+    if (line[0] === '/') {
+      const [cmd, ...rest] = line.slice(1).split(/\s+/);
+      try {
+        if (cmd === 'quit' || cmd === 'exit' || cmd === 'q') break;
+        else if (cmd === 'help')
+          out(ui.dim('/usage /list /use <name> /next /model [m] /new (fresh session) /quit'));
+        else if (cmd === 'usage') cmdUsage([]);
+        else if (cmd === 'list') cmdList();
+        else if (cmd === 'use') cmdUse(rest);
+        else if (cmd === 'next') cmdNext();
+        else if (cmd === 'model') cmdModel(rest);
+        else if (cmd === 'new') {
+          inSession = false;
+          out(ui.ok('starting a fresh session on the next prompt'));
+        } else out(ui.warn(`unknown command /${cmd} — try /help`));
+      } catch (e) {
+        out(ui.fail(e.message));
+      }
+      continue;
+    }
+
+    const code = await cmdExec(inSession ? ['resume', '--last', line] : [line]);
+    if (code === 0) inSession = true;
+    else if (code === 2) out(ui.fail('all accounts exhausted — try again later or /use a specific account'));
+  }
+  rl.close();
+  return 0;
+}
+
 function warnIfOverThreshold(name) {
   const meta = store.loadMeta();
   const account = store.listAccounts().find((a) => a.name === name);
@@ -644,6 +901,15 @@ async function main(argv) {
     case 'usage':
     case 'status':
       return cmdUsage(args), 0;
+    case 'watch':
+    case 'dashboard':
+      return cmdWatch();
+    case 'probe':
+    case 'warmup':
+      return cmdProbe(args);
+    case 'log':
+    case 'activity':
+      return cmdLog(args), 0;
     case 'use':
       return cmdUse(args), 0;
     case 'current':
@@ -699,6 +965,9 @@ async function main(argv) {
       return cmdRun(args);
     case 'exec':
       return cmdExec(args);
+    case 'chat':
+    case 'repl':
+      return cmdChat();
     default:
       // Forward everything else to codex under the managed account, so
       // codexswitch is a drop-in replacement: "cxs goal", "cxs resume", ...

package/src/runner.js

@@ -164,7 +164,8 @@ function refreshCopy(target, dest) {
 // Run codex for one account inside its overlay profile.
 // capture=false: interactive, stdio inherited. capture=true: stream output
 // through while also collecting it so the caller can detect limit errors.
-function runCodex(name, args, { capture = false } = {}) {
+// silent=true (with capture): collect without echoing (used by probe).
+function runCodex(name, args, { capture = false, silent = false } = {}) {
   assertCodexAvailable();
   const profile = buildProfile(name);
   const env = { ...process.env, CODEX_HOME: profile };
@@ -182,7 +183,7 @@ function runCodex(name, args, { capture = false } = {}) {
         stream.on('data', (chunk) => {
           out += chunk.toString('utf8');
           if (out.length > 262144) out = out.slice(-131072);
-          dest.write(chunk);
+          if (!silent) dest.write(chunk);
         });
       };
       collect(child.stdout, process.stdout);

package/src/store.js

@@ -36,6 +36,34 @@ function loadMeta() {
   return meta;
 }
 
+// Append an event to the activity log (rotations, limits, auth failures...).
+function logEvent(type, message) {
+  try {
+    ensureDir(paths().home);
+    fs.appendFileSync(
+      path.join(paths().home, 'activity.log'),
+      JSON.stringify({ at: new Date().toISOString(), type, message }) + '\n'
+    );
+  } catch {
+    /* logging must never break the tool */
+  }
+}
+
+function readEvents(count = 20) {
+  try {
+    const lines = fs.readFileSync(path.join(paths().home, 'activity.log'), 'utf8').trim().split('\n');
+    return lines.slice(-count).map((l) => {
+      try {
+        return JSON.parse(l);
+      } catch {
+        return null;
+      }
+    }).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
 function saveMeta(meta) {
   writeJSONAtomic(paths().metaPath, meta);
 }
@@ -83,14 +111,27 @@ function listAccounts() {
       return {
         name,
         ...authInfo(auth),
-        priority: m.priority ?? 0,
+        priority: m.priority ?? null, // null = auto (use-or-lose ordering)
         disabled: !!m.disabled,
         limitedUntil: m.limitedUntil || null,
         usage: m.usage || null,
         active: meta.active === name,
       };
     })
-    .sort((a, b) => a.priority - b.priority || a.name.localeCompare(b.name));
+    .sort(rotationCompare);
+}
+
+// Rotation order: pinned accounts (explicit priority) come first in pin
+// order; auto accounts follow, spending the one whose weekly quota resets
+// soonest first (use-or-lose — quota about to refresh anyway gets burned
+// first). Ties prefer the active account to avoid needless switching.
+function rotationCompare(a, b) {
+  const aPinned = a.priority != null;
+  const bPinned = b.priority != null;
+  if (aPinned !== bPinned) return aPinned ? -1 : 1;
+  if (aPinned && a.priority !== b.priority) return a.priority - b.priority;
+  const reset = (x) => (x.usage && x.usage.weekly && x.usage.weekly.resetAt) || Infinity;
+  return reset(a) - reset(b) || Number(b.active) - Number(a.active) || a.name.localeCompare(b.name);
 }
 
 // Copy refreshed tokens from a live auth.json back into the store, so a
@@ -187,8 +228,10 @@ function pickAccount(exclude = []) {
   const meta = loadMeta();
   const usable = listAccounts().filter((a) => !exclude.includes(a.name) && isUsable(a, meta, now));
   if (usable.length === 0) return null;
-  const group = usable.filter((a) => a.priority === usable[0].priority);
-  return group.find((a) => a.active) || group[0];
+  // listAccounts is already in rotation order (pins first, then use-or-lose,
+  // active as tiebreaker) — but a pinned tie should still stick to active.
+  const top = usable.filter((a) => a.priority != null && a.priority === usable[0].priority);
+  return top.find((a) => a.active) || usable[0];
 }
 
 // Next usable account after the active one, following priority order and
@@ -223,6 +266,8 @@ module.exports = {
   isUsable,
   pickAccount,
   nextAccount,
+  logEvent,
+  readEvents,
   ensureDirs() {
     const p = paths();
     ensureDir(p.home);