@phnx-labs/agents-cli 1.22.112 → 1.22.114

package/dist/lib/feed-policy.d.ts

@@ -1,24 +1,22 @@
 import { type OpenBlock, type AnswerRecord } from './feed/feed.js';
-export type BlockClass = 'approval' | 'decision';
-export interface ClassPolicy {
+type BlockClass = 'approval' | 'decision';
+interface ClassPolicy {
     timeoutMinutes: number;
     /** For approval class only: the answer to apply when the timeout fires. */
     safeDefault?: string;
 }
-export interface FeedPolicy {
+interface FeedPolicy {
     approval: ClassPolicy;
     decision: ClassPolicy;
     /** High-cost-of-delay blocks below this threshold do not page the phone. */
     phoneNotifyThreshold: 'low' | 'medium' | 'high';
 }
 export declare const DEFAULT_POLICY: FeedPolicy;
-export declare function getPolicyPath(root?: string): string;
 export declare function loadPolicy(root?: string): FeedPolicy;
 export declare function blockClass(block: OpenBlock): BlockClass;
 export declare function isPhoneUrgent(block: OpenBlock, policy: FeedPolicy): boolean;
-export declare function minutesElapsed(block: OpenBlock, now: Date): number;
 export declare function isTimedOut(block: OpenBlock, policy: FeedPolicy, now: Date): boolean;
-export interface PolicyResult {
+interface PolicyResult {
     blockId: string;
     action: 'none' | 'defaulted' | 'parked';
     answer?: AnswerRecord;
@@ -28,3 +26,4 @@ export interface PolicyResult {
  * Caller is responsible for persistence/logging side effects not owned by feed.ts.
  */
 export declare function applyPolicyToBlock(block: OpenBlock, policy: FeedPolicy, now: Date, root?: string, mailboxRoot?: string): PolicyResult;
+export {};

package/dist/lib/feed-policy.js

@@ -25,7 +25,7 @@ export const DEFAULT_POLICY = {
     decision: { timeoutMinutes: 60 },
     phoneNotifyThreshold: 'medium',
 };
-export function getPolicyPath(root) {
+function getPolicyPath(root) {
     return path.join(root ?? getUserAgentsDir(), POLICY_FILE);
 }
 function normalizeClassPolicy(raw, fallback) {
@@ -65,7 +65,7 @@ export function isPhoneUrgent(block, policy) {
     const cost = block.costOfDelay ?? 'low';
     return COST_RANK[cost] >= COST_RANK[policy.phoneNotifyThreshold];
 }
-export function minutesElapsed(block, now) {
+function minutesElapsed(block, now) {
     const ts = Date.parse(block.ts);
     if (Number.isNaN(ts))
         return 0;

package/dist/lib/feed-post.d.ts

@@ -4,7 +4,7 @@ import { type PidSessionEntry } from './session/pid-registry.js';
 export declare const STATUS_POST_MAX_CHARS = 500;
 /** Title is a phone subject line - about four or five words, not a paragraph. */
 export declare const STATUS_TITLE_MAX_CHARS = 60;
-export interface FeedPostInput {
+interface FeedPostInput {
     /**
      * Short subject (required for new posts). ~4–5 words. Phone broadcasts put
      * this on the first line so a scan names the topic before the body.
@@ -53,7 +53,7 @@ export interface FeedPostInput {
     /** Override full registry list for launchId match (tests). */
     listEntries?: () => PidSessionEntry[];
 }
-export interface FeedPostResult {
+interface FeedPostResult {
     event: ActivityEvent;
 }
 export interface PostIdentity {
@@ -78,8 +78,6 @@ export interface PostIdentity {
 export declare function resolvePostIdentity(input: Pick<FeedPostInput, 'sessionId' | 'env' | 'cwd' | 'activityRoot' | 'startPid' | 'getParentPid' | 'readEntry' | 'listEntries'>): PostIdentity | undefined;
 /** Walk up to 16 ancestors looking for a by-pid registry entry with a session. */
 export declare function walkPidRegistry(startPid: number, getParent: (pid: number) => number | undefined, readEntry: (pid: number) => PidSessionEntry | undefined): PidSessionEntry | undefined;
-/** Best-effort parent pid of `pid` (Linux /proc, else `ps`). */
-export declare function parentPidOf(pid: number): number | undefined;
 /**
  * Turn one `--attach` token into an {@link Attachment}. Remote URLs become
  * `link` (or a media kind when the extension is unambiguous). Local files are
@@ -112,3 +110,4 @@ export declare function normalizeStatusTitle(title: string): string;
  * Throws if title/text is empty or session identity cannot be resolved.
  */
 export declare function postFeedStatus(input: FeedPostInput): FeedPostResult;
+export {};

package/dist/lib/feed-post.js

@@ -21,7 +21,7 @@ import { resolveProjectNameForCwd, listProjectDefs } from './projects.js';
 import { getHistoryDir } from './state.js';
 import { machineId } from './machine-id.js';
 import { isValidMailboxId } from './mailbox.js';
-import { listPidSessionEntries, readPidSessionEntry, } from './session/pid-registry.js';
+import { listPidSessionEntries, readLivePidSessionEntry as readPidSessionEntry, } from './session/pid-registry.js';
 /** Soft cap so a runaway agent can't flood the activity lane with essays. */
 export const STATUS_POST_MAX_CHARS = 500;
 /** Title is a phone subject line - about four or five words, not a paragraph. */
@@ -120,7 +120,7 @@ export function walkPidRegistry(startPid, getParent, readEntry) {
     return firstHit;
 }
 /** Best-effort parent pid of `pid` (Linux /proc, else `ps`). */
-export function parentPidOf(pid) {
+function parentPidOf(pid) {
     if (!Number.isInteger(pid) || pid <= 1)
         return undefined;
     if (process.platform === 'linux') {

package/dist/lib/feed-ranking.d.ts

@@ -20,14 +20,14 @@ export interface FeedSessionSignal {
     cloudProvider?: string;
     cloudTaskId?: string;
 }
-export interface RankedFeedBlock extends OpenBlock {
+interface RankedFeedBlock extends OpenBlock {
     delayRank: NonNullable<OpenBlock['delayRank']>;
 }
 export declare function buildSessionSignals(active: ActiveSession[], metas?: SessionMeta[]): FeedSessionSignal[];
 export declare function decisionIrreducibility(c: Classification): number;
 export declare function burnUsdPerHour(signal: FeedSessionSignal | undefined, block: OpenBlock): number;
 export declare function rankFeedBlocks(blocks: OpenBlock[], signals?: FeedSessionSignal[], now?: Date): RankedFeedBlock[];
-export declare function recentAskCount(stats: FeedAskStats, now?: Date): number;
 export declare function needyControlCards(stats: FeedAskStats[], signals?: FeedSessionSignal[], now?: Date, threshold?: number): OpenBlock[];
 export declare function runawayControlCards(signals: FeedSessionSignal[], now?: Date): OpenBlock[];
 export declare function synthesizeControlCards(signals: FeedSessionSignal[], stats: FeedAskStats[], now?: Date): OpenBlock[];
+export {};

package/dist/lib/feed-ranking.js

@@ -127,7 +127,7 @@ export function rankFeedBlocks(blocks, signals = [], now = new Date()) {
         return Date.parse(a.ts) - Date.parse(b.ts);
     });
 }
-export function recentAskCount(stats, now = new Date()) {
+function recentAskCount(stats, now = new Date()) {
     const cutoff = now.getTime() - 60 * 60_000;
     return stats.recentAskTimestamps.filter((ts) => {
         const parsed = Date.parse(ts);

package/dist/lib/fleet/apply.d.ts

@@ -52,7 +52,7 @@ export interface SourceAuth {
  * list (PHNX-2371).
  */
 export declare function fleetSecretsBundles(declared: string[] | undefined): string[];
-export interface DiffContext {
+interface DiffContext {
     /** agents-cli version the source is on — the fleet target version. */
     targetCliVersion: string;
     sourceAuth: SourceAuth;
@@ -72,7 +72,7 @@ export interface DiffContext {
 /** Pure: desired vs probed -> per-device diff + flat action list. */
 export declare function diffFleet(desired: DeviceDesired[], probes: Map<string, DeviceProbe>, ctx: DiffContext): FleetPlan;
 /** Why a declared bundle is or is not pushed to one device. */
-export interface SecretPushDecision {
+interface SecretPushDecision {
     push: boolean;
     /** Where it would land on the remote. Only meaningful when `push`. */
     backend: RemoteBackend;
@@ -108,7 +108,7 @@ export interface SecretPushDecision {
  * the one fleet-shared setup-token store (PHNX-2371).
  */
 export declare function decideSecretPush(bundle: string, desired: DeviceDesired, probe: DeviceProbe, ctx: DiffContext): SecretPushDecision;
-export interface ProbeOptions {
+interface ProbeOptions {
     /** Also fetch per-agent installed versions (one extra `agents view --json`
      * round-trip). Enable only when the plan has a version-pinned spec. */
     withVersions?: boolean;
@@ -141,18 +141,17 @@ export interface DeviceApplyResult {
     steps: ApplyStep[];
     note?: string;
 }
-export interface ExecContext {
+interface ExecContext {
     targetCliVersion: string;
     source: string;
     sourceAuth: SourceAuth;
     /** Set for a dry run — probe + plan only, execute nothing. */
     dryRun?: boolean;
 }
-/** Execute one device's planned actions in order. Real SSH — no mocks. */
-export declare function reconcileDevice(row: DeviceDiff, device: DeviceProfile, ctx: ExecContext): Promise<DeviceApplyResult>;
 /** Run a pool of async tasks with a concurrency cap, preserving input order. */
 export declare function pool<T, R>(items: T[], limit: number, fn: (item: T, index: number) => Promise<R>): Promise<R[]>;
 /** Reconcile every device row in parallel (capped). */
 export declare function runFleetApply(rows: DeviceDiff[], nameToProfile: Map<string, DeviceProfile>, ctx: ExecContext, concurrency?: number): Promise<DeviceApplyResult[]>;
 /** Default home for source snapshots (overridable in tests). */
 export declare function sourceHome(): string;
+export {};

package/dist/lib/fleet/apply.js

@@ -9,7 +9,7 @@
  */
 import * as os from 'os';
 import { pushBundleToHost } from '../secrets-client.js';
-import { AUTH_BUNDLE_NAME, inspectReservedAuthBundle, isReservedBundleName } from '../secrets-policy.js';
+import { AUTH_STORE_ALIAS, inspectReservedAuthBundle, isReservedBundleName } from '../secrets-policy.js';
 import { deviceIdentityArgs, sshTargetFor } from '../devices/connect.js';
 import { readyProbe, bootstrapAgentsCli } from '../hosts/ready.js';
 import { buildRemoteAgentsInvocation } from '../hosts/remote-cmd.js';
@@ -98,8 +98,8 @@ export function parseInstalledVersions(stdout) {
 export function fleetSecretsBundles(declared) {
     const out = [...(declared ?? [])];
     const auth = inspectReservedAuthBundle();
-    if (auth.exists && auth.ok && !out.includes(AUTH_BUNDLE_NAME)) {
-        out.push(AUTH_BUNDLE_NAME);
+    if (auth.exists && auth.ok && !out.includes(AUTH_STORE_ALIAS)) {
+        out.push(AUTH_STORE_ALIAS);
     }
     return out;
 }
@@ -371,7 +371,7 @@ export function parseRemoteBundles(stdout) {
     }
 }
 /** Execute one device's planned actions in order. Real SSH — no mocks. */
-export async function reconcileDevice(row, device, ctx) {
+async function reconcileDevice(row, device, ctx) {
     if (!row.probe.reachable) {
         return { device: row.device, ok: false, steps: [], note: row.probe.note ?? 'unreachable' };
     }

package/dist/lib/fleet/manifest.d.ts

@@ -12,7 +12,7 @@ import type { FleetManifest, DeviceDesired } from './types.js';
 export declare function parseFleetManifest(raw: unknown): FleetManifest;
 /** Read a YAML file and extract + validate its `fleet:` block. */
 export declare function readFleetFile(filePath: string): FleetManifest;
-export interface ResolveContext {
+interface ResolveContext {
     /** Device names currently online (used to expand `devices: all`). */
     onlineDevices: string[];
     /** All registered device names (used to validate explicit entries). */
@@ -50,3 +50,4 @@ export declare function emptyTargetsMessage(manifest: FleetManifest): {
     style: 'hint' | 'plain';
     lines: string[];
 };
+export {};

package/dist/lib/fleet/remote-login.d.ts

@@ -3,7 +3,7 @@ import type { DeviceProfile } from '../devices/registry.js';
 import { type AuthVerdict, type AuthHealth } from '../auth-health.js';
 import { type LoginFlow } from './auth-sync.js';
 /** A verification URL + user code scraped from a device-code login screen. */
-export interface ScrapedLogin {
+interface ScrapedLogin {
     url?: string;
     code?: string;
 }
@@ -17,7 +17,7 @@ export interface ScrapedLogin {
  */
 export declare function scrapeLogin(screenText: string, flow: LoginFlow): ScrapedLogin;
 /** Why a logged-out (agent, device) pair can or cannot be driven remotely. */
-export interface FlowClassification {
+interface FlowClassification {
     flow: LoginFlow | null;
     remotable: boolean;
     reason?: string;
@@ -38,7 +38,7 @@ export declare function classifyLoginFlow(agent: AgentId | string, platform: str
  */
 export declare function isPendingVerdict(verdict: AuthVerdict | undefined): boolean;
 /** A logged-out (agent, device) pair `fleet login` will target or explain. */
-export interface PendingLogin {
+interface PendingLogin {
     device: string;
     agent: AgentId | string;
     platform?: string;
@@ -51,7 +51,7 @@ export interface PendingLogin {
     /** Present when `!remotable` — why it must be done on the box itself. */
     reason?: string;
 }
-export interface SelectLoginOptions {
+interface SelectLoginOptions {
     /** Include pairs already logged-in (verdict live/unverified) — for a forced re-login. */
     includeLoggedIn?: boolean;
 }
@@ -68,7 +68,7 @@ export interface SelectLoginOptions {
 export declare function selectLoginTargets(devices: DeviceProfile[], agents: (AgentId | string)[], cache: Record<string, AuthHealth>, opts?: SelectLoginOptions): PendingLogin[];
 /**
  * Build the `ssh -tt <target> <loginCommand>` command string driven through the
- * PTY sidecar. `-tt` forces a tty so the remote CLI enters its interactive
+ * `term` CLI. `-tt` forces a tty so the remote CLI enters its interactive
  * device-code flow; `accept-new` learns a first-seen host key without a prompt.
  * Both the target and the login command are shell-quoted. Pure/testable.
  *
@@ -77,7 +77,7 @@ export declare function selectLoginTargets(devices: DeviceProfile[], agents: (Ag
  * are a follow-up (TODO), surfaced as an error rather than silently mis-driven.
  */
 export declare function buildRemoteLoginSshCommand(target: string, flow: LoginFlow, extraSshArgs?: string[]): string;
-export type LoginMode = 'bulk' | 'interactive';
+type LoginMode = 'bulk' | 'interactive';
 /** Per-pair status shape shared between the driver, the status endpoint, and the page. */
 export type LoginStatusState = 'pending' | 'driving' | 'ready' | 'authorized' | 'error' | 'skipped';
 export interface LoginStatus {
@@ -101,8 +101,8 @@ export interface LoginStatus {
  * light variant via `prefers-color-scheme`.
  */
 export declare function buildDashboardHtml(pending: PendingLogin[], mode: LoginMode): string;
-/** The subset of the PTY sidecar `driveRemoteLogin` needs — faked in tests. */
-export interface PtyDriver {
+/** The subset of the `term` CLI `driveRemoteLogin` needs — faked in tests. */
+export interface TermDriver {
     start(opts?: {
         rows?: number;
         cols?: number;
@@ -115,8 +115,8 @@ export interface PtyDriver {
     }>;
     stop(id: string): Promise<void>;
 }
-/** Real driver over the pty sidecar (`ptyRequest`). */
-export declare function defaultPtyDriver(): PtyDriver;
+/** Real driver over the standalone `term` CLI (`../term-client.js`). */
+export declare function defaultTermDriver(): TermDriver;
 export interface DriveOptions {
     /** Wait after launching ssh before steering / scraping (default 4000ms). */
     initialDelayMs?: number;
@@ -125,41 +125,22 @@ export interface DriveOptions {
     /** Overall scrape deadline (default 90000ms). */
     timeoutMs?: number;
 }
-export interface DriveResult extends ScrapedLogin {
+interface DriveResult extends ScrapedLogin {
     /** True when the underlying ssh session already exited (login finished or failed). */
     exited: boolean;
-    /** The pty session id, so the caller can keep polling / stop it. */
+    /** The term session id, so the caller can keep polling / stop it. */
     sessionId: string;
 }
 /**
  * Drive one remote device-code login: launch `ssh -tt <target> <loginCommand>`
- * in a PTY, send the flow's `deviceCodeSelect` keystrokes (if any) to reach the
+ * in a `term` session, send the flow's `deviceCodeSelect` keystrokes (if any) to reach the
  * device-code path, then poll the screen until {@link scrapeLogin} yields both a
  * URL and a code (or the deadline / session-exit). The human completes the code
  * in the browser; the caller polls the credential file for completion. Testable
- * against a fake {@link PtyDriver}.
+ * against a fake {@link TermDriver}.
  */
-export declare function driveRemoteLogin(target: string, flow: LoginFlow, driver: PtyDriver, opts?: DriveOptions, extraSshArgs?: string[]): Promise<DriveResult>;
-export interface DetectOptions {
-    agents?: (AgentId | string)[];
-    devices?: string[];
-    includeLoggedIn?: boolean;
-}
-/**
- * Resolve the online fleet devices, then compute pending logins
- * from the shared auth-health cache (populated by `agents fleet ping`). Thin I/O
- * over the pure {@link selectLoginTargets}. Devices/agents can be narrowed by the
- * caller's flags; the default agent set is every agent with a defined flow.
- */
-export declare function detectPending(opts?: DetectOptions): Promise<PendingLogin[]>;
-/**
- * Best-effort epoch-seconds mtime of a home-relative file on a remote box, or 0
- * when it is absent/unreadable. Used to detect the credential file appearing /
- * bumping after the human completes the browser step. POSIX `stat` only (the
- * device-code agents are all POSIX-fleet).
- */
-export declare function remoteFileMtime(target: string, homeRel: string, extraSshArgs?: string[]): Promise<number>;
-export interface RunFleetLoginOptions {
+export declare function driveRemoteLogin(target: string, flow: LoginFlow, driver: TermDriver, opts?: DriveOptions, extraSshArgs?: string[]): Promise<DriveResult>;
+interface RunFleetLoginOptions {
     agents?: (AgentId | string)[];
     devices?: string[];
     interactive?: boolean;
@@ -167,7 +148,7 @@ export interface RunFleetLoginOptions {
     /** Target every device-code pair regardless of cached login state (cold cache / forced re-login). */
     all?: boolean;
     /** Overrides for testing / non-default cadence. */
-    driver?: PtyDriver;
+    driver?: TermDriver;
     drive?: DriveOptions;
     /** Port for the local dashboard (0 = ephemeral). */
     port?: number;
@@ -186,3 +167,4 @@ export interface RunFleetLoginOptions {
  * this wires them to the live fleet.
  */
 export declare function runFleetLogin(opts?: RunFleetLoginOptions): Promise<LoginStatus[]>;
+export {};

package/dist/lib/fleet/remote-login.js

@@ -17,8 +17,9 @@
  * Layering — pure vs I/O, so the valuable logic is unit-testable without SSH:
  *  - `scrapeLogin` / `classifyLoginFlow` / `selectLoginTargets` /
  *    `buildRemoteLoginSshCommand` / `buildDashboardHtml` are PURE.
- *  - `driveRemoteLogin` drives a PTY through an injectable {@link PtyDriver}
- *    (fake in tests; real over the pty sidecar in prod).
+ *  - `driveRemoteLogin` drives a terminal through an injectable {@link TermDriver}
+ *    (fake in tests; real over the standalone `term` CLI in prod — see
+ *    `../term-client.js`).
  *  - `detectPending` / `runFleetLogin` do the real fleet I/O.
  *
  * The device codes have a ~15 min TTL, so the default (bulk) mode requests every
@@ -32,7 +33,7 @@ import { deviceIdentityArgs, fleetDialTarget } from '../devices/connect.js';
 import { planFleetTargets } from '../devices/fleet.js';
 import { assertValidSshTarget, shellQuote, sshExecAsync } from '../ssh-exec.js';
 import { machineId } from '../session/sync/config.js';
-import { ptyRequest } from '../pty-client.js';
+import { termStart, termExec, termWrite, termScreen, termStop } from '../term-client.js';
 import { showUrl } from '../open-url.js';
 import { readAuthHealthCache, } from '../auth-health.js';
 import { FLEET_LOGIN_FLOWS, KEYCHAIN_BOUND_ON_MAC, } from './auth-sync.js';
@@ -144,7 +145,7 @@ export function selectLoginTargets(devices, agents, cache, opts = {}) {
 }
 /**
  * Build the `ssh -tt <target> <loginCommand>` command string driven through the
- * PTY sidecar. `-tt` forces a tty so the remote CLI enters its interactive
+ * `term` CLI. `-tt` forces a tty so the remote CLI enters its interactive
  * device-code flow; `accept-new` learns a first-seen host key without a prompt.
  * Both the target and the login command are shell-quoted. Pure/testable.
  *
@@ -331,42 +332,42 @@ export function buildDashboardHtml(pending, mode) {
 </body>
 </html>`;
 }
-/** Real driver over the pty sidecar (`ptyRequest`). */
-export function defaultPtyDriver() {
+/** Real driver over the standalone `term` CLI (`../term-client.js`). */
+export function defaultTermDriver() {
     const expectOk = (res, what) => {
         if (!res.ok)
-            throw new Error(`pty ${what} failed: ${res.error ?? 'unknown'}`);
+            throw new Error(`term ${what} failed: ${res.error ?? 'unknown'}`);
     };
     return {
         async start(opts) {
-            const res = await ptyRequest('start', undefined, { rows: opts?.rows ?? 40, cols: opts?.cols ?? 120 });
+            const res = await termStart({ rows: opts?.rows ?? 40, cols: opts?.cols ?? 120 });
             expectOk(res, 'start');
             return res.id;
         },
         async exec(id, command) {
-            expectOk(await ptyRequest('exec', id, { command }), 'exec');
+            expectOk(await termExec(id, command), 'exec');
         },
         async write(id, input) {
-            expectOk(await ptyRequest('write', id, { input }), 'write');
+            expectOk(await termWrite(id, input), 'write');
         },
         async screen(id) {
-            const res = await ptyRequest('screen', id);
+            const res = await termScreen(id);
             expectOk(res, 'screen');
             return { screen: res.screen ?? '', exited: Boolean(res.exited) };
         },
         async stop(id) {
-            await ptyRequest('stop', id).catch(() => undefined);
+            await termStop(id).catch(() => undefined);
         },
     };
 }
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 /**
  * Drive one remote device-code login: launch `ssh -tt <target> <loginCommand>`
- * in a PTY, send the flow's `deviceCodeSelect` keystrokes (if any) to reach the
+ * in a `term` session, send the flow's `deviceCodeSelect` keystrokes (if any) to reach the
  * device-code path, then poll the screen until {@link scrapeLogin} yields both a
  * URL and a code (or the deadline / session-exit). The human completes the code
  * in the browser; the caller polls the credential file for completion. Testable
- * against a fake {@link PtyDriver}.
+ * against a fake {@link TermDriver}.
  */
 export async function driveRemoteLogin(target, flow, driver, opts = {}, extraSshArgs = []) {
     const initialDelayMs = opts.initialDelayMs ?? 4000;
@@ -374,8 +375,8 @@ export async function driveRemoteLogin(target, flow, driver, opts = {}, extraSsh
     const timeoutMs = opts.timeoutMs ?? 90000;
     const id = await driver.start();
     // Everything past start() must tear the session down on a mid-flight throw —
-    // otherwise the caller never receives a sessionId and the PTY (and the
-    // `ssh -tt` process it drives) leaks until the sidecar's idle reaper. On the
+    // otherwise the caller never receives a sessionId and the term session (and
+    // the `ssh -tt` process it drives) leaks until term's own idle reaper. On the
     // normal return paths the caller owns stop() via the returned sessionId.
     try {
         await driver.exec(id, buildRemoteLoginSshCommand(target, flow, extraSshArgs));
@@ -412,7 +413,7 @@ export async function driveRemoteLogin(target, flow, driver, opts = {}, extraSsh
  * over the pure {@link selectLoginTargets}. Devices/agents can be narrowed by the
  * caller's flags; the default agent set is every agent with a defined flow.
  */
-export async function detectPending(opts = {}) {
+async function detectPending(opts = {}) {
     const reg = await loadDevices();
     const self = machineId();
     const online = planFleetTargets(reg)
@@ -432,7 +433,7 @@ export async function detectPending(opts = {}) {
  * bumping after the human completes the browser step. POSIX `stat` only (the
  * device-code agents are all POSIX-fleet).
  */
-export async function remoteFileMtime(target, homeRel, extraSshArgs = []) {
+async function remoteFileMtime(target, homeRel, extraSshArgs = []) {
     const cmd = `stat -c %Y "$HOME/${homeRel}" 2>/dev/null || stat -f %m "$HOME/${homeRel}" 2>/dev/null || echo 0`;
     const res = await sshExecAsync(target, cmd, { timeoutMs: 15000, multiplex: true, extraSshArgs }).catch(() => null);
     if (!res || res.code !== 0)
@@ -507,7 +508,7 @@ export async function runFleetLogin(opts = {}) {
             console.error(`  ${dashUrl}`);
         }
     }
-    const driver = opts.driver ?? defaultPtyDriver();
+    const driver = opts.driver ?? defaultTermDriver();
     const remotable = pending.filter((p) => p.remotable);
     const driveOne = async (p) => {
         const k = key(p.device, p.agent);

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

@@ -204,14 +204,6 @@ export interface AuthFilePayload {
     /** POSIX mode to restore (e.g. 0o600 for credentials). */
     mode: number;
 }
-/** The plaintext we encrypt before shipping auth over the wire. */
-export interface AuthBundle {
-    /** Schema version for forward-compat. */
-    v: 1;
-    /** Source machine name the snapshot was taken on. */
-    source: string;
-    files: AuthFilePayload[];
-}
 /** Result of classifying one source agent's auth for propagation. */
 export interface AuthSnapshotResult {
     files: AuthFilePayload[];

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

@@ -1,18 +1,3 @@
-/**
- * One synchronous, disk-only read facade over the fleet/usage caches.
- *
- * These readers NEVER touch the network and NEVER SSH — they read the caches
- * the daemon keeps warm (usage snapshot, projected headroom, fleet status) and
- * return instantly. That is the whole point: the routing hot path
- * (`agents run` → rotate.ts), device affinity (smart-launch.ts), and Factory can
- * consult live-ish fleet state without paying a provider fetch or an ssh probe
- * on a latency-sensitive path.
- *
- * Writers live elsewhere (the daemon's `runUsageRefresh` for usage/headroom,
- * `runFleetStatusPublish` for the fleet-status mirror); this module is the read
- * side only.
- */
-import { type UsageSnapshot } from './accounting/usage.js';
 import { type FleetStatusRow } from './fleet-status.js';
 /**
  * The fleet-status union the daemon publishes (own row) and the fleet-status
@@ -21,10 +6,8 @@ import { type FleetStatusRow } from './fleet-status.js';
  */
 export declare function readFleetStatus(): Record<string, FleetStatusRow>;
 export type { FleetStatusRow };
-/** The last cached usage snapshot for an account, or null. Cache-only. */
-export declare function readAccountUsage(usageKey: string): UsageSnapshot | null;
 /** An account's projected headroom, as published by the daemon refresher. */
-export interface AccountHeadroom {
+interface AccountHeadroom {
     status: 'available' | 'rate_limited' | null;
     /** Projected minutes until the session window caps; null = unknown/idle. */
     minutesToLimit: number | null;

package/dist/lib/fleet-cache.js

@@ -12,7 +12,6 @@
  * `runFleetStatusPublish` for the fleet-status mirror); this module is the read
  * side only.
  */
-import { readClaudeUsageCache } from './accounting/usage.js';
 import { readHeadroomEntry } from './usage-refresh.js';
 import { readFleetStatus as readFleetStatusMirror } from './fleet-status.js';
 /**
@@ -23,10 +22,6 @@ import { readFleetStatus as readFleetStatusMirror } from './fleet-status.js';
 export function readFleetStatus() {
     return readFleetStatusMirror();
 }
-/** The last cached usage snapshot for an account, or null. Cache-only. */
-export function readAccountUsage(usageKey) {
-    return readClaudeUsageCache(usageKey);
-}
 /**
  * The daemon-computed headroom for an account, or null when nothing has been
  * published yet. Cache-only — a cold cache simply yields null, and callers

package/dist/lib/fleet-shared-repo-sync.d.ts

@@ -1,5 +1,4 @@
 export declare const FLEET_SHARED_REPO_SYNC_DEADLINE_MS = 45000;
-export declare const FLEET_SHARED_REPO_KILL_GRACE_MS = 250;
 export declare const FLEET_SHARED_REPO_OUTPUT_MAX_BYTES: number;
 /**
  * When the shared-state exchange last completed successfully, in epoch ms, or
@@ -7,13 +6,13 @@ export declare const FLEET_SHARED_REPO_OUTPUT_MAX_BYTES: number;
  * Reads the default daemon-dir marker the periodic exchange writes.
  */
 export declare function readLastSuccessfulExchangeMs(): number | null;
-export interface BoundedProcessResult {
+interface BoundedProcessResult {
     code: number | null;
     stdout: string;
     stderr: string;
     timedOut: boolean;
 }
-export interface FleetSharedRepoSyncOptions {
+interface FleetSharedRepoSyncOptions {
     userAgentsDir?: string;
     device?: string;
     timeoutMs?: number;
@@ -53,3 +52,4 @@ export declare function runBoundedProcess(command: string, args: string[], optio
  * this resolves successfully.
  */
 export declare function syncFleetSharedStateRepo(options?: FleetSharedRepoSyncOptions): Promise<FleetSharedRepoSyncResult>;
+export {};

package/dist/lib/fleet-shared-repo-sync.js

@@ -18,7 +18,7 @@ import { logAndContinueOnLockCompromised } from './lock-compromise.js';
 import { machineId } from './session/sync/config.js';
 import { getDaemonDir, getUserAgentsDir } from './state.js';
 export const FLEET_SHARED_REPO_SYNC_DEADLINE_MS = 45_000;
-export const FLEET_SHARED_REPO_KILL_GRACE_MS = 250;
+const FLEET_SHARED_REPO_KILL_GRACE_MS = 250;
 export const FLEET_SHARED_REPO_OUTPUT_MAX_BYTES = 1024 * 1024;
 const FLEET_SHARED_REPO_PUSH_ATTEMPTS = 3;
 const FLEET_SHARED_REPO_REBASE_CLEANUP_RESERVE_MS = 5_000;

package/dist/lib/fleet-shared-state.d.ts

@@ -57,12 +57,12 @@ export interface FleetSharedDeviceState {
         rows: SessionMirrorRow[];
     };
 }
-export interface FleetSharedStatePatch {
+interface FleetSharedStatePatch {
     usage?: FleetSharedDeviceState['usage'];
     auth?: FleetSharedDeviceState['auth'];
     sessions?: FleetSharedDeviceState['sessions'];
 }
-export interface FleetSharedStateReadResult {
+interface FleetSharedStateReadResult {
     states: FleetSharedDeviceState[];
     errors: Array<{
         device: string;
@@ -89,3 +89,4 @@ export declare function updateFleetSharedDeviceStateAsync(device: string, patch:
 }>;
 /** Read every valid peer-owned state file; malformed peers fail separately. */
 export declare function readFleetSharedDeviceStates(userAgentsDir?: string): FleetSharedStateReadResult;
+export {};

package/dist/lib/format.d.ts

@@ -1,5 +1,5 @@
 /** Options for {@link die} — opt into machine-readable failure output. */
-export interface DieOptions {
+interface DieOptions {
     /**
      * Emit a machine-readable `{"error", "hint"?}` object to **stdout** instead of
      * red text on stderr. Pass `isJsonMode(options)` from a `--json` command so an
@@ -98,3 +98,4 @@ export declare function readStdinSync(): string;
  * stdout is a TTY; otherwise return `text` unchanged.
  */
 export declare function termLink(text: string, filePath: string): string;
+export {};

package/dist/lib/friction-heuristics.d.ts

@@ -7,7 +7,7 @@
  * an agent stuck retrying the SAME denied action instead of adapting.
  */
 import type { EventRecord } from './feed/events.js';
-export interface RepeatedGuardBlockFinding {
+interface RepeatedGuardBlockFinding {
     /** Session id the repeated blocks happened in, or 'unknown' when the
      *  friction event carried no session (e.g. a guard fired outside any
      *  tracked agent session). */
@@ -30,3 +30,4 @@ export interface RepeatedGuardBlockFinding {
 export declare function detectRepeatedGuardBlocks(events: EventRecord[], opts?: {
     minRepeats?: number;
 }): RepeatedGuardBlockFinding[];
+export {};

package/dist/lib/fs-walk.d.ts

@@ -1,5 +1,5 @@
 /** A file surfaced by the walk, carrying the mtime+size from the walk's own stat. */
-export interface WalkedFile {
+interface WalkedFile {
     path: string;
     mtimeMs: number;
     size: number;
@@ -19,3 +19,4 @@ export declare function walkForFiles(dir: string, ext: string, limit: number): s
  * Hot-path helper for the `agents run` account-recency probe.
  */
 export declare function latestFileMtimeMs(dir: string, ext: string): number | null;
+export {};