@phnx-labs/agents-cli 1.22.116 → 1.22.118

package/dist/lib/browser/ffmpeg.js

@@ -1,184 +0,0 @@
-import { execFile } from 'node:child_process';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { promisify } from 'node:util';
-const execFileAsync = promisify(execFile);
-let resolvedFfmpeg;
-function canonicalDirs(platform) {
-    if (platform === 'darwin')
-        return ['/opt/homebrew/bin', '/usr/local/bin'];
-    if (platform === 'linux')
-        return ['/usr/local/bin', '/usr/bin', '/snap/bin'];
-    return [];
-}
-function pathCandidates(env, platform, platformDirs) {
-    const names = platform === 'win32' ? ['ffmpeg.exe'] : ['ffmpeg'];
-    const dirs = [...new Set([...(env.PATH ?? '').split(path.delimiter).filter(Boolean), ...platformDirs])];
-    return dirs.flatMap((dir) => names.map((name) => path.join(dir, name)));
-}
-function managedCandidates(home, platform) {
-    const name = platform === 'win32' ? 'ffmpeg.exe' : 'ffmpeg';
-    return [
-        path.join(home, '.agents', '.cache', 'bin', name),
-        path.join(home, '.agents', '.cache', 'ffmpeg', 'bin', name),
-        path.join(home, '.agents', '.cache', 'ffmpeg', 'node_modules', 'ffmpeg-static', name),
-    ];
-}
-async function isUsable(binary) {
-    try {
-        await execFileAsync(binary, ['-version'], { timeout: 10_000, windowsHide: true });
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-async function firstUsable(candidates) {
-    for (const candidate of candidates) {
-        if (fs.existsSync(candidate) && await isUsable(candidate))
-            return candidate;
-    }
-    return undefined;
-}
-function commandOnPath(name, env, platform, platformDirs) {
-    const names = platform === 'win32' ? [`${name}.exe`, `${name}.cmd`, name] : [name];
-    const dirs = [...new Set([...(env.PATH ?? '').split(path.delimiter).filter(Boolean), ...platformDirs])];
-    for (const dir of dirs) {
-        for (const candidate of names.map((entry) => path.join(dir, entry))) {
-            try {
-                fs.accessSync(candidate, platform === 'win32' ? fs.constants.F_OK : fs.constants.X_OK);
-                return candidate;
-            }
-            catch { /* keep looking */ }
-        }
-    }
-    return undefined;
-}
-export function ffmpegManualCommand(platform, osRelease = '') {
-    if (platform === 'darwin')
-        return 'brew install ffmpeg';
-    if (platform === 'win32')
-        return 'winget install Gyan.FFmpeg';
-    if (/\b(ID|ID_LIKE)=(?:"[^"]*\b)?(?:ubuntu|debian)\b/m.test(osRelease)) {
-        return 'sudo apt-get update && sudo apt-get install -y ffmpeg';
-    }
-    return 'install ffmpeg with your system package manager';
-}
-function readOsRelease() {
-    try {
-        return fs.readFileSync('/etc/os-release', 'utf8');
-    }
-    catch {
-        return '';
-    }
-}
-async function installManagedFfmpeg(home, env, platform, platformDirs) {
-    const npm = commandOnPath('npm', env, platform, platformDirs);
-    if (!npm)
-        return undefined;
-    const prefix = path.join(home, '.agents', '.cache', 'ffmpeg');
-    await fs.promises.mkdir(prefix, { recursive: true });
-    await execFileAsync(npm, [
-        'install', '--prefix', prefix, '--no-save', '--no-audit', '--no-fund',
-        'ffmpeg-static@5.2.0',
-    ], { env, timeout: 10 * 60_000, windowsHide: true });
-    return firstUsable(managedCandidates(home, platform));
-}
-function installAttempt(platform, env, osRelease, platformDirs) {
-    if (platform === 'darwin') {
-        const brew = commandOnPath('brew', env, platform, platformDirs);
-        return brew ? [{ command: brew, args: ['install', 'ffmpeg'] }] : undefined;
-    }
-    if (platform === 'win32') {
-        const winget = commandOnPath('winget', env, platform, platformDirs);
-        return winget ? [{ command: winget, args: ['install', '--id', 'Gyan.FFmpeg', '--exact', '--accept-source-agreements', '--accept-package-agreements'] }] : undefined;
-    }
-    if (platform !== 'linux')
-        return undefined;
-    if (/\b(ID|ID_LIKE)=(?:"[^"]*\b)?(?:ubuntu|debian)\b/m.test(osRelease)) {
-        const apt = commandOnPath('apt-get', env, platform, platformDirs);
-        if (!apt)
-            return undefined;
-        if (typeof process.getuid === 'function' && process.getuid() === 0) {
-            return [
-                { command: apt, args: ['update'] },
-                { command: apt, args: ['install', '-y', 'ffmpeg'] },
-            ];
-        }
-        const sudo = commandOnPath('sudo', env, platform, platformDirs);
-        return sudo ? [
-            { command: sudo, args: ['-n', apt, 'update'] },
-            { command: sudo, args: ['-n', apt, 'install', '-y', 'ffmpeg'] },
-        ] : undefined;
-    }
-    const managers = [
-        ['apk', ['add', 'ffmpeg']],
-        ['dnf', ['install', '-y', 'ffmpeg']],
-        ['yum', ['install', '-y', 'ffmpeg']],
-        ['pacman', ['-S', '--noconfirm', 'ffmpeg']],
-        ['zypper', ['--non-interactive', 'install', 'ffmpeg']],
-    ];
-    for (const [name, args] of managers) {
-        const command = commandOnPath(name, env, platform, platformDirs);
-        if (command)
-            return [{ command, args }];
-    }
-    return undefined;
-}
-export async function resolveFfmpeg(options = {}) {
-    if (resolvedFfmpeg)
-        return resolvedFfmpeg;
-    resolvedFfmpeg = (async () => {
-        const env = options.env ?? process.env;
-        const home = options.home ?? os.homedir();
-        const platform = options.platform ?? os.platform();
-        const osRelease = options.osRelease ?? readOsRelease();
-        const executableDirs = options.executableDirs ?? canonicalDirs(platform);
-        const candidates = [...pathCandidates(env, platform, executableDirs), ...managedCandidates(home, platform)];
-        const existing = await firstUsable(candidates);
-        if (existing)
-            return existing;
-        const attempt = installAttempt(platform, env, osRelease, executableDirs);
-        let failure = 'no supported automatic installer was found';
-        if (attempt) {
-            try {
-                for (const step of attempt) {
-                    await execFileAsync(step.command, step.args, {
-                        env,
-                        timeout: 10 * 60_000,
-                        windowsHide: true,
-                    });
-                }
-                const installed = await firstUsable([...pathCandidates(env, platform, executableDirs), ...managedCandidates(home, platform)]);
-                if (installed)
-                    return installed;
-                failure = `${path.basename(attempt.at(-1).command)} completed but ffmpeg is still unavailable`;
-            }
-            catch (error) {
-                failure = `${path.basename(attempt.at(-1).command)} failed: ${error.message}`;
-            }
-        }
-        try {
-            const managed = await installManagedFfmpeg(home, env, platform, executableDirs);
-            if (managed)
-                return managed;
-            failure += '; managed npm installation was unavailable';
-        }
-        catch (error) {
-            failure += `; managed npm installation failed: ${error.message}`;
-        }
-        const manual = ffmpegManualCommand(platform, osRelease);
-        throw new Error(`ffmpeg is required for browser recording and automatic installation failed (${failure}). Run \`${manual}\`, then retry.`);
-    })();
-    try {
-        return await resolvedFfmpeg;
-    }
-    catch (error) {
-        resolvedFfmpeg = undefined;
-        throw error;
-    }
-}
-export function resetFfmpegResolverForTest() {
-    resolvedFfmpeg = undefined;
-}

package/dist/lib/browser/firefox-discovery.d.ts

@@ -1,69 +0,0 @@
-interface FirefoxIniProfile {
-    /** `Name=` of the `[ProfileN]` section. */
-    name: string;
-    /** Absolute profile directory (`Path=` resolved against the ini's dir when `IsRelative=1`). */
-    dir: string;
-    /** `Default=1` on the entry (a legacy marker; `[Install*]` sections carry the real one). */
-    isDefault: boolean;
-    /** The `profiles.ini` this entry came from. */
-    iniPath: string;
-}
-type FirefoxDiscoveryResult = {
-    ok: true;
-    profiles: FirefoxIniProfile[];
-    iniPaths: string[];
-} | {
-    ok: false;
-    kind: 'not-installed' | 'invalid';
-    reason: string;
-};
-/**
- * Every directory a `profiles.ini` may live in on this machine. Ubuntu's snap
- * Firefox keeps its whole `.mozilla` under `~/snap/firefox/common/`, a deb or
- * tarball Firefox uses `~/.mozilla/firefox/` — a box can carry both, so both
- * are read. `AGENTS_FIREFOX_DIRS` (path-separator list) points tests and
- * non-default installs elsewhere.
- */
-export declare function firefoxProfileRoots(): string[];
-/**
- * Parse one `profiles.ini`. Only `[Profile<n>]` sections are profiles;
- * `[General]` and `[Install<hash>]` (which record the per-install default) are
- * skipped. A `[Profile]` section that lacks `Name` or `Path` is a malformed
- * file, not a profile to guess at.
- */
-export declare function parseProfilesIni(iniPath: string): FirefoxIniProfile[] | {
-    error: string;
-};
-export declare function discoverFirefoxProfilesAt(roots: string[]): FirefoxDiscoveryResult;
-export declare function discoverFirefoxProfiles(): FirefoxDiscoveryResult;
-/** One discovered Firefox profile as an agents-cli profile row. */
-interface FirefoxDiscoveredProfile {
-    /** The agents-cli profile name: `firefox-<name-slug>`. */
-    name: string;
-    profileName: string;
-    profileDir: string;
-    iniPath: string;
-    isDefault: boolean;
-    /** The local WebDriver BiDi port this profile is pinned to. */
-    port: number;
-}
-/** Firefox BiDi ports live in their own range so they never collide with the 9222-9399 CDP profiles. */
-export declare const FIREFOX_PORT_RANGE: Readonly<{
-    base: 9600;
-    size: 100;
-}>;
-/**
- * The port a discovered Firefox profile listens on: derived from its directory,
- * so the relaunch hint in an attach error is the same string every time and a
- * daemon restart reattaches to the Firefox it launched earlier. Collisions
- * between two discovered profiles resolve by linear probing within the range.
- */
-export declare function firefoxProfilePort(profileDir: string, taken?: Set<number>): number;
-/**
- * Flatten discovery into one agents-cli profile per `profiles.ini` entry, named
- * `firefox-<name>` (`firefox-default`, `firefox-default-release`, …). Two
- * entries with the same name (one per ini, say) get the first six hex
- * characters of their directory hash appended so the names stay distinct.
- */
-export declare function firefoxDiscoveredProfiles(result: FirefoxDiscoveryResult): FirefoxDiscoveredProfile[];
-export {};

package/dist/lib/browser/firefox-discovery.js

@@ -1,162 +0,0 @@
-/**
- * Read-only Firefox profile discovery from `profiles.ini` (PHNX-4043).
- *
- * One agents-cli profile per `[ProfileN]` entry, named `firefox-<name-slug>`
- * and pinned to that entry's directory. The profile already carries its
- * cookies and logins, so it IS the browser profile agents pick with
- * `--profile` — the same shape Arc Space discovery uses (`arc-discovery.ts`).
- */
-import * as fs from 'node:fs';
-import * as os from 'node:os';
-import * as path from 'node:path';
-/**
- * Every directory a `profiles.ini` may live in on this machine. Ubuntu's snap
- * Firefox keeps its whole `.mozilla` under `~/snap/firefox/common/`, a deb or
- * tarball Firefox uses `~/.mozilla/firefox/` — a box can carry both, so both
- * are read. `AGENTS_FIREFOX_DIRS` (path-separator list) points tests and
- * non-default installs elsewhere.
- */
-export function firefoxProfileRoots() {
-    const override = process.env.AGENTS_FIREFOX_DIRS;
-    if (override)
-        return override.split(path.delimiter).filter(Boolean).map((p) => path.resolve(p));
-    const home = os.homedir();
-    switch (process.platform) {
-        case 'darwin':
-            return [path.join(home, 'Library', 'Application Support', 'Firefox')];
-        case 'win32':
-            return [path.join(process.env.APPDATA || path.join(home, 'AppData', 'Roaming'), 'Mozilla', 'Firefox')];
-        default:
-            return [
-                path.join(home, '.mozilla', 'firefox'),
-                path.join(home, 'snap', 'firefox', 'common', '.mozilla', 'firefox'),
-            ];
-    }
-}
-/**
- * Parse one `profiles.ini`. Only `[Profile<n>]` sections are profiles;
- * `[General]` and `[Install<hash>]` (which record the per-install default) are
- * skipped. A `[Profile]` section that lacks `Name` or `Path` is a malformed
- * file, not a profile to guess at.
- */
-export function parseProfilesIni(iniPath) {
-    let text;
-    try {
-        text = fs.readFileSync(iniPath, 'utf8');
-    }
-    catch (error) {
-        return { error: `Cannot read ${iniPath}: ${error instanceof Error ? error.message : String(error)}` };
-    }
-    const root = path.dirname(iniPath);
-    const sections = [];
-    for (const raw of text.split(/\r?\n/)) {
-        const line = raw.trim();
-        if (!line || line.startsWith(';') || line.startsWith('#'))
-            continue;
-        const header = line.match(/^\[(.+)\]$/);
-        if (header) {
-            sections.push({ header: header[1], values: {} });
-            continue;
-        }
-        const eq = line.indexOf('=');
-        if (eq === -1 || sections.length === 0) {
-            return { error: `${iniPath} has a malformed line: ${JSON.stringify(raw)}` };
-        }
-        sections[sections.length - 1].values[line.slice(0, eq).trim()] = line.slice(eq + 1).trim();
-    }
-    const profiles = [];
-    for (const section of sections) {
-        if (!/^Profile\d+$/.test(section.header))
-            continue;
-        const name = section.values.Name;
-        const rel = section.values.Path;
-        if (!name || !rel) {
-            return { error: `${iniPath} [${section.header}] has no Name or Path` };
-        }
-        const isRelative = section.values.IsRelative !== '0';
-        const dir = isRelative ? path.resolve(root, rel) : path.resolve(rel);
-        profiles.push({ name, dir, isDefault: section.values.Default === '1', iniPath });
-    }
-    return profiles;
-}
-export function discoverFirefoxProfilesAt(roots) {
-    const iniPaths = roots.map((root) => path.join(root, 'profiles.ini')).filter((p) => fs.existsSync(p));
-    if (iniPaths.length === 0) {
-        return {
-            ok: false,
-            kind: 'not-installed',
-            reason: `No Firefox profiles.ini under ${roots.join(', ')}`,
-        };
-    }
-    const profiles = [];
-    for (const iniPath of iniPaths) {
-        const parsed = parseProfilesIni(iniPath);
-        if ('error' in parsed)
-            return { ok: false, kind: 'invalid', reason: parsed.error };
-        profiles.push(...parsed);
-    }
-    if (profiles.length === 0) {
-        return { ok: false, kind: 'invalid', reason: `No [Profile] entries in ${iniPaths.join(', ')}` };
-    }
-    return { ok: true, profiles, iniPaths };
-}
-export function discoverFirefoxProfiles() {
-    return discoverFirefoxProfilesAt(firefoxProfileRoots());
-}
-function slugify(value) {
-    return value.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
-}
-/** FNV-1a over the path, folded into the range. Stable across runs and daemons. */
-function stableHash(value) {
-    let hash = 0x811c9dc5;
-    for (let i = 0; i < value.length; i++) {
-        hash ^= value.charCodeAt(i);
-        hash = Math.imul(hash, 0x01000193) >>> 0;
-    }
-    return hash;
-}
-/** Firefox BiDi ports live in their own range so they never collide with the 9222-9399 CDP profiles. */
-export const FIREFOX_PORT_RANGE = Object.freeze({ base: 9600, size: 100 });
-/**
- * The port a discovered Firefox profile listens on: derived from its directory,
- * so the relaunch hint in an attach error is the same string every time and a
- * daemon restart reattaches to the Firefox it launched earlier. Collisions
- * between two discovered profiles resolve by linear probing within the range.
- */
-export function firefoxProfilePort(profileDir, taken = new Set()) {
-    const { base, size } = FIREFOX_PORT_RANGE;
-    let port = base + (stableHash(profileDir) % size);
-    for (let i = 0; i < size && taken.has(port); i++) {
-        port = base + ((port - base + 1) % size);
-    }
-    return port;
-}
-/**
- * Flatten discovery into one agents-cli profile per `profiles.ini` entry, named
- * `firefox-<name>` (`firefox-default`, `firefox-default-release`, …). Two
- * entries with the same name (one per ini, say) get the first six hex
- * characters of their directory hash appended so the names stay distinct.
- */
-export function firefoxDiscoveredProfiles(result) {
-    if (!result.ok)
-        return [];
-    const taken = new Set();
-    const flat = result.profiles.map((profile) => {
-        const port = firefoxProfilePort(profile.dir, taken);
-        taken.add(port);
-        return {
-            name: `firefox-${slugify(profile.name) || 'profile'}`,
-            profileName: profile.name,
-            profileDir: profile.dir,
-            iniPath: profile.iniPath,
-            isDefault: profile.isDefault,
-            port,
-        };
-    });
-    const counts = new Map();
-    for (const entry of flat)
-        counts.set(entry.name, (counts.get(entry.name) ?? 0) + 1);
-    return flat.map((entry) => (counts.get(entry.name) ?? 0) > 1
-        ? { ...entry, name: `${entry.name}-${stableHash(entry.profileDir).toString(16).padStart(8, '0').slice(0, 6)}` }
-        : entry);
-}

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

@@ -1,85 +0,0 @@
-import type { NetworkRequest } from './types.js';
-/**
- * Minimal HAR 1.2 shapes. We only produce what our request buffer can back —
- * fields the buffer doesn't populate (headers, cookies, bodies, timings) are
- * emitted with the spec-mandated empty defaults or `-1` sentinels so validators
- * still accept the document.
- *
- * Spec: http://www.softwareishard.com/blog/har-12-spec/
- */
-interface HarLog {
-    version: '1.2';
-    creator: {
-        name: string;
-        version: string;
-    };
-    pages: HarPage[];
-    entries: HarEntry[];
-}
-interface HarPage {
-    startedDateTime: string;
-    id: string;
-    title: string;
-    pageTimings: {
-        onContentLoad: number;
-        onLoad: number;
-    };
-}
-interface HarEntry {
-    startedDateTime: string;
-    time: number;
-    request: HarRequest;
-    response: HarResponse;
-    cache: Record<string, never>;
-    timings: HarTimings;
-}
-interface HarRequest {
-    method: string;
-    url: string;
-    httpVersion: string;
-    cookies: never[];
-    headers: never[];
-    queryString: Array<{
-        name: string;
-        value: string;
-    }>;
-    headersSize: number;
-    bodySize: number;
-}
-interface HarResponse {
-    status: number;
-    statusText: string;
-    httpVersion: string;
-    cookies: never[];
-    headers: never[];
-    content: {
-        size: number;
-        mimeType: string;
-        text?: string;
-    };
-    redirectURL: string;
-    headersSize: number;
-    bodySize: number;
-}
-interface HarTimings {
-    send: number;
-    wait: number;
-    receive: number;
-}
-interface BuildHarOptions {
-    creatorName?: string;
-    creatorVersion?: string;
-}
-/**
- * Serialize a buffered `NetworkRequest[]` into a HAR 1.2 document.
- *
- * The buffer only records `url`, `method`, `status`, `mimeType`, `timestamp`.
- * Everything downstream — cookies, headers, bodies, per-phase timings — is
- * unknown and must be emitted as the spec's "unknown" sentinels: `-1` for
- * sizes / timings, empty arrays for cookies / headers. HAR validators accept
- * this shape (browsers do the same for opaque cross-origin responses).
- */
-export declare function buildHar(requests: NetworkRequest[], opts?: BuildHarOptions): {
-    log: HarLog;
-};
-export {};

package/dist/lib/browser/har.js

@@ -1,77 +0,0 @@
-/**
- * Serialize a buffered `NetworkRequest[]` into a HAR 1.2 document.
- *
- * The buffer only records `url`, `method`, `status`, `mimeType`, `timestamp`.
- * Everything downstream — cookies, headers, bodies, per-phase timings — is
- * unknown and must be emitted as the spec's "unknown" sentinels: `-1` for
- * sizes / timings, empty arrays for cookies / headers. HAR validators accept
- * this shape (browsers do the same for opaque cross-origin responses).
- */
-export function buildHar(requests, opts = {}) {
-    const creator = {
-        name: opts.creatorName ?? 'agents-cli',
-        version: opts.creatorVersion ?? '',
-    };
-    const startedAt = requests.length > 0 ? Math.min(...requests.map((r) => r.timestamp)) : Date.now();
-    const page = {
-        startedDateTime: new Date(startedAt).toISOString(),
-        id: 'page_1',
-        title: 'agents browser session',
-        pageTimings: { onContentLoad: -1, onLoad: -1 },
-    };
-    const entries = requests.map((r) => {
-        const queryString = extractQueryString(r.url);
-        const mimeType = r.mimeType ?? '';
-        return {
-            startedDateTime: new Date(r.timestamp).toISOString(),
-            time: -1,
-            request: {
-                method: r.method,
-                url: r.url,
-                httpVersion: 'HTTP/1.1',
-                cookies: [],
-                headers: [],
-                queryString,
-                headersSize: -1,
-                bodySize: -1,
-            },
-            response: {
-                status: r.status ?? 0,
-                statusText: '',
-                httpVersion: 'HTTP/1.1',
-                cookies: [],
-                headers: [],
-                content: { size: -1, mimeType },
-                redirectURL: '',
-                headersSize: -1,
-                bodySize: -1,
-            },
-            cache: {},
-            timings: { send: -1, wait: -1, receive: -1 },
-        };
-    });
-    return {
-        log: {
-            version: '1.2',
-            creator,
-            pages: [page],
-            entries,
-        },
-    };
-}
-/**
- * Pull `?a=1&b=2` off a URL into HAR's `queryString` array. Returns `[]` when
- * the URL has no query or fails to parse (opaque URLs like `data:` shouldn't
- * abort the whole HAR).
- */
-function extractQueryString(url) {
-    try {
-        const u = new URL(url);
-        const out = [];
-        u.searchParams.forEach((value, name) => out.push({ name, value }));
-        return out;
-    }
-    catch {
-        return [];
-    }
-}

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

@@ -1,97 +0,0 @@
-import { type PidSessionEntry } from '../session/pid-registry.js';
-import { type ReapResult, type Task } from './types.js';
-/**
- * The slice of `BrowserService` the reaper needs. Structural, so a test drives
- * it with a stub and `BrowserService` satisfies it without an import — which
- * also keeps this module off the service's import cycle.
- */
-export interface ReapableService {
-    listTasks(): Array<{
-        profile: string;
-        task: Task;
-    }>;
-    recordStatus(taskName: string): Promise<{
-        recording: boolean;
-    }>;
-    stop(taskName: string): Promise<{
-        ok: boolean;
-        profile?: string;
-    }>;
-}
-/**
- * Injectable liveness sources. Same shape as `feed-post.ts`
- * (`input.listEntries ?? listPidSessionEntries`, feed-post.ts:119) — the
- * defaults are the real registry and the real process table, so a test can
- * substitute them without mocking a module.
- */
-export interface ReapDeps {
-    listEntries?: () => PidSessionEntry[];
-    pidAlive?: (pid: number, startedAtMs?: number) => boolean;
-    sessionIdOfPid?: (pid: number) => string | undefined;
-    sessionLiveOnProcessTable?: (sessionId: string) => Promise<boolean>;
-}
-export interface ReapOptions {
-    /**
-     * Idle window in ms. Default {@link DEFAULT_IDLE_MS}.
-     *
-     * `null` is the explicit "idle reaping is off" signal
-     * (`browser.task-idle-minutes=0`) — session-dead reaping below is
-     * unaffected. A caller-supplied `0` is a DIFFERENT thing and still throws
-     * (see the guard below): it is far likelier to be a bug (a value that
-     * survived `??` unset) than an intentional "reap everything immediately."
-     */
-    idleMs?: number | null;
-    /** Clock, injectable for tests. Default `Date.now()`. */
-    now?: number;
-    /** Report what would be closed without closing anything. */
-    dryRun?: boolean;
-    deps?: ReapDeps;
-}
-interface LiveIdentities {
-    sessions: Set<string>;
-    launches: Set<string>;
-}
-/**
- * Session and launch ids belonging to a process that is alive right now.
- *
- * Built from the per-pid launch registry, filtered to live pids —
- * `isPidAlive(pid, startedAtMs)` rather than a bare existence check, so a pid
- * the OS recycled onto an unrelated process does not read as a live agent.
- * An entry with no recorded `sessionId` still contributes one when the live
- * process carries `--session-id` on its argv, which is the RUSH-2384 recovery
- * path the registry itself documents (pid-registry.ts:102-107).
- */
-export declare function resolveLiveIdentities(deps?: ReapDeps): LiveIdentities;
-/**
- * True when the task's owner is PROVABLY gone. The bar is proof, not absence of
- * evidence, because being wrong here closes a working agent's tabs.
- *
- * Only a `sessionId` can carry that proof. It has two independent sources — the
- * per-pid launch registry, and a live process carrying `--session-id <id>` in
- * its argv — so a session the registry missed is still caught by the process
- * table. The registry misses constantly: a wrapper pid exits, a prune sweeps
- * the entry, or the agent was never launched via `agents run`
- * (pid-registry.ts:102-107, RUSH-2384).
- *
- * A `launchId` has NO second source — the registry is its only witness, and
- * that witness is the unreliable one. So a task carrying only a `launchId` is
- * never session-reaped, exactly like a task carrying no identity at all; both
- * fall through to the idle rule. This is not a corner case: `launchId` is
- * minted for every run (`exec.ts` `resolveLaunchId`) while `AGENT_SESSION_ID`
- * is Claude-only and skipped on resume, so treating a missing registry entry as
- * proof of death would close the tabs of every live codex/droid/grok run whose
- * launch pid had already exited.
- *
- * A live `launchId` still RESCUES a task whose `sessionId` looks dead — proof of
- * life needs only one witness, unlike proof of death.
- */
-export declare function taskOwnerIsGone(task: Task, live: LiveIdentities, deps?: ReapDeps): Promise<boolean>;
-/**
- * Stop every task whose owner is gone or that has sat untouched past `idleMs`.
- *
- * Returns what it closed and how many it left alone. A task that is mid-
- * recording is always left alone: reaping it would truncate a capture the user
- * asked for, and an in-flight recording is itself proof the task is in use.
- */
-export declare function reapAbandonedTasks(service: ReapableService, opts?: ReapOptions): Promise<ReapResult>;
-export {};