@tigorhutasuhut/claude-retry 0.1.1 → 0.1.3

package/README.md

@@ -1,6 +1,6 @@
 # claude-retry
 
-Watches every Claude CLI pane in a [zellij](https://zellij.dev/) terminal session. When a pane hits Anthropic's 5-hour usage limit, it detects the rate-limit message, waits until that pane's reset time, then injects `continue` to resume automatically. One daemon covers all your Claude sessions at once.
+Watches every pane across **all** your [zellij](https://zellij.dev/) sessions. When a pane hits Anthropic's usage/session limit, it detects the on-screen rate-limit banner, then confirms against Anthropic's usage API — the same data the `/usage` command shows — to get the **exact** reset time and to discard stale banners. Once the reset elapses it clears the input and injects `continue` to resume automatically. One daemon covers every session at once — even detached ones.
 
 ## Install
 
@@ -12,35 +12,31 @@ The package is scoped (`@tigorhutasuhut/claude-retry`); the installed command is
 
 ## Usage
 
-Must be run inside a zellij session. The recommended way to run claude-retry is as a foreground daemon in a dedicated zellij pane:
-
-1. In your main pane, run `claude` as normal.
-2. Open a second pane (e.g. `Ctrl+p` then `d` to split down).
-3. In the new pane, start the daemon:
+Run it as a foreground daemon, ideally in its **own dedicated zellij session** (the daemon skips its own session, so this keeps it from scanning itself):
 
 ```bash
+# in a session you keep around, e.g. "Claude Retry Monitor":
 claude-retry start
 ```
 
-`start` rediscovers Claude panes on **every pass** (every 60s) via `zellij action list-clients`. This means:
+`start` re-scans **every pass** (60s): it walks all live zellij sessions and every pane in them, dumps each pane's screen, and acts on the ones showing a rate-limit banner. This means:
+
+- **One** daemon covers every session — projects, branches, all of them.
+- It works on **detached** sessions (uses zellij's global `--session` flag, not attached clients).
+- Open a brand-new Claude session anywhere → picked up on the next pass. **No restart needed.**
+- Close a pane → dropped from the watch list silently.
+- Each pane keeps its own independent rate-limit state.
 
-- You only ever need **one** daemon, no matter how many Claude sessions you run.
-- Open a new Claude session in a new pane → it's picked up automatically on the next pass. **No restart needed.**
-- Close a Claude pane → it's dropped from the watch list silently.
-- Each pane gets its own independent rate-limit state.
+Leave it running — the pane *is* the daemon. zellij keeps it alive across detach/attach, so you don't need systemd or any external supervisor. Chatty logs stream to stderr so you always see signs of life.
 
-Leave it running — the pane *is* the daemon. zellij keeps it alive across detach/attach, so you don't need systemd or any external supervisor. Logs stream to stderr so you always see signs of life.
+> **Start Claude the right way for detection.** Launch the session with the plain `claude` command, then run the `/remote-control` slash command *inside* it. Do **not** use the `claude remote-control` CLI subcommand directly — that mode silences the on-screen text, so `dump-screen` captures nothing and the rate-limit banner can't be detected. Running `claude` → `/remote-control` keeps the session "live" and visible to the monitor.
 
-> **Start Claude the right way for detection.** Launch the session with the plain `claude` command, then run the `/remote-control` slash command *inside* it. Do **not** use the `claude remote-control` CLI subcommand directly — that mode silences the on-screen text, so `dump-screen` captures nothing and the rate-limit message can't be detected. Running `claude` → `/remote-control` keeps the session "live" and visible to the monitor.
+### Single-pane mode (legacy)
 
-To pin the daemon to a single pane instead of auto-discovery:
+To watch just one pane in the **current** session, by ID:
 
 ```bash
-# Watch one specific pane by ID:
 claude-retry monitor 3
-
-# Or restrict 'start' to one pane via env:
-CLAUDE_PANE_ID=3 claude-retry start
 ```
 
 ### Optional: shell wrapper
@@ -57,28 +53,30 @@ source (npm root -g)/claude-retry/shell/wrapper.fish
 source "$(npm root -g)/claude-retry/shell/wrapper.bash"
 ```
 
-## Configuration
-
-```bash
-CLAUDE_PANE_ID=3 claude-retry start   # pin to one pane, skip auto-discovery
-```
-
 ## How it works
 
 Every pass (60s for `start`, 5s for single-pane `monitor`):
 
-1. **Discover** — `start` lists Claude panes via `zellij action list-clients`, matching panes whose command is the `claude` CLI (the daemon's own `claude-retry` pane is excluded). New panes are added, closed panes are pruned.
-2. **Capture** — for each pane, grabs the screen with `zellij action dump-screen` (ANSI stripped).
-3. **Match** — checks the text against the rate-limit patterns.
-4. **Retry** — on detection, parses the reset time and marks the pane `waiting`; once the reset elapses, injects `continue` via `zellij action write-chars`.
+1. **Discover** — `zellij list-sessions` enumerates live sessions (EXITED ones and the daemon's own `$ZELLIJ_SESSION_NAME` are skipped). For each, `zellij --session <name> action list-panes -j` lists its panes; plugins and exited panes are dropped. New panes are added, gone ones pruned.
+2. **Capture** — each pane's visible screen is dumped with `zellij --session <name> action dump-screen --pane-id <id>` (ANSI stripped). This works on detached sessions, no attached client required.
+3. **Match** — the text is checked against the rate-limit patterns. Panes that aren't showing a limit banner are simply left alone.
+4. **Resolve** — on a banner match, the reset time is determined via a three-tier cascade:
+   - **Tier 1 — usage API (primary).** Once per pass, the daemon discovers every Claude account in use by reading `CLAUDE_CONFIG_DIR` from each Claude process via `/proc` (Linux). For each account it calls `GET https://api.anthropic.com/api/oauth/usage` with the OAuth token from `<CLAUDE_CONFIG_DIR>/.credentials.json`. If the account is **not** limited the banner is stale — it is silently ignored, no wait issued. If the account **is** limited the daemon waits until the API's exact `resets_at` timestamp. Credentials are re-read every pass, so token refreshes are picked up automatically.
+   - **Tier 2 — /proc pane→account bridge (planned).** Needed only when two or more accounts are limited simultaneously, so the daemon must map a specific pane to its account. This is a phase-2 stub; until implemented, that case falls through to tier 3.
+   - **Tier 3 — text fallback.** Used when the API is unreachable, the account is unknown, or tier 2 is unresolved. Falls back to parsing the reset time from the on-screen banner text (the original behavior). A banner is never silently ignored when the account is unknown — this ensures a real limit is never missed.
+5. **Retry** — once the resolved reset time elapses, the daemon sends **Ctrl+C** (clears any half-typed input — a single Ctrl+C in Claude Code doesn't quit), then types `continue` and Enter via `write-chars` / `write`.
+
+Per-pane state (keyed by `session:paneId`) persists across passes, so a pane mid-wait isn't disturbed by rediscovery. It runs as a plain foreground process — no transparent session wrapping, no external daemon. The zellij pane is the daemon.
 
-Per-pane state persists across passes, so a pane mid-wait isn't disturbed by rediscovery. It runs as a plain foreground process inside the same zellij session as Claude — no transparent session wrapping, no external daemon. The zellij pane is the daemon.
+> **Multi-account note.** On Linux, account discovery reads `CLAUDE_CONFIG_DIR` from every live Claude process via `/proc`. This means the daemon polls usage for every account in use — not just the default one. On non-Linux systems it falls back to the default account (`~/.claude`) plus tier-3 text parsing.
 
 ## Requirements
 
-- Node.js >= 20
+- Node.js >= 20 (required for global `fetch`, used by the usage API)
 - zellij >= 0.40
 - Must be inside a zellij session when running
+- A logged-in Claude Code installation with a valid `<CLAUDE_CONFIG_DIR>/.credentials.json` (for usage-API tier 1 detection; without it the daemon degrades to text parsing)
+- `/proc` account discovery is Linux-only; on other platforms the daemon uses the default account and text fallback
 
 ## Development
 

package/dist/accounts.d.ts

@@ -0,0 +1,35 @@
+import { type AccountUsage } from './usage.ts';
+import type { PaneTarget } from './zellij.ts';
+export interface AccountSnapshot {
+    byDir: Map<string, AccountUsage>;
+}
+export declare function parseConfigDirFromEnviron(buf: string): string | null;
+export interface DiscoverDeps {
+    platform: string;
+    readdir: (path: string) => Promise<string[]>;
+    readFile: (path: string) => Promise<string>;
+    defaultDir: () => string;
+}
+export interface ProcDeps {
+    platform?: string;
+    listProcPids: () => Promise<string[]>;
+    readCmdline: (pid: string) => Promise<string>;
+    readEnviron: (pid: string) => Promise<string>;
+    listFds: (pid: string) => Promise<string[]>;
+    readlink: (path: string) => Promise<string>;
+}
+interface ClaudeProc {
+    pid: string;
+    configDir: string;
+    pts: string | null;
+}
+interface ZellijServer {
+    session: string;
+    pts: Set<string>;
+}
+export declare function listClaudeProcs(deps: ProcDeps): Promise<ClaudeProc[]>;
+export declare function listZellijServers(deps: ProcDeps): Promise<ZellijServer[]>;
+export declare function discoverAccountDirs(deps?: Partial<DiscoverDeps>): Promise<string[]>;
+export declare function resolvePaneConfigDir(target: PaneTarget, _snapshot: AccountSnapshot, deps?: ProcDeps): Promise<string | null>;
+export {};
+//# sourceMappingURL=accounts.d.ts.map

package/dist/accounts.js

@@ -0,0 +1,197 @@
+import { defaultConfigDir } from "./usage.js";
+export function parseConfigDirFromEnviron(buf) {
+    const entries = buf.split('\0');
+    for (const entry of entries) {
+        if (entry.startsWith('CLAUDE_CONFIG_DIR=')) {
+            const val = entry.slice('CLAUDE_CONFIG_DIR='.length);
+            return val.length > 0 ? val : null;
+        }
+    }
+    return null;
+}
+function defaultProcDeps() {
+    return {
+        platform: process.platform,
+        listProcPids: async () => {
+            const { readdir } = await import('node:fs/promises');
+            const entries = await readdir('/proc');
+            return entries.filter(e => /^\d+$/.test(e));
+        },
+        readCmdline: async (pid) => {
+            const { readFile } = await import('node:fs/promises');
+            return readFile(`/proc/${pid}/cmdline`, 'utf8');
+        },
+        readEnviron: async (pid) => {
+            const { readFile } = await import('node:fs/promises');
+            return readFile(`/proc/${pid}/environ`, 'utf8');
+        },
+        listFds: async (pid) => {
+            const { readdir } = await import('node:fs/promises');
+            return readdir(`/proc/${pid}/fd`);
+        },
+        readlink: async (path) => {
+            const { readlink } = await import('node:fs/promises');
+            return readlink(path);
+        },
+    };
+}
+const CONTRACT_VERSION_SEG = '/contract_version_1/';
+export async function listClaudeProcs(deps) {
+    const result = [];
+    let pids;
+    try {
+        pids = await deps.listProcPids();
+    }
+    catch {
+        return result;
+    }
+    await Promise.all(pids.map(async (pid) => {
+        try {
+            const cmdline = await deps.readCmdline(pid);
+            if (!cmdline.includes('claude'))
+                return;
+            let configDir;
+            try {
+                const environ = await deps.readEnviron(pid);
+                configDir = parseConfigDirFromEnviron(environ) ?? defaultConfigDir();
+            }
+            catch {
+                configDir = defaultConfigDir();
+            }
+            let pts = null;
+            try {
+                const target = await deps.readlink(`/proc/${pid}/fd/0`);
+                if (/^\/dev\/pts\/\d+$/.test(target)) {
+                    pts = target;
+                }
+            }
+            catch {
+                // fd/0 unreadable — pts stays null
+            }
+            result.push({ pid, configDir, pts });
+        }
+        catch {
+            // skip unreadable pid
+        }
+    }));
+    return result;
+}
+export async function listZellijServers(deps) {
+    const result = [];
+    let pids;
+    try {
+        pids = await deps.listProcPids();
+    }
+    catch {
+        return result;
+    }
+    await Promise.all(pids.map(async (pid) => {
+        try {
+            const cmdline = await deps.readCmdline(pid);
+            const args = cmdline.split('\0');
+            const serverIdx = args.indexOf('--server');
+            if (serverIdx === -1)
+                return;
+            const serverPath = args[serverIdx + 1];
+            if (serverPath === undefined)
+                return;
+            const idx = serverPath.lastIndexOf(CONTRACT_VERSION_SEG);
+            if (idx === -1)
+                return;
+            const session = serverPath.slice(idx + CONTRACT_VERSION_SEG.length).trimEnd();
+            if (!session)
+                return;
+            const pts = new Set();
+            try {
+                const fds = await deps.listFds(pid);
+                await Promise.all(fds.map(async (fd) => {
+                    try {
+                        const target = await deps.readlink(`/proc/${pid}/fd/${fd}`);
+                        if (/^\/dev\/pts\/\d+$/.test(target)) {
+                            pts.add(target);
+                        }
+                    }
+                    catch {
+                        // skip unreadable fd
+                    }
+                }));
+            }
+            catch {
+                // listFds failed — server with empty pts still recorded
+            }
+            result.push({ session, pts });
+        }
+        catch {
+            // skip unreadable pid
+        }
+    }));
+    return result;
+}
+export async function discoverAccountDirs(deps) {
+    const platform = deps?.platform ?? process.platform;
+    const readdirFn = deps?.readdir ?? (async (p) => {
+        const { readdir } = await import('node:fs/promises');
+        return readdir(p);
+    });
+    const readFileFn = deps?.readFile ?? (async (p) => {
+        const { readFile } = await import('node:fs/promises');
+        return readFile(p, 'utf8');
+    });
+    const defaultDir = deps?.defaultDir ?? (() => defaultConfigDir());
+    const base = defaultDir();
+    const dirs = new Set([base]);
+    if (platform !== 'linux') {
+        return [base];
+    }
+    try {
+        const entries = await readdirFn('/proc');
+        const pids = entries.filter(e => /^\d+$/.test(e));
+        await Promise.all(pids.map(async (pid) => {
+            try {
+                const cmdline = await readFileFn(`/proc/${pid}/cmdline`);
+                if (!cmdline.includes('claude'))
+                    return;
+                const environ = await readFileFn(`/proc/${pid}/environ`);
+                const dir = parseConfigDirFromEnviron(environ) ?? base;
+                dirs.add(dir);
+            }
+            catch {
+                // skip unreadable pids
+            }
+        }));
+    }
+    catch {
+        // /proc unreadable or other failure → return default only
+        return [base];
+    }
+    return Array.from(dirs);
+}
+export async function resolvePaneConfigDir(target, _snapshot, deps) {
+    try {
+        const d = deps ?? defaultProcDeps();
+        const platform = d.platform ?? process.platform;
+        if (platform !== 'linux')
+            return null;
+        const [servers, claudeProcs] = await Promise.all([
+            listZellijServers(d),
+            listClaudeProcs(d),
+        ]);
+        const server = servers.find(s => s.session === target.session);
+        if (server === undefined)
+            return null;
+        const dirs = new Set();
+        for (const proc of claudeProcs) {
+            if (proc.pts !== null && server.pts.has(proc.pts)) {
+                dirs.add(proc.configDir);
+            }
+        }
+        if (dirs.size === 1) {
+            return [...dirs][0];
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=accounts.js.map

package/dist/cli.js

@@ -1,32 +1,63 @@
 #!/usr/bin/env node
-import { capturePane, inject, listClaudePanes } from "./zellij.js";
+import { capturePane, inject, listPaneTargets, captureTarget, injectTarget, } from "./zellij.js";
 import { runMonitor, runMultiMonitor } from "./monitor.js";
+import { readAccessToken, fetchUsage } from "./usage.js";
+import { discoverAccountDirs, resolvePaneConfigDir } from "./accounts.js";
 const USAGE = `claude-retry — Auto-inject 'continue' when Claude hits a rate limit in zellij
 
 Usage:
-  claude-retry start               Watch ALL Claude panes (re-discovers each pass)
-  claude-retry monitor <pane-id>   Watch one specific zellij pane by ID
+  claude-retry start               Watch ALL Claude panes across ALL sessions
+  claude-retry monitor <pane-id>   Watch one pane by ID in the current session
   claude-retry help                Show this help
 
-Options:
-  CLAUDE_PANE_ID=<id>   Pin 'start' to a single pane instead of auto-discovery
+Run as a foreground daemon in any zellij pane (a dedicated session is ideal).
+'start' polls every 60s, walks every live zellij session and every pane, and
+auto-injects 'continue' after each Claude pane's rate-limit reset time. It works
+on detached sessions and skips its own session. New Claude panes are picked up
+automatically; closed ones are dropped. Logs go to stderr.
 
-Run as a foreground daemon in a dedicated zellij pane. 'start' polls every
-60s, finds every pane running the 'claude' CLI, and injects 'continue' after
-each one's rate-limit reset time. New Claude sessions are picked up
-automatically; closed panes are dropped. Logs go to stderr.`;
+'monitor <pane-id>' is the legacy single-pane mode (current session only).`;
 /** Timestamped stderr logger — chatty so the daemon shows clear signs of life. */
 function log(msg) {
     const ts = new Date().toISOString().slice(11, 19); // HH:MM:SS
     process.stderr.write(`[${ts}] ${msg}\n`);
 }
-const deps = {
+const now = () => Date.now();
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+// Single-pane (legacy 'monitor') deps — addressed by bare pane id.
+const singleDeps = {
     capture: (id) => capturePane(id),
     inject: (id, text) => inject(id, text),
-    now: () => Date.now(),
-    sleep: (ms) => new Promise((r) => setTimeout(r, ms)),
-    listPanes: () => listClaudePanes(),
+    now,
+    sleep,
+};
+// Multi-session ('start') deps — addressed by PaneTarget across sessions.
+const multiDeps = {
+    listTargets: () => listPaneTargets(),
+    capture: (t) => captureTarget(t),
+    inject: (t, text) => injectTarget(t, text),
+    now,
+    sleep,
     log,
+    getAccountSnapshot: async () => {
+        const dirs = await discoverAccountDirs();
+        const byDir = new Map();
+        await Promise.all(dirs.map(async (dir) => {
+            try {
+                const tok = await readAccessToken(dir);
+                if (!tok)
+                    return;
+                const usage = await fetchUsage(tok.token);
+                if (usage)
+                    byDir.set(dir, usage);
+            }
+            catch {
+                // swallow per-account errors — one bad account must not break the pass
+            }
+        }));
+        return { byDir };
+    },
+    resolvePaneAccount: (t, snapshot) => resolvePaneConfigDir(t, snapshot),
 };
 const [, , subcommand, ...rest] = process.argv;
 async function main() {
@@ -39,12 +70,13 @@ async function main() {
                 process.exit(1);
             }
             log(`monitoring single pane ${paneId} (poll 5s)`);
-            await runMonitor(paneId, deps);
+            await runMonitor(paneId, singleDeps);
             break;
         }
         case 'start': {
-            log('claude-retry daemon starting — discovering Claude panes (poll 60s)');
-            await runMultiMonitor(deps);
+            log('claude-retry daemon starting — walking all sessions/panes (poll 60s)');
+            log('usage-API detection enabled — account-aware rate-limit resolution active');
+            await runMultiMonitor(multiDeps);
             break;
         }
         case 'help': {

package/dist/monitor.d.ts

@@ -1,13 +1,25 @@
+import type { PaneTarget } from './zellij.ts';
+import type { AccountSnapshot } from './accounts.ts';
 export interface MonitorDeps {
     capture: (paneId: string) => Promise<string>;
     inject: (paneId: string, text: string) => Promise<void>;
     now: () => number;
     sleep: (ms: number) => Promise<void>;
 }
-export interface MultiMonitorDeps extends MonitorDeps {
-    listPanes: () => Promise<string[]>;
+/** Deps for watching many Claude panes across sessions. Capture/inject are
+ *  addressed by PaneTarget rather than a bare pane id. */
+export interface MultiMonitorDeps {
+    listTargets: () => Promise<PaneTarget[]>;
+    capture: (target: PaneTarget) => Promise<string>;
+    inject: (target: PaneTarget, text: string) => Promise<void>;
+    now: () => number;
+    sleep: (ms: number) => Promise<void>;
     /** Optional sink for chatty progress logs (wired to stderr by the CLI). */
     log?: (msg: string) => void;
+    /** If provided, called ONCE per multiTick pass to get current account usage snapshot. */
+    getAccountSnapshot?: () => Promise<AccountSnapshot>;
+    /** If provided, used to resolve which account a pane belongs to when ambiguous. */
+    resolvePaneAccount?: (t: PaneTarget, s: AccountSnapshot) => Promise<string | null>;
 }
 export type PaneStates = Map<string, MonitorState>;
 export type MonitorStatus = 'monitoring' | 'rate-limited' | 'retried' | 'exited';
@@ -19,12 +31,13 @@ export declare function createState(): MonitorState;
 export declare function tick(paneId: string, state: MonitorState, deps: MonitorDeps, marginSeconds?: number, fallbackHours?: number): Promise<MonitorStatus>;
 export declare function runMonitor(paneId: string, deps: MonitorDeps, pollIntervalMs?: number, marginSeconds?: number, fallbackHours?: number): Promise<void>;
 /**
- * One discovery+monitor pass over every live Claude pane.
+ * One discovery+monitor pass over every Claude pane in every live session.
  *
- * Re-discovers panes each call so new Claude sessions are picked up and
- * closed panes are pruned. Per-pane state lives in `states`, keyed by pane ID,
- * and persists across calls. A failed discovery or a single pane's
- * capture/inject error is swallowed so one bad pane never stops the others.
+ * Re-discovers targets each call so new Claude sessions/panes are picked up and
+ * closed ones are pruned. Per-pane state lives in `states`, keyed by the
+ * target's label (session:paneId), and persists across calls. A failed
+ * discovery or a single pane's capture/inject error is swallowed so one bad
+ * pane never stops the others.
  */
 export declare function multiTick(states: PaneStates, deps: MultiMonitorDeps, marginSeconds?: number, fallbackHours?: number): Promise<void>;
 export declare function runMultiMonitor(deps: MultiMonitorDeps, pollIntervalMs?: number, marginSeconds?: number, fallbackHours?: number): Promise<void>;

package/dist/monitor.js

@@ -3,14 +3,21 @@ import { parseResetTime, calculateWaitMs } from "./time-parser.js";
 export function createState() {
     return { status: 'monitoring', waitUntil: 0 };
 }
-export async function tick(paneId, state, deps, marginSeconds, fallbackHours) {
-    const screenText = await deps.capture(paneId);
+/**
+ * Core state transition for one pane, given its current screen text.
+ * `injectContinue` is called only when a wait period has elapsed. Shared by
+ * single-pane (tick) and multi-session (tickTarget) monitoring.
+ *
+ * When snapshot/resolver/target/log are provided, applies the three-tier
+ * account-aware limit resolution. Single-pane callers omit these — text path only.
+ */
+async function stepState(state, screenText, now, injectContinue, marginSeconds, fallbackHours, snapshot, resolvePaneAccount, target, log) {
     if (state.status === 'waiting') {
-        if (deps.now() < state.waitUntil) {
+        if (now < state.waitUntil) {
             return 'rate-limited';
         }
         // Wait period elapsed — inject continue
-        await deps.inject(paneId, 'continue');
+        await injectContinue();
         state.status = 'monitoring';
         state.waitUntil = 0;
         return 'retried';
@@ -18,15 +25,74 @@ export async function tick(paneId, state, deps, marginSeconds, fallbackHours) {
     // state.status === 'monitoring'
     const result = match(screenText);
     if (result.limited) {
+        const label = target?.label ?? 'pane';
+        const logger = log ?? (() => { });
+        // Tier 1: account-aware resolution when snapshot is available
+        if (snapshot !== undefined) {
+            let accountDir = null;
+            if (snapshot.byDir.size === 1) {
+                // Single account — always attributable, regardless of limited state
+                // (covers both fresh-limit and stale-banner cases without resolver)
+                accountDir = [...snapshot.byDir.keys()][0];
+            }
+            else {
+                // Find dirs that are limited in snapshot
+                const limitedDirs = [];
+                for (const [dir, usage] of snapshot.byDir) {
+                    if (usage.limited)
+                        limitedDirs.push(dir);
+                }
+                if (limitedDirs.length === 1) {
+                    // Exactly one limited account — attribute banner to it
+                    accountDir = limitedDirs[0];
+                }
+                else if (target !== undefined && resolvePaneAccount !== undefined) {
+                    // Ambiguous (0 or 2+) — try proc bridge (phase 2 stub, returns null)
+                    accountDir = await resolvePaneAccount(target, snapshot);
+                }
+            }
+            if (accountDir !== null) {
+                const usage = snapshot.byDir.get(accountDir);
+                if (usage !== undefined) {
+                    if (!usage.limited) {
+                        // Staleness gate: account is not limited → banner is stale → ignore
+                        logger(`${label} stale banner ignored (account not limited)`);
+                        return 'monitoring';
+                    }
+                    // Account confirmed limited — use resetsAtMs if available
+                    const marginMs = (marginSeconds ?? 60) * 1000;
+                    if (usage.resetsAtMs !== null) {
+                        state.waitUntil = usage.resetsAtMs + marginMs;
+                        state.status = 'waiting';
+                        logger(`${label} account ${accountDir} limited, reset ${new Date(usage.resetsAtMs).toISOString()}`);
+                        return 'rate-limited';
+                    }
+                    // resetsAtMs null — fall through to text parse for the time, but
+                    // we know account is limited so we don't need to gate on text
+                    // (fall through to tier 3 below)
+                }
+                // usage missing for this dir — fall through to tier 3
+            }
+            // accountDir null or usage missing — fall through to tier 3
+        }
+        // Tier 3: text fallback (current behavior, unchanged)
         const resetLine = result.resetLine ?? '';
         const parsed = parseResetTime(resetLine);
-        const waitMs = calculateWaitMs(parsed, marginSeconds, fallbackHours, new Date(deps.now()));
-        state.waitUntil = deps.now() + waitMs;
+        const waitMs = calculateWaitMs(parsed, marginSeconds, fallbackHours, new Date(now));
+        state.waitUntil = now + waitMs;
         state.status = 'waiting';
         return 'rate-limited';
     }
     return 'monitoring';
 }
+export async function tick(paneId, state, deps, marginSeconds, fallbackHours) {
+    const screenText = await deps.capture(paneId);
+    return stepState(state, screenText, deps.now(), () => deps.inject(paneId, 'continue'), marginSeconds, fallbackHours);
+}
+async function tickTarget(target, state, deps, marginSeconds, fallbackHours, snapshot) {
+    const screenText = await deps.capture(target);
+    return stepState(state, screenText, deps.now(), () => deps.inject(target, 'continue'), marginSeconds, fallbackHours, snapshot, deps.resolvePaneAccount, target, deps.log);
+}
 export async function runMonitor(paneId, deps, pollIntervalMs, marginSeconds, fallbackHours) {
     const state = createState();
     for (;;) {
@@ -35,66 +101,77 @@ export async function runMonitor(paneId, deps, pollIntervalMs, marginSeconds, fa
     }
 }
 /**
- * One discovery+monitor pass over every live Claude pane.
+ * One discovery+monitor pass over every Claude pane in every live session.
  *
- * Re-discovers panes each call so new Claude sessions are picked up and
- * closed panes are pruned. Per-pane state lives in `states`, keyed by pane ID,
- * and persists across calls. A failed discovery or a single pane's
- * capture/inject error is swallowed so one bad pane never stops the others.
+ * Re-discovers targets each call so new Claude sessions/panes are picked up and
+ * closed ones are pruned. Per-pane state lives in `states`, keyed by the
+ * target's label (session:paneId), and persists across calls. A failed
+ * discovery or a single pane's capture/inject error is swallowed so one bad
+ * pane never stops the others.
  */
 export async function multiTick(states, deps, marginSeconds, fallbackHours) {
     const log = deps.log ?? (() => { });
-    let panes;
+    let targets;
     try {
-        panes = await deps.listPanes();
+        targets = await deps.listTargets();
     }
     catch {
         // Discovery failed this round — keep existing states, retry next tick.
-        log('scan failed: could not list panes (will retry)');
+        log('scan failed: could not list sessions/panes (will retry)');
         return;
     }
+    // Fetch account snapshot once per pass (swallow errors → undefined).
+    let snapshot;
+    if (deps.getAccountSnapshot !== undefined) {
+        try {
+            snapshot = await deps.getAccountSnapshot();
+        }
+        catch {
+            snapshot = undefined;
+        }
+    }
     // Prune state for panes that no longer exist.
-    const live = new Set(panes);
-    for (const id of [...states.keys()]) {
-        if (!live.has(id)) {
-            states.delete(id);
-            log(`pane ${id} gone — dropped from watch`);
+    const live = new Set(targets.map((t) => t.label));
+    for (const key of [...states.keys()]) {
+        if (!live.has(key)) {
+            states.delete(key);
+            log(`${key} gone — dropped from watch`);
         }
     }
-    log(panes.length === 0
+    log(targets.length === 0
         ? 'scan: no Claude panes found'
-        : `scan: watching ${panes.length} Claude pane(s) [${panes.join(', ')}]`);
-    for (const id of panes) {
-        let state = states.get(id);
+        : `scan: watching ${targets.length} Claude pane(s) [${targets.map((t) => t.label).join(', ')}]`);
+    for (const target of targets) {
+        let state = states.get(target.label);
         if (!state) {
             state = createState();
-            states.set(id, state);
-            log(`pane ${id} — new Claude session, now watching`);
+            states.set(target.label, state);
+            log(`${target.label} — new Claude pane, now watching`);
         }
         const before = state.status;
         try {
-            const status = await tick(id, state, deps, marginSeconds, fallbackHours);
-            logPaneStatus(log, id, before, state, status);
+            const status = await tickTarget(target, state, deps, marginSeconds, fallbackHours, snapshot);
+            logPaneStatus(log, target.label, before, state, status);
         }
         catch {
             // This pane's capture/inject failed — leave its state, keep going.
-            log(`pane ${id} — capture/inject error (skipped this round)`);
+            log(`${target.label} — capture/inject error (skipped this round)`);
         }
     }
 }
-function logPaneStatus(log, id, before, state, status) {
+function logPaneStatus(log, label, before, state, status) {
     if (status === 'rate-limited' && before === 'monitoring') {
         const until = new Date(state.waitUntil).toISOString();
-        log(`pane ${id} — RATE LIMITED, waiting until ${until}`);
+        log(`${label} — RATE LIMITED, waiting until ${until}`);
     }
     else if (status === 'rate-limited') {
-        log(`pane ${id} — still waiting for reset`);
+        log(`${label} — still waiting for reset`);
     }
     else if (status === 'retried') {
-        log(`pane ${id} — reset reached, injected 'continue'`);
+        log(`${label} — reset reached, cleared input + injected 'continue'`);
     }
     else {
-        log(`pane ${id} — ok`);
+        log(`${label} — ok`);
     }
 }
 export async function runMultiMonitor(deps, pollIntervalMs, marginSeconds, fallbackHours) {

package/dist/usage.d.ts

@@ -0,0 +1,23 @@
+export interface WindowUsage {
+    utilization: number;
+    resetsAtMs: number | null;
+}
+export interface AccountUsage {
+    limited: boolean;
+    resetsAtMs: number | null;
+}
+export type FetchFn = (url: string, init: {
+    headers: Record<string, string>;
+}) => Promise<{
+    status: number;
+    json: () => Promise<unknown>;
+}>;
+export type ReadFileFn = (path: string) => Promise<string>;
+export declare const LIMIT_THRESHOLD: number;
+export declare function defaultConfigDir(env?: NodeJS.ProcessEnv): string;
+export declare function readAccessToken(configDir: string, readFile?: ReadFileFn): Promise<{
+    token: string;
+    expiresAtMs: number | null;
+} | null>;
+export declare function fetchUsage(token: string, fetchFn?: FetchFn, threshold?: number): Promise<AccountUsage | null>;
+//# sourceMappingURL=usage.d.ts.map

package/dist/usage.js

@@ -0,0 +1,91 @@
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { readFile as fsReadFile } from 'node:fs/promises';
+export const LIMIT_THRESHOLD = (() => {
+    const raw = process.env['CLAUDE_RETRY_LIMIT_THRESHOLD'];
+    if (raw !== undefined) {
+        const n = Number(raw);
+        if (!Number.isNaN(n))
+            return n;
+    }
+    return 90;
+})();
+export function defaultConfigDir(env) {
+    const e = env ?? process.env;
+    return e['CLAUDE_CONFIG_DIR'] || path.join(os.homedir(), '.claude');
+}
+export async function readAccessToken(configDir, readFile = (p) => fsReadFile(p, 'utf8')) {
+    try {
+        const credPath = path.join(configDir, '.credentials.json');
+        const raw = await readFile(credPath);
+        const parsed = JSON.parse(raw);
+        const oauth = parsed['claudeAiOauth'];
+        if (oauth === null || typeof oauth !== 'object')
+            return null;
+        const oauthObj = oauth;
+        const token = oauthObj['accessToken'];
+        if (typeof token !== 'string' || token === '')
+            return null;
+        const expiresAt = oauthObj['expiresAt'];
+        const expiresAtMs = typeof expiresAt === 'number' ? expiresAt : null;
+        return { token, expiresAtMs };
+    }
+    catch {
+        return null;
+    }
+}
+const USAGE_URL = 'https://api.anthropic.com/api/oauth/usage';
+const WINDOW_KEYS = ['five_hour', 'seven_day', 'seven_day_opus', 'seven_day_sonnet'];
+function defaultFetchFn(url, init) {
+    return fetch(url, init).then((r) => ({
+        status: r.status,
+        json: () => r.json(),
+    }));
+}
+export async function fetchUsage(token, fetchFn = defaultFetchFn, threshold = LIMIT_THRESHOLD) {
+    try {
+        const res = await fetchFn(USAGE_URL, {
+            headers: {
+                'Authorization': `Bearer ${token}`,
+                'anthropic-beta': 'oauth-2025-04-20',
+                'anthropic-version': '2023-06-01',
+            },
+        });
+        if (res.status !== 200)
+            return null;
+        const body = await res.json();
+        if (body === null || typeof body !== 'object')
+            return null;
+        const data = body;
+        const windows = [];
+        for (const key of WINDOW_KEYS) {
+            const w = data[key];
+            if (w === null || w === undefined || typeof w !== 'object')
+                continue;
+            const wObj = w;
+            const utilization = wObj['utilization'];
+            const resetsAt = wObj['resets_at'];
+            if (typeof utilization !== 'number')
+                continue;
+            const resetsAtMs = typeof resetsAt === 'string' ? Date.parse(resetsAt) : null;
+            windows.push({ utilization, resetsAtMs: resetsAtMs !== null && !Number.isNaN(resetsAtMs) ? resetsAtMs : null });
+        }
+        const overThreshold = windows.filter((w) => w.utilization >= threshold);
+        const limited = overThreshold.length > 0;
+        let resetsAtMs = null;
+        if (limited) {
+            for (const w of overThreshold) {
+                if (w.resetsAtMs !== null) {
+                    if (resetsAtMs === null || w.resetsAtMs > resetsAtMs) {
+                        resetsAtMs = w.resetsAtMs;
+                    }
+                }
+            }
+        }
+        return { limited, resetsAtMs };
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=usage.js.map

package/dist/zellij.d.ts

@@ -4,6 +4,39 @@ export type ExecFileFn = (cmd: string, args: string[]) => Promise<{
 }>;
 export declare function capturePane(paneId: string | number, execFileFn?: ExecFileFn): Promise<string>;
 export declare function inject(paneId: string | number, text: string, execFileFn?: ExecFileFn): Promise<void>;
+/**
+ * A single Claude pane to watch, addressable across zellij sessions.
+ * `label` is a stable human-readable key (session:paneId) used for state
+ * tracking and logs.
+ */
+export interface PaneTarget {
+    session: string;
+    paneId: string;
+    label: string;
+}
+/**
+ * List all live zellij session names, skipping EXITED/resurrectable ones and
+ * the daemon's own session (ZELLIJ_SESSION_NAME) so it never watches itself.
+ */
+export declare function listSessions(execFileFn?: ExecFileFn): Promise<string[]>;
+/**
+ * Walk every live session and return every non-plugin, non-exited pane as a
+ * target. We do NOT try to identify which pane is Claude — pane titles and
+ * commands are unreliable (interactive `claude` reports the shell, titles are
+ * the cwd). Instead the monitor dumps each pane's screen and only acts on the
+ * ones actually showing a rate-limit banner. Works on detached sessions via
+ * the global `--session` flag; the daemon's own session is already excluded by
+ * listSessions, so its logs are never scanned.
+ */
+export declare function listPaneTargets(execFileFn?: ExecFileFn): Promise<PaneTarget[]>;
+/** Dump a target pane's visible screen across sessions. */
+export declare function captureTarget(t: PaneTarget, execFileFn?: ExecFileFn): Promise<string>;
+/**
+ * Inject into a target pane across sessions: Ctrl+C to clear any half-typed
+ * input first, then type text + Enter. A single Ctrl+C in Claude Code only
+ * clears the input box (shows "Press Ctrl-C again to exit"), it does not quit.
+ */
+export declare function injectTarget(t: PaneTarget, text: string, execFileFn?: ExecFileFn): Promise<void>;
 /**
  * Discover every live Claude pane (deduped pane IDs).
  *

package/dist/zellij.js

@@ -12,9 +12,95 @@ export async function capturePane(paneId, execFileFn = defaultExecFile) {
     return stdout;
 }
 export async function inject(paneId, text, execFileFn = defaultExecFile) {
+    // Ctrl+C first clears any half-typed input (does not quit Claude), then type + Enter.
+    await execFileFn('zellij', ['action', 'write', '--pane-id', String(paneId), '3']);
     await execFileFn('zellij', ['action', 'write-chars', '--pane-id', String(paneId), text]);
     await execFileFn('zellij', ['action', 'write', '--pane-id', String(paneId), '13']);
 }
+/**
+ * List all live zellij session names, skipping EXITED/resurrectable ones and
+ * the daemon's own session (ZELLIJ_SESSION_NAME) so it never watches itself.
+ */
+export async function listSessions(execFileFn = defaultExecFile) {
+    const own = process.env['ZELLIJ_SESSION_NAME'];
+    const names = [];
+    const { stdout } = await execFileFn('zellij', ['list-sessions', '-n']);
+    for (const line of stdout.split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        if (/\(EXITED/.test(trimmed))
+            continue; // skip dead/resurrectable sessions
+        // Session names may contain spaces ("Rainbow Road"); the name is everything
+        // before the " [Created ...]" suffix that zellij appends.
+        const idx = trimmed.indexOf(' [');
+        const name = (idx >= 0 ? trimmed.slice(0, idx) : trimmed).trim();
+        if (!name)
+            continue;
+        if (own && name === own)
+            continue; // never watch our own session
+        names.push(name);
+    }
+    return names;
+}
+/**
+ * Walk every live session and return every non-plugin, non-exited pane as a
+ * target. We do NOT try to identify which pane is Claude — pane titles and
+ * commands are unreliable (interactive `claude` reports the shell, titles are
+ * the cwd). Instead the monitor dumps each pane's screen and only acts on the
+ * ones actually showing a rate-limit banner. Works on detached sessions via
+ * the global `--session` flag; the daemon's own session is already excluded by
+ * listSessions, so its logs are never scanned.
+ */
+export async function listPaneTargets(execFileFn = defaultExecFile) {
+    const sessions = await listSessions(execFileFn);
+    const targets = [];
+    for (const session of sessions) {
+        let panes;
+        try {
+            const { stdout } = await execFileFn('zellij', [
+                '--session',
+                session,
+                'action',
+                'list-panes',
+                '-j',
+            ]);
+            panes = JSON.parse(stdout);
+        }
+        catch {
+            continue; // session vanished or output unparseable — skip this round
+        }
+        for (const p of panes) {
+            if (p.is_plugin || p.exited)
+                continue;
+            targets.push({ session, paneId: String(p.id), label: `${session}:${p.id}` });
+        }
+    }
+    return targets;
+}
+/** Dump a target pane's visible screen across sessions. */
+export async function captureTarget(t, execFileFn = defaultExecFile) {
+    const { stdout } = await execFileFn('zellij', [
+        '--session',
+        t.session,
+        'action',
+        'dump-screen',
+        '--pane-id',
+        t.paneId,
+    ]);
+    return stdout;
+}
+/**
+ * Inject into a target pane across sessions: Ctrl+C to clear any half-typed
+ * input first, then type text + Enter. A single Ctrl+C in Claude Code only
+ * clears the input box (shows "Press Ctrl-C again to exit"), it does not quit.
+ */
+export async function injectTarget(t, text, execFileFn = defaultExecFile) {
+    const base = ['--session', t.session, 'action'];
+    await execFileFn('zellij', [...base, 'write', '--pane-id', t.paneId, '3']); // Ctrl+C clears input
+    await execFileFn('zellij', [...base, 'write-chars', '--pane-id', t.paneId, text]);
+    await execFileFn('zellij', [...base, 'write', '--pane-id', t.paneId, '13']); // Enter
+}
 /** True when a list-clients RUNNING_COMMAND is the `claude` CLI itself.
  *  Excludes `claude-retry` (the monitor's own pane) and other claude-* tools. */
 function paneCommandIsClaude(runningCommand) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tigorhutasuhut/claude-retry",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Monitor Claude CLI in a zellij pane, auto-inject continue on rate-limit",
   "type": "module",
   "license": "MIT",