@phnx-labs/agents-cli 1.22.35 → 1.22.38

package/dist/lib/session/host-link.js

@@ -25,8 +25,8 @@
  */
 /**
  * How long an IDE window's registry slice may go without a refresh before we
- * treat that window as gone. The Factory extension force-republishes its slice
- * every 4 minutes (`KEEPALIVE_FORCE_MS` in `apps/factory/src/vscode/foreman.registry.ts`)
+ * treat that window as gone. AGI EXT force-republishes its slice
+ * every 4 minutes (`KEEPALIVE_FORCE_MS` in `apps/ext/src/vscode/foreman.registry.ts`)
  * and on every terminal open/close, so a slice this old means the window is no
  * longer running — it is not merely quiet. Deliberately the same 10 minutes the
  * extension itself uses to garbage-collect a peer window's slice, so the CLI and

package/dist/lib/session/pid-registry.d.ts

@@ -43,7 +43,28 @@ export interface PidSessionEntry {
     tmuxPane?: string;
     startedAtMs: number;
 }
+export declare function isSessionIdShape(value: string): boolean;
 export declare function extractSessionIdArg(args: string[]): string | undefined;
+/**
+ * Read a live process's original argv (best-effort).
+ *
+ * Linux: NUL-separated `/proc/<pid>/cmdline`. Darwin: `ps -ww -o args=` then
+ * whitespace-split (good enough for Claude's `--session-id <uuid>` tokens;
+ * not a full shell-quote parser). Other platforms: undefined.
+ *
+ * RUSH-2384: the by-pid registry is often empty mid-run (launch pid was a
+ * wrapper that exited, prune wiped it, or the agent was not launched via
+ * `agents run`). The live process still carries `--session-id` on its argv —
+ * the same signal the incident used to prove the session was alive — so the
+ * active scan and `agents message` can recover identity without the registry.
+ */
+export declare function readProcessArgv(pid: number): string[] | undefined;
+/**
+ * Exact session id a live agent process was launched with, read from its
+ * current argv. Undefined when the process is gone, the platform can't expose
+ * argv, or the vector carries no `--session-id`.
+ */
+export declare function sessionIdFromLivePid(pid: number): string | undefined;
 /** Record a launched agent process. Never throws — the registry is an optimization. */
 export declare function writePidSessionEntry(entry: PidSessionEntry): void;
 /** Look up a live pid's recorded session. Returns undefined if absent/corrupt. */

package/dist/lib/session/pid-registry.js

@@ -18,6 +18,7 @@
  */
 import fs from 'fs';
 import path from 'path';
+import { execFileSync } from 'child_process';
 import { getTerminalsDir } from '../state.js';
 /**
  * Pull an explicit `--session-id <uuid>` (or `--session-id=<uuid>`) out of a
@@ -27,6 +28,9 @@ import { getTerminalsDir } from '../state.js';
  * gets from generating the id itself.
  */
 const SESSION_ID_VALUE_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+export function isSessionIdShape(value) {
+    return SESSION_ID_VALUE_RE.test(value);
+}
 export function extractSessionIdArg(args) {
     for (let i = 0; i < args.length; i++) {
         const a = args[i];
@@ -43,6 +47,59 @@ export function extractSessionIdArg(args) {
     }
     return undefined;
 }
+/**
+ * Read a live process's original argv (best-effort).
+ *
+ * Linux: NUL-separated `/proc/<pid>/cmdline`. Darwin: `ps -ww -o args=` then
+ * whitespace-split (good enough for Claude's `--session-id <uuid>` tokens;
+ * not a full shell-quote parser). Other platforms: undefined.
+ *
+ * RUSH-2384: the by-pid registry is often empty mid-run (launch pid was a
+ * wrapper that exited, prune wiped it, or the agent was not launched via
+ * `agents run`). The live process still carries `--session-id` on its argv —
+ * the same signal the incident used to prove the session was alive — so the
+ * active scan and `agents message` can recover identity without the registry.
+ */
+export function readProcessArgv(pid) {
+    if (!pid || pid < 1)
+        return undefined;
+    if (process.platform === 'linux') {
+        try {
+            const buf = fs.readFileSync(`/proc/${pid}/cmdline`);
+            const parts = buf.toString('utf8').split('\0').filter(Boolean);
+            return parts.length > 0 ? parts : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    if (process.platform === 'darwin') {
+        try {
+            const out = execFileSync('ps', ['-ww', '-p', String(pid), '-o', 'args='], {
+                encoding: 'utf-8',
+                stdio: ['ignore', 'pipe', 'ignore'],
+            }).trim();
+            if (!out)
+                return undefined;
+            return out.split(/\s+/);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    return undefined;
+}
+/**
+ * Exact session id a live agent process was launched with, read from its
+ * current argv. Undefined when the process is gone, the platform can't expose
+ * argv, or the vector carries no `--session-id`.
+ */
+export function sessionIdFromLivePid(pid) {
+    const argv = readProcessArgv(pid);
+    if (!argv)
+        return undefined;
+    return extractSessionIdArg(argv);
+}
 function pidRegistryDir() {
     return path.join(getTerminalsDir(), 'by-pid');
 }

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

@@ -44,7 +44,21 @@ export function parseRemoteActive(stdout, machine) {
     const out = [];
     for (const x of parsed) {
         if (x && typeof x === 'object' && !Array.isArray(x)) {
-            const row = { ...x, machine };
+            // The dialed machine still wins by default. That is deliberate: the peer
+            // reports `machineId()` (its hostname) while we key on the REGISTERED
+            // device name, and stamping ours is the only thing reconciling the two —
+            // drop it and a device whose registered name differs from its hostname
+            // silently answers a `--device <name>` scope with zero rows.
+            //
+            // The one row that must keep its own answer is an offloaded run, whose
+            // execution host is a THIRD box, not the peer we dialed
+            // (foldExecutionMachine, RUSH-2479). `offloadedFrom` marks exactly that
+            // row, so it is the discriminator rather than "the peer said something".
+            const reported = x;
+            const row = {
+                ...reported,
+                machine: reported.offloadedFrom && reported.machine ? reported.machine : machine,
+            };
             row.viewingIn = parseViewingIn(x.viewingIn);
             out.push(row);
         }

package/dist/lib/session/remote.js

@@ -58,7 +58,7 @@ export function buildForwardedArgs(argv, hosts = new Set()) {
     const out = [];
     for (let i = 0; i < args.length; i++) {
         const a = args[i];
-        if (a === '--host' || a === '-H' || a === '--device') {
+        if (a === '--host' || a === '-H' || a === '--device' || a === '--devices') {
             // Commander's `<target...>` variadic accepts both `--host a --host b` and
             // `--host a b` — consume every consecutive token that is a known host so
             // the variadic form doesn't leak the extra hosts into the remote argv.
@@ -75,7 +75,7 @@ export function buildForwardedArgs(argv, hosts = new Set()) {
             }
             continue;
         }
-        if (a.startsWith('--host=') || a.startsWith('-H=') || a.startsWith('--device='))
+        if (a.startsWith('--host=') || a.startsWith('-H=') || a.startsWith('--device=') || a.startsWith('--devices='))
             continue;
         if (/^-H.+/.test(a))
             continue; // glued short form: -Hyosemite-s1

package/dist/lib/session/session-cache.d.ts

@@ -1,15 +1,11 @@
-import type { ActiveSession } from './active.js';
+import { type ActiveSession } from './active.js';
 /**
  * How long a snapshot may be served before a reader re-gathers.
  * Short on purpose: live status (running/idle/waiting) must not go stale.
- * The daemon warms more frequently than this ceiling so normal readers hit a
- * fresh snapshot while expiry still forces a live gather after a missed tick.
+ * One-shot readers may re-gather after this ceiling. Long-lived watchers never
+ * do: they read one reset then tail the canonical writer journal.
  */
 export declare const DEFAULT_ACTIVE_CACHE_MAX_AGE_MS = 15000;
-/** Daemon warm interval — below the freshness ceiling to avoid an expiry gap. */
-export declare const SESSION_CACHE_WARM_INTERVAL_MS = 10000;
-/** Kick off the first warm shortly after daemon start, staggered off bootstrap. */
-export declare const SESSION_CACHE_WARM_KICKOFF_MS = 5000;
 /** Snapshot scope: this host only, or a fleet-wide merge written by a reader. */
 export type ActiveCacheScope = 'local' | 'fleet';
 export interface ActiveSessionsSnapshot {
@@ -21,6 +17,14 @@ export interface ActiveSessionsSnapshot {
     /** Peer count from the last fleet gather (fleet scope only). */
     remoteDeviceCount?: number;
 }
+export interface ActiveSessionsJournalRecord {
+    version: 1;
+    scope: ActiveCacheScope;
+    capturedAt: number;
+    upserts: ActiveSession[];
+    removes: string[];
+}
+export declare function activeSessionJournalIdentity(row: ActiveSession): string;
 /**
  * Per-session fields that are stable until the transcript changes. Keyed on
  * transcript mtime so a rewrite invalidates them. Live status is intentionally
@@ -61,6 +65,9 @@ export declare function setActiveSessionsSnapshotPathForTest(p: string | null):
 export declare function clearActiveSnapshotMemoryForTest(): void;
 /** Test seam: redirect the immutable-memo file. Returns the previous override. */
 export declare function setImmutableMemoPathForTest(p: string | null): string | null;
+/** Test seam: redirect the append-only live-state journal. */
+export declare function setActiveSessionsJournalPathForTest(p: string | null): string | null;
+export declare function activeSessionsJournalPath(): string;
 /** Read one scope from the snapshot file (best-effort; missing/corrupt → null). */
 export declare function readActiveSessionsCache(scope: ActiveCacheScope): ActiveSessionsSnapshot | null;
 /**

package/dist/lib/session/session-cache.js

@@ -8,8 +8,9 @@
  *
  * Pattern mirrors {@link ../devices/stats-cache.ts} / {@link ../fleet-status.ts}:
  *
- * - **Daemon warm:** each daemon publishes THIS host's local active sessions
- *   on a short tick (`publishLocalActiveSessions`). Publish-own only — no
+ * - **Daemon publish:** each daemon publishes THIS host's local active sessions
+ *   (`publishLocalActiveSessions`). Each write appends row deltas to the journal
+ *   consumed by long-lived watchers. Publish-own only — no
  *   cross-host SSH from the daemon (avoids the N² fan-out of RUSH-2061).
  * - **Readers** (`loadLocalActiveSessions`, fleet path in `gatherActiveSessions`)
  *   serve the warm snapshot when it is within {@link DEFAULT_ACTIVE_CACHE_MAX_AGE_MS};
@@ -26,21 +27,22 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { createMemoryCache } from '../memory-cache.js';
 import { getCacheDir } from '../state.js';
+import { sessionProcessIsLocal } from './active.js';
 /** Snapshot file under `getCacheDir()` (regenerable, gitignored). */
 const SNAPSHOT_FILE = '.active-sessions.json';
 /** Immutable-field memo file (keyed by sessionId + transcript mtime). */
 const IMMUTABLE_FILE = '.active-session-immutable.json';
+const JOURNAL_FILE = '.active-sessions.journal.jsonl';
 /**
  * How long a snapshot may be served before a reader re-gathers.
  * Short on purpose: live status (running/idle/waiting) must not go stale.
- * The daemon warms more frequently than this ceiling so normal readers hit a
- * fresh snapshot while expiry still forces a live gather after a missed tick.
+ * One-shot readers may re-gather after this ceiling. Long-lived watchers never
+ * do: they read one reset then tail the canonical writer journal.
  */
 export const DEFAULT_ACTIVE_CACHE_MAX_AGE_MS = 15_000;
-/** Daemon warm interval — below the freshness ceiling to avoid an expiry gap. */
-export const SESSION_CACHE_WARM_INTERVAL_MS = 10_000;
-/** Kick off the first warm shortly after daemon start, staggered off bootstrap. */
-export const SESSION_CACHE_WARM_KICKOFF_MS = 5_000;
+export function activeSessionJournalIdentity(row) {
+    return row.sessionId ?? `${row.context}:${row.kind}:${row.pid ?? ''}:${row.startedAtMs ?? ''}`;
+}
 /** Process-local L1. The atomic snapshot remains the cross-process source. */
 const activeSnapshotMemory = createMemoryCache({
     max: 2,
@@ -95,6 +97,7 @@ export const LIVE_STATUS_KEYS = [
 // ── path overrides (test seam) ─────────────────────────────────────────────
 let snapshotPathOverride = null;
 let immutablePathOverride = null;
+let journalPathOverride = null;
 /** Test seam: redirect the snapshot file. Returns the previous override. */
 export function setActiveSessionsSnapshotPathForTest(p) {
     const prev = snapshotPathOverride;
@@ -112,12 +115,22 @@ export function setImmutableMemoPathForTest(p) {
     immutablePathOverride = p;
     return prev;
 }
+/** Test seam: redirect the append-only live-state journal. */
+export function setActiveSessionsJournalPathForTest(p) {
+    const prev = journalPathOverride;
+    journalPathOverride = p;
+    return prev;
+}
 function snapshotPath() {
     return snapshotPathOverride ?? path.join(getCacheDir(), SNAPSHOT_FILE);
 }
 function immutablePath() {
     return immutablePathOverride ?? path.join(getCacheDir(), IMMUTABLE_FILE);
 }
+export function activeSessionsJournalPath() {
+    return journalPathOverride
+        ?? (snapshotPathOverride ? `${snapshotPathOverride}.journal.jsonl` : path.join(getCacheDir(), JOURNAL_FILE));
+}
 // ── snapshot read / write ──────────────────────────────────────────────────
 /** Read one scope from the snapshot file (best-effort; missing/corrupt → null). */
 export function readActiveSessionsCache(scope) {
@@ -163,12 +176,34 @@ export function writeActiveSessionsCache(scope, sessions, opts = {}) {
         catch {
             // empty
         }
+        const hadPrevious = Boolean(entries[scope]);
+        const previousSessions = entries[scope]?.sessions ?? [];
         entries[scope] = snap;
         const body = { version: 1, entries };
         // Atomic replace so a concurrent reader never sees a partial write.
         const tmp = `${snapshotPath()}.tmp`;
         fs.writeFileSync(tmp, JSON.stringify(body));
         fs.renameSync(tmp, snapshotPath());
+        // The snapshot writer is the canonical publisher. Watchers tail this
+        // append-only journal and compute stream deltas; they never trigger their
+        // own full active-session gather on a timer.
+        const previous = new Map(previousSessions.map((row) => [activeSessionJournalIdentity(row), row]));
+        const next = new Map(sessions.map((row) => [activeSessionJournalIdentity(row), row]));
+        const upserts = sessions.filter((row) => {
+            const before = previous.get(activeSessionJournalIdentity(row));
+            return !before || JSON.stringify(before) !== JSON.stringify(row);
+        });
+        const removes = [...previous.keys()].filter((key) => !next.has(key));
+        try {
+            if (!hadPrevious || upserts.length > 0 || removes.length > 0) {
+                fs.appendFileSync(activeSessionsJournalPath(), `${JSON.stringify({
+                    version: 1, scope, capturedAt: snap.capturedAt, upserts, removes,
+                })}\n`);
+            }
+        }
+        catch {
+            // Journal delivery is best-effort; the canonical snapshot remains valid.
+        }
         activeSnapshotMemory.set(scope, snap);
     }
     catch {
@@ -392,7 +427,14 @@ export async function loadFleetActiveSessions(opts) {
     // with ghost rows would make watchdog / `--local` report sessions that are
     // gone (review on RUSH-2062 / PR #2116).
     if (self !== undefined) {
-        const localOnly = live.sessions.filter((s) => !s.machine || s.machine === self);
+        // "Local" here means the PROCESS is on this box, which is not `machine ===
+        // self` for an offloaded run: its shim runs here while the agent executes on
+        // the peer (RUSH-2479). The other writer of this same key,
+        // `loadLocalActiveSessions`, seeds from `getActiveSessions({localOnly:true})`
+        // and keeps that shim — so comparing `machine` here would make the two
+        // disagree and leave `--local` showing or hiding the row depending on which
+        // surface last warmed the 15s cache.
+        const localOnly = live.sessions.filter((s) => sessionProcessIsLocal(s, self));
         writeCache('local', localOnly, { capturedAt: now });
     }
     return {

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

@@ -60,7 +60,7 @@ export interface DetectedTicket {
 }
 /**
  * Detect per-session rate-limit / usage-limit signals in assistant or error
- * text (RUSH-1523). Matches the same shapes Factory's prewarm detectBlockingPrompt
+ * text (RUSH-1523). Matches the same shapes the ext's prewarm detectBlockingPrompt
  * uses, plus common Claude/Codex/Gemini limit strings.
  */
 export declare function detectRateLimited(text?: string): boolean;
@@ -91,7 +91,7 @@ export interface SessionState {
     plan?: string;
     /**
      * Live plan progress from the most recent `TodoWrite` (RUSH-1380). Present when
-     * the session has written a todo list; drives the Factory Floor N/M pill +
+     * the session has written a todo list; drives the Fleet N/M pill +
      * checklist, notably for remote/device-dispatched agents with no local stream.
      */
     todos?: TodoProgress;

package/dist/lib/session/state.js

@@ -18,7 +18,7 @@ import * as path from 'path';
 import { isCompletedTodoStatus, SNAPSHOT_TODO_TOOLS, 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
+ * text (RUSH-1523). Matches the same shapes the ext's prewarm detectBlockingPrompt
  * uses, plus common Claude/Codex/Gemini limit strings.
  */
 export function detectRateLimited(text) {

package/dist/lib/session/sync/config.d.ts

@@ -1,14 +1,14 @@
 /**
- * R2 credential resolution + this machine's stable identity. The only field
- * `agents sessions export --encrypt` / `import` actually consume is the
- * shared `R2_SYNC_ENC_KEY` transcript key (`resolveSyncEncKey`); the other R2
- * fields (account/bucket/access keys) are validated here as a presence gate —
- * no `r2.backups` bundle configured means no shared key, so export/import
- * fall back to an ephemeral one. There is no R2 network client in this
- * codebase today (it moved with the rest of the R2/CRDT background sync this
- * bundle used to back — see git history for `./r2.ts`); a future R2-backed
- * feature (an export destination, a fleet cache) would add one where it's
- * actually wired. Credentials come from the `r2.backups` secrets bundle (OS
+ * R2 credential resolution + this machine's stable identity. Two consumers read
+ * these fields: `agents sessions export --encrypt` / `import` use only the shared
+ * `R2_SYNC_ENC_KEY` transcript key (`resolveSyncEncKey`), falling back to an
+ * ephemeral key when no bundle is configured; and the off-box backup target
+ * (`agents sessions export --to-r2` / `import --from-r2`, RUSH-2437) uses the full
+ * credential set (account/bucket/access keys/endpoint) to talk to R2 through the
+ * network client in `./r2.ts`. The `--to-r2`/`--from-r2` paths gate on
+ * `isSyncConfigured()` and fail loud when the bundle is absent (no silent
+ * fallback). This is a pure on-demand backup target, NOT the retired R2/CRDT
+ * background sync. Credentials come from the `r2.backups` secrets bundle (OS
  * keychain on macOS, libsecret on Linux) — never from env or disk.
  */
 /** Secrets bundle holding the R2 credentials. */

package/dist/lib/session/sync/config.js

@@ -1,14 +1,14 @@
 /**
- * R2 credential resolution + this machine's stable identity. The only field
- * `agents sessions export --encrypt` / `import` actually consume is the
- * shared `R2_SYNC_ENC_KEY` transcript key (`resolveSyncEncKey`); the other R2
- * fields (account/bucket/access keys) are validated here as a presence gate —
- * no `r2.backups` bundle configured means no shared key, so export/import
- * fall back to an ephemeral one. There is no R2 network client in this
- * codebase today (it moved with the rest of the R2/CRDT background sync this
- * bundle used to back — see git history for `./r2.ts`); a future R2-backed
- * feature (an export destination, a fleet cache) would add one where it's
- * actually wired. Credentials come from the `r2.backups` secrets bundle (OS
+ * R2 credential resolution + this machine's stable identity. Two consumers read
+ * these fields: `agents sessions export --encrypt` / `import` use only the shared
+ * `R2_SYNC_ENC_KEY` transcript key (`resolveSyncEncKey`), falling back to an
+ * ephemeral key when no bundle is configured; and the off-box backup target
+ * (`agents sessions export --to-r2` / `import --from-r2`, RUSH-2437) uses the full
+ * credential set (account/bucket/access keys/endpoint) to talk to R2 through the
+ * network client in `./r2.ts`. The `--to-r2`/`--from-r2` paths gate on
+ * `isSyncConfigured()` and fail loud when the bundle is absent (no silent
+ * fallback). This is a pure on-demand backup target, NOT the retired R2/CRDT
+ * background sync. Credentials come from the `r2.backups` secrets bundle (OS
  * keychain on macOS, libsecret on Linux) — never from env or disk.
  */
 import { readAndResolveBundleEnv } from '../../secrets/bundles.js';

package/dist/lib/session/sync/r2.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Minimal S3-compatible client for Cloudflare R2, built on aws4fetch (SigV4
+ * over the platform `fetch` + WebCrypto — works identically under Bun and
+ * Node >= 22). Only the verbs the backup target needs: put / get / head / list /
+ * delete.
+ *
+ * No mounting, no FUSE: this is a plain object-store client driven on demand by
+ * `agents sessions export --to-r2` / `import --from-r2`, which is the only
+ * approach that is seamless on both macOS and Linux (Mountpoint for S3 is
+ * Linux-only; rclone-mount needs macFUSE).
+ */
+import type { R2Config } from './config.js';
+export interface HeadResult {
+    size: number;
+    etag: string;
+}
+export declare class R2Client {
+    private aws;
+    private base;
+    constructor(cfg: R2Config);
+    private url;
+    /** Upload an object. Overwrites unconditionally. */
+    put(key: string, body: string | Uint8Array, contentType?: string): Promise<void>;
+    /** Fetch an object as text, or null if it does not exist (404). */
+    get(key: string): Promise<string | null>;
+    /** HEAD an object for size + etag, or null if it does not exist. */
+    head(key: string): Promise<HeadResult | null>;
+    /** Delete an object (no error if it is already absent). */
+    delete(key: string): Promise<void>;
+    /** List immediate sub-prefixes under a prefix (delimiter '/'), e.g. machine dirs. */
+    listPrefixes(prefix: string): Promise<string[]>;
+    /** List all object keys under a prefix (handles pagination). */
+    list(prefix: string): Promise<string[]>;
+}

package/dist/lib/session/sync/r2.js

@@ -0,0 +1,123 @@
+/**
+ * Minimal S3-compatible client for Cloudflare R2, built on aws4fetch (SigV4
+ * over the platform `fetch` + WebCrypto — works identically under Bun and
+ * Node >= 22). Only the verbs the backup target needs: put / get / head / list /
+ * delete.
+ *
+ * No mounting, no FUSE: this is a plain object-store client driven on demand by
+ * `agents sessions export --to-r2` / `import --from-r2`, which is the only
+ * approach that is seamless on both macOS and Linux (Mountpoint for S3 is
+ * Linux-only; rclone-mount needs macFUSE).
+ */
+import { AwsClient } from 'aws4fetch';
+export class R2Client {
+    aws;
+    base;
+    constructor(cfg) {
+        this.aws = new AwsClient({
+            accessKeyId: cfg.accessKeyId,
+            secretAccessKey: cfg.secretAccessKey,
+            service: 's3',
+            region: 'auto',
+        });
+        this.base = `${cfg.endpoint}/${encodeURIComponent(cfg.bucket)}`;
+    }
+    url(key) {
+        const encoded = key.split('/').map(encodeURIComponent).join('/');
+        return `${this.base}/${encoded}`;
+    }
+    /** Upload an object. Overwrites unconditionally. */
+    async put(key, body, contentType = 'application/octet-stream') {
+        const res = await this.aws.fetch(this.url(key), {
+            method: 'PUT',
+            body,
+            headers: { 'content-type': contentType },
+        });
+        if (!res.ok)
+            throw new Error(`R2 PUT ${key} failed: ${res.status} ${await safeText(res)}`);
+    }
+    /** Fetch an object as text, or null if it does not exist (404). */
+    async get(key) {
+        const res = await this.aws.fetch(this.url(key), { method: 'GET' });
+        if (res.status === 404)
+            return null;
+        if (!res.ok)
+            throw new Error(`R2 GET ${key} failed: ${res.status} ${await safeText(res)}`);
+        return await res.text();
+    }
+    /** HEAD an object for size + etag, or null if it does not exist. */
+    async head(key) {
+        const res = await this.aws.fetch(this.url(key), { method: 'HEAD' });
+        if (res.status === 404)
+            return null;
+        if (!res.ok)
+            throw new Error(`R2 HEAD ${key} failed: ${res.status}`);
+        return {
+            size: Number(res.headers.get('content-length') ?? '0'),
+            etag: (res.headers.get('etag') ?? '').replace(/"/g, ''),
+        };
+    }
+    /** Delete an object (no error if it is already absent). */
+    async delete(key) {
+        const res = await this.aws.fetch(this.url(key), { method: 'DELETE' });
+        if (!res.ok && res.status !== 404) {
+            throw new Error(`R2 DELETE ${key} failed: ${res.status}`);
+        }
+    }
+    /** List immediate sub-prefixes under a prefix (delimiter '/'), e.g. machine dirs. */
+    async listPrefixes(prefix) {
+        const prefixes = [];
+        let token;
+        do {
+            const params = new URLSearchParams({ 'list-type': '2', prefix, delimiter: '/' });
+            if (token)
+                params.set('continuation-token', token);
+            const res = await this.aws.fetch(`${this.base}?${params.toString()}`, { method: 'GET' });
+            if (!res.ok)
+                throw new Error(`R2 LIST(prefixes) ${prefix} failed: ${res.status} ${await safeText(res)}`);
+            const xml = await res.text();
+            for (const m of xml.matchAll(/<CommonPrefixes><Prefix>([^<]+)<\/Prefix><\/CommonPrefixes>/g)) {
+                prefixes.push(decodeXml(m[1]));
+            }
+            const truncated = /<IsTruncated>true<\/IsTruncated>/.test(xml);
+            token = truncated ? xml.match(/<NextContinuationToken>([^<]+)<\/NextContinuationToken>/)?.[1] : undefined;
+        } while (token);
+        return prefixes;
+    }
+    /** List all object keys under a prefix (handles pagination). */
+    async list(prefix) {
+        const keys = [];
+        let token;
+        do {
+            const params = new URLSearchParams({ 'list-type': '2', prefix });
+            if (token)
+                params.set('continuation-token', token);
+            const res = await this.aws.fetch(`${this.base}?${params.toString()}`, { method: 'GET' });
+            if (!res.ok)
+                throw new Error(`R2 LIST ${prefix} failed: ${res.status} ${await safeText(res)}`);
+            const xml = await res.text();
+            for (const m of xml.matchAll(/<Key>([^<]+)<\/Key>/g)) {
+                keys.push(decodeXml(m[1]));
+            }
+            const truncated = /<IsTruncated>true<\/IsTruncated>/.test(xml);
+            token = truncated ? xml.match(/<NextContinuationToken>([^<]+)<\/NextContinuationToken>/)?.[1] : undefined;
+        } while (token);
+        return keys;
+    }
+}
+function decodeXml(s) {
+    return s
+        .replace(/&amp;/g, '&')
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&quot;/g, '"')
+        .replace(/&apos;/g, "'");
+}
+async function safeText(res) {
+    try {
+        return (await res.text()).slice(0, 200);
+    }
+    catch {
+        return '';
+    }
+}

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

@@ -3,7 +3,7 @@
  *
  * Computes a rolling tokens-per-second readout from a session transcript's raw
  * content. This is the single source of truth for the throughput number the
- * Factory Floor shows next to a running agent — the extension used to carry its
+ * Fleet shows next to a running agent — the extension used to carry its
  * own copy of this math (`computeOutputTokensPerSec`); it now reads `tokPerSec`
  * straight off `agents sessions --active --json` instead (issue #741).
  */

package/dist/lib/session/throughput.js

@@ -3,7 +3,7 @@
  *
  * Computes a rolling tokens-per-second readout from a session transcript's raw
  * content. This is the single source of truth for the throughput number the
- * Factory Floor shows next to a running agent — the extension used to carry its
+ * Fleet shows next to a running agent — the extension used to carry its
  * own copy of this math (`computeOutputTokensPerSec`); it now reads `tokPerSec`
  * straight off `agents sessions --active --json` instead (issue #741).
  */

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

@@ -17,6 +17,19 @@ export declare const SESSION_AGENTS: SessionAgentId[];
  * of {@link SESSION_AGENTS}). The single predicate every session-index writer
  * gates on, so "is this a trackable agent?" is decided in exactly one place.
  */
+/**
+ * The tmux session name the CLI mints for an agent run: `ag-<agent>-<shortid>`.
+ *
+ * ONE definition. This shape was independently re-written as a regex literal in
+ * five places (focus's selector test, sessions-resume's direct-selector test,
+ * active's name parsers, actor-sidecar, and the deeplink parser); they drifted —
+ * focus accepted a 6+ hex suffix while the others required exactly 8 — which is
+ * how the same alias could be an "identity" to one code path and a keyword query
+ * to the next.
+ */
+export declare const AG_TMUX_NAME_RE: RegExp;
+/** Whether `name` is an `ag-<agent>-<shortid>` tmux session name. */
+export declare function isAgentTmuxAlias(name: string): boolean;
 export declare function isSessionTrackedAgent(agent: string): agent is SessionAgentId;
 /** A single normalized event within a session (message, tool call, thinking, etc.). */
 export interface SessionEvent {
@@ -239,7 +252,7 @@ export interface SessionMeta {
      * (Claude sessions only), captured at scan time. Present whenever the session
      * ever entered plan-review; consumers can pair it with a live
      * `awaitingReason === 'plan_review'` to decide whether it is still pending.
-     * Fills the gap that forced the Factory extension to re-read raw JSONL to
+     * Fills the gap that forced AGI EXT to re-read raw JSONL to
      * recover the plan text — the CLI now carries it on the metadata row.
      */
     plan?: string;
@@ -326,6 +339,15 @@ export interface SessionMeta {
      * `parseRemoteList`; transient (never persisted, stripped from --json).
      */
     _remote?: boolean;
+    /**
+     * True when the transcript file is gone from disk but the session's user turns
+     * still live in the local DB (session_text), so the row is served and rendered
+     * from the DB instead of vanishing (RUSH-2436). Absent for a live session whose
+     * file is present. Backed by the persisted `archived_at` column.
+     */
+    archived?: boolean;
+    /** Epoch ms the transcript file was first confirmed gone (pairs with {@link archived}). */
+    archivedAt?: number;
     /** Terms that matched the current search query */
     _matchedTerms?: string[];
     /** BM25 relevance score from the most recent content-index search */