@phnx-labs/agents-cli 1.22.29 → 1.22.31

package/dist/commands/exec.js

@@ -445,17 +445,18 @@ async function handleTerminalHandoff(agentSpec, options, prompt) {
     // the whole Kimi/DeepSeek/Qwen/GLM path — for `--terminal` runs only.
     const rawTarget = parseRunAccountPickerRequest(agentSpec).normalizedAgentSpec.split('@')[0];
     const knownAgent = resolveAgentName(rawTarget);
-    if (knownAgent && isAgentHardDeprecated(knownAgent)) {
+    const [{ profileExists }, { resolveWorkflowRef }] = await Promise.all([
+        import('../lib/profiles.js'),
+        import('../lib/workflows.js'),
+    ]);
+    const hasProfile = profileExists(rawTarget);
+    if (knownAgent && !hasProfile && isAgentHardDeprecated(knownAgent)) {
         console.error(chalk.red(hardDeprecationError(knownAgent)));
         process.exit(1);
     }
     if (!knownAgent) {
-        const [{ profileExists }, { resolveWorkflowRef }] = await Promise.all([
-            import('../lib/profiles.js'),
-            import('../lib/workflows.js'),
-        ]);
         const probeCwd = options.cwd ?? process.cwd();
-        if (!profileExists(rawTarget) && !resolveWorkflowRef(rawTarget, probeCwd)) {
+        if (!hasProfile && !resolveWorkflowRef(rawTarget, probeCwd)) {
             console.error(chalk.red(`Unknown agent, profile, or workflow: ${rawTarget}. See \`agents list\` for the installed harnesses.`));
             process.exit(1);
         }
@@ -545,6 +546,7 @@ export function registerRunCommand(program) {
         .option('--fallback <agents>', 'Comma-separated agents to try on rate-limit failure. Each entry accepts an optional @version pin (e.g., codex@0.116.0,antigravity). The primary runs first; if it exits with a rate-limit error, the next agent picks up via /continue handoff.')
         .option('-b, --balanced', 'Shortcut for --strategy balanced. Ignored when @version is pinned.')
         .option('--strategy <strategy>', 'Version/account selection strategy: pinned | available | balanced. Defaults to run.<agent>.strategy, then balanced (spreads load across healthy accounts and skips any that are rate-limited). (Legacy `rotate` accepted as alias for `balanced`.)')
+        .option('--account <label>', 'Run a healthy installed version currently signed into this named account (never falls back to another identity)')
         .option('--acp', 'Route through the Agent Client Protocol instead of direct exec. Supported for claude via @zed-industries/claude-code-acp adapter. Unified event stream; emits ndjson when --json.')
         .option('-y, --yes', 'Skip the interactive budget-confirm prompt (require_confirm_over). Never skips a hard budget block.', false)
         .option('--loop', 'Re-inject the prompt/entrypoint each iteration until a stop condition (issue #332). Guards (--max-iterations, --budget, --until) are enforced outside the agent. Writes a checkpoint after every iteration for --resume-checkpoint.')
@@ -812,8 +814,10 @@ export function registerRunCommand(program) {
             process.exit(1);
         }
         // Hard-deprecated harnesses cannot be run — point the user at the successor.
-        const runBaseAgentId = resolveAgentName(normalizedAgentSpec.split('@')[0]);
-        if (runBaseAgentId && isAgentHardDeprecated(runBaseAgentId)) {
+        const runBaseAgentName = normalizedAgentSpec.split('@')[0];
+        const runBaseAgentId = resolveAgentName(runBaseAgentName);
+        const { profileExists: runProfileExists } = await import('../lib/profiles.js');
+        if (runBaseAgentId && !runProfileExists(runBaseAgentName) && isAgentHardDeprecated(runBaseAgentId)) {
             console.error(chalk.red(hardDeprecationError(runBaseAgentId)));
             process.exit(1);
         }
@@ -1567,6 +1571,7 @@ export function registerRunCommand(program) {
                         agent: runAgent,
                         version: resumeId ? undefined : runVersion,
                         strategy: resumeId ? undefined : runStrategy,
+                        account: resumeId ? undefined : options.account,
                         fallback: options.fallback,
                         prompt,
                         mode: forwardedMode,
@@ -1654,6 +1659,7 @@ export function registerRunCommand(program) {
                     agent: runAgent,
                     version: resumeId ? undefined : runVersion,
                     strategy: resumeId ? undefined : runStrategy,
+                    account: resumeId ? undefined : options.account,
                     fallback: options.fallback,
                     prompt,
                     mode: forwardedMode,
@@ -1840,11 +1846,11 @@ export function registerRunCommand(program) {
         // degenerates to a no-op ("I'll wait for the completion notification").
         let workflowHasSubagents = false;
         const cwd = options.cwd ?? process.cwd();
+        if (accountPickerRequested && profileExists(rawAgent)) {
+            console.error(chalk.red(`Account selection is not available for custom harness '${rawAgent}'. Run its concrete host agent with @ instead.`));
+            process.exit(1);
+        }
         if (accountPickerRequested && !isValidAgent(rawAgent)) {
-            if (profileExists(rawAgent)) {
-                console.error(chalk.red(`Account selection is not available for custom harness '${rawAgent}'. Run its concrete host agent with @ instead.`));
-                process.exit(1);
-            }
             if (resolveWorkflowRef(rawAgent, cwd)) {
                 console.error(chalk.red(`Account selection is not available for workflow '${rawAgent}'. Run a concrete agent with @ instead.`));
                 process.exit(1);
@@ -1886,14 +1892,11 @@ export function registerRunCommand(program) {
                 process.stderr.write(chalk.yellow(`[agents] --session-id ignored: auto picked ${agent} (only claude accepts a forced session id)\n`));
             }
         }
-        else if (isValidAgent(rawAgent)) {
-            agent = rawAgent;
-        }
         else if (profileExists(rawAgent)) {
-            // Not a known agent id, but a profile by this name exists. Profiles
-            // bind (host agent, version, env overrides, keychain-backed auth)
-            // so Chinese models (Kimi, DeepSeek, Qwen, GLM) can run inside
-            // Claude Code without a local proxy.
+            // A profile by this exact name exists. Profiles bind (host agent,
+            // version, env overrides, keychain-backed auth) so Chinese models
+            // (Kimi, DeepSeek, Qwen, GLM) can run inside Claude Code without a
+            // local proxy, including when the profile name matches a native id.
             try {
                 const resolved = resolveProfileForRun(rawAgent, options.model);
                 agent = resolved.agent;
@@ -1925,6 +1928,9 @@ export function registerRunCommand(program) {
                 process.exit(1);
             }
         }
+        else if (isValidAgent(rawAgent)) {
+            agent = rawAgent;
+        }
         else if (resolveWorkflowRef(rawAgent, cwd)) {
             // Workflow: explicit directory, project .agents/workflows/<name>, user, system, or extra repo.
             // Resolution follows resource precedence: direct path, then project > user > system > extras.
@@ -2148,6 +2154,23 @@ export function registerRunCommand(program) {
             }
         }
         version = resolveVersionAlias(agent, version);
+        if (options.account) {
+            if (options.cloud || options.provider || options.lease) {
+                console.error(chalk.red('--account selects a local installed identity and cannot be combined with cloud or lease placement.'));
+                process.exit(1);
+            }
+            const { resolveAccountLabel } = await import('../lib/account-labels.js');
+            try {
+                const selected = await resolveAccountLabel(agent, options.account);
+                if (version && version !== selected)
+                    throw new Error(`${agent}@${version} is not a healthy match for account '${options.account}'.`);
+                version ??= selected;
+            }
+            catch (err) {
+                console.error(chalk.red(err.message));
+                process.exit(1);
+            }
+        }
         // --resume: resolve a prior conversation and rewrite the run target to
         // continue it. `version` here is already the alias-resolved candidate-version
         // FILTER (undefined for default/any, concrete for @latest/@oldest/@x.y.z);
@@ -2320,7 +2343,7 @@ export function registerRunCommand(program) {
         // the bare primary still resolves through the strategy — otherwise every
         // `agents run claude --fallback codex` run lands on the pinned default
         // account and account rotation silently stops (the gh-monitor heal bug).
-        if (!accountPickerRequested && (strategy !== 'pinned' || options.balanced || explicitStrategy)) {
+        if (!accountPickerRequested && !options.account && (strategy !== 'pinned' || options.balanced || explicitStrategy)) {
             if (version) {
                 process.stderr.write(chalk.yellow(`[agents] strategy ${strategy} ignored: version ${version} is pinned\n`));
             }
@@ -2434,6 +2457,29 @@ export function registerRunCommand(program) {
                 version = healed;
             }
         }
+        // The harness may simply not be on this machine. The self-heal above only
+        // runs when a managed version resolved, so with nothing installed we used
+        // to fall through and spawn the bare `cliCommand`, which dies as
+        // `exec: cursor-agent: not found` (exit 127) after a misleading
+        // "looks logged out" banner (RUSH-2339). Probe the executable
+        // buildExecCommand will actually spawn and fail loud instead.
+        //
+        // This is an EXISTENCE probe, not "does agents-cli manage a version". A
+        // harness the user installed themselves (Homebrew, a vendor `curl | sh`, a
+        // distro package) has no version home and MUST still launch — the PATH
+        // branch of resolveLaunchBinary is what keeps that working.
+        {
+            const { resolveLaunchBinary } = await import('../lib/exec.js');
+            // `version` already carries the self-heal's resolution above (it assigns
+            // `version = healed` whenever a version resolved at all), so re-deriving
+            // it with resolveVersion here would be dead.
+            if (!resolveLaunchBinary(agent, version)) {
+                const target = version ? `${agent}@${version}` : agent;
+                console.error(chalk.red(`agents: ${target} is not installed on this machine.`));
+                console.error(chalk.yellow(`Install it with: agents add ${target}`));
+                process.exit(1);
+            }
+        }
         const defaultVersion = version ?? resolveVersion(agent, cwd);
         // Re-apply the active rules preset before every launch (issue: preset
         // changes via `setActiveRulesPreset` only took effect after an explicit

package/dist/commands/focus.d.ts

@@ -42,7 +42,7 @@ export interface FocusOptions {
     since?: string;
     until?: string;
     limit?: string;
-    favorites?: boolean;
+    bookmarks?: boolean;
     unmanaged?: boolean;
     sort?: string;
     working?: boolean;
@@ -74,6 +74,9 @@ export declare function selectFallback(attachOnly: boolean | undefined): Unreach
 export declare function focusAction(id: string | undefined, opts: FocusOptions): Promise<void>;
 /** A retained pane is not attachable merely because tmux can still display it. */
 export declare function isAttachableLiveSession(session: ActiveSession): boolean;
+/** Focus one row selected by the shared session browser through the same
+ * attach/recover decision as `agents sessions focus <id>`. */
+export declare function focusSelectedSession(meta: SessionMeta, active: ActiveSession | undefined, self: string): Promise<void>;
 /**
  * How a single selected live session opens in its new tab.
  *  - `attach` — a live tmux pane joined in the tab (a second client, no fork),

package/dist/commands/focus.js

@@ -32,7 +32,7 @@ const INHERITED_FOCUS_OPTIONS = [
     'local', 'host', 'device', 'active', 'agent',
     'claude', 'codex', 'kimi', 'antigravity', 'grok', 'opencode',
     'all', 'teams', 'inTeam', 'routine', 'project', 'skill', 'plugin',
-    'since', 'until', 'limit', 'favorites', 'unmanaged', 'sort',
+    'since', 'until', 'limit', 'bookmarks', 'unmanaged', 'sort',
     'working', 'idle', 'waiting', 'orphan', 'orphaned', 'crashed',
     'closed', 'abandoned', 'queued', 'unknown',
 ];
@@ -93,7 +93,7 @@ export function registerFocusCommand(program) {
         .option('--since <time>', 'Only sessions newer than this (for example 7d)')
         .option('--until <time>', 'Only sessions older than this timestamp')
         .option('-n, --limit <n>', 'Maximum candidates to load', '500')
-        .option('--favorites', 'Only favorited sessions')
+        .option('--bookmarks', 'Only bookmarked sessions')
         .option('--unmanaged', 'Also include native-home sessions outside managed versions')
         .option('--sort <field>', 'Order candidates by recent, cost, or duration', 'recent')
         .option('--working', 'Only live sessions currently doing work')
@@ -184,7 +184,7 @@ export async function focusAction(id, opts) {
             agent: agentSelector ?? focusOptionAgent(opts),
             teams: opts.teams === true,
             team: opts.inTeam,
-            favorites: opts.favorites === true,
+            bookmarks: opts.bookmarks === true,
             projectScope: opts.all || hosts.length > 0 || !!opts.project || idLookup ? 'all' : 'repo',
             project: opts.project,
             window: opts.since ?? (opts.all || idLookup ? undefined : '30d'),
@@ -304,7 +304,7 @@ function looksLikeIdentitySelector(selector) {
 function hasFocusFilters(opts, statuses) {
     return statuses.length > 0 || !!(opts.active || opts.local || opts.host?.length || opts.device?.length || focusOptionAgent(opts) ||
         opts.all || opts.teams || opts.inTeam || opts.routine || opts.project || opts.skill || opts.plugin ||
-        opts.since || opts.until || opts.favorites || opts.unmanaged || (opts.sort && opts.sort !== 'recent'));
+        opts.since || opts.until || opts.bookmarks || opts.unmanaged || (opts.sort && opts.sort !== 'recent'));
 }
 function focusSort(value) {
     if (!value || value === 'recent')
@@ -370,6 +370,21 @@ async function focusResolvedSession(meta, liveById, self, fallback, attachOnly)
     }
     await resumeSessionInPlace(meta);
 }
+/** Focus one row selected by the shared session browser through the same
+ * attach/recover decision as `agents sessions focus <id>`. */
+export async function focusSelectedSession(meta, active, self) {
+    if (active && !active.sessionId) {
+        if (isAttachableLiveSession(active)) {
+            await jumpTo(active, self, resumeInNewTab);
+            return;
+        }
+        console.log(chalk.yellow('This live session has no session id or living attach rail to focus.'));
+        process.exitCode = 1;
+        return;
+    }
+    const liveById = active ? new Map([[meta.id, active]]) : new Map();
+    await focusResolvedSession(meta, liveById, self, resumeInNewTab, false);
+}
 function activeFromMeta(meta) {
     return {
         context: 'headless',

package/dist/commands/routines.js

@@ -11,7 +11,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 import * as yaml from 'yaml';
 import { isDaemonRunning, signalDaemonReload, startDaemon, stopDaemon, readDaemonLog, getDaemonStatus, } from '../lib/daemon.js';
-import { assertSchedulerEnabled } from '../lib/device-config.js';
+import { assertSchedulerEnabled, assertDaemonEnabled, isDaemonEnabled } from '../lib/device-config.js';
 import { resolveAgentName, isAgentHardDeprecated, hardDeprecationError, ROUTINE_AGENT_IDS } from '../lib/agents.js';
 import { humanizeCron, humanizeNextRun, formatRepoLink, REPO_DISPLAY_MAX } from '../lib/routines-format.js';
 import { listJobs as listAllJobs, deleteJob, readJob, validateJob, writeJob, setJobEnabled, listRuns, routineStats, getLatestRun, getRunDir, getJobPath, parseAtTime, hasCompletedOneShotRun, isOneShotLikeSchedule, isOneShotRoutine, isPastOneShotRoutine, jobRunsOnThisDevice, checkJobDeviceEligibility, normalizeTriggerEvent, parseHostStrategy, resolveHostStrategy, HOST_STRATEGIES, computeProjectGroup, computeProjectGroupKind, projectGroupKey, projectGroupTitle, projectGroupOrder, normalizeProjects, } from '../lib/routines.js';
@@ -344,6 +344,7 @@ function parseRoutineTrigger(options) {
 function ensureSchedulerRunning(opts = {}) {
     const log = opts.stderr ? console.error : console.log;
     try {
+        assertDaemonEnabled();
         assertSchedulerEnabled();
     }
     catch (err) {
@@ -1282,11 +1283,18 @@ export function registerRoutinesCommands(program) {
             console.log(`  ${chalk.cyan(job.name)} — missed ${chalk.gray(job.expectedAt.toLocaleString())}, last ran ${chalk.gray(last)}`);
         }
         // Need the daemon alive so spawned jobs are monitored and meta.json is
-        // finalized. Start it if it isn't already running.
+        // finalized. Start it if it isn't already running — unless daemon.enabled
+        // is off, in which case this auto-start is skipped with a stated reason.
         if (!options.dryRun && !isDaemonRunning()) {
-            const started = startDaemon();
-            if (started.pid) {
-                console.log(chalk.gray(`\nStarted scheduler (PID: ${started.pid}) so catchup runs are monitored.`));
+            try {
+                assertDaemonEnabled();
+                const started = startDaemon();
+                if (started.pid) {
+                    console.log(chalk.gray(`\nStarted scheduler (PID: ${started.pid}) so catchup runs are monitored.`));
+                }
+            }
+            catch (err) {
+                console.log(chalk.yellow(`\n${err.message}`));
             }
         }
         console.log(chalk.bold(options.dryRun ? '\nRecording misses...' : '\nTriggering catchup runs...'));
@@ -1372,11 +1380,18 @@ export function registerRoutinesCommands(program) {
             return;
         }
         // Fired jobs run detached via executeJobDetached (the same path cron
-        // uses). Keep the daemon alive so each run's meta.json is finalized.
+        // uses). Keep the daemon alive so each run's meta.json is finalized —
+        // unless daemon.enabled is off, in which case this auto-start is
+        // skipped with a stated reason.
         if (!isDaemonRunning()) {
-            const started = startDaemon();
-            if (started.pid) {
-                console.log(chalk.gray(`Started scheduler (PID: ${started.pid}) so webhook runs are monitored.`));
+            if (!isDaemonEnabled()) {
+                console.log(chalk.yellow(`Daemon is disabled (daemon.enabled=false) — run(s) below fire but are not monitored. Re-enable with: agents daemon enable`));
+            }
+            else {
+                const started = startDaemon();
+                if (started.pid) {
+                    console.log(chalk.gray(`Started scheduler (PID: ${started.pid}) so webhook runs are monitored.`));
+                }
             }
         }
         const fired = await fireWebhookJobs(webhook);
@@ -1649,8 +1664,11 @@ export function registerRoutinesCommands(program) {
         .description('Start the background scheduler. Usually unnecessary — it auto-starts when you add your first routine.')
         .action(() => {
         try {
-            // A manual start on a scheduler-disabled device refuses with the same
-            // message the auto-start surfaces give.
+            // A manual start on a disabled device refuses with the same message the
+            // auto-start surfaces give — `agents routines start` is a convenience
+            // wrapper around the daemon, not the deliberate override. Use
+            // `agents daemon start` to bypass daemon.enabled explicitly.
+            assertDaemonEnabled();
             assertSchedulerEnabled();
         }
         catch (err) {

package/dist/commands/secrets.d.ts

@@ -12,6 +12,7 @@ import { bundleEnvToDotenv } from '../lib/secrets/push.js';
 export { bundleEnvToDotenv };
 import { type SecretsBackend, type SecretsBundle, type SecretsPolicy } from '../lib/secrets/bundles.js';
 import { type SecretsListFilterOpts } from '../lib/secrets/list-filter.js';
+import { type SecretLease } from '../lib/secrets/lease.js';
 import { type BundleUsageSummary } from '../lib/secrets/usage-db.js';
 /** Read all available data from stdin synchronously, trimmed. */
 /**
@@ -51,6 +52,25 @@ export declare function parseImportSource(opts: {
  * without a live SSH session.
  */
 export declare function resolveUnlockTtlMs(ttl: string | undefined, until: string | undefined, now?: number): number;
+/**
+ * Decide what an `unlock` holds: the whole bundle env, or — with --keys — only
+ * the resolved subset behind a lease that scopes the broker entry (agent.ts
+ * re-selects on load) and its own expiry. Fails closed: createSecretLease throws
+ * on an unknown or empty key subset. The unlock action's single scoping seam,
+ * exported so the whole-bundle vs scoped-subset decision is unit-testable without
+ * a live broker.
+ */
+export declare function scopeHeldEnv(input: {
+    bundle: string;
+    env: Record<string, string>;
+    keys: string | null;
+    ttlMs: number;
+    harness: string;
+    sleepPersist: boolean;
+}): {
+    heldEnv: Record<string, string>;
+    lease?: SecretLease;
+};
 export declare function buildRemoteUnlockArgs(names: string[], opts: {
     all?: boolean;
     ttl?: string;
@@ -149,6 +169,23 @@ export declare function renderViewStatusLine(b: SecretsBundle, heldExpiresAt: nu
  * and a hard abort at inject time, i.e. after it had already broken something.
  */
 export declare function renderExpiringCol(b: SecretsBundle, now?: number): string;
+/**
+ * Resolve an existing import target bundle (inheriting its backend) or create a
+ * new one with the requested backend. Refuses to silently downgrade a
+ * keychain-backed bundle to `file` — shared by every `import` source so the
+ * guard can't drift between them.
+ *
+ * `force` additionally recreates a bundle whose METADATA RECORD is present but
+ * undecryptable — a file store whose key was lost or rotated out from under it.
+ * That is precisely the state provisioning exists to repair (import is how a box
+ * gets its bundles back), and without this the import dies on `readBundle` and
+ * the only route left is deleting the record by hand on an already-degraded
+ * store. It is gated on `--force` on purpose: recreating unconditionally would
+ * destroy a perfectly healthy bundle for someone who merely forgot to set
+ * `AGENTS_SECRETS_PASSPHRASE`, which is the hazard `readBundleIfDecryptable`
+ * exists to describe. `--force` already means "overwrite what is there".
+ */
+export declare function resolveImportBundle(name: string, backendOpt: string | undefined, synced?: boolean, force?: boolean): SecretsBundle;
 /** Register the `agents secrets` command tree. */
 export declare function registerSecretsCommands(program: Command): void;
 /** Validate a prompt-policy value, throwing a clear message on a bad one (the