@phnx-labs/agents-cli 1.22.113 → 1.22.115

package/dist/lib/browser/runtime-state.d.ts

@@ -46,7 +46,7 @@ export declare function identityLoopbackMismatch(profile: BrowserProfileWithDecl
  * The one-value-per-file fields are kept for backward compat with older
  * builds; `meta.json` is additive and consulted preferentially.
  */
-export interface ProfileRuntime {
+interface ProfileRuntime {
     pid: number;
     port?: number;
     command?: string;
@@ -110,7 +110,7 @@ export declare function isProcessAlive(pid: number, expectedCommand?: string): b
  * Combines the on-disk meta record with live-process probes so callers can
  * tell at a glance which entries are alive, stale, or have outright leaked.
  */
-export interface ProfileSnapshot {
+interface ProfileSnapshot {
     /** Composite name as the cache dir is keyed: `<profile>` or `<profile>@<endpoint>`. */
     name: string;
     /** Absolute path of the cache dir. */
@@ -144,10 +144,59 @@ export declare function listAllProfileSnapshots(): ProfileSnapshot[];
  * alone — we'd rather leak than wrongly kill a user-owned process that
  * happens to share metadata.
  */
+/**
+ * Clean up what a DEAD daemon genuinely left behind — which is not the browser.
+ *
+ * A live local browser outliving its daemon is the NORMAL case, not an orphan.
+ * `BrowserService.shutdown` deliberately closes only CDP and leaves the browser
+ * running, and on macOS the spawn is detached so the daemon's own positive-pid
+ * `killTree` reaches the daemon alone. This reaper used to read "the recorded
+ * `daemonPid` has exited" as "everything it recorded is garbage" and SIGTERM the
+ * browser — so replacing the daemon (a menubar activation, an upgrade, a crash
+ * restart) killed a browser the user was looking at, and `clearProfileRuntime`
+ * then removed the `port`/meta that {@link readProfileRuntime} needs, so even a
+ * survivor could not be re-attached and a second browser would launch beside it.
+ *
+ * The three cases are now decided independently:
+ *
+ * - **A live local browser/electron is preserved untouched** — not signalled, not
+ *   cleared, and its `daemonPid` deliberately NOT rewritten. Ownership is adopted
+ *   only after an identity-checked attach succeeds (`adoptProfileRuntimeOwner`,
+ *   called from the reuse branch in `BrowserService.connectProfile`), so nothing
+ *   claims a browser it has not proven it can talk to. Re-running this is a no-op.
+ * - **A dead browser record is cleared**, with no signal sent: there is nothing
+ *   alive to signal, and the stale pid/port would otherwise mislead the next
+ *   attach.
+ * - **A stale tunnel IS reaped.** A local `ssh -L` cannot outlive its purpose, so
+ *   a dead owner does make it an orphan. This is the one thing the old code was
+ *   right about; it just shared a code path with the browser.
+ *
+ * The accepted trade: a genuinely leaked browser from a long-dead daemon is no
+ * longer force-killed here. Idle/abandoned cleanup has its own owner in
+ * `browser/hygiene.ts` (session-dead + idle), which the daemon's periodic tick and
+ * `agents browser prune` both call — that is the right place for it, because it can
+ * tell "idle and abandoned" from "in use right now" and this function cannot.
+ */
 export declare function reapOrphanedProcesses(): {
     reaped: number;
     details: string[];
 };
+/**
+ * Take ownership of a runtime record after an identity-checked attach succeeded.
+ *
+ * Called from the reuse branch in `BrowserService.connectProfile`, which has just
+ * probed `/json/version` and run `verifyBrowserIdentity` against the profile's
+ * expected browser family — so by this point the process on the recorded port is
+ * proven to be ours. Only then may a new service claim it.
+ *
+ * Rewrites `daemonPid` ALONE. Every other field — `pid`, `port`, `command`,
+ * `userDataDir`, `spawnedAt`, `kind`, `tunnelPid` — is the original launch's
+ * metadata and stays exactly as recorded: this is an ownership handover, not a
+ * re-registration, and rewriting the rest would lose the provenance the reaper and
+ * the hygiene pass both read. A record that has since disappeared is left alone
+ * rather than recreated from a partial view.
+ */
+export declare function adoptProfileRuntimeOwner(profileName: string, daemonPid?: number): boolean;
 /**
  * True when ANY cache dir belonging to this profile still has a live browser or
  * SSH tunnel, or an open task. The composite naming (`<name>@<endpoint>`) means
@@ -160,7 +209,7 @@ export declare function reapOrphanedProcesses(): {
  */
 export declare function isProfileInUse(profileName: string): boolean;
 /** Why a profile is considered dead. */
-export type PruneReason = 'binary-missing' | 'never-used';
+type PruneReason = 'binary-missing' | 'never-used';
 export interface PruneCandidate {
     name: string;
     scope: PruneProfileClass;
@@ -168,7 +217,7 @@ export interface PruneCandidate {
     /** Cache dirs that would be removed along with the config entry. */
     cacheDirs: string[];
 }
-export interface PrunePlan {
+interface PrunePlan {
     /** Profiles that would be (or were) removed. */
     candidates: PruneCandidate[];
     /** Profiles deliberately left alone, with the guard that kept them. */
@@ -233,4 +282,10 @@ export declare function buildProfilePrunePlan(): Promise<PrunePlan>;
  * went, matching what `--dry-run` printed.
  */
 export declare function pruneProfiles(plan: PrunePlan): Promise<PrunePlan>;
+/**
+ * The executable/image name the live `pid` is running, or null if it can't be
+ * determined. The process-listing API differs per OS: Windows has no `ps`, so
+ * we query `tasklist` (CSV image name in column 1); POSIX uses `ps -o comm=`.
+ */
+export declare function liveProcessCommand(pid: number): string | null;
 export {};

package/dist/lib/browser/runtime-state.js

@@ -258,6 +258,39 @@ function readTaskCount(dir) {
  * alone — we'd rather leak than wrongly kill a user-owned process that
  * happens to share metadata.
  */
+/**
+ * Clean up what a DEAD daemon genuinely left behind — which is not the browser.
+ *
+ * A live local browser outliving its daemon is the NORMAL case, not an orphan.
+ * `BrowserService.shutdown` deliberately closes only CDP and leaves the browser
+ * running, and on macOS the spawn is detached so the daemon's own positive-pid
+ * `killTree` reaches the daemon alone. This reaper used to read "the recorded
+ * `daemonPid` has exited" as "everything it recorded is garbage" and SIGTERM the
+ * browser — so replacing the daemon (a menubar activation, an upgrade, a crash
+ * restart) killed a browser the user was looking at, and `clearProfileRuntime`
+ * then removed the `port`/meta that {@link readProfileRuntime} needs, so even a
+ * survivor could not be re-attached and a second browser would launch beside it.
+ *
+ * The three cases are now decided independently:
+ *
+ * - **A live local browser/electron is preserved untouched** — not signalled, not
+ *   cleared, and its `daemonPid` deliberately NOT rewritten. Ownership is adopted
+ *   only after an identity-checked attach succeeds (`adoptProfileRuntimeOwner`,
+ *   called from the reuse branch in `BrowserService.connectProfile`), so nothing
+ *   claims a browser it has not proven it can talk to. Re-running this is a no-op.
+ * - **A dead browser record is cleared**, with no signal sent: there is nothing
+ *   alive to signal, and the stale pid/port would otherwise mislead the next
+ *   attach.
+ * - **A stale tunnel IS reaped.** A local `ssh -L` cannot outlive its purpose, so
+ *   a dead owner does make it an orphan. This is the one thing the old code was
+ *   right about; it just shared a code path with the browser.
+ *
+ * The accepted trade: a genuinely leaked browser from a long-dead daemon is no
+ * longer force-killed here. Idle/abandoned cleanup has its own owner in
+ * `browser/hygiene.ts` (session-dead + idle), which the daemon's periodic tick and
+ * `agents browser prune` both call — that is the right place for it, because it can
+ * tell "idle and abandoned" from "in use right now" and this function cannot.
+ */
 export function reapOrphanedProcesses() {
     const root = getBrowserRuntimeDir();
     if (!fs.existsSync(root))
@@ -275,28 +308,76 @@ export function reapOrphanedProcesses() {
         // Owning daemon still alive — leave its kids alone.
         if (isProcessAlive(meta.daemonPid))
             continue;
-        // Kill what the dead daemon left behind. Best-effort.
-        const kill = (pid, label) => {
-            if (!pid || pid === 0)
-                return;
-            // Only kill if it matches the recorded command — guards against
-            // pid reuse handing us an unrelated process to murder.
-            if (meta.command && !matchesCommand(pid, meta.command) &&
-                !matchesCommand(pid, 'ssh'))
-                return;
-            try {
-                process.kill(pid, 'SIGTERM');
-                reaped++;
-                details.push(`reaped ${label ?? 'pid'} ${pid} (profile ${profileName})`);
+        // A local `ssh -L` whose owner is gone is genuinely orphaned: nothing is
+        // driving it and it cannot be re-adopted, so it is the one process to signal.
+        // Matched against the recorded command (or `ssh`) so a recycled pid is not
+        // mistaken for our tunnel.
+        if (meta.tunnelPid && meta.tunnelPid !== 0) {
+            const cmdOk = !meta.command
+                || matchesCommand(meta.tunnelPid, meta.command)
+                || matchesCommand(meta.tunnelPid, 'ssh');
+            if (cmdOk) {
+                try {
+                    process.kill(meta.tunnelPid, 'SIGTERM');
+                    reaped++;
+                    details.push(`reaped tunnel ${meta.tunnelPid} (profile ${profileName})`);
+                }
+                catch { /* already gone */ }
             }
-            catch { /* already gone */ }
-        };
-        kill(meta.pid, 'browser');
-        kill(meta.tunnelPid, 'tunnel');
+        }
+        // A tunnel-kind record has no local browser of its own, so clearing it is the
+        // whole cleanup. `pid` on such a record is the REMOTE browser (normally 0) and
+        // is never ours to signal.
+        if (meta.kind === 'tunnel') {
+            clearProfileRuntime(profileName);
+            continue;
+        }
+        // `isProcessAlive` re-checks the recorded command, so a recycled pid does not
+        // read as our browser. A record with no pid at all is stale by definition.
+        const liveBrowser = !!meta.pid && meta.pid !== 0 && isProcessAlive(meta.pid, meta.command);
+        if (liveBrowser) {
+            details.push(`preserved live browser ${meta.pid} (profile ${profileName})`);
+            continue;
+        }
+        // Dead browser: clear the stale record. No signal — there is nothing there.
         clearProfileRuntime(profileName);
+        if (meta.pid)
+            details.push(`cleared dead browser record ${meta.pid} (profile ${profileName})`);
     }
     return { reaped, details };
 }
+/**
+ * Take ownership of a runtime record after an identity-checked attach succeeded.
+ *
+ * Called from the reuse branch in `BrowserService.connectProfile`, which has just
+ * probed `/json/version` and run `verifyBrowserIdentity` against the profile's
+ * expected browser family — so by this point the process on the recorded port is
+ * proven to be ours. Only then may a new service claim it.
+ *
+ * Rewrites `daemonPid` ALONE. Every other field — `pid`, `port`, `command`,
+ * `userDataDir`, `spawnedAt`, `kind`, `tunnelPid` — is the original launch's
+ * metadata and stays exactly as recorded: this is an ownership handover, not a
+ * re-registration, and rewriting the rest would lose the provenance the reaper and
+ * the hygiene pass both read. A record that has since disappeared is left alone
+ * rather than recreated from a partial view.
+ */
+export function adoptProfileRuntimeOwner(profileName, daemonPid = process.pid) {
+    const meta = readProfileRuntimeMeta(profileName);
+    if (!meta)
+        return false;
+    if (meta.daemonPid === daemonPid)
+        return true;
+    const dir = getProfileRuntimeDir(profileName);
+    try {
+        fs.writeFileSync(path.join(dir, META_FILE), JSON.stringify({ ...meta, daemonPid }));
+        return true;
+    }
+    catch {
+        // Losing the handover is not worth failing an otherwise good attach; the next
+        // startup simply preserves the browser again and re-attaches.
+        return false;
+    }
+}
 /**
  * True when ANY cache dir belonging to this profile still has a live browser or
  * SSH tunnel, or an open task. The composite naming (`<name>@<endpoint>`) means
@@ -478,7 +559,7 @@ function matchesCommand(pid, expectedCommand) {
  * determined. The process-listing API differs per OS: Windows has no `ps`, so
  * we query `tasklist` (CSV image name in column 1); POSIX uses `ps -o comm=`.
  */
-function liveProcessCommand(pid) {
+export function liveProcessCommand(pid) {
     try {
         if (process.platform === 'win32') {
             const out = execFileSync('tasklist', ['/FI', `PID eq ${pid}`, '/NH', '/FO', 'CSV'], {

package/dist/lib/browser/service.d.ts

@@ -6,7 +6,7 @@ import { type ReapOptions } from './hygiene.js';
 import { type RefOpts, type RefNode } from './refs.js';
 import type { TargetFilter, PageOpenResult, ArcNativeProfileIdentity, FirefoxProfileIdentity } from './types.js';
 import { FirefoxBiDiClient } from './drivers/firefox.js';
-export type UploadMode = 'auto' | 'input' | 'drop' | 'chooser';
+type UploadMode = 'auto' | 'input' | 'drop' | 'chooser';
 export declare function resolveScreenshotOutputPath(outputPath: string | undefined, automaticPath: string): string;
 /**
  * Parse a `targetFilter` string into its kind + value, or return `null`
@@ -137,7 +137,7 @@ type TargetInfo = {
     title?: string;
 };
 /** Describes a ref that was re-resolved from a drifted integer via its cached descriptor. */
-export interface HealInfo {
+interface HealInfo {
     from: number;
     to: number;
     role: string;
@@ -161,7 +161,7 @@ export declare function resolveTaskIdentity(forwarded: {
     launchId?: string;
     sessionId?: string;
 };
-export interface StartOptions {
+interface StartOptions {
     taskName?: string;
     url?: string;
     endpointName?: string;
@@ -180,7 +180,7 @@ export interface StartOptions {
     /** Injected reachability probe — production uses ssh; tests pass a fake. */
     probe?: DeviceProbe;
 }
-export interface StartResult {
+interface StartResult {
     task: string;
     name: string;
     tabId?: string;

package/dist/lib/browser/service.js

@@ -8,7 +8,7 @@ import { assertRemoteControlAllowedForRequest } from './remote-control.js';
 import { connectLocal } from './drivers/local.js';
 import { connectSSH, shellQuote } from './drivers/ssh.js';
 import { adoptLegacyRuntimeIfLocal, isLegacyEndpointKey, resolveBrowserTarget, shouldForkProfile, } from './resolve-target.js';
-import { clearProfileRuntime, listProfileCacheDirs, readProfileRuntimeMeta, isProcessAlive } from './runtime-state.js';
+import { adoptProfileRuntimeOwner, clearProfileRuntime, listProfileCacheDirs, readProfileRuntimeMeta, isProcessAlive } from './runtime-state.js';
 import { resolveDomainSkill } from './domain-skills.js';
 import { generateTaskId, generateShortId, asConnectionKey, parseConnectionKey, keyBelongsToProfile, } from './types.js';
 import { reapAbandonedTasks, resolveLiveIdentities, taskOwnerIsGone, } from './hygiene.js';
@@ -1212,6 +1212,8 @@ export class BrowserService {
             await this.saveTaskState(task.profile, conn.tasks);
             return { tabId: resolvedTabId };
         }
+        requireCdp(conn, 'enumerate');
+        await conn.cdp.send('Target.activateTarget', { targetId: task.tabs[resolvedTabId] });
         task.currentTabId = resolvedTabId;
         await this.saveTaskState(task.profile, conn.tasks);
         return { tabId: resolvedTabId };
@@ -2771,6 +2773,12 @@ export class BrowserService {
                 await cdp.connect(wsUrl);
                 await this.enableDomains(cdp);
                 const tasks = this.loadTaskState(key);
+                // The attach is now PROVEN: the stored port answered /json/version and
+                // `verifyBrowserIdentity` matched the profile's browser family. Only here
+                // may this service claim a browser the startup reaper deliberately left
+                // alone — it rewrites `daemonPid` only, keeping the original launch's
+                // metadata. An ambiguous identity throws above and adopts nothing.
+                adoptProfileRuntimeOwner(key);
                 return {
                     backend: 'cdp',
                     cdp,
@@ -3398,6 +3406,10 @@ export class BrowserService {
             const port = parseEndpointUrl(resolved.target)?.port ?? 9600;
             try {
                 const ff = await connectFirefox(profile, key, port, { profileDir: profile.userDataDir });
+                // A served port that accepted a fresh BiDi session is this profile's own
+                // Firefox, so claim the record for this daemon (see the local-CDP claim
+                // below for why adoption waits for a proven attach).
+                adoptProfileRuntimeOwner(key);
                 const tasks = this.loadTaskState(key);
                 for (const [k, t] of diskTasks) {
                     if (!tasks.has(k))
@@ -3476,6 +3488,14 @@ export class BrowserService {
             const cdp = new CDPClient();
             await cdp.connect(wsUrl);
             await this.enableDomains(cdp);
+            // This is the path a replacement daemon takes to recover a browser its
+            // predecessor launched, so it is where ownership actually transfers. Only
+            // now — after `verifyBrowserIdentity` confirmed the browser family on the
+            // recorded port and CDP is attached — is it proven that this record
+            // describes a browser we are driving. `adoptProfileRuntimeOwner` rewrites
+            // `daemonPid` alone; an ambiguous identity throws above and adopts
+            // nothing, leaving the record (and the browser) untouched.
+            adoptProfileRuntimeOwner(key);
             const tasks = this.loadTaskState(key);
             for (const [k, t] of diskTasks) {
                 if (!tasks.has(k))

package/dist/lib/browser/sessions-list.d.ts

@@ -15,16 +15,6 @@ export interface ProfileArtifacts {
     profile: string;
     artifacts: BrowserArtifact[];
 }
-/** Every capture for one profile, newest first. */
-export declare function listProfileArtifacts(profile: string): BrowserArtifact[];
-/**
- * Captures grouped by profile. With `only` set, returns just that profile (even
- * when empty); otherwise every profile dir on disk that has at least one capture.
- */
-export declare function listBrowserSessions(only?: string): ProfileArtifacts[];
-/** Per-kind counts over a flat artifact list — shared by the printed table and
- *  the interactive row labels. */
-export declare function countByKind(artifacts: BrowserArtifact[]): Record<ArtifactKind, number>;
 /** Human table for the CLI. Returns lines (no trailing newline). */
 export declare function renderBrowserSessions(groups: ProfileArtifacts[]): string;
 /**

package/dist/lib/browser/sessions-list.js

@@ -62,7 +62,7 @@ function walkFiles(dir) {
     return out;
 }
 /** Every capture for one profile, newest first. */
-export function listProfileArtifacts(profile) {
+function listProfileArtifacts(profile) {
     const root = getProfileRuntimeDir(profile);
     const artifacts = [];
     const sessionsRoot = path.join(root, 'sessions');
@@ -97,7 +97,7 @@ export function listProfileArtifacts(profile) {
  * Captures grouped by profile. With `only` set, returns just that profile (even
  * when empty); otherwise every profile dir on disk that has at least one capture.
  */
-export function listBrowserSessions(only) {
+function listBrowserSessions(only) {
     let profiles;
     if (only) {
         // A profile's live tasks/captures may live under a composite runtime dir
@@ -127,7 +127,7 @@ export function listBrowserSessions(only) {
 }
 /** Per-kind counts over a flat artifact list — shared by the printed table and
  *  the interactive row labels. */
-export function countByKind(artifacts) {
+function countByKind(artifacts) {
     const counts = { screenshot: 0, pdf: 0, recording: 0, download: 0 };
     for (const a of artifacts)
         counts[a.kind]++;

package/dist/lib/browser/stream.d.ts

@@ -1,5 +1,5 @@
 import type { Readable, Writable } from 'stream';
-export interface BrowserIPCStreamOptions {
+interface BrowserIPCStreamOptions {
     input: Readable;
     output: Writable;
     task?: string;
@@ -14,3 +14,4 @@ export interface BrowserIPCStreamOptions {
  * The Node process and daemon connection stay alive until input closes.
  */
 export declare function runBrowserIPCStream(options: BrowserIPCStreamOptions): Promise<void>;
+export {};

package/dist/lib/browser/task-index.d.ts

@@ -1,4 +1,4 @@
-export interface TaskBinding {
+interface TaskBinding {
     device: string;
     profile?: string;
     url?: string;
@@ -6,9 +6,9 @@ export interface TaskBinding {
     launchId?: string;
     createdAt: number;
 }
-export type TaskIndex = Record<string, TaskBinding>;
+type TaskIndex = Record<string, TaskBinding>;
 export declare const REJECT_DEVICE_MESSAGE: string;
-export type TaskRoute = {
+type TaskRoute = {
     kind: 'proceed';
     task?: string;
     device: string;
@@ -24,7 +24,6 @@ export type TaskRoute = {
     message: string;
 };
 export declare function isTerminalBrowserVerb(verb: string): boolean;
-export declare function taskIndexPath(): string;
 export declare function readTaskIndex(): TaskIndex;
 export declare function getTaskBinding(name: string): TaskBinding | undefined;
 export declare function listTaskBindings(): Array<{
@@ -76,3 +75,4 @@ export declare function resolveTaskRoute(opts: {
  * the captured file to the requested path. Same path → no copy.
  */
 export declare function honorScreenshotOutput(requested: string | undefined, daemonPath: string): string;
+export {};

package/dist/lib/browser/task-index.js

@@ -32,7 +32,7 @@ const TERMINAL_BROWSER_VERBS = new Set(['done', 'stop']);
 export function isTerminalBrowserVerb(verb) {
     return TERMINAL_BROWSER_VERBS.has(verb);
 }
-export function taskIndexPath() {
+function taskIndexPath() {
     return path.join(getBrowserRuntimeDir(), 'task-index.json');
 }
 export function readTaskIndex() {

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

@@ -523,17 +523,6 @@ export interface PageOpenResult {
     refreshed: boolean;
     message?: string;
 }
-/** Subset of IPCResponse describing a recording start result. */
-export interface RecordStartFields {
-    fps?: number;
-    durationCapSec?: number;
-    maxMb?: number;
-}
-/** Subset of IPCResponse describing a recording stop result. */
-export interface RecordStopFields {
-    durationMs?: number;
-    stopReason?: 'manual' | 'duration-cap' | 'size-cap';
-}
 export interface IPCResponse {
     ok: boolean;
     error?: string;
@@ -635,15 +624,6 @@ export interface DeviceDescriptor {
     deviceScaleFactor: number;
     mobile: boolean;
 }
-export declare const TASK_ID_REGEX: RegExp;
 export declare function isValidTaskId(id: string): boolean;
 export declare function generateTaskId(): string;
 export declare function generateShortId(): string;
-export declare function generateFunName(): string;
-/**
- * Auto-generated task name: `<adjective>-<noun>-<noun>-<hex8>`, e.g.
- * `swift-crab-falcon-a3f92b1c`. Three English words make it memorable and
- * easy to read; 32 bits of hex give every spawned task enough entropy that
- * parallel agents never collide on the daemon side.
- */
-export declare function generateTaskName(): string;

package/dist/lib/browser/types.js

@@ -49,7 +49,7 @@ export function parseConnectionKey(key) {
 export function keyBelongsToProfile(key, profile) {
     return parseConnectionKey(key).profile === profile;
 }
-export const TASK_ID_REGEX = /^[a-z0-9][a-z0-9-]*$/;
+const TASK_ID_REGEX = /^[a-z0-9][a-z0-9-]*$/;
 export function isValidTaskId(id) {
     return TASK_ID_REGEX.test(id) && id.length <= 64;
 }
@@ -59,36 +59,3 @@ export function generateTaskId() {
 export function generateShortId() {
     return crypto.randomUUID().split('-')[0]; // 8 chars
 }
-const ADJECTIVES = [
-    'swift', 'cosmic', 'jolly', 'quiet', 'bold', 'bright', 'calm', 'eager',
-    'golden', 'happy', 'keen', 'lucky', 'noble', 'proud', 'quick', 'royal',
-    'silver', 'amber', 'crimson', 'misty', 'sunny', 'gentle', 'wild', 'brave',
-    'merry', 'sleek', 'wise', 'fierce', 'curious', 'humble', 'spry', 'witty',
-];
-const NOUNS = [
-    'falcon', 'comet', 'tiger', 'nebula', 'phoenix', 'river', 'summit', 'wave',
-    'aurora', 'breeze', 'crystal', 'dragon', 'ember', 'forest', 'glacier', 'harbor',
-    'crab', 'otter', 'hawk', 'fox', 'wolf', 'panda', 'lynx', 'raven',
-    'meadow', 'canyon', 'valley', 'orchid', 'cedar', 'thistle', 'lotus', 'briar',
-];
-export function generateFunName() {
-    const adj = ADJECTIVES[Math.floor(Math.random() * ADJECTIVES.length)];
-    const noun = NOUNS[Math.floor(Math.random() * NOUNS.length)];
-    return `${adj}-${noun}`;
-}
-/**
- * Auto-generated task name: `<adjective>-<noun>-<noun>-<hex8>`, e.g.
- * `swift-crab-falcon-a3f92b1c`. Three English words make it memorable and
- * easy to read; 32 bits of hex give every spawned task enough entropy that
- * parallel agents never collide on the daemon side.
- */
-export function generateTaskName() {
-    const adj = ADJECTIVES[Math.floor(Math.random() * ADJECTIVES.length)];
-    const noun1 = NOUNS[Math.floor(Math.random() * NOUNS.length)];
-    let noun2 = NOUNS[Math.floor(Math.random() * NOUNS.length)];
-    while (noun2 === noun1) {
-        noun2 = NOUNS[Math.floor(Math.random() * NOUNS.length)];
-    }
-    const hex8 = crypto.randomUUID().replace(/-/g, '').slice(0, 8);
-    return `${adj}-${noun1}-${noun2}-${hex8}`;
-}

package/dist/lib/browser/upload.d.ts

@@ -1,32 +1,5 @@
 import type { CDPClient } from './cdp.js';
 import { type RefNode } from './refs.js';
-/**
- * File upload strategies for `agents browser upload`.
- *
- * Every uploader on the web is one of three patterns:
- *
- *   A. Direct file input — the page exposes (or hides) `<input type=file>`.
- *      `DOM.setFileInputFiles` plants the paths directly. The cleanest
- *      path; works whenever the input is in the DOM, even when CSS-hidden
- *      or visually offscreen.
- *
- *   B. Drag-drop target — the page listens for `drop` events on a region
- *      (Canva, Notion, Linear, GitHub PRs). We dispatch synthetic
- *      `dragenter`/`dragover`/`drop` events with a `DataTransfer` whose
- *      `files` list carries a `File` built from disk bytes. The dispatch
- *      uses real elementFromPoint coordinates so React/DOM listeners fire.
- *
- *   C. Native chooser interception — the user clicks a button that calls
- *      `input.click()` and the only file input is dynamically created in
- *      response. `Page.setInterceptFileChooserDialog` flips the chooser
- *      from a blocking OS dialog into a CDP event; we click the trigger,
- *      wait for `Page.fileChooserOpened`, then satisfy it with
- *      `Page.handleFileChooser({ action: 'accept', files })`. Lifecycle:
- *      enable interception -> click -> wait -> accept -> disable.
- */
-export interface UploadOptions {
-    files: string[];
-}
 export declare function getUploadStagingDir(): string;
 export declare function stageUploadFile(source: string): string;
 /** Pattern A — direct file input via `DOM.setFileInputFiles`. */

package/dist/lib/budget/ledger.d.ts

@@ -29,8 +29,6 @@ export interface UsageObservation {
     cacheReadTokens?: number;
     cacheCreationTokens?: number;
 }
-/** Default ledger path: <history>/spend/ledger.jsonl. */
-export declare function defaultLedgerPath(): string;
 /** Local YYYY-MM-DD for a Date (defaults to now). Local, not UTC — caps are a human-day notion. */
 export declare function localDay(d?: Date): string;
 /**

package/dist/lib/budget/ledger.js

@@ -17,7 +17,7 @@ import * as path from 'path';
 import { getHistoryDir } from '../state.js';
 import { actualCost } from '../pricing/index.js';
 /** Default ledger path: <history>/spend/ledger.jsonl. */
-export function defaultLedgerPath() {
+function defaultLedgerPath() {
     return path.join(getHistoryDir(), 'spend', 'ledger.jsonl');
 }
 /** Local YYYY-MM-DD for a Date (defaults to now). Local, not UTC — caps are a human-day notion. */

package/dist/lib/budget/live-cloud.d.ts

@@ -15,7 +15,7 @@
 import type { CloudProvider, CloudEvent } from '../cloud/types.js';
 import { type BreachInfo } from './enforce.js';
 /** Result surface exposed to the caller so it can act on a mid-stream breach. */
-export interface CloudBudgetGate {
+interface CloudBudgetGate {
     /** True once a cap crossed and cancel() was invoked. */
     breached(): boolean;
     breach(): BreachInfo | null;
@@ -40,3 +40,4 @@ export declare function wrapStreamWithBudgetGate(args: {
     wrap: (source: AsyncIterable<CloudEvent>) => AsyncIterable<CloudEvent>;
     gate: CloudBudgetGate;
 } | null;
+export {};

package/dist/lib/budget/preflight.d.ts

@@ -15,7 +15,7 @@
 import type { BudgetConfig } from '../types.js';
 import type { SpendEntry } from './ledger.js';
 /** A pre-flight cost estimate for one run. */
-export interface RunEstimate {
+interface RunEstimate {
     /** Estimated USD for this run. 0 when the model is unpriced. */
     estUsd: number;
     /** How the token count was derived. */
@@ -48,7 +48,7 @@ export declare function ledgerAverageTokens(agent: string, ledger: SpendEntry[])
     output: number;
 } | null;
 /** Decision returned by the pre-flight gate. */
-export interface PreflightDecision {
+interface PreflightDecision {
     /** Whether the run may proceed. */
     allow: boolean;
     /** Whether the caller must interactively confirm (estimate >= require_confirm_over). */
@@ -80,10 +80,8 @@ export declare function ledgerStateFor(agent: string, project: string, ledger?:
  * reports the truth).
  */
 export declare function enforcePreflight(cfg: BudgetConfig, state: LedgerState, est: RunEstimate): PreflightDecision;
-/** Build a one-line human estimate banner for `agents run` preamble. */
-export declare function formatEstimateBanner(agent: string, model: string, est: RunEstimate): string;
 /** Result of the high-level run gate consumed by `agents run` / teams / cloud. */
-export interface PreflightGateResult {
+interface PreflightGateResult {
     /** True when no caps are configured — budget feature dormant, nothing to do. */
     dormant: boolean;
     cfg: BudgetConfig;

package/dist/lib/budget/preflight.js

@@ -153,7 +153,7 @@ export function enforcePreflight(cfg, state, est) {
     };
 }
 /** Build a one-line human estimate banner for `agents run` preamble. */
-export function formatEstimateBanner(agent, model, est) {
+function formatEstimateBanner(agent, model, est) {
     const cost = est.priced ? formatUsd(est.estUsd) : 'unpriced';
     const basisLabel = est.basis === 'ledger-average'
         ? 'recent average'

package/dist/lib/catchup.d.ts

@@ -87,7 +87,7 @@ export declare function missedRunId(expectedAt: Date): string;
  * still on the record for a human to see and re-run.
  */
 export declare function claimMissedFire(job: JobConfig, expectedAt: Date): RunMeta | null;
-export interface CatchupOptions {
+interface CatchupOptions {
     /** Record misses but start no late runs. Powers `catchup --dry-run`. */
     dryRun?: boolean;
     /** Clock injection seam for tests. */
@@ -103,3 +103,4 @@ export interface CatchupOptions {
  * same routine.
  */
 export declare function runCatchup(opts?: CatchupOptions): Promise<CatchupOutcome[]>;
+export {};