@phnx-labs/agents-cli 1.22.120 → 1.22.121

package/dist/lib/deeplink/register.d.ts

@@ -2,33 +2,18 @@ export declare const AGENTS_URL_SCHEME = "agents";
 interface SchemeStatus {
     registered: boolean;
     platform: NodeJS.Platform;
-    /** One human line: where the handler is, or why it is not registered. */
     detail: string;
 }
-/**
- * POSIX single-quote a path so a space or metacharacter in it can never break
- * out of the handler command.
- */
 export declare function shQuote(p: string): string;
-/** The freedesktop `.desktop` entry that claims `x-scheme-handler/agents`. */
 export declare function linuxDesktopEntry(invocation: string): string;
-/**
- * AppleScript whose `on open location` handler fires when macOS routes an
- * `agents://` URL to the app. `quoted form of` makes the URL a single safe
- * shell argument — the URL is never concatenated unquoted.
- */
 export declare function macAppleScriptSource(invocation: string): string;
-/** PlistBuddy commands that add the `agents` URL type to a compiled app's Info.plist. */
 export declare function macPlistBuddyCommands(plistPath: string): string[][];
-/** `reg add` argv lists that register the scheme under HKCU on Windows. */
 export declare function windowsRegistryCommands(invocation: string): string[][];
 export declare function linuxDesktopPath(home?: string): string;
-/** Whether the handler artifact exists on disk (a cheap, side-effect-free check). */
 export declare function agentsUrlSchemeStatus(platform?: NodeJS.Platform, home?: string): SchemeStatus;
 interface RegisterOptions {
     platform?: NodeJS.Platform;
     home?: string;
-    /** Skip if already present (used by best-effort callers like setup). */
     ifMissing?: boolean;
 }
 export declare function registerAgentsUrlScheme(opts?: RegisterOptions): SchemeStatus;

package/dist/lib/deeplink/register.js

@@ -1,22 +1,3 @@
-/**
- * Register the `agents://` URL scheme with the OS so a click in an artifact
- * routes to the machine-only `agents _callback <url>` verb (see url.ts +
- * commands/open.ts). Humans manage the handler with `agents setup url-scheme`.
- *
- * A browser page cannot spawn a shell; a registered URL scheme is the
- * OS-sanctioned hand-off. Each platform gets its own handler:
- *   - Linux:   a `.desktop` entry claiming `x-scheme-handler/agents`, made the
- *              default via `xdg-mime`.
- *   - macOS:   a tiny AppleScript app whose `on open location` runs the CLI;
- *              its Info.plist declares the `agents` scheme, registered with
- *              LaunchServices via `lsregister`.
- *   - Windows: `HKCU\Software\Classes\agents` shell-open-command registry keys.
- *
- * The content generators below are pure and unit-tested. The `register*` /
- * `unregister*` / `status*` functions apply them and never throw — they return a
- * {@link SchemeStatus} so callers (setup, `agents setup url-scheme register`,
- * doctor) can report without a try/catch.
- */
 import { execFileSync } from 'node:child_process';
 import * as fs from 'node:fs';
 import * as os from 'node:os';
@@ -26,24 +7,9 @@ export const AGENTS_URL_SCHEME = 'agents';
 const MAC_BUNDLE_ID = 'dev.agents.urlhandler';
 const LINUX_DESKTOP_FILE = 'agents-url-handler.desktop';
 const MAC_APP_NAME = 'AgentsURLHandler.app';
-// ---------------------------------------------------------------------------
-// Invocation resolution — the absolute command the handler runs.
-// ---------------------------------------------------------------------------
-/**
- * POSIX single-quote a path so a space or metacharacter in it can never break
- * out of the handler command.
- */
 export function shQuote(p) {
     return `'${p.replace(/'/g, `'\\''`)}'`;
 }
-/**
- * Resolve how the OS handler should invoke this CLI, as an already-quoted
- * command prefix (without the `open <url>` suffix).
- *
- * A macOS GUI app does NOT inherit the shell PATH, so the handler must use an
- * absolute path. Prefer the `agents` shim on PATH (directly executable); fall
- * back to `<node> <entry>` for a bare JS install.
- */
 function resolveAgentsInvocation(platform = os.platform()) {
     const onPath = whichAgents(platform);
     if (onPath)
@@ -64,10 +30,6 @@ function whichAgents(platform) {
         return null;
     }
 }
-// ---------------------------------------------------------------------------
-// Pure content generators (unit-tested).
-// ---------------------------------------------------------------------------
-/** The freedesktop `.desktop` entry that claims `x-scheme-handler/agents`. */
 export function linuxDesktopEntry(invocation) {
     return [
         '[Desktop Entry]',
@@ -81,14 +43,7 @@ export function linuxDesktopEntry(invocation) {
         '',
     ].join('\n');
 }
-/**
- * AppleScript whose `on open location` handler fires when macOS routes an
- * `agents://` URL to the app. `quoted form of` makes the URL a single safe
- * shell argument — the URL is never concatenated unquoted.
- */
 export function macAppleScriptSource(invocation) {
-    // Escape the (already shell-quoted) invocation for an AppleScript double-quoted
-    // string literal, so a `"` or `\` in the install path cannot break osacompile.
     const literal = invocation.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
     return [
         'on open location this_URL',
@@ -96,7 +51,6 @@ export function macAppleScriptSource(invocation) {
         'end open location',
     ].join('\n');
 }
-/** PlistBuddy commands that add the `agents` URL type to a compiled app's Info.plist. */
 export function macPlistBuddyCommands(plistPath) {
     const b = ['/usr/libexec/PlistBuddy', '-c'];
     return [
@@ -108,7 +62,6 @@ export function macPlistBuddyCommands(plistPath) {
         [...b, `Add :CFBundleURLTypes:0:CFBundleURLSchemes:0 string ${AGENTS_URL_SCHEME}`, plistPath],
     ];
 }
-/** `reg add` argv lists that register the scheme under HKCU on Windows. */
 export function windowsRegistryCommands(invocation) {
     const base = 'HKCU\\Software\\Classes\\agents';
     return [
@@ -117,19 +70,12 @@ export function windowsRegistryCommands(invocation) {
         ['add', `${base}\\shell\\open\\command`, '/ve', '/d', `${invocation} _callback "%1"`, '/f'],
     ];
 }
-// ---------------------------------------------------------------------------
-// Paths.
-// ---------------------------------------------------------------------------
 export function linuxDesktopPath(home = os.homedir()) {
     return path.join(home, '.local', 'share', 'applications', LINUX_DESKTOP_FILE);
 }
 function macAppPath(home = os.homedir()) {
     return path.join(home, 'Applications', MAC_APP_NAME);
 }
-// ---------------------------------------------------------------------------
-// Status.
-// ---------------------------------------------------------------------------
-/** Whether the handler artifact exists on disk (a cheap, side-effect-free check). */
 export function agentsUrlSchemeStatus(platform = os.platform(), home = os.homedir()) {
     if (platform === 'linux') {
         const p = linuxDesktopPath(home);
@@ -207,7 +153,6 @@ function registerLinux(home) {
     const dest = linuxDesktopPath(home);
     fs.mkdirSync(path.dirname(dest), { recursive: true });
     fs.writeFileSync(dest, linuxDesktopEntry(invocation), 'utf8');
-    // Make it the default handler for the scheme; best-effort DB refresh.
     run('xdg-mime', ['default', LINUX_DESKTOP_FILE, 'x-scheme-handler/agents'], true);
     run('update-desktop-database', [path.dirname(dest)], true);
     return { registered: true, platform: 'linux', detail: `handler: ${dest}` };
@@ -217,7 +162,6 @@ function registerMac(home) {
     const app = macAppPath(home);
     fs.mkdirSync(path.dirname(app), { recursive: true });
     fs.rmSync(app, { recursive: true, force: true });
-    // Compile the AppleScript into an .app, then inject the URL scheme into its plist.
     const scriptFile = path.join(os.tmpdir(), `agents-url-handler-${process.pid}.applescript`);
     fs.writeFileSync(scriptFile, macAppleScriptSource(invocation), 'utf8');
     try {
@@ -227,11 +171,8 @@ function registerMac(home) {
         fs.rmSync(scriptFile, { force: true });
     }
     const plist = path.join(app, 'Contents', 'Info.plist');
-    // Non-optional: if the URL type is not written, the scheme is never claimed —
-    // registerAgentsUrlScheme must report failure, not a false "registered".
     for (const cmd of macPlistBuddyCommands(plist))
         run(cmd[0], cmd.slice(1), false);
-    // Register with LaunchServices so the scheme resolves without a reboot.
     const lsregister = '/System/Library/Frameworks/CoreServices.framework/Versions/A/Frameworks/LaunchServices.framework/Versions/A/Support/lsregister';
     run(lsregister, ['-f', app], true);
     return { registered: true, platform: 'darwin', detail: `handler: ${app}` };
@@ -242,7 +183,6 @@ function registerWindows(platform) {
         run('reg', args, false);
     return { registered: true, platform, detail: 'handler: HKCU\\Software\\Classes\\agents' };
 }
-/** Run a helper command. `optional` swallows failures (best-effort DB refreshes). */
 function run(cmd, args, optional) {
     try {
         execFileSync(cmd, args, { stdio: 'ignore' });

package/dist/lib/deeplink/url.d.ts

@@ -1,35 +1,11 @@
-/**
- * Parse the `agents://` deep-link scheme.
- *
- * A rendered artifact (a plan or report) embeds `agents://session/<id>` in its
- * provenance line. Clicking it hands the URL to the OS, which routes it to the
- * registered handler (see register.ts) that runs the machine-only `agents _callback
- * <url>` verb (`open` remains a hidden back-compat alias). This module turns that URL
- * into a validated {@link AgentsSessionLink} the resume dispatcher consumes.
- *
- * Parsing is deliberately strict: the session id is the only thing that ever
- * reaches a child process, and the `_callback` command passes it as argv (never
- * interpolated into a shell), so a hostile URL cannot inject a command. Anything
- * that is not `agents://session/<valid-id>` is rejected with a reason.
- *
- * URL shape:
- *   agents://session/<id>              — resume <id>, owner host resolved from the id
- *   agents://session/<id>?host=<name>  — the same, with a routing hint
- */
 interface AgentsSessionLink {
     kind: 'session';
-    /** The session id (or short-id/alias) to resume. */
     id: string;
-    /** Optional owning-host hint; resume self-resolves the owner from the id regardless. */
     host?: string;
 }
 interface AgentsUrlError {
     error: string;
 }
 export declare function isDeepLinkSessionId(raw: string): boolean;
-/**
- * Parse an `agents://…` URL into a {@link AgentsSessionLink}, or return an
- * {@link AgentsUrlError} with a human reason. Never throws.
- */
 export declare function parseAgentsUrl(input: string): AgentsSessionLink | AgentsUrlError;
 export {};

package/dist/lib/deeplink/url.js

@@ -1,32 +1,6 @@
-/**
- * Parse the `agents://` deep-link scheme.
- *
- * A rendered artifact (a plan or report) embeds `agents://session/<id>` in its
- * provenance line. Clicking it hands the URL to the OS, which routes it to the
- * registered handler (see register.ts) that runs the machine-only `agents _callback
- * <url>` verb (`open` remains a hidden back-compat alias). This module turns that URL
- * into a validated {@link AgentsSessionLink} the resume dispatcher consumes.
- *
- * Parsing is deliberately strict: the session id is the only thing that ever
- * reaches a child process, and the `_callback` command passes it as argv (never
- * interpolated into a shell), so a hostile URL cannot inject a command. Anything
- * that is not `agents://session/<valid-id>` is rejected with a reason.
- *
- * URL shape:
- *   agents://session/<id>              — resume <id>, owner host resolved from the id
- *   agents://session/<id>?host=<name>  — the same, with a routing hint
- */
-/**
- * Session-id shapes accepted from a deep link. Mirrors `looksLikeSessionId`
- * (lib/session/discover.ts) WITHOUT importing the heavy session module, so the
- * `open` command stays cold-start cheap: a bare hex short-id/prefix (>=6 chars),
- * a UUID (optionally `session_`-prefixed), a `ses_<ulid>` (OpenCode), or an
- * `ag-…-<8hex>` tmux alias. The upper length bound is a sanity cap, not a format
- * rule.
- */
 const HEX_ID = /^[0-9a-f-]{6,}$/i;
 const SES_ULID = /^ses_[0-9a-hjkmnp-tv-z]{26}$/i;
-import { AG_TMUX_NAME_RE as AG_ALIAS } from '../session/types.js';
+import { AG_TMUX_NAME_RE as AG_ALIAS } from '@phnx-labs/sessions-cli/reader';
 const HOST_HINT = /^[a-z0-9][a-z0-9._-]{0,63}$/i;
 export function isDeepLinkSessionId(raw) {
     const id = (raw ?? '').trim();
@@ -35,10 +9,6 @@ export function isDeepLinkSessionId(raw) {
     const bare = id.replace(/^session_/i, '');
     return HEX_ID.test(bare) || SES_ULID.test(id) || AG_ALIAS.test(id);
 }
-/**
- * Parse an `agents://…` URL into a {@link AgentsSessionLink}, or return an
- * {@link AgentsUrlError} with a human reason. Never throws.
- */
 export function parseAgentsUrl(input) {
     const raw = (input ?? '').trim();
     if (!raw)
@@ -53,8 +23,6 @@ export function parseAgentsUrl(input) {
     if (url.protocol !== 'agents:') {
         return { error: `unsupported scheme: ${url.protocol}// (expected agents://)` };
     }
-    // agents://session/<id> → hostname="session", pathname="/<id>". The authority
-    // is compared case-insensitively because some browsers normalize its casing.
     const verb = url.hostname.toLowerCase();
     if (verb !== 'session') {
         return { error: `unknown agents:// target "${verb || '(none)'}" (expected agents://session/<id>)` };

package/dist/lib/device-config.d.ts

@@ -1,68 +1,14 @@
-/**
- * Device/user config keys — typed read/write over the three-layer store.
- *
- * One registry (`CONFIG_KEYS`) maps each CLI dotted name to where it lives:
- *   - user scope   → central `~/.agents/agents.yaml` under `config:` (syncs
- *                    fleet-wide via `agents repo push/pull`)
- *   - device scope → the per-device TRACKED doc
- *                    `~/.agents/devices/<name>/agents.yaml` under `config:` —
- *                    conflict-free by construction (each machine writes only
- *                    its own folder, and the churny auto-written pins no longer
- *                    share the file)
- *   - fleet layer  → central `~/.agents/agents.yaml` under
- *                    `fleet.defaults.config` — fleet-wide defaults written by
- *                    `agents devices config --fleet <key> <value>`
- *
- * Read order for a device-scope key: built-in default < fleet.defaults.config
- * < per-device config:. Names and non-secret values only (a secrets-bundle
- * NAME is fine; a credential never is).
- *
- * The device registry (`~/.agents/.history/devices/registry.json`) stays the
- * DISCOVERY cache (address, tailscale snapshot, reachability); the profile
- * fields config can override (ssh.*, platform, user) are overlaid onto it at
- * read time by `lib/devices/resolve-profile.ts`.
- *
- * Legacy stores (central `fleet.devices.<name>.config`, legacy auto-launch.json,
- * doc-level defaultBrowserProfile, pins in tracked docs) are folded into this
- * layout once by `lib/devices/config-migration.ts`, invoked on the first
- * read/write in a process — after migration there is ONE read path per layer,
- * no fallback branches.
- *
- * Unset always means today's behavior (the documented default).
- */
-/** Which tier of the agents.yaml store a key lives in. */
 export type ConfigScope = 'user' | 'device';
-/**
- * For a device-scope key: WHO READS IT. Storage is still the three-layer
- * store (per-device doc / fleet.defaults.config); visibility only gates
- * whether a PEER may read or write the key.
- *
- * - `shared`  — a peer reads it (ssh.*, platform, role, caps), so any box
- *   may set it for any device. Lands in that device's tracked doc.
- * - `machine` — only the owning box ever reads it (scheduler, daemon, tmux,
- *   browser consent). Refused for a peer — run it on that box instead.
- */
 export type ConfigVisibility = 'shared' | 'machine';
-/** Value type of a config key — drives validation and `--json` rendering. */
 type ConfigType = 'string' | 'int' | 'bool' | 'string-list';
-/** Fields every key carries, regardless of scope. */
 interface ConfigKeySpecBase {
-    /** CLI dotted name, e.g. `interactive.host`. */
     name: string;
-    /** camelCase key under the YAML config block. */
     yamlKey: string;
     type: ConfigType;
-    /** One-line description for help/list output. */
     description: string;
-    /** The effective value when the key is unset (bool keys; drives the interactive menu's default). */
     defaultValue?: unknown;
-    /** Extra validation beyond the type check; return an error string or null. */
     validate?: (value: unknown) => string | null;
 }
-/**
- * One known config key. A device-scope key MUST declare its `visibility`; a
- * user-scope key has none (it is fleet-wide by definition).
- */
 export type ConfigKeySpec = (ConfigKeySpecBase & {
     scope: 'user';
     visibility?: never;
@@ -70,191 +16,54 @@ export type ConfigKeySpec = (ConfigKeySpecBase & {
     scope: 'device';
     visibility: ConfigVisibility;
 });
-/** Which layer set a key's effective value (`default` = unset, built-in behavior). */
 export type ConfigSource = 'user' | 'device' | 'fleet' | 'default';
-/** A key with its resolved value and the layer that set it. */
 export interface ConfigEntry {
     spec: ConfigKeySpec;
-    /** The effective value, or undefined when unset (unset = default behavior). */
     value: unknown;
-    /** Which layer set the effective value. */
     source: ConfigSource;
 }
-/** Options scoping a read/write: a specific device (default: this machine), or the fleet-defaults layer. */
 interface ConfigTarget {
     device?: string;
-    /** Write/read the fleet-wide defaults layer (central fleet.defaults.config). */
     fleet?: boolean;
 }
-/** Roles a device can be marked with — see the `role` key below. */
 declare const DEVICE_ROLES: readonly ["worker", "personal", "desktop"];
-/** Which devices automatic placement may pick — see the `auto.pool` key below. */
 declare const AUTO_POOL_MODES: readonly ["workers", "all"];
+export declare const MENUBAR_TABS: readonly ["home", "sessions", "inbox", "projects"];
 export declare const CONFIG_KEYS: readonly ConfigKeySpec[];
 export declare function configKeySpec(name: string): ConfigKeySpec;
-/** Throw when `value` does not match the key's declared type or validation. */
 export declare function assertValidValue(spec: ConfigKeySpec, value: unknown): void;
-/**
- * The effective device-scope config block for `device`: fleet.defaults.config
- * overlaid with the per-device doc's config:. This is the single read path
- * post-migration — the profile resolver (`lib/devices/resolve-profile.ts`)
- * goes through here. Deliberately does NOT auto-trigger the migration: it
- * serves the hot dial/render paths. Sync and cheap (small local files).
- */
 export declare function readDeviceConfigValues(device: string): Record<string, unknown>;
-/** Get one config key's effective value and the layer that set it. */
 export declare function getConfigValue(name: string, opts?: ConfigTarget): ConfigEntry;
-/**
- * Async, non-blocking twin of {@link getConfigValue} for the daemon's tick paths
- * (PHNX-3695) — e.g. the watchdog tick reading `watchdog.enabled` every ~3min.
- * Same layer precedence (device doc → fleet defaults → default), but the
- * per-device doc READ is async. The user/fleet layers go through `readMeta`,
- * which serves from an mtime-stamped in-memory cache (≈ 2 stat syscalls on the
- * hot path, no file read), and `ensureDeviceConfigMigrated` is a one-shot no-op
- * after the first process-wide fold — neither blocks the loop meaningfully.
- */
 export declare function getConfigValueAsync(name: string, opts?: ConfigTarget): Promise<ConfigEntry>;
-/**
- * List every known key with its effective value and the layer that set it.
- *
- * Listing a PEER omits its machine-local keys rather than throwing — those
- * values live on that box and are unknowable from here, but a bulk listing
- * must not hard-fail. Asking for such a key by name still errors.
- */
 export declare function listConfig(opts?: ConfigTarget): ConfigEntry[];
-/**
- * Set a config key (validated). Device-scope keys target this machine unless
- * `opts.device` names a peer; `opts.fleet` writes the fleet-wide defaults layer
- * instead. User-scope keys reject `fleet` (they are already fleet-wide).
- */
 export declare function setConfigValue(name: string, value: unknown, opts?: ConfigTarget): void;
-/** Unset a config key — restores the next layer down (fleet default, then the
- * built-in default). No-op when already unset at that layer. */
 export declare function unsetConfigValue(name: string, opts?: ConfigTarget): void;
-/** A role an operator marked a device with (`agents devices role <name> <role>`). */
 export type ConfiguredDeviceRole = (typeof DEVICE_ROLES)[number];
-/** Which devices automatic placement may pick (`auto.pool`). */
 export type AutoPoolMode = (typeof AUTO_POOL_MODES)[number];
-/**
- * The role marked on one device, or undefined when the operator never marked it.
- *
- * Undefined is meaningful and is NOT the same as `worker`: an unmarked device is
- * eligible for automatic placement only while no device anywhere carries an
- * explicit `worker` mark (see {@link listConfiguredDeviceRoles}).
- */
 export declare function configuredDeviceRole(name: string): ConfiguredDeviceRole | undefined;
-/**
- * The role marked on THIS machine — the one running the CLI — or undefined when
- * it was never marked. Keyed off {@link machineId} (overridable via
- * AGENTS_SYNC_MACHINE_ID), so it matches the device's own config-folder key.
- *
- * The auth strategy reads this: a headed device (`personal` or `desktop`, see
- * {@link isHeadedDeviceRole}) holds a real per-version login and MUST
- * authenticate from it for EVERY run, interactive or headless; only a `worker`
- * uses the file-based setup-token (RUSH-2395). `undefined` is treated as
- * non-headed (worker-equivalent) by that gate — an unmarked box has no login to
- * defer to.
- */
 export declare function selfConfiguredDeviceRole(): ConfiguredDeviceRole | undefined;
-/**
- * A "headed" device — one with an interactive desktop login, so it authenticates
- * from its own per-version Claude login (which carries the `user:profile` scope
- * the usage endpoint needs) rather than the headless file setup-token. Both
- * `personal` (the box you sit at) and `desktop` (a headed always-on box like a
- * Mac mini) qualify; a `worker` and an unmarked box do NOT. This is the single
- * predicate the auth-bucket sites read, so `personal` and `desktop` never drift
- * apart (claude adapter, routine spawn env, `agents view` usage login).
- */
 export declare function isHeadedDeviceRole(role: ConfiguredDeviceRole | undefined): boolean;
-/** Mark a device's role fleet-wide; `undefined` clears the mark. */
 export declare function setConfiguredDeviceRole(name: string, role: ConfiguredDeviceRole | undefined): void;
-/**
- * Devices whose OWN config pins one of the browser profile keys to `profile`.
- *
- * Used by `profiles rename` to warn rather than silently leave a peer pointing at
- * a name that no longer exists. Deliberately read-only: rewriting another
- * machine's device doc from here would be a cross-machine mutation nobody asked
- * for, and the pin may well be correct there (a local profile of the same name).
- */
 export declare function devicesPinningBrowserProfile(profile: string): Array<{
     device: string;
     key: 'browser.profile' | 'browser.viewer';
 }>;
-/**
- * Every device with an effective role, keyed by device name. Layers like every
- * other device-scope key: the fleet default (central fleet.defaults.config)
- * applies fleet-wide and the per-device doc wins on conflict. `roster` (the
- * registered device names) lets a fleet default reach devices that have no doc
- * of their own; without it only devices with docs are considered — so a
- * fleet-wide `role` default would silently miss a doc-less device and drop it
- * from the worker allowlist. Mirrors {@link loadAutoLaunchPreferences}.
- */
 export declare function listConfiguredDeviceRoles(roster?: string[]): Record<string, ConfiguredDeviceRole>;
-/** The configured automatic-placement pool mode. Unset means `workers`. */
 export declare function autoPoolMode(): AutoPoolMode;
-/**
- * A device's auto-launch flags, read by the automatic-placement pool
- * (`filterAutoPool` drops `enabled: false`; `pickBestDevice` boosts
- * `preferred: true` — see `lib/devices/pool.ts`) and by the menu-bar snapshot.
- */
 export interface AutoLaunchPreference {
     enabled?: boolean;
     preferred?: boolean;
 }
-/** True if the device is enabled for auto-launch. Unset defaults to true. */
 export declare function isAutoLaunchEnabled(name: string): boolean;
-/** Set whether a device is enabled for auto-launch. Setting the default
- * (enabled) removes the key to keep the doc minimal. */
 export declare function setAutoLaunchEnabled(name: string, enabled: boolean): void;
-/** True if the device is preferred for auto-launch ranking. */
 export declare function isAutoLaunchPreferred(name: string): boolean;
-/** Set whether a device is preferred for auto-launch. Setting the default
- * (not preferred) removes the key to keep the doc minimal. */
 export declare function setAutoLaunchPreferred(name: string, preferred: boolean): void;
-/**
- * Every device's effective auto-launch flags, keyed by device name — the shape
- * the menu-bar snapshot consumes. Layers like every other device-scope key: the
- * fleet default (central fleet.defaults.config) applies fleet-wide and the
- * per-device doc wins on conflict. `roster` (the registered device names) lets
- * a fleet default reach devices that have no doc of their own; without it only
- * devices with docs are listed.
- */
 export declare function loadAutoLaunchPreferences(roster?: string[]): Record<string, AutoLaunchPreference>;
-/** True unless this machine's config disables the routines scheduler. */
 export declare function isSchedulerEnabled(): boolean;
-/**
- * Throw when the routines scheduler is disabled on this machine, naming the
- * setting and the fix. The single message every scheduler-start surface
- * (auto-start on `routines add`, manual `routines start`, the daemon's own
- * scheduler init) refuses with.
- */
 export declare function assertSchedulerEnabled(): void;
-/** True only when this machine explicitly enables the managed tmux wrap. */
 export declare function isTmuxEnabled(): boolean;
-/** True unless this machine's config disables the daemon outright (top-level kill switch). */
 export declare function isDaemonEnabled(): boolean;
-/**
- * Throw when the daemon is disabled on this machine, naming the setting and
- * the fix. Every AUTO-start surface (routines add/start/catchup/webhook,
- * monitors add, `ensureDaemonStarted`) refuses with this before calling
- * `startDaemon()`. `agents daemon start` is the deliberate override and does
- * NOT call this — disable only blocks auto-start, mirroring `systemctl disable`.
- */
 export declare function assertDaemonEnabled(): void;
-/**
- * Idle window (ms) the browser-task reaper (`browser/hygiene.ts`) uses on THIS
- * machine, or `null` when idle reaping is off (`browser.task-idle-minutes=0`)
- * — session-dead reaping is unaffected either way. Unset means the default 30
- * minutes. Read by the daemon's periodic tick and, as the fallback when a
- * caller omits `--idle-minutes`, by the `gc` IPC action.
- */
-/** Async so the daemon's browser-task-reap tick reads the config off the shared event loop (PHNX-3695). */
 export declare function resolveBrowserTaskIdleMs(): Promise<number | null>;
-/**
- * Read the effective `agents.max-concurrent` cap for each named device (fleet
- * defaults layered under the per-device doc; no SSH). Devices without a cap
- * are omitted — uncapped is the default. Used as an input to host ranking
- * (teams placement, AGI EXT auto-launch), never as a remote probe.
- */
 export declare function readMaxConcurrentCaps(devices: string[]): Record<string, number>;
 export {};