@phnx-labs/agents-cli 1.20.52 → 1.20.53

package/dist/lib/session/active.d.ts

@@ -1,3 +1,4 @@
+import type { CloudTaskStatus } from '../cloud/types.js';
 import { type PidSessionEntry } from './pid-registry.js';
 import { type SessionActivity, type AwaitingReason, type StructuredQuestion, type DetectedPr, type DetectedWorktree, type DetectedTicket } from './state.js';
 import { type SessionProvenance } from './provenance.js';
@@ -28,6 +29,12 @@ export interface ActiveSession {
     preview?: string;
     /** Inferred activity: working / waiting_input / idle (from the transcript tail). */
     activity?: SessionActivity;
+    /**
+     * Output-token throughput (tokens/sec) over a rolling 60s window, from the
+     * transcript tail. The number the Factory Floor shows next to a running agent;
+     * absent when no transcript is resolvable or the agent format reports no usage.
+     */
+    tokPerSec?: number;
     /** Why the agent is waiting, when activity is waiting_input. */
     awaitingReason?: AwaitingReason;
     /** The structured decision (question/plan/permission + options) the agent is waiting on. */
@@ -46,6 +53,8 @@ export interface ActiveSession {
     worktree?: DetectedWorktree;
     /** Tracker ticket the session is tied to. */
     ticket?: DetectedTicket;
+    /** Per-session rate/usage limit detected in the transcript (RUSH-1523). */
+    rateLimited?: boolean;
     /** Tracker refs the session CREATED (Linear create_issue / gh issue create). */
     createdTickets?: string[];
     /** Team name the session SPAWNED via `agents teams create/add`. */
@@ -112,10 +121,19 @@ export interface ActiveSession {
         tab?: number;
     };
 }
+export declare function activeStatusFromCloudStatus(status: CloudTaskStatus): ActiveStatus;
 export interface ActiveQueryOptions {
     /** Skip the `ps` scan for ad-hoc headless agents. */
     skipHeadless?: boolean;
 }
+/**
+ * A live process can only borrow an indexed session file if that transcript
+ * has been touched recently enough to plausibly belong to the process. This is
+ * deliberately wider than ACTIVE_MTIME_WINDOW_MS: an inactive-but-live CLI can
+ * be idle for longer than 2 minutes, but it must not attach to a weeks-old
+ * transcript just because a GUI app service with the same basename is alive.
+ */
+export declare const ACTIVE_SESSION_STALE_MS: number;
 /**
  * Resolve an agent kind from a process's reported executable. `comm` may be an
  * absolute path (shim-launched agents), and Windows image names carry an

package/dist/lib/session/active.js

@@ -29,7 +29,8 @@ import { buildClaudeLabelMap } from './discover.js';
 import { buildRunNameMap } from './run-names.js';
 import { latestSessionFileForCwd } from './db.js';
 import { extractSessionTopic } from './prompt.js';
-import { readSessionTail } from './tail.js';
+import { readSessionTailWithRaw } from './tail.js';
+import { computeTokPerSec } from './throughput.js';
 import { inferSessionState } from './state.js';
 import { detectProvenance } from './provenance.js';
 import { mapBounded } from '../concurrency.js';
@@ -42,6 +43,18 @@ const execFileAsync = promisify(execFile);
  */
 export const LSOF_CONCURRENCY = 4;
 const LSOF_STAGGER_MS = 10;
+export function activeStatusFromCloudStatus(status) {
+    switch (status) {
+        case 'running':
+            return 'running';
+        case 'idle':
+            return 'idle';
+        case 'input_required':
+            return 'input_required';
+        default:
+            return 'queued';
+    }
+}
 const HOME = os.homedir();
 const LIVE_TERMINALS_FILE = path.join(getTerminalsDir(), 'live-terminals.json');
 /**
@@ -50,6 +63,14 @@ const LIVE_TERMINALS_FILE = path.join(getTerminalsDir(), 'live-terminals.json');
  * healthy session writes several times a minute.
  */
 const ACTIVE_MTIME_WINDOW_MS = 2 * 60_000;
+/**
+ * A live process can only borrow an indexed session file if that transcript
+ * has been touched recently enough to plausibly belong to the process. This is
+ * deliberately wider than ACTIVE_MTIME_WINDOW_MS: an inactive-but-live CLI can
+ * be idle for longer than 2 minutes, but it must not attach to a weeks-old
+ * transcript just because a GUI app service with the same basename is alive.
+ */
+export const ACTIVE_SESSION_STALE_MS = 24 * 60 * 60_000;
 /** Executables we recognize as agent CLIs when scanning the process table. */
 const AGENT_CLI_NAMES = {
     claude: 'claude',
@@ -194,7 +215,7 @@ export function findSessionFileForKind(kind, cwd, sessionId) {
     if (kind === 'claude')
         return findClaudeSessionFile(cwd, sessionId);
     if (kind === 'codex')
-        return latestSessionFileForCwd('codex', cwd);
+        return latestSessionFileForCwd('codex', cwd, { maxAgeMs: ACTIVE_SESSION_STALE_MS });
     return undefined;
 }
 /** Recover the session UUID from a transcript filename (Claude `<uuid>.jsonl`, Codex `rollout-…-<uuid>.jsonl`). */
@@ -204,20 +225,28 @@ function sessionIdFromFile(file) {
         return undefined;
     return path.basename(file).match(UUID_RE)?.[0];
 }
-/** Infer live state from a session file's tail (Claude/Codex). Undefined when unreadable. */
-function computeLiveState(kind, sessionFile, cwd, pidAlive) {
+/**
+ * Read a session file's tail ONCE and derive both the inferred state and the
+ * output-token throughput from it. State needs the normalized event model;
+ * throughput needs the raw lines the event model drops (Codex `token_count`), so
+ * both come off the same {@link readSessionTailWithRaw} read. Only Claude/Codex
+ * carry live state; other kinds yield an empty signal set.
+ */
+function computeLiveSignals(kind, sessionFile, cwd, pidAlive) {
     if (!sessionFile)
-        return undefined;
+        return {};
     const agent = kind === 'codex' ? 'codex' : 'claude';
-    const events = readSessionTail(sessionFile, agent);
+    const { events, content } = readSessionTailWithRaw(sessionFile, agent);
     if (events.length === 0)
-        return undefined;
+        return {};
     let mtimeMs;
     try {
         mtimeMs = fs.statSync(sessionFile).mtimeMs;
     }
     catch { /* vanished between calls */ }
-    return inferSessionState(events, { cwd, pidAlive, mtimeMs, activeWindowMs: ACTIVE_MTIME_WINDOW_MS });
+    const state = inferSessionState(events, { cwd, pidAlive, mtimeMs, activeWindowMs: ACTIVE_MTIME_WINDOW_MS });
+    const tokPerSec = computeTokPerSec(content, agent);
+    return { state, tokPerSec: tokPerSec > 0 ? tokPerSec : undefined };
 }
 /** Map inferred activity onto the coarse ActiveStatus used by the renderer and counts. */
 function statusFromActivity(activity) {
@@ -246,6 +275,7 @@ function applyState(base, state, fallbackFile) {
         ticket: state.ticket,
         createdTickets: state.createdTickets,
         spawnedTeam: state.spawnedTeam,
+        rateLimited: state.rateLimited,
     };
 }
 /**
@@ -329,7 +359,7 @@ export async function listTeamsActive() {
         const sessionId = a.parentSessionId ?? a.remoteSessionId ?? undefined;
         const sessionFile = findSessionFileForKind(a.agentType, a.cwd ?? undefined, sessionId ?? undefined);
         const topic = sessionFile ? quickExtractTopic(sessionFile) : undefined;
-        const state = computeLiveState(a.agentType, sessionFile, a.cwd ?? undefined, a.pid ? isPidAlive(a.pid) : true);
+        const { state, tokPerSec } = computeLiveSignals(a.agentType, sessionFile, a.cwd ?? undefined, a.pid ? isPidAlive(a.pid) : true);
         return applyState({
             context: 'teams',
             kind: a.agentType,
@@ -338,6 +368,7 @@ export async function listTeamsActive() {
             cwd: a.cwd ?? undefined,
             label: a.name ?? undefined,
             topic,
+            tokPerSec,
             sessionFile,
             startedAtMs: a.startedAt.getTime(),
             teamName: a.taskName,
@@ -378,7 +409,7 @@ export async function listTerminalsActive() {
         const name = resolvedId ? runNameMap.get(resolvedId) ?? undefined : undefined;
         // Extract topic from session file (first meaningful user message)
         const topic = sessionFile ? quickExtractTopic(sessionFile) : undefined;
-        const state = computeLiveState(t.kind, sessionFile, t.cwd ?? undefined, isPidAlive(t.pid));
+        const { state, tokPerSec } = computeLiveSignals(t.kind, sessionFile, t.cwd ?? undefined, isPidAlive(t.pid));
         return applyState({
             context: 'terminal',
             kind: t.kind,
@@ -390,6 +421,7 @@ export async function listTerminalsActive() {
             label,
             name,
             topic,
+            tokPerSec,
             sessionFile,
             startedAtMs: t.startedAtMs,
             windowId: t.windowId,
@@ -410,11 +442,7 @@ export function listCloudActive() {
         kind: t.agent || 'cloud',
         label: t.prompt.length > 60 ? t.prompt.slice(0, 57) + '...' : t.prompt,
         startedAtMs: Date.parse(t.createdAt) || undefined,
-        status: t.status === 'running'
-            ? 'running'
-            : t.status === 'input_required'
-                ? 'input_required'
-                : 'queued',
+        status: activeStatusFromCloudStatus(t.status),
         cloudProvider: t.provider,
         cloudTaskId: t.id,
         cloudStatus: t.status,
@@ -747,7 +775,7 @@ export async function listUnattributedActive(attributed) {
         const topic = sessionFile ? quickExtractTopic(sessionFile) : undefined;
         const host = detectHost(pid, procByPid);
         const context = host && UI_HOSTS.has(host) ? 'terminal' : 'headless';
-        const state = computeLiveState(kind, sessionFile, cwd, true);
+        const { state, tokPerSec } = computeLiveSignals(kind, sessionFile, cwd, true);
         out.push(applyState({
             context,
             kind,
@@ -757,6 +785,7 @@ export async function listUnattributedActive(attributed) {
             cwd,
             sessionId: entry?.sessionId ?? sessionIdFromFile(sessionFile),
             topic,
+            tokPerSec,
             sessionFile,
             pidCount: 1 + (foldedByRoot.get(pid) ?? 0),
         }, state, sessionFile));
@@ -816,7 +845,7 @@ export async function listTmuxAgentSessions() {
         const cwd = meta?.cwd ?? (curPath || undefined);
         const sessionFile = findSessionFileForKind(agent, cwd, sessionId);
         const topic = sessionFile ? quickExtractTopic(sessionFile) : undefined;
-        const state = computeLiveState(agent, sessionFile, cwd, pid ? isPidAlive(pid) : true);
+        const { state, tokPerSec } = computeLiveSignals(agent, sessionFile, cwd, pid ? isPidAlive(pid) : true);
         // Provenance is known exactly here (the pane IS a tmux pane) — set it so
         // enrichProvenance skips it and the locator/reply rails resolve off the pane.
         const provenance = {
@@ -833,6 +862,7 @@ export async function listTmuxAgentSessions() {
             sessionId,
             cwd,
             topic,
+            tokPerSec,
             sessionFile,
             provenance,
         }, state, sessionFile));

package/dist/lib/session/db.d.ts

@@ -157,13 +157,21 @@ export declare function seedLabelsFromNames(nameMap: Map<string, string | null>)
  * Returns the number of rows updated.
  */
 export declare function syncTopics(topicMap: Map<string, string>): number;
+export declare function isSessionActivityFresh(row: {
+    last_activity: string | null;
+    timestamp: string;
+    file_mtime_ms: number | null;
+}, maxAgeMs: number, nowMs: number): boolean;
 /**
  * Newest indexed session file for an agent working in `cwd`. Lets the live
  * `--active` scanner locate a Codex transcript (whose files are date-partitioned,
  * not cwd-keyed like Claude's) by reusing the index. Returns undefined if the
  * session hasn't been scanned yet — the caller degrades to no live state.
  */
-export declare function latestSessionFileForCwd(agent: SessionAgentId, cwd: string): string | undefined;
+export declare function latestSessionFileForCwd(agent: SessionAgentId, cwd: string, options?: {
+    maxAgeMs?: number;
+    nowMs?: number;
+}): string | undefined;
 /** Query sessions from the database, applying filters and ordering by last-activity descending (default). */
 export declare function querySessions(options?: QueryOptions): SessionMeta[];
 /** Count sessions matching the given filter options. */

package/dist/lib/session/db.js

@@ -801,13 +801,18 @@ function resolveLastActivity(meta, scan) {
         return new Date(scan.fileMtimeMs).toISOString();
     return meta.timestamp;
 }
+export function isSessionActivityFresh(row, maxAgeMs, nowMs) {
+    const parsedActivityMs = Date.parse(row.last_activity ?? row.timestamp);
+    const activityMs = Number.isFinite(parsedActivityMs) ? parsedActivityMs : row.file_mtime_ms ?? undefined;
+    return activityMs != null && nowMs - activityMs <= maxAgeMs;
+}
 /**
  * Newest indexed session file for an agent working in `cwd`. Lets the live
  * `--active` scanner locate a Codex transcript (whose files are date-partitioned,
  * not cwd-keyed like Claude's) by reusing the index. Returns undefined if the
  * session hasn't been scanned yet — the caller degrades to no live state.
  */
-export function latestSessionFileForCwd(agent, cwd) {
+export function latestSessionFileForCwd(agent, cwd, options) {
     if (!cwd)
         return undefined;
     let normalized = cwd;
@@ -817,9 +822,19 @@ export function latestSessionFileForCwd(agent, cwd) {
     catch { /* use as-is */ }
     const db = getDB();
     const row = db
-        .prepare(`SELECT file_path FROM sessions WHERE agent = ? AND cwd = ? ORDER BY timestamp DESC LIMIT 1`)
+        .prepare(`SELECT file_path, last_activity, timestamp, file_mtime_ms
+              FROM sessions
+              WHERE agent = ? AND cwd = ?
+              ORDER BY COALESCE(last_activity, timestamp) DESC
+              LIMIT 1`)
         .get(agent, normalized);
-    return row?.file_path;
+    if (!row)
+        return undefined;
+    if (options?.maxAgeMs != null) {
+        if (!isSessionActivityFresh(row, options.maxAgeMs, options.nowMs ?? Date.now()))
+            return undefined;
+    }
+    return row.file_path;
 }
 /** Build a parameterized WHERE clause from query options. */
 function buildSessionWhere(options) {

package/dist/lib/session/discover.d.ts

@@ -121,6 +121,19 @@ export declare function shouldDeferRecentAppend(prev: ScanStamp, current: ScanSt
  * realpath to avoid double-counting symlinked version homes.
  */
 export declare function getAgentSessionDirs(agent: string, subdir: string): string[];
+/** A session-agent's on-disk watch roots (every version home + backup mirror). */
+export interface SessionRoots {
+    agent: SessionAgentId;
+    /** Absolute directories that hold this agent's transcripts, existing right now. */
+    dirs: string[];
+}
+/**
+ * The directories `agents sessions` scans for each on-disk session agent,
+ * resolved to what exists on this machine. Emitted by `agents sessions --roots
+ * --json` so external watchers stay in lockstep with the CLI's discovery paths.
+ * Agents with no directories present are omitted.
+ */
+export declare function getSessionRoots(): SessionRoots[];
 /**
  * Build a map of Claude sessionId -> user-given label from ~/.claude/sessions/*.json.
  * Each JSON has shape { pid, sessionId, cwd, startedAt, name?, ... }. The

package/dist/lib/session/discover.js

@@ -303,6 +303,37 @@ export function getAgentSessionDirs(agent, subdir) {
     }
     return dirs;
 }
+/**
+ * The (agent, subdir) pairs `discoverSessions` walks for JSONL transcripts —
+ * the single source of truth for which directories hold live session files.
+ * `getSessionRoots` expands each pair to its concrete directories so a consumer
+ * (the Factory extension's fs.watch, see issue #741) can configure its watcher
+ * from the CLI instead of hardcoding `~/.claude|.codex|.gemini`. Adding a new
+ * on-disk agent here makes every consumer watch it automatically.
+ */
+const SESSION_ROOT_SPECS = [
+    { agent: 'claude', subdir: 'projects' },
+    { agent: 'codex', subdir: 'sessions' },
+    { agent: 'gemini', subdir: 'tmp' },
+    { agent: 'antigravity', subdir: 'conversations' },
+    { agent: 'droid', subdir: 'sessions' },
+    { agent: 'kimi', subdir: 'sessions' },
+];
+/**
+ * The directories `agents sessions` scans for each on-disk session agent,
+ * resolved to what exists on this machine. Emitted by `agents sessions --roots
+ * --json` so external watchers stay in lockstep with the CLI's discovery paths.
+ * Agents with no directories present are omitted.
+ */
+export function getSessionRoots() {
+    const out = [];
+    for (const { agent, subdir } of SESSION_ROOT_SPECS) {
+        const dirs = getAgentSessionDirs(agent, subdir);
+        if (dirs.length > 0)
+            out.push({ agent, dirs });
+    }
+    return out;
+}
 // ---------------------------------------------------------------------------
 // Claude account info
 // ---------------------------------------------------------------------------

package/dist/lib/session/parse.d.ts

@@ -42,6 +42,14 @@ export declare function parseClaude(filePath: string): SessionEvent[];
 export declare function parseClaudeContent(content: string): SessionEvent[];
 /** Parse a Codex JSONL session file into normalized events. */
 export declare function parseCodex(filePath: string): SessionEvent[];
+/**
+ * Extract target file path(s) from a Codex apply_patch envelope. The patch body
+ * opens with `*** Begin Patch` and carries one or more file ops of the form
+ * `*** Update File: <path>` / `*** Add File: <path>` / `*** Delete File: <path>`.
+ * Returns every path in order (a multi-file patch emits multiple paths so
+ * artifact discovery sees each file — RUSH-1410). Empty when unparseable.
+ */
+export declare function applyPatchTargetPaths(input: string): string[];
 /**
  * Parse Codex JSONL *content* (already read into a string) into normalized
  * events. Split from `parseCodex` so the tail reader can parse just the last

package/dist/lib/session/parse.js

@@ -430,14 +430,25 @@ export function parseCodex(filePath) {
     return parseCodexContent(safeReadSessionFile(filePath));
 }
 /**
- * Extract the target file path from a Codex apply_patch envelope. The patch body
+ * Extract target file path(s) from a Codex apply_patch envelope. The patch body
  * opens with `*** Begin Patch` and carries one or more file ops of the form
  * `*** Update File: <path>` / `*** Add File: <path>` / `*** Delete File: <path>`.
- * Returns the first file path found, or undefined for an unparseable body.
+ * Returns every path in order (a multi-file patch emits multiple paths so
+ * artifact discovery sees each file — RUSH-1410). Empty when unparseable.
  */
+export function applyPatchTargetPaths(input) {
+    const paths = [];
+    const re = /^\*\*\* (?:Update|Add|Delete) File: (.+)$/gm;
+    for (const m of input.matchAll(re)) {
+        const p = m[1].trim();
+        if (p)
+            paths.push(p);
+    }
+    return paths;
+}
+/** @deprecated Prefer applyPatchTargetPaths — kept for single-file call sites. */
 function applyPatchTargetPath(input) {
-    const m = input.match(/^\*\*\* (?:Update|Add|Delete) File: (.+)$/m);
-    return m ? m[1].trim() : undefined;
+    return applyPatchTargetPaths(input)[0];
 }
 /**
  * Parse Codex JSONL *content* (already read into a string) into normalized
@@ -566,24 +577,34 @@ export function parseCodexContent(content) {
                 const rawName = payload.name || 'unknown';
                 const input = typeof payload.input === 'string' ? payload.input : '';
                 const isApplyPatch = rawName === 'apply_patch';
-                const patchPath = isApplyPatch ? applyPatchTargetPath(input) : undefined;
-                // Normalize apply_patch to the shared Edit tool so it flows through
-                // artifact discovery (WRITE_TOOLS) and the Edit summarizer.
+                // Multi-file patches: one tool_use per file so artifact discovery sees
+                // every path (RUSH-1410). Single-file / non-patch keep one event.
+                const patchPaths = isApplyPatch ? applyPatchTargetPaths(input) : [];
                 const tool = isApplyPatch ? 'Edit' : rawName;
-                const args = { input: input.length > 500 ? input.slice(0, 497) + '...' : input };
-                if (patchPath)
-                    args.file_path = patchPath;
-                const callId = payload.call_id || payload.id;
-                if (callId)
-                    callMap.set(callId, { name: tool, args });
-                events.push({
-                    type: 'tool_use',
-                    agent: 'codex',
-                    timestamp,
-                    tool,
-                    args,
-                    path: patchPath,
-                });
+                const truncatedInput = input.length > 500 ? input.slice(0, 497) + '...' : input;
+                const emitOne = (patchPath) => {
+                    const args = { input: truncatedInput };
+                    if (patchPath)
+                        args.file_path = patchPath;
+                    const callId = payload.call_id || payload.id;
+                    if (callId)
+                        callMap.set(callId, { name: tool, args });
+                    events.push({
+                        type: 'tool_use',
+                        agent: 'codex',
+                        timestamp,
+                        tool,
+                        args,
+                        path: patchPath,
+                    });
+                };
+                if (isApplyPatch && patchPaths.length > 0) {
+                    for (const p of patchPaths)
+                        emitOne(p);
+                }
+                else {
+                    emitOne(undefined);
+                }
             }
             else if (ptype === 'custom_tool_call_output') {
                 const callId = payload.call_id || payload.id;

package/dist/lib/session/remote-active.js

@@ -14,36 +14,13 @@
  * laptop must not blank the whole view. SSH runs are async + parallel (a fresh
  * `spawn`, not the sync `sshExec`) so N peers cost one round-trip, not N.
  */
-import { spawn } from 'child_process';
-import chalk from 'chalk';
-import { SSH_OPTS, controlOpts, assertValidSshTarget, shellQuote } from '../ssh-exec.js';
-import { sshTargetFor } from '../devices/connect.js';
-import { resolveExplicitTargets } from '../devices/resolve-target.js';
-import { loadDevices } from '../devices/registry.js';
-import { remoteShellFor, buildWindowsAgentsCommand } from '../hosts/remote-cmd.js';
-import { machineId, normalizeHost } from './sync/config.js';
-/** Per-host SSH budget. Slightly above SSH_OPTS' ConnectTimeout=10 so a
- * reachable-but-slow remote still answers before we give up. */
-const REMOTE_TIMEOUT_MS = 12_000;
+import { gatherRemoteAgentsJson } from '../remote-agents-json.js';
 /**
  * Recursion guard, passed as an env var (not a CLI flag) so an OLDER remote
  * `agents` that predates this feature ignores it harmlessly instead of erroring
  * on an unknown option. A remote new enough to fan out reads it and stays local.
  */
 export const NO_FANOUT_ENV = 'AGENTS_SESSIONS_LOCAL';
-/** The command run on each peer: answer for itself, as JSON, without recursing.
- * A Windows peer gets a PowerShell invocation (ssh lands in cmd.exe/PowerShell
- * there, where `bash -lc` is not a command); every other OS keeps `bash -lc`. */
-function remoteActiveCommand(os) {
-    if (remoteShellFor(os) === 'powershell') {
-        return buildWindowsAgentsCommand({
-            args: ['sessions', '--active', '--json'],
-            env: { [NO_FANOUT_ENV]: '1' },
-        });
-    }
-    const inner = `${NO_FANOUT_ENV}=1 agents sessions --active --json`;
-    return `bash -lc ${shellQuote(inner)}`;
-}
 /**
  * Parse a peer's `--active --json` stdout into active sessions, tagging each
  * with `machine`. Defensive against version skew / partial output: non-JSON or
@@ -68,36 +45,6 @@ export function parseRemoteActive(stdout, machine) {
     }
     return out;
 }
-/** Run one remote `agents sessions --active --json --local` and capture stdout.
- * Resolves `{ code: null }` on spawn error or timeout (host treated as dead). */
-function sshCapture(target, remoteCmd, timeoutMs) {
-    assertValidSshTarget(target);
-    return new Promise((resolve) => {
-        const args = [...SSH_OPTS, ...controlOpts(), target, remoteCmd];
-        const child = spawn('ssh', args, { stdio: ['ignore', 'pipe', 'ignore'] });
-        let stdout = '';
-        let settled = false;
-        const done = (code) => {
-            if (settled)
-                return;
-            settled = true;
-            clearTimeout(timer);
-            resolve({ code, stdout });
-        };
-        const timer = setTimeout(() => { child.kill('SIGKILL'); done(null); }, timeoutMs);
-        child.stdout.on('data', (d) => { stdout += d.toString(); });
-        child.on('error', () => done(null));
-        child.on('close', (code) => done(code));
-    });
-}
-async function fetchByTarget(target, machine, display, os) {
-    const { code, stdout } = await sshCapture(target, remoteActiveCommand(os), REMOTE_TIMEOUT_MS);
-    if (code !== 0) {
-        process.stderr.write(chalk.gray(`  ${display}: unreachable or no agents CLI — skipped\n`));
-        return [];
-    }
-    return parseRemoteActive(stdout, machine);
-}
 /**
  * Gather active sessions from other machines. With an explicit `hosts` list
  * (from `--host`), fan out to exactly those. Otherwise sweep the registered,
@@ -105,39 +52,11 @@ async function fetchByTarget(target, machine, display, os) {
  * address. Results from all peers run in parallel and are flattened.
  */
 export async function gatherRemoteActive(hosts) {
-    const self = machineId();
-    const targets = [];
-    if (hosts && hosts.length > 0) {
-        // Resolve each token through the device registry so an explicit --host/--device
-        // dials the exact same address (and machine id) as the auto-discovery sweep.
-        targets.push(...await resolveExplicitTargets(hosts));
-    }
-    else {
-        let reg;
-        try {
-            reg = await loadDevices();
-        }
-        catch {
-            return { sessions: [], deviceCount: 0 };
-        }
-        for (const d of Object.values(reg)) {
-            if (d.tailscale?.online !== true)
-                continue;
-            if (normalizeHost(d.name) === self)
-                continue;
-            // Only machines that can actually run the CLI. iOS/tablet nodes register as
-            // `unknown` platform and can never answer, so skip them rather than burn a
-            // full ConnectTimeout on each.
-            if (d.platform !== 'windows' && d.platform !== 'linux' && d.platform !== 'macos')
-                continue;
-            try {
-                targets.push({ target: sshTargetFor(d), machine: normalizeHost(d.name), name: d.name, os: d.platform });
-            }
-            catch {
-                // No address on the profile — nothing to dial; skip silently.
-            }
-        }
-    }
-    const results = await Promise.all(targets.map((t) => fetchByTarget(t.target, t.machine, t.name, t.os)));
-    return { sessions: results.flat(), deviceCount: targets.length };
+    const result = await gatherRemoteAgentsJson({
+        args: ['sessions', '--active', '--json'],
+        noFanoutEnv: NO_FANOUT_ENV,
+        hosts,
+        parse: parseRemoteActive,
+    });
+    return { sessions: result.items, deviceCount: result.deviceCount };
 }

package/dist/lib/session/state.d.ts

@@ -57,6 +57,12 @@ export interface DetectedTicket {
     id: string;
     url?: string;
 }
+/**
+ * Detect per-session rate-limit / usage-limit signals in assistant or error
+ * text (RUSH-1523). Matches the same shapes Factory's prewarm detectBlockingPrompt
+ * uses, plus common Claude/Codex/Gemini limit strings.
+ */
+export declare function detectRateLimited(text?: string): boolean;
 export interface SessionState {
     activity: SessionActivity;
     awaitingReason?: AwaitingReason;
@@ -64,6 +70,11 @@ export interface SessionState {
     lastEventKind?: SessionEvent['type'];
     /** Single-line description of the latest turn (message text or tool action). */
     preview?: string;
+    /**
+     * True when the transcript shows the session is rate/usage limited (RUSH-1523).
+     * Distinct from account-level usageStatus — this is per-session evidence.
+     */
+    rateLimited?: boolean;
     /**
      * The structured decision the agent is waiting on (question / plan / permission),
      * with its options when it offered any. Set only when activity is waiting_input.

package/dist/lib/session/state.js

@@ -15,6 +15,25 @@
  * shape + mtime — same function, driven off the normalized events.
  */
 import { summarizeToolUse } from './parse.js';
+/**
+ * Detect per-session rate-limit / usage-limit signals in assistant or error
+ * text (RUSH-1523). Matches the same shapes Factory's prewarm detectBlockingPrompt
+ * uses, plus common Claude/Codex/Gemini limit strings.
+ */
+export function detectRateLimited(text) {
+    if (!text)
+        return false;
+    const t = text.toLowerCase();
+    return (/\brate[- ]?limit(ed|s)?\b/.test(t) ||
+        /\btoo many requests\b/.test(t) ||
+        /\b429\b/.test(t) ||
+        /\busage[- ]?limit(ed)?\b/.test(t) ||
+        /\bhit your (usage |rate )?limit\b/.test(t) ||
+        /\byou('ve| have) (hit|reached|exceeded) (your |the )?(rate |usage )?limit\b/.test(t) ||
+        /\bout of (credits|quota)\b/.test(t) ||
+        /\bquota exceeded\b/.test(t) ||
+        /\btry again (in|later|after)\b/.test(t) && /\b(limit|rate|quota|throttl)\b/.test(t));
+}
 /** A healthy live session writes several times a minute; 2 min ⇒ "recently active". */
 const ACTIVE_WINDOW_MS = 2 * 60_000;
 /**
@@ -378,6 +397,23 @@ export function inferSessionState(events, ctx = {}) {
     const state = inferActivity(events, ctx);
     const { pr, ticket, createdTickets, spawnedTeam } = detectDurableSignals(events);
     const worktree = detectWorktree(ctx.cwd, ctx.gitBranch);
+    // Rate-limit: scan the most recent assistant messages + tool errors (tail-first).
+    let rateLimited = false;
+    for (let i = events.length - 1; i >= 0 && i >= events.length - 12; i--) {
+        const e = events[i];
+        if (!e)
+            continue;
+        if (e.type === 'message' && e.role === 'assistant' && detectRateLimited(e.content)) {
+            rateLimited = true;
+            break;
+        }
+        if (e.type === 'tool_result' && detectRateLimited(e.output)) {
+            rateLimited = true;
+            break;
+        }
+    }
+    if (!rateLimited && detectRateLimited(state.preview))
+        rateLimited = true;
     return {
         ...state,
         pr: pr ?? state.pr,
@@ -385,5 +421,6 @@ export function inferSessionState(events, ctx = {}) {
         ticket: ticket ?? detectTicket(undefined, ctx.gitBranch) ?? state.ticket,
         createdTickets,
         spawnedTeam,
+        rateLimited: rateLimited || undefined,
     };
 }