@carjms/codexswitch 0.6.4 → 0.7.0

package/README.ko.md

@@ -200,15 +200,18 @@ cxs list                # 계정별 5h/week 사용량 % 확인
 
 | 명령 | 설명 |
 |---|---|
+| `cxs` | **기본 지속형 프롬프트**: 2열 시작 대시보드에서 계정·프로젝트·최근 작업을 확인하고 계속 입력. 두 번째 요청부터 같은 Codex 세션을 자동으로 이어감 |
 | `cxs login [이름]` | 새 계정 로그인 후 저장 (기존 로그인 유지, 이름 생략 시 이메일 사용) |
 | `cxs import [이름]` | 현재 `~/.codex`에 로그인된 계정을 저장소로 가져오기 |
 | `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 chat [--simple]` | `cxs`와 같은 지속형 입력창. `--simple`은 전체 화면 시작 대시보드를 생략. `/paste`로 여러 줄 입력(`/end`로 완료) |
 | `cxs watch` | 실시간 인터랙티브 대시보드 — 5초마다 갱신; 키: `↑/↓` 선택, `s` 전환, `e` 활성/비활성, `p` 프로브, `q` 종료 |
 | `cxs probe [이름]` | 계정마다 최소 요청 1회를 보내 사용량 게이지 워밍업 (토큰 소량 소모) |
 | `cxs log [개수]` | 최근 활동 기록: 계정 전환, 한도 도달, 로테이션, 프로브 |
+| `cxs history [개수]` | 실제 작업 이력: 요청, 성공 여부, 계정 전환 흐름, 소요 시간, 변경 파일 |
+| `cxs history show <ID\|latest>` | 요청 원문과 계정별 시도 결과, 실행 후 Git 변경 파일 상세 확인 |
 | `cxs use <이름>` | 활성 계정 전환 |
 | `cxs current` | 현재 활성 계정 확인 |
 | `cxs next` | 설정된 순서의 다음 계정으로 전환 (끝에 오면 처음으로 순환) |
@@ -219,14 +222,17 @@ cxs list                # 계정별 5h/week 사용량 % 확인
 | `cxs model [모델명]` | `run`/`exec`에 자동 적용할 기본 모델 설정 (`default`로 초기화) |
 | `cxs threshold [5h%] [주간%]` | 사용량이 이 퍼센트에 도달하면 다음 계정으로 전환 (기본 95, 값 하나면 둘 다) |
 | `cxs reasoning <show\|concise\|hide>` | 실행 중 모델 추론("생각") 출력량 조절 — `hide`는 완전 숨김, `concise`는 한 줄 요약 |
+| `cxs output <auto\|compact\|raw>` | 출력 가독성. `auto`는 터미널에서 중간 diff를 접고 최종 답변·작업 요약만 표시하며, 파이프에서는 raw 유지 |
+| `cxs memory [명령]` | 계정 간 기억 관리. `shared`는 모든 계정이 공유, `isolated`는 계정별 분리, `off`는 주입 중단. `add/show/path` 지원 |
 | `cxs sandbox <read-only\|write\|write+net\|full>` | exec/chat의 파일 접근 권한 — `write`는 작업 폴더 수정, `write+net`은 ssh/curl 등 네트워크까지 허용, `full`은 샌드박스 해제 |
 | `cxs patterns [add/remove]` | 한도 감지에 쓸 커스텀 정규식 패턴 추가/삭제 |
 | `cxs export <파일>` | 전체 계정·설정 백업 (⚠️ 토큰 포함 — 비밀번호처럼 취급) |
 | `cxs restore <파일>` | 백업 파일에서 계정 복원 (다른 PC 이전용) |
 | `cxs completion <bash\|zsh>` | 셸 자동완성 스크립트 출력 |
 | `cxs <그 외 명령>` | codex로 그대로 전달 — `cxs resume`, `cxs goal ...`, `cxs apply` 등 codex의 모든 명령을 관리 계정으로 바로 사용 가능 |
-| `cxs server [--port N]` | **실험 기능** 로컬 프록시(teamclaude 방식): 요청마다 인증을 교체하고, 429는 다음 계정으로 재시도, 응답 헤더에서 사용량을 실시간 수집 |
-| `cxs run --proxy [인자]` | codex를 로컬 프록시 경유로 실행 — 대화형 세션 안에서도 요청 단위 로테이션 |
+| `cxs server [--port N]` | **실험 기능** 로컬 프록시(teamclaude 방식): 할당량 429만 계정 전환하고 짧은 분당 제한은 같은 계정에서 재시도, 사용량 실시간 수집 |
+| `cxs server status` | 프록시 연결 상태와 요청 단위 로테이션 활성 여부 확인 |
+| `cxs run --proxy [인자]` | 프록시가 있으면 경유하고 없으면 직접 실행. 반드시 필요하면 `--require-proxy` 사용 |
 | `cxs remove <이름>` | 계정 삭제 |
 | `cxs rename <옛이름> <새이름>` | 계정 이름 변경 |
 | `cxs disable / enable <이름>` | 로테이션에서 임시 제외 / 복귀 |

package/README.md

@@ -202,15 +202,18 @@ cxs list                # per-account 5h/week usage columns
 
 | Command | Description |
 |---|---|
+| `cxs` | **Default persistent prompt**: two-column account/project/history dashboard, then continuous input; turns 2+ continue the same Codex session |
 | `cxs login [name]` | Log in to a new account and store it (existing login untouched; defaults to the email as the name) |
 | `cxs import [name]` | Import the account currently in `~/.codex` |
 | `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 chat [--simple]` | Launch the same persistent prompt; `--simple` skips the full-screen landing. Use `/paste` for multiline input |
 | `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 history [count]` | Work history: request, result, account flow, duration, and changed files |
+| `cxs history show <ID\|latest>` | Full request, per-account attempts, and Git workspace changes for one run |
 | `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) |
@@ -221,14 +224,17 @@ cxs list                # per-account 5h/week usage columns
 | `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 reasoning <show\|concise\|hide>` | How much model reasoning ("thinking") to print during runs — `hide` for clean output, `concise` for one-line summaries |
+| `cxs output <auto\|compact\|raw>` | Output readability: `auto` folds intermediate diffs in a TTY and shows the final result plus work summary; pipes stay raw |
+| `cxs memory [command]` | Manage persistent context: `shared` across accounts, per-account `isolated`, or `off`; supports `add/show/path` |
 | `cxs sandbox <read-only\|write\|write+net\|full>` | File access for exec/chat — `write` edits files in cwd, `write+net` also allows ssh/curl/network, `full` disables the sandbox |
 | `cxs patterns [add/remove]` | Custom regex patterns treated as rate-limit errors |
 | `cxs export <file>` | Back up all accounts + settings (⚠️ contains tokens — treat like a password) |
 | `cxs restore <file>` | Restore accounts from a backup (for moving machines) |
 | `cxs completion <bash\|zsh>` | Print a shell completion script |
 | `cxs <anything else>` | Forwarded to codex under the managed account — `cxs resume`, `cxs goal ...`, `cxs apply` all work like their codex counterparts |
-| `cxs server [--port N]` | **EXPERIMENTAL** local proxy (teamclaude-style): swaps credentials per request, retries 429s on the next account, and feeds usage gauges live from response headers |
-| `cxs run --proxy [args]` | Run codex routed through the local proxy — per-request rotation even inside interactive sessions |
+| `cxs server [--port N]` | **EXPERIMENTAL** local proxy (teamclaude-style): rotates on quota 429s, retries short throttles on the same account, and collects live usage |
+| `cxs server status` | Check proxy reachability and whether per-request rotation is active |
+| `cxs run --proxy [args]` | Use the proxy when available and fall back to direct mode; add `--require-proxy` for strict mode |
 | `cxs remove <name>` | Delete an account |
 | `cxs rename <old> <new>` | Rename an account |
 | `cxs disable / enable <name>` | Temporarily exclude from / restore to rotation |

package/package.json

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

package/src/cli.js

@@ -3,6 +3,7 @@
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
+const { spawnSync } = require('child_process');
 const { readJSONSafe, writeJSONAtomic, authInfo, ensureDir, fmtDate, fmtRemaining, table } = require('./util.js');
 const store = require('./store.js');
 const runner = require('./runner.js');
@@ -10,6 +11,8 @@ const ui = require('./ui.js');
 
 const HELP = `codexswitch — multi-account manager for the OpenAI Codex CLI
 
+Run without a command to open the persistent interactive prompt.
+
 Accounts
   login [name]            log in to a new account (isolated "codex login") and store it
   import [name]           import the account currently in ~/.codex/auth.json
@@ -21,6 +24,8 @@ Accounts
   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
+  history [count]         work history: request, result, account, duration, files
+  history show <id>       full details (use "latest" for the newest run)
   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)
@@ -34,10 +39,11 @@ Accounts
   clear-limit <name>      forget a recorded rate-limit for an account
 
 Running codex
-  chat                    interactive prompt loop (Claude Code-style): each turn
+  chat [--simple]         interactive prompt loop with a two-column welcome
+                          dashboard (--simple skips the full-screen landing): each turn
                           runs through rotation and resumes the same session,
                           so the conversation survives account switches
-                          (/usage /use /next /model /new /quit inside)
+                          (/status /usage /memory /use /next /model /new /quit)
   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
@@ -47,12 +53,16 @@ Running codex
       --no-resume         restart the prompt instead of resuming on rotation
   server [--port N]       EXPERIMENTAL local proxy: per-request account
                           rotation with live usage from response headers
-  run --proxy [args...]   run codex routed through the local proxy
+  server status           show whether the local proxy is reachable
+  run --proxy [args...]   use proxy when available, otherwise run directly
+      --require-proxy     fail instead of falling back when proxy is unavailable
 
 Settings
   model [name|default]    show/set the default model injected into run/exec
   reasoning [mode]        how much model reasoning to print during runs:
                           show (codex default) | concise | hide
+  output [mode]           exec/chat display: auto (compact on TTY, raw when
+                          piped) | compact (result + summary) | raw
   sandbox [mode]          file access for exec/chat: read-only (codex default)
                           | write (edit files in cwd) | write+net (also allow
                           ssh/curl/network) | full (no sandbox)
@@ -60,6 +70,8 @@ Settings
                           of the 5-hour / weekly window (default 95, one value = both)
   cooldown [minutes]      show/set rate-limit cooldown (default 60)
   patterns [add|remove]   extra regex patterns treated as rate-limit errors
+  memory [command]        cross-account memory for exec/chat: status, shared,
+                          isolated, off, add <text>, show [account], path [account]
 
 Maintenance
   sync                    save tokens refreshed by codex back into the store
@@ -155,7 +167,7 @@ function cmdLogin(args) {
 function cmdList() {
   const accounts = store.listAccounts();
   if (accounts.length === 0) {
-    out('no accounts yet — add one with "codexswitch login" or "codexswitch import"');
+    printEmptyAccounts();
     return;
   }
   const now = Date.now();
@@ -170,10 +182,10 @@ function cmdList() {
     const status = a.disabled
       ? ui.red('disabled')
       : a.limitedUntil && a.limitedUntil > now
-        ? ui.yellow(`limited ${fmtRemaining(a.limitedUntil)}`)
+        ? ui.yellow(`paused ${fmtRemaining(a.limitedUntil)}`)
         : over
           ? ui.yellow(`over-${over}`)
-          : ui.green('ok');
+          : ui.green('ready');
     return [
       a.active ? ui.green('●') : '',
       a.active ? ui.bold(a.name) : a.name,
@@ -187,7 +199,19 @@ function cmdList() {
     ];
   });
   out(table(rows, ['', 'name', 'email', 'plan', 'prio', 'status', '5h', 'week', 'token refreshed']));
-  out(ui.dim(`(rotate threshold: 5h ${meta.threshold5h}% / weekly ${meta.thresholdWeekly}% — change with "codexswitch threshold")`));
+  const ready = accounts.filter((a) => store.isUsable(a, meta, now));
+  const next = store.pickAccount();
+  out(ui.dim(`\n${ready.length}/${accounts.length} ready · next: ${next ? next.name : 'none'} · threshold: 5h ${meta.threshold5h}% / week ${meta.thresholdWeekly}%`));
+  if (!next) out(ui.warn('No account can run now. Check details with "codexswitch usage".'));
+}
+
+function printEmptyAccounts() {
+  out(ui.bold('No accounts yet'));
+  out('  1. Import the account already signed in to Codex:');
+  out(`     ${ui.cyan('codexswitch import')}`);
+  out('  2. Add another account in an isolated login:');
+  out(`     ${ui.cyan('codexswitch login <name>')}`);
+  out(ui.dim('\nYour current Codex login is never replaced during step 2.'));
 }
 
 function cmdUse(args) {
@@ -272,6 +296,12 @@ function cmdRename(args) {
   if (store.accountExists(to)) throw new Error(`account "${to}" already exists`);
   store.writeAccountAuth(to, auth);
   fs.rmSync(store.accountPath(from), { force: true });
+  const oldMemory = store.memoryPath('isolated', from);
+  const newMemory = store.memoryPath('isolated', to);
+  if (fs.existsSync(oldMemory)) {
+    ensureDir(path.dirname(newMemory));
+    fs.renameSync(oldMemory, newMemory);
+  }
   const meta = store.loadMeta();
   meta.accounts[to] = meta.accounts[from] || { priority: 0 };
   delete meta.accounts[from];
@@ -377,6 +407,13 @@ function cmdModel(args) {
 function usageLines(accounts, meta, { cursor = -1 } = {}) {
   const now = Date.now();
   const lines = [];
+  const usable = accounts.filter((a) => store.isUsable(a, meta, now));
+  const active = accounts.find((a) => a.active);
+  lines.push(
+    `${ui.bold('Usage overview')}  ${ui.green(`${usable.length} ready`)} / ${accounts.length}` +
+      `${active ? ui.dim(` · active ${active.name}`) : ''}`
+  );
+  lines.push('');
   const bar = (pct, threshold) => {
     const width = 20;
     const filled = Math.max(0, Math.min(width, Math.round((pct / 100) * width)));
@@ -396,7 +433,7 @@ function usageLines(accounts, meta, { cursor = -1 } = {}) {
     const state = a.disabled ? ui.red(' [disabled]') : a.limitedUntil && a.limitedUntil > now ? ui.yellow(` [limited ${fmtRemaining(a.limitedUntil)}]`) : '';
     lines.push(`${cursor >= 0 ? sel : ''}${mark} ${ui.bold(a.name)}${ui.dim(` (${a.plan || a.email || '-'})`)}${state}`);
     if (!a.usage) {
-      lines.push(ui.dim('  no usage data yet — codex records it during runs (try "codexswitch run" once)'));
+      lines.push(ui.dim(`  no usage data yet — measure it with "codexswitch probe ${a.name}"`));
     } else {
       lines.push(gauge('5h    ', a.usage.p5h, meta.threshold5h));
       lines.push(gauge('weekly', a.usage.weekly, meta.thresholdWeekly));
@@ -404,7 +441,8 @@ function usageLines(accounts, meta, { cursor = -1 } = {}) {
     }
   });
   const next = store.pickAccount();
-  lines.push(ui.dim(`\nrotation would pick: ${next ? next.name : '(none usable)'} · threshold 5h ${meta.threshold5h}% / weekly ${meta.thresholdWeekly}%`));
+  lines.push(`\n${ui.dim('Next account')}  ${next ? ui.bold(next.name) : ui.red('none usable')}`);
+  lines.push(ui.dim(`Thresholds    5h ${meta.threshold5h}% · week ${meta.thresholdWeekly}%`));
   return lines;
 }
 
@@ -416,7 +454,7 @@ function cmdUsage(args) {
     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"');
+    printEmptyAccounts();
     return;
   }
   for (const l of usageLines(accounts, meta)) out(l);
@@ -483,6 +521,93 @@ function cmdLog(args) {
   }
 }
 
+function shortText(value, max = 56) {
+  const oneLine = String(value || '').replace(/\s+/g, ' ').trim();
+  return oneLine.length > max ? `${oneLine.slice(0, max - 1)}…` : oneLine;
+}
+
+function formatDuration(ms) {
+  if (!Number.isFinite(ms)) return '-';
+  if (ms < 1000) return `${ms}ms`;
+  if (ms < 60000) return `${(ms / 1000).toFixed(ms < 10000 ? 1 : 0)}s`;
+  return `${Math.floor(ms / 60000)}m${Math.round((ms % 60000) / 1000)}s`;
+}
+
+function cmdHistory(args) {
+  if (args[0] === 'show') {
+    const id = requireArg(args, 1, 'history id (or "latest")');
+    const run = store.findRun(id);
+    if (!run) throw new Error(`no history entry matching "${id}"`);
+    out(`${ui.bold(run.id)}  ${run.status === 'done' ? ui.green('done') : ui.red(run.status)}`);
+    out(`${ui.dim('Started')}   ${fmtDate(run.startedAt)}`);
+    out(`${ui.dim('Duration')}  ${formatDuration(run.durationMs)}`);
+    out(`${ui.dim('Directory')} ${run.cwd || '-'}`);
+    out(`${ui.dim('Session')}   ${run.session} · memory ${run.memory} · reasoning ${run.reasoning}`);
+    out(`\n${ui.bold('Request')}\n${run.prompt || ui.dim('(not captured)')}`);
+    out(`\n${ui.bold('Attempts')}`);
+    for (const attempt of run.attempts || []) {
+      const paint = attempt.status === 'done' ? ui.green : attempt.status === 'rate-limited' ? ui.yellow : ui.red;
+      out(`  ${paint(attempt.status.padEnd(12))} ${attempt.account} · ${formatDuration(attempt.durationMs)}`);
+    }
+    out(`\n${ui.bold('Files changed during this run')}`);
+    if (run.touchedFiles && run.touchedFiles.length) run.touchedFiles.forEach((file) => out(`  ${file}`));
+    else out(ui.dim('  no file changes detected'));
+    out(`\n${ui.bold('Git workspace after run')}`);
+    if (run.files && run.files.length) run.files.forEach((file) => out(`  ${file}`));
+    else out(ui.dim('  clean'));
+    if (run.promptTruncated) out(ui.warn('\nRequest was truncated to the last 16 KiB in history.'));
+    return;
+  }
+  const count = args[0] == null ? 20 : parseInt(args[0], 10);
+  if (Number.isNaN(count) || count < 1 || count > 200) {
+    throw new Error('usage: codexswitch history [1-200] | history show <id|latest>');
+  }
+  const runs = store.readRuns(count);
+  if (runs.length === 0) {
+    out('no work history yet — exec, run <account> exec, and chat runs appear here');
+    return;
+  }
+  const rows = runs.map((run) => [
+    run.id,
+    fmtDate(run.startedAt),
+    run.status === 'done' ? ui.green('done') : ui.red(run.status),
+    (run.attempts || []).map((a) => a.account).join(' → ') || '-',
+    formatDuration(run.durationMs),
+    shortText(run.prompt),
+  ]);
+  out(table(rows, ['id', 'started', 'result', 'account flow', 'time', 'request']));
+  out(ui.dim('\nFull details: codexswitch history show <id>'));
+  out(ui.dim(`Stored locally in ${path.join(store.paths().home, 'history.jsonl')} (contains prompts)`));
+}
+
+function workspaceSnapshot() {
+  const result = spawnSync('git', ['status', '--short', '--untracked-files=all'], { cwd: process.cwd(), encoding: 'utf8' });
+  if (result.status !== 0 || !result.stdout) return {};
+  const snapshot = {};
+  for (const line of result.stdout.trim().split(/\r?\n/).filter(Boolean).slice(0, 100)) {
+    let file = line.slice(3);
+    if (file.includes(' -> ')) file = file.split(' -> ').pop();
+    if (file.startsWith('"')) {
+      try { file = JSON.parse(file); } catch { /* keep Git's displayed path */ }
+    }
+    try {
+      const stat = fs.statSync(path.resolve(file), { bigint: true });
+      snapshot[line] = `${stat.size}:${stat.mtimeNs}`;
+    } catch {
+      snapshot[line] = 'missing';
+    }
+  }
+  return snapshot;
+}
+
+function promptFromExecArgs(args) {
+  if (!args.length) return '';
+  const separator = args.lastIndexOf('--');
+  const value = args[args.length - 1];
+  if (separator < 0 && String(value).startsWith('-')) return '';
+  return String(value);
+}
+
 // 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.
@@ -646,8 +771,8 @@ function cmdNames() {
 }
 
 const COMMANDS =
-  'login import add-key list usage watch probe log chat server use current next run exec order model remove rename ' +
-  'enable disable priority clear-limit cooldown threshold reasoning sandbox patterns export restore sync completion help';
+  'login import add-key list usage watch probe log history chat server use current next run exec order model remove rename ' +
+  'enable disable priority clear-limit cooldown threshold reasoning output sandbox memory patterns export restore sync completion help';
 
 function cmdCompletion(args) {
   const shell = args[0];
@@ -773,9 +898,157 @@ function cmdReasoning(args) {
   );
 }
 
+function cmdOutput(args) {
+  const meta = store.loadMeta();
+  if (args[0] == null) {
+    out(`output: ${meta.outputMode || 'auto'} ${ui.dim('(auto | compact | raw)')}`);
+    out(ui.dim('auto uses compact output in a terminal and raw output when piped'));
+    return;
+  }
+  const mode = args[0];
+  if (!['auto', 'compact', 'raw'].includes(mode)) throw new Error('usage: codexswitch output <auto|compact|raw>');
+  if (mode === 'auto') delete meta.outputMode;
+  else meta.outputMode = mode;
+  store.saveMeta(meta);
+  out(ui.ok(`output set to ${mode}`));
+}
+
+function compactOutputEnabled(meta) {
+  const mode = meta.outputMode || 'auto';
+  return mode === 'compact' || (mode === 'auto' && process.stdout.isTTY);
+}
+
+function outputFileArg(args, file) {
+  if (args.some((a) => a === '-o' || a === '--output-last-message' || a.startsWith('--output-last-message='))) return args;
+  const result = [...args];
+  const resumeOffset = result[0] === 'resume' ? (result[1] === '--last' || /^[0-9a-f][0-9a-f-]{7,}$/i.test(result[1] || '') ? 2 : 1) : 0;
+  result.splice(resumeOffset, 0, '--output-last-message', file);
+  return result;
+}
+
+function existingOutputFile(args) {
+  for (let i = 0; i < args.length; i++) {
+    if ((args[i] === '-o' || args[i] === '--output-last-message') && args[i + 1]) return path.resolve(args[i + 1]);
+    if (args[i].startsWith('--output-last-message=')) return path.resolve(args[i].slice(args[i].indexOf('=') + 1));
+  }
+  return null;
+}
+
+function startCompactProgress(account, attempt, session) {
+  const started = Date.now();
+  const label = () => `Working · ${account} · ${session} session · ${Math.round((Date.now() - started) / 1000)}s`;
+  if (!process.stdout.isTTY) {
+    out(ui.info(label()));
+    return () => {};
+  }
+  const draw = () => process.stderr.write(`\r\x1b[2K${ui.cyan('●')} ${label()}`);
+  draw();
+  const timer = setInterval(draw, 1000);
+  return () => {
+    clearInterval(timer);
+    process.stderr.write('\r\x1b[2K');
+  };
+}
+
+function printCompactResult(message, run) {
+  out(`\n${ui.bold(ui.green('Result'))}`);
+  out(ui.dim('─'.repeat(48)));
+  out((message || '').trim() || ui.dim('(Codex returned no final message)'));
+  out(`\n${ui.bold('Work summary')}`);
+  out(ui.dim('─'.repeat(48)));
+  out(`${ui.green('✓')} ${run.status} · ${formatDuration(run.durationMs)} · ${(run.attempts || []).map((a) => a.account).join(' → ')}`);
+  if (run.touchedFiles && run.touchedFiles.length) {
+    out(`${ui.dim('Changed')} ${run.touchedFiles.length} file(s)`);
+    run.touchedFiles.slice(0, 12).forEach((file) => out(`  ${file}`));
+    if (run.touchedFiles.length > 12) out(ui.dim(`  … and ${run.touchedFiles.length - 12} more`));
+  } else {
+    out(ui.dim('Changed 0 files'));
+  }
+}
+
+function memoryTarget(meta, requestedAccount = null) {
+  if (meta.memoryMode !== 'isolated') return null;
+  const picked = store.pickAccount();
+  const name = requestedAccount || meta.active || (picked && picked.name);
+  if (!name || !store.accountExists(name)) throw new Error('isolated memory needs a valid account (activate one with "codexswitch use")');
+  return name;
+}
+
+function cmdMemory(args) {
+  const meta = store.loadMeta();
+  const sub = args[0];
+  if (!sub || sub === 'status') {
+    const mode = meta.memoryMode || 'off';
+    const account = mode === 'isolated' ? memoryTarget(meta) : null;
+    const file = mode === 'off' ? null : store.memoryPath(mode, account);
+    const size = file ? Buffer.byteLength(store.readMemory(mode, account), 'utf8') : 0;
+    out(`memory: ${ui.bold(mode)}${account ? ` · account ${ui.bold(account)}` : ''}`);
+    out(ui.dim(file ? `  ${size} bytes · ${file}` : '  disabled · existing Codex session files are still shared'));
+    if (mode === 'off') out(`  Enable: ${ui.cyan('codexswitch memory shared')} ${ui.dim('(shared across accounts)')}`);
+    return;
+  }
+  if (['shared', 'isolated', 'off'].includes(sub)) {
+    meta.memoryMode = sub;
+    store.saveMeta(meta);
+    if (sub === 'shared') out(ui.ok('shared memory enabled for exec/chat — all accounts read the same memory file'));
+    else if (sub === 'isolated') out(ui.ok('isolated memory enabled — each account reads only its own memory file'));
+    else out(ui.ok('memory injection disabled — stored memory files were kept'));
+    if (sub !== 'off') out(ui.dim(`add a note: codexswitch memory add "your note"`));
+    return;
+  }
+  const mode = meta.memoryMode || 'off';
+  if (mode === 'off') throw new Error('memory is off — choose "codexswitch memory shared" or "memory isolated" first');
+  if (sub === 'add') {
+    const account = memoryTarget(meta);
+    const text = args.slice(1).join(' ');
+    const file = store.appendMemory(mode, account, text);
+    out(ui.ok(`memory added${account ? ` for "${account}"` : ''}`));
+    out(ui.dim(file));
+    return;
+  }
+  if (sub === 'show') {
+    const target = memoryTarget(meta, args[1]);
+    const text = store.readMemory(mode, target);
+    out(text || ui.dim('(memory is empty)'));
+    return;
+  }
+  if (sub === 'path') {
+    out(store.memoryPath(mode, memoryTarget(meta, args[1])));
+    return;
+  }
+  throw new Error('usage: codexswitch memory [status|shared|isolated|off|add <text>|show [account]|path [account]]');
+}
+
+function withMemoryPrompt(args, accountName, meta) {
+  const mode = meta.memoryMode || 'off';
+  if (mode === 'off') return args;
+  const memory = store.readMemory(mode, mode === 'isolated' ? accountName : null).trim();
+  if (!memory) return args;
+  const result = [...args];
+  const separator = result.lastIndexOf('--');
+  const promptIndex = separator >= 0 && separator < result.length - 1
+    ? result.length - 1
+    : result.length > 0 && !String(result[result.length - 1]).startsWith('-')
+      ? result.length - 1
+      : -1;
+  if (promptIndex < 0) return result;
+  result[promptIndex] =
+    `<codexswitch-memory mode="${mode}">\n${memory}\n</codexswitch-memory>\n\n` +
+    `<user-request>\n${result[promptIndex]}\n</user-request>`;
+  return result;
+}
+
 // EXPERIMENTAL: foreground proxy server for per-request rotation.
 async function cmdServer(args) {
   const proxy = require('./proxy.js');
+  if (args[0] === 'status') {
+    const state = readJSONSafe(path.join(store.paths().home, 'proxy.json'));
+    const port = (state && state.port) || proxy.DEFAULT_PORT;
+    const running = await proxy.ping(port);
+    out(running ? ui.ok(`proxy running on http://127.0.0.1:${port}`) : ui.warn(`proxy not reachable on port ${port}`));
+    out(ui.dim(running ? `${store.listAccounts().length} account(s) available · per-request rotation active` : '"codexswitch run --proxy" will fall back to direct mode'));
+    return 0;
+  }
   let port = proxy.DEFAULT_PORT;
   for (let i = 0; i < args.length; i++) {
     if (args[i] === '--port' || args[i] === '-p') port = parseInt(args[++i], 10);
@@ -807,13 +1080,18 @@ async function cmdServer(args) {
 async function cmdRun(args) {
   store.syncBack(); // pick up tokens refreshed by plain codex before overlaying
   let proxyPort = null;
+  const requireProxy = args.includes('--require-proxy');
+  args = args.filter((a) => a !== '--require-proxy');
   if (args.includes('--proxy')) {
     const proxy = require('./proxy.js');
     args = args.filter((a) => a !== '--proxy');
     const state = readJSONSafe(path.join(store.paths().home, 'proxy.json'));
     proxyPort = (state && state.port) || proxy.DEFAULT_PORT;
     if (!(await proxy.ping(proxyPort))) {
-      throw new Error(`no proxy on port ${proxyPort} — start it first with "codexswitch server"`);
+      if (requireProxy) throw new Error(`no proxy on port ${proxyPort} — start it first with "codexswitch server"`);
+      out(ui.warn(`proxy unavailable on port ${proxyPort} — running directly with the selected account`));
+      out(ui.dim('use --require-proxy to fail instead of falling back'));
+      proxyPort = null;
     }
   }
   let name = null;
@@ -829,9 +1107,10 @@ async function cmdRun(args) {
     name = meta.active && store.accountExists(meta.active) ? meta.active : picked.name;
   }
   if (rest[0] === '--') rest = rest.slice(1);
+  const rawExecArgs = rest[0] === 'exec' ? rest.slice(1) : null;
   const meta = store.loadMeta();
   if (rest[0] === 'exec') {
-    rest = ['exec', ...buildExecArgs(rest.slice(1), meta)];
+    rest = ['exec', ...buildExecArgs(withMemoryPrompt(rest.slice(1), name, meta), meta)];
   } else if (rest.length === 0) {
     // interactive TUI launch — apply the same defaults
     if (meta.model) rest = ['-m', meta.model];
@@ -839,8 +1118,30 @@ async function cmdRun(args) {
   }
   out(ui.info(`running codex as ${ui.bold(`"${name}"`)}${proxyPort ? ui.dim(` via proxy :${proxyPort}`) : ''}`));
   const startTs = Date.now();
+  const before = rawExecArgs ? workspaceSnapshot() : null;
   const res = await runner.runCodex(name, rest, { proxyPort });
   runner.recordUsage(name, res.profile, startTs);
+  if (rawExecArgs) {
+    const rawPrompt = promptFromExecArgs(rawExecArgs);
+    const after = workspaceSnapshot();
+    const id = `${startTs.toString(36)}-${Math.random().toString(36).slice(2, 5)}`;
+    store.logRun({
+      id,
+      startedAt: startTs,
+      cwd: process.cwd(),
+      prompt: rawPrompt.length > 16384 ? rawPrompt.slice(-16384) : rawPrompt,
+      promptTruncated: rawPrompt.length > 16384,
+      session: rawExecArgs[0] === 'resume' ? 'continue' : 'new',
+      memory: meta.memoryMode || 'off',
+      reasoning: meta.reasoning || 'show',
+      status: res.code === 0 ? 'done' : `failed-${res.code}`,
+      durationMs: Date.now() - startTs,
+      attempts: [{ account: name, status: res.code === 0 ? 'done' : `exit-${res.code}`, durationMs: Date.now() - startTs }],
+      files: Object.keys(after),
+      touchedFiles: Object.keys({ ...before, ...after }).filter((file) => before[file] !== after[file]),
+    });
+    console.error(ui.info(ui.dim(`history ${id} · view: codexswitch history show ${id}`)));
+  }
   return res.code;
 }
 
@@ -872,9 +1173,45 @@ async function cmdExec(args) {
 
   store.syncBack(); // pick up tokens refreshed by plain codex before overlaying
   const meta = store.loadMeta();
+  const sessionMode = rest[0] === 'resume' ? 'continue' : 'new';
+  const reasoningMode = meta.reasoning || 'show';
+  const compact = compactOutputEnabled(meta);
+  const userOutputFile = existingOutputFile(rest);
+  const lastMessageFile = userOutputFile || path.join(os.tmpdir(), `codexswitch-result-${process.pid}-${Date.now()}.txt`);
+  const cleanupResult = () => {
+    if (!userOutputFile) fs.rmSync(lastMessageFile, { force: true });
+  };
   const total = store.listAccounts().length;
   if (total === 0) throw new Error('no accounts — add one with "codexswitch login"');
 
+  const historyStarted = Date.now();
+  const rawPrompt = promptFromExecArgs(rest);
+  const promptTruncated = rawPrompt.length > 16384;
+  const runRecord = {
+    id: `${historyStarted.toString(36)}-${Math.random().toString(36).slice(2, 5)}`,
+    startedAt: historyStarted,
+    cwd: process.cwd(),
+    prompt: promptTruncated ? rawPrompt.slice(-16384) : rawPrompt,
+    promptTruncated,
+    session: sessionMode,
+    memory: meta.memoryMode || 'off',
+    reasoning: reasoningMode,
+    status: 'running',
+    attempts: [],
+    workspaceBefore: workspaceSnapshot(),
+  };
+  const finishHistory = (status) => {
+    runRecord.status = status;
+    runRecord.durationMs = Date.now() - historyStarted;
+    const after = workspaceSnapshot();
+    runRecord.files = Object.keys(after);
+    runRecord.touchedFiles = Object.keys({ ...runRecord.workspaceBefore, ...after }).filter(
+      (file) => runRecord.workspaceBefore[file] !== after[file]
+    );
+    delete runRecord.workspaceBefore;
+    store.logRun(runRecord);
+  };
+
   const tried = [];
   let useResume = false;
   for (let attempt = 0; attempt < total; attempt++) {
@@ -887,25 +1224,47 @@ async function cmdExec(args) {
       name = picked.name;
     }
     tried.push(name);
-    console.error(
-      ui.info(`exec as ${ui.bold(`"${name}"`)}${ui.dim(attempt > 0 ? ` (attempt ${attempt + 1}${useResume ? ', resuming session' : ''})` : '')}`)
-    );
+    if (!compact) {
+      console.error(
+        ui.info(
+          `account ${ui.bold(`"${name}"`)}${ui.dim(` · session ${useResume || sessionMode === 'continue' ? 'continue' : 'new'} · reasoning ${reasoningMode}`)}` +
+            `${ui.dim(attempt > 0 ? ` · attempt ${attempt + 1}` : '')}`
+        )
+      );
+    }
     // On rotation, continue the same session with the next account instead
     // of restarting the whole prompt — the session files are shared.
-    const codexArgs = useResume
-      ? ['exec', 'resume', '--last', ...buildExecArgs([], meta), '--', RESUME_PROMPT]
-      : ['exec', ...buildExecArgs(rest, meta)];
+    const memoryArgs = useResume
+      ? withMemoryPrompt(['resume', '--last', '--', RESUME_PROMPT], name, meta)
+      : withMemoryPrompt(rest, name, meta);
+    const displayArgs = compact ? outputFileArg(memoryArgs, lastMessageFile) : memoryArgs;
+    const codexArgs = ['exec', ...buildExecArgs(displayArgs, meta)];
     const startTs = Date.now();
-    const res = await runner.runCodex(name, codexArgs, { capture: true });
+    const stopProgress = compact
+      ? startCompactProgress(name, attempt + 1, useResume || sessionMode === 'continue' ? 'continued' : 'new')
+      : () => {};
+    const res = await runner.runCodex(name, codexArgs, { capture: true, silent: compact });
+    stopProgress();
     runner.recordUsage(name, res.profile, startTs);
     if (res.code === 0) {
+      runRecord.attempts.push({ account: name, status: 'done', durationMs: Date.now() - startTs });
       store.clearLimited(name);
-      console.error(ui.ok(`done as ${ui.bold(`"${name}"`)}`));
+      if (!compact) console.error(ui.ok(`done as ${ui.bold(`"${name}"`)}`));
       store.logEvent('exec', `done as "${name}"${useResume ? ' (resumed session)' : ''}`);
       warnIfOverThreshold(name);
+      finishHistory('done');
+      if (compact) {
+        const finalMessage = (() => {
+          try { return fs.readFileSync(lastMessageFile, 'utf8'); } catch { return ''; }
+        })();
+        printCompactResult(finalMessage, runRecord);
+      }
+      cleanupResult();
+      console.error(ui.info(ui.dim(`history ${runRecord.id} · view: codexswitch history show ${runRecord.id}`)));
       return 0;
     }
     if (runner.looksRateLimited(res.output, meta.limitPatterns)) {
+      runRecord.attempts.push({ account: name, status: 'rate-limited', durationMs: Date.now() - startTs });
       const until = Date.now() + runner.limitCooldownMs(res.output, meta.cooldownMinutes);
       store.markLimited(name, until);
       if (allowResume && !useResume && runner.sessionTouchedSince(res.profile, startTs)) {
@@ -918,6 +1277,7 @@ async function cmdExec(args) {
       continue;
     }
     if (runner.looksAuthFailed(res.output)) {
+      runRecord.attempts.push({ account: name, status: 'auth-failed', durationMs: Date.now() - startTs });
       // A revoked token won't heal by itself — take the account out of
       // rotation and keep the task going on the next one.
       setFlag(name, { disabled: true });
@@ -927,9 +1287,19 @@ async function cmdExec(args) {
       store.logEvent('auth', `"${name}" disabled (revoked login)`);
       continue;
     }
+    runRecord.attempts.push({ account: name, status: `exit-${res.code}`, durationMs: Date.now() - startTs });
+    finishHistory(`failed-${res.code}`);
+    if (compact) {
+      console.error(ui.fail('Codex failed'));
+      console.error(res.output.trim().split(/\r?\n/).slice(-12).join('\n'));
+    }
+    cleanupResult();
     return res.code; // real failure, don't burn other accounts on it
   }
   console.error(ui.fail('all accounts are rate-limited, over threshold, or disabled'));
+  finishHistory('exhausted');
+  cleanupResult();
+  console.error(ui.info(ui.dim(`history ${runRecord.id} · view: codexswitch history show ${runRecord.id}`)));
   return 2;
 }
 
@@ -937,21 +1307,32 @@ async function cmdExec(args) {
 // 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() {
+async function cmdChat({ welcome = true } = {}) {
   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'));
+  let welcomePrompt = null;
+  if (welcome) {
+    const landing = await require('./welcome.js').readWelcomePrompt();
+    if (landing.shown && landing.prompt == null) return 0;
+    welcomePrompt = landing.prompt;
+  }
+  const chatStatus = () => {
+    const currentMeta = store.loadMeta();
+    const active = store.listAccounts().find((a) => a.active);
+    const next = store.pickAccount();
+    return `model ${currentMeta.model || 'default'} · reasoning ${currentMeta.reasoning || 'show'} · output ${currentMeta.outputMode || 'auto'} · memory ${currentMeta.memoryMode || 'off'} · account ${(active && active.name) || (next && next.name) || 'none'}`;
+  };
+  out(`${ui.bold('codexswitch chat')} ${ui.dim(`· ${chatStatus()}`)}`);
+  out(ui.dim('Enter sends · /paste starts multiline input · /help lists commands\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 pending = welcomePrompt ? [welcomePrompt] : [];
   const waiters = [];
   let closed = false;
   rl.on('line', (l) => {
@@ -971,6 +1352,7 @@ async function cmdChat() {
   };
 
   let inSession = false;
+  let turn = 0;
   for (;;) {
     const raw = await ask();
     if (raw == null) break; // EOF (Ctrl-D or piped input ended)
@@ -982,7 +1364,9 @@ async function cmdChat() {
       try {
         if (cmd === 'quit' || cmd === 'exit' || cmd === 'q') break;
         else if (cmd === 'help')
-          out(ui.dim('/usage /list /use <name> /next /model [m] /sandbox [mode] /reasoning [mode] /new (fresh session) /quit'));
+          out(ui.dim('/status /history [id] /usage /list /use <name> /next /model [m] /sandbox [mode] /reasoning [mode] /output [mode] /memory [command] /paste /new /quit'));
+        else if (cmd === 'status') out(ui.info(chatStatus()));
+        else if (cmd === 'history') cmdHistory(rest.length ? ['show', rest[0]] : []);
         else if (cmd === 'usage') cmdUsage([]);
         else if (cmd === 'list') cmdList();
         else if (cmd === 'use') cmdUse(rest);
@@ -990,9 +1374,33 @@ async function cmdChat() {
         else if (cmd === 'model') cmdModel(rest);
         else if (cmd === 'sandbox') cmdSandbox(rest);
         else if (cmd === 'reasoning') cmdReasoning(rest);
+        else if (cmd === 'output') cmdOutput(rest);
+        else if (cmd === 'memory') cmdMemory(rest);
         else if (cmd === 'new') {
           inSession = false;
+          turn = 0;
           out(ui.ok('starting a fresh session on the next prompt'));
+        } else if (cmd === 'paste' || cmd === 'multiline') {
+          out(ui.info('multiline input · finish with /end on its own line · cancel with /cancel'));
+          const parts = [];
+          for (;;) {
+            const pasted = await ask();
+            if (pasted == null || pasted.trim() === '/cancel') {
+              parts.length = 0;
+              out(ui.warn('multiline input cancelled'));
+              break;
+            }
+            if (pasted.trim() === '/end') break;
+            parts.push(pasted);
+          }
+          if (parts.length > 0) {
+            const prompt = parts.join('\n');
+            turn++;
+            out(ui.info(`turn ${turn} · ${inSession ? 'continuing session' : 'new session'} · ${prompt.split('\n').length} lines`));
+            const code = await cmdExec(inSession ? ['resume', '--last', '--', prompt] : ['--', prompt]);
+            if (code === 0) inSession = true;
+            else if (code === 2) out(ui.fail('all accounts exhausted — try again later or /use a specific account'));
+          }
         } else out(ui.warn(`unknown command /${cmd} — try /help`));
       } catch (e) {
         out(ui.fail(e.message));
@@ -1002,11 +1410,14 @@ async function cmdChat() {
 
     // "--" marks the prompt as positional so lines starting with "-" are
     // never parsed as codex options.
+    turn++;
+    out(ui.info(`turn ${turn} · ${inSession ? 'continuing session' : 'new session'}`));
     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();
+  out(ui.dim(`\nsession ended · ${turn} turn${turn === 1 ? '' : 's'}${turn > 0 ? ' · review with "codexswitch history"' : ''}`));
   return 0;
 }
 
@@ -1027,6 +1438,11 @@ async function main(argv) {
   const [cmd, ...args] = argv;
   switch (cmd) {
     case undefined:
+      if (store.listAccounts().length === 0) {
+        printEmptyAccounts();
+        return 0;
+      }
+      return cmdChat();
     case 'help':
     case '--help':
     case '-h':
@@ -1056,6 +1472,9 @@ async function main(argv) {
     case 'log':
     case 'activity':
       return cmdLog(args), 0;
+    case 'history':
+    case 'work':
+      return cmdHistory(args), 0;
     case 'use':
       return cmdUse(args), 0;
     case 'current':
@@ -1084,8 +1503,12 @@ async function main(argv) {
       return cmdModel(args), 0;
     case 'reasoning':
       return cmdReasoning(args), 0;
+    case 'output':
+      return cmdOutput(args), 0;
     case 'sandbox':
       return cmdSandbox(args), 0;
+    case 'memory':
+      return cmdMemory(args), 0;
     case 'add-key':
     case 'apikey':
       return cmdAddKey(args), 0;
@@ -1117,7 +1540,7 @@ async function main(argv) {
       return cmdExec(args);
     case 'chat':
     case 'repl':
-      return cmdChat();
+      return cmdChat({ welcome: !args.includes('--simple') });
     case 'server':
     case 'proxy':
       return cmdServer(args);

package/src/proxy.js

@@ -16,6 +16,7 @@ const store = require('./store.js');
 
 const DEFAULT_PORT = 8437;
 const MAX_BODY = 32 * 1024 * 1024;
+const RATE_LIMIT_ABSORB_MAX_MS = 60000;
 
 function upstreamBase() {
   return new URL(process.env.CODEX_SWITCH_UPSTREAM || 'https://chatgpt.com');
@@ -62,6 +63,29 @@ function usageFromHeaders(headers) {
   return { p5h, weekly, at };
 }
 
+function retryAfterMs(headers, now = Date.now()) {
+  const value = headers['retry-after'];
+  if (value == null) return null;
+  const seconds = Number(value);
+  if (Number.isFinite(seconds)) return Math.max(0, seconds * 1000);
+  const date = Date.parse(value);
+  return Number.isNaN(date) ? null : Math.max(0, date - now);
+}
+
+// Inspired by teamclaude: a quota rejection should rotate immediately, while
+// a short per-minute throttle should stay on the same account to preserve its
+// prompt cache and avoid cascading the burst across every account.
+function classify429(headers, usage, meta) {
+  const rejected = Object.entries(headers).some(
+    ([key, value]) => /(?:codex|quota|limit).*(?:status|state)/i.test(key) && /rejected|exhausted|quota/i.test(String(value))
+  );
+  const overQuota = [
+    usage && usage.p5h && [usage.p5h.pct, meta.threshold5h],
+    usage && usage.weekly && [usage.weekly.pct, meta.thresholdWeekly],
+  ].some((pair) => pair && pair[0] >= pair[1]);
+  return rejected || overQuota ? 'quota' : 'rate';
+}
+
 function swapHeaders(headers, acct, host) {
   const h = {};
   for (const [k, v] of Object.entries(headers)) {
@@ -129,6 +153,7 @@ function startServer({ port = DEFAULT_PORT, log = () => {} } = {}) {
     const meta = store.loadMeta();
     const total = store.listAccounts().length;
     const tried = [];
+    const absorbed = new Set();
     for (let attempt = 0; attempt < Math.max(1, total); attempt++) {
       const acct = pickAuth(tried);
       if (!acct) {
@@ -147,12 +172,32 @@ function startServer({ port = DEFAULT_PORT, log = () => {} } = {}) {
       }
       const usage = usageFromHeaders(upRes.headers);
       if (usage) store.saveUsage(acct.name, usage);
-      if (upRes.statusCode === 429 && tried.length < total) {
-        store.markLimited(acct.name, Date.now() + meta.cooldownMinutes * 60000);
-        store.logEvent('limit', `proxy: "${acct.name}" got 429 — rotating`);
-        log('rotate', `${acct.name} hit 429 -> trying next account`);
-        upRes.resume(); // discard
-        continue;
+      if (upRes.statusCode === 429) {
+        const kind = classify429(upRes.headers, usage, meta);
+        const retryMs = retryAfterMs(upRes.headers);
+        if (kind === 'rate') {
+          if (retryMs != null && retryMs <= RATE_LIMIT_ABSORB_MAX_MS && !absorbed.has(acct.name)) {
+            absorbed.add(acct.name);
+            log('rate', `${acct.name} throttled for ${Math.ceil(retryMs)}ms — retrying same account`);
+            upRes.resume();
+            await new Promise((resolve) => setTimeout(resolve, retryMs));
+            tried.pop();
+            attempt--;
+            continue;
+          }
+          const pauseMs = retryMs == null ? Math.min(meta.cooldownMinutes * 60000, RATE_LIMIT_ABSORB_MAX_MS) : retryMs;
+          store.markLimited(acct.name, Date.now() + pauseMs);
+          store.logEvent('limit', `proxy: "${acct.name}" temporarily throttled — not rotating`);
+          log('rate', `${acct.name} temporarily throttled — preserving account cache`);
+        } else if (tried.length < total) {
+          store.markLimited(acct.name, Date.now() + meta.cooldownMinutes * 60000);
+          store.logEvent('limit', `proxy: "${acct.name}" quota exhausted — rotating`);
+          log('rotate', `${acct.name} quota exhausted -> trying next account`);
+          upRes.resume();
+          continue;
+        } else {
+          store.markLimited(acct.name, Date.now() + meta.cooldownMinutes * 60000);
+        }
       }
       log('req', `${acct.name} ${req.method} ${req.url} -> ${upRes.statusCode}`);
       res.writeHead(upRes.statusCode, upRes.headers);
@@ -217,4 +262,4 @@ function ping(port) {
   });
 }
 
-module.exports = { startServer, ping, DEFAULT_PORT, usageFromHeaders };
+module.exports = { startServer, ping, DEFAULT_PORT, usageFromHeaders, retryAfterMs, classify429 };

package/src/store.js

@@ -19,6 +19,7 @@ function paths() {
     codexHome,
     accountsDir: path.join(home, 'accounts'),
     profilesDir: path.join(home, 'profiles'),
+    memoryDir: path.join(home, 'memory'),
     metaPath: path.join(home, 'meta.json'),
     authPath: path.join(codexHome, 'auth.json'),
   };
@@ -64,10 +65,80 @@ function readEvents(count = 20) {
   }
 }
 
+// Structured work history is separate from the operational activity log.
+// It intentionally contains user prompts, so the file is created private.
+function logRun(record) {
+  try {
+    ensureDir(paths().home);
+    fs.appendFileSync(path.join(paths().home, 'history.jsonl'), JSON.stringify(record) + '\n', { mode: 0o600 });
+  } catch {
+    /* history must never break an actual Codex run */
+  }
+}
+
+function readRuns(count = 20) {
+  try {
+    const lines = fs.readFileSync(path.join(paths().home, 'history.jsonl'), 'utf8').trim().split('\n');
+    return lines.slice(-count).map((line) => {
+      try {
+        return JSON.parse(line);
+      } catch {
+        return null;
+      }
+    }).filter(Boolean).reverse();
+  } catch {
+    return [];
+  }
+}
+
+function findRun(id) {
+  const runs = readRuns(1000);
+  if (id === 'latest') return runs[0] || null;
+  return runs.find((run) => run.id === id || run.id.startsWith(id)) || null;
+}
+
 function saveMeta(meta) {
   writeJSONAtomic(paths().metaPath, meta);
 }
 
+function memoryPath(mode, accountName = null) {
+  const p = paths();
+  if (mode === 'shared') return path.join(p.memoryDir, 'shared.md');
+  if (mode === 'isolated') {
+    if (!accountName) throw new Error('isolated memory requires an account name');
+    // Reuse the account-name validation used for credential filenames.
+    accountPath(accountName);
+    return path.join(p.memoryDir, 'accounts', `${accountName}.md`);
+  }
+  return null;
+}
+
+function readMemory(mode, accountName = null) {
+  const file = memoryPath(mode, accountName);
+  if (!file) return '';
+  try {
+    // Bound prompt growth even if the file was edited externally.
+    const text = fs.readFileSync(file, 'utf8');
+    return text.length > 32768 ? text.slice(-32768) : text;
+  } catch {
+    return '';
+  }
+}
+
+function appendMemory(mode, accountName, text) {
+  const file = memoryPath(mode, accountName);
+  if (!file) throw new Error('memory is off — enable it with "codexswitch memory shared" or "memory isolated"');
+  const clean = String(text || '').trim();
+  if (!clean) throw new Error('memory text cannot be empty');
+  ensureDir(path.dirname(file));
+  if (!fs.existsSync(file)) {
+    const title = mode === 'shared' ? '# Shared Codex memory\n' : `# Memory for ${accountName}\n`;
+    fs.writeFileSync(file, `${title}\n`, { mode: 0o600 });
+  }
+  fs.appendFileSync(file, `- ${clean.replace(/\n/g, '\n  ')}\n`, { mode: 0o600 });
+  return file;
+}
+
 function accountPath(name) {
   // Unicode letters/digits are fine (names become filenames); block path
   // separators, traversal, and characters invalid on Windows filesystems.
@@ -268,10 +339,17 @@ module.exports = {
   nextAccount,
   logEvent,
   readEvents,
+  logRun,
+  readRuns,
+  findRun,
+  memoryPath,
+  readMemory,
+  appendMemory,
   ensureDirs() {
     const p = paths();
     ensureDir(p.home);
     ensureDir(p.accountsDir);
     ensureDir(p.profilesDir);
+    ensureDir(p.memoryDir);
   },
 };

package/src/util.js

@@ -89,11 +89,37 @@ function fmtRemaining(untilTs) {
   return h > 0 ? `${h}h${m}m` : `${m}m`;
 }
 
+// Terminal columns are not the same as JavaScript string length: Korean,
+// Japanese, Chinese and emoji commonly occupy two columns. Keeping this
+// small and dependency-free is sufficient for account names and table data.
+function displayWidth(value) {
+  const text = require('./ui.js').visible(String(value));
+  let width = 0;
+  for (const ch of text) {
+    const cp = ch.codePointAt(0);
+    // Combining marks and variation selectors do not advance the cursor.
+    if (/\p{Mark}/u.test(ch) || (cp >= 0xfe00 && cp <= 0xfe0f)) continue;
+    const wide =
+      cp >= 0x1100 &&
+      (cp <= 0x115f ||
+        cp === 0x2329 || cp === 0x232a ||
+        (cp >= 0x2e80 && cp <= 0xa4cf) ||
+        (cp >= 0xac00 && cp <= 0xd7a3) ||
+        (cp >= 0xf900 && cp <= 0xfaff) ||
+        (cp >= 0xfe10 && cp <= 0xfe6f) ||
+        (cp >= 0xff00 && cp <= 0xff60) ||
+        (cp >= 0x1f300 && cp <= 0x1faff) ||
+        (cp >= 0x20000 && cp <= 0x3fffd));
+    width += wide ? 2 : 1;
+  }
+  return width;
+}
+
 function table(rows, headers) {
-  const { visible, dim } = require('./ui.js');
+  const { dim } = require('./ui.js');
   const all = [headers, ...rows].map((r) => r.map((c) => String(c == null ? '-' : c)));
-  const widths = headers.map((_, i) => Math.max(...all.map((r) => visible(r[i]).length)));
-  const pad = (c, w) => c + ' '.repeat(Math.max(0, w - visible(c).length));
+  const widths = headers.map((_, i) => Math.max(...all.map((r) => displayWidth(r[i]))));
+  const pad = (c, w) => c + ' '.repeat(Math.max(0, w - displayWidth(c)));
   const line = (r) => r.map((c, i) => pad(c, widths[i])).join('  ').trimEnd();
   return [dim(line(all[0])), dim(line(widths.map((w) => '-'.repeat(w)))), ...all.slice(1).map(line)].join('\n');
 }
@@ -108,5 +134,6 @@ module.exports = {
   parseDurationMs,
   fmtDate,
   fmtRemaining,
+  displayWidth,
   table,
 };

package/src/welcome.js

@@ -0,0 +1,184 @@
+'use strict';
+
+const path = require('path');
+const { spawnSync } = require('child_process');
+const store = require('./store.js');
+const ui = require('./ui.js');
+const { displayWidth, fmtRemaining } = require('./util.js');
+const pkg = require('../package.json');
+
+const MIN_WIDTH = 76;
+const MIN_HEIGHT = 22;
+
+function crop(value, width) {
+  const text = String(value == null ? '' : value);
+  if (displayWidth(text) <= width) return text;
+  let out = '';
+  for (const ch of text) {
+    if (displayWidth(out + ch + '…') > width) break;
+    out += ch;
+  }
+  return out + '…';
+}
+
+function fit(value, width) {
+  const text = crop(value, width);
+  return text + ' '.repeat(Math.max(0, width - displayWidth(text)));
+}
+
+function center(value, width) {
+  const text = crop(value, width);
+  const gap = Math.max(0, width - displayWidth(text));
+  return ' '.repeat(Math.floor(gap / 2)) + text + ' '.repeat(Math.ceil(gap / 2));
+}
+
+function percent(account) {
+  const win = account.usage && account.usage.p5h;
+  return win && typeof win.pct === 'number' ? `${Math.round(win.pct)}%` : '--';
+}
+
+function accountState(account, now = Date.now()) {
+  if (account.disabled) return 'disabled';
+  if (account.limitedUntil && account.limitedUntil > now) return `paused ${fmtRemaining(account.limitedUntil)}`;
+  return 'ready';
+}
+
+function projectPulse(cwd = process.cwd()) {
+  const branch = spawnSync('git', ['branch', '--show-current'], { cwd, encoding: 'utf8' });
+  const status = spawnSync('git', ['status', '--short'], { cwd, encoding: 'utf8' });
+  return {
+    branch: branch.status === 0 && branch.stdout.trim() ? branch.stdout.trim() : '(not a git repository)',
+    changes: status.status === 0 && status.stdout.trim() ? status.stdout.trim().split(/\r?\n/).length : 0,
+  };
+}
+
+function welcomeState() {
+  const meta = store.loadMeta();
+  const accounts = store.listAccounts();
+  const active = accounts.find((a) => a.active) || store.pickAccount() || accounts[0] || null;
+  return {
+    version: pkg.version,
+    accounts,
+    active,
+    model: meta.model || 'default',
+    reasoning: meta.reasoning || 'show',
+    memory: meta.memoryMode || 'off',
+    output: meta.outputMode || 'auto',
+    history: store.readRuns(3),
+    project: projectPulse(),
+    cwd: process.cwd(),
+  };
+}
+
+function buildWelcomeFrame({ width, height, input = '', state = welcomeState() }) {
+  if (width < MIN_WIDTH || height < MIN_HEIGHT) return null;
+  const inner = width - 2;
+  const leftW = Math.max(34, Math.floor(inner * 0.49));
+  const rightW = inner - leftW - 1;
+  const bodyH = height - 6;
+  const left = [];
+  const right = [];
+
+  const logo = [
+    ' ██████╗██╗  ██╗███████╗',
+    '██╔════╝╚██╗██╔╝██╔════╝',
+    '██║      ╚███╔╝ ███████╗',
+    '██║      ██╔██╗ ╚════██║',
+    '╚██████╗██╔╝ ██╗███████║',
+    ' ╚═════╝╚═╝  ╚═╝╚══════╝',
+  ];
+  const topPad = Math.max(1, Math.floor((bodyH - 14) / 2));
+  for (let i = 0; i < topPad; i++) left.push('');
+  left.push(center(ui.bold(ui.cyan('CODEX SWITCH')), leftW));
+  left.push(center(ui.dim('rotate · continue · remember'), leftW));
+  left.push('');
+  logo.forEach((line) => left.push(center(ui.cyan(line), leftW)));
+  left.push('');
+  left.push(center(state.active ? `${ui.green('●')} ${ui.bold(state.active.name)} · ${accountState(state.active)} · ${percent(state.active)}` : ui.yellow('No usable account'), leftW));
+  left.push(center(ui.dim(`${state.accounts.length} account(s) · memory ${state.memory}`), leftW));
+
+  right.push(ui.bold(ui.cyan('Quick commands')));
+  right.push(ui.dim('/help  /usage  /history  /output  /memory  /new'));
+  right.push(ui.dim('Enter send · /paste multiline · /quit exit'));
+  right.push(ui.dim('─'.repeat(Math.max(1, rightW))));
+  right.push(ui.bold(ui.cyan('Account pool')));
+  for (const account of state.accounts.slice(0, 5)) {
+    const mark = account.active ? ui.green('●') : '○';
+    right.push(`${mark} ${account.name}  ${ui.dim(`${accountState(account)} · 5h ${percent(account)}`)}`);
+  }
+  if (state.accounts.length > 5) right.push(ui.dim(`… ${state.accounts.length - 5} more`));
+  right.push(ui.dim('─'.repeat(Math.max(1, rightW))));
+  right.push(ui.bold(ui.cyan('Project pulse')));
+  right.push(`branch ${ui.bold(state.project.branch)} · ${state.project.changes} change(s)`);
+  right.push(ui.dim(crop(state.cwd, rightW)));
+  right.push(ui.dim('─'.repeat(Math.max(1, rightW))));
+  right.push(ui.bold(ui.cyan('Session trail')));
+  if (state.history.length === 0) right.push(ui.dim('No saved work history'));
+  else state.history.forEach((run) => right.push(`${run.status === 'done' ? ui.green('✓') : ui.yellow('!')} ${crop(run.prompt || '(no prompt)', Math.max(8, rightW - 13))} ${ui.dim(run.id)}`));
+
+  while (left.length < bodyH) left.push('');
+  while (right.length < bodyH) right.push('');
+  const title = ` cxs v${state.version} · persistent Codex workspace `;
+  const topLeft = Math.max(0, leftW - displayWidth(title) - 1);
+  const lines = [`┌─${title}${'─'.repeat(topLeft)}┬${'─'.repeat(rightW)}┐`];
+  for (let i = 0; i < bodyH; i++) lines.push(`│${fit(left[i], leftW)}│${fit(right[i], rightW)}│`);
+  lines.push(`└${'─'.repeat(leftW)}┴${'─'.repeat(rightW)}┘`);
+
+  const status = state.active
+    ? `${ui.green('●')} ${state.active.name} · model ${state.model} · reasoning ${state.reasoning} · ${crop(state.cwd, Math.max(8, width - 48))}`
+    : ui.yellow('No usable account');
+  lines.push(fit(status, width));
+  lines.push(`┌${'─'.repeat(width - 2)}┐`);
+  const prompt = input ? `› ${input}` : ui.dim('› Type your message…  Enter: send · /help: commands · Ctrl-C: exit');
+  lines.push(`│${fit(prompt, width - 2)}│`);
+  lines.push(`└${'─'.repeat(width - 2)}┘`);
+  return lines.slice(0, height).map((line) => fit(line, width)).join('\r\n');
+}
+
+async function readWelcomePrompt() {
+  if (!process.stdin.isTTY || !process.stdout.isTTY || process.env.CXS_SIMPLE_UI === '1') return { prompt: null, shown: false };
+  if ((process.stdout.columns || 80) < MIN_WIDTH || (process.stdout.rows || 24) < MIN_HEIGHT) return { prompt: null, shown: false };
+  let input = '';
+  let done = false;
+  const draw = () => {
+    const frame = buildWelcomeFrame({
+      width: process.stdout.columns || 80,
+      height: process.stdout.rows || 24,
+      input,
+    });
+    if (frame) process.stdout.write(`\x1b[H${frame}`);
+  };
+  process.stdout.write('\x1b[?1049h\x1b[2J\x1b[H\x1b[?25h');
+  process.stdin.setRawMode(true);
+  process.stdin.resume();
+  process.stdin.setEncoding('utf8');
+  draw();
+  const prompt = await new Promise((resolve) => {
+    const onResize = () => draw();
+    const finish = (value) => {
+      if (done) return;
+      done = true;
+      process.stdin.removeListener('data', onData);
+      process.stdout.removeListener('resize', onResize);
+      resolve(value);
+    };
+    const onData = (data) => {
+      if (data === '\u0003' || data === '\u0004' || data === '\u001b') return finish(null);
+      if (data === '\r' || data === '\n') {
+        if (input.trim()) finish(input.trim());
+        return;
+      }
+      if (data === '\u007f' || data === '\b') input = Array.from(input).slice(0, -1).join('');
+      else if (!data.startsWith('\u001b')) input += Array.from(data).filter((ch) => ch >= ' ' && ch !== '\u007f').join('');
+      draw();
+    };
+    process.stdin.on('data', onData);
+    process.stdout.on('resize', onResize);
+  });
+  try { process.stdin.setRawMode(false); } catch { /* best effort */ }
+  process.stdin.pause();
+  process.stdout.write('\x1b[?25h\x1b[?1049l');
+  return { prompt, shown: true };
+}
+
+module.exports = { buildWelcomeFrame, readWelcomePrompt, welcomeState, MIN_WIDTH, MIN_HEIGHT };