@phnx-labs/agents-cli 1.22.42 → 1.22.44

package/dist/lib/staleness/index.js

@@ -4,7 +4,9 @@
  *
  *   - `buildManifest(agent, version, cwd)` — snapshot current state.
  *   - `isStale(manifest, agent, version, cwd)` — true when any tracked
- *     resource has drifted from its stored fingerprint.
+ *     resource has drifted from its stored fingerprint, or when an artifact
+ *     the last full sync wrote (`writtenTargets`) has been deleted from the
+ *     version home (#2398).
  *
  * `loadManifest` / `saveManifest` round-trip the on-disk JSON. The format
  * version stays at 1; new optional fields (workflows, plugins) on old files
@@ -91,6 +93,12 @@ export function buildManifest(agent, version, cwd, previous) {
         subagents: {},
         workflows: {},
         plugins: {},
+        // Empty baseline ("nothing recorded to verify"). The full-sync
+        // orchestrator (versions.ts) replaces this with the writer-reported
+        // artifact paths right before saving; a manifest built outside that path
+        // simply verifies nothing. Only an ABSENT field (a pre-upgrade manifest
+        // on disk) forces the one-time migration re-sync in isStale.
+        writtenTargets: [],
     };
     for (const { checker, field } of STANDARD_CHECKERS) {
         const target = manifest[field];
@@ -143,5 +151,17 @@ export function isStale(manifest, agent, version, cwd) {
         return true;
     if (isRulesStale(manifest.rules, agent, version, cwd))
         return true;
+    // Home-side deletion check (#2398): every artifact the last full sync wrote
+    // must still exist, or the version home has rotted and needs a re-sync —
+    // regardless of source fingerprints. One existsSync per path, no content
+    // reads, so the fast-guard budget holds (RUSH-2320). A manifest that
+    // predates the field reads as stale once so the next full sync records the
+    // baseline (same precedent as the optional workflows/plugins maps).
+    if (manifest.writtenTargets === undefined)
+        return true;
+    for (const target of manifest.writtenTargets) {
+        if (!fs.existsSync(target))
+            return true;
+    }
     return false;
 }

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

@@ -54,4 +54,15 @@ export interface SyncManifest {
     subagents: Record<string, DirEntry>;
     workflows?: Record<string, DirEntry>;
     plugins?: Record<string, PluginEntry>;
+    /**
+     * Absolute paths of the artifacts the last full sync materialized in the
+     * version home (writer-reported — see `WriteResult.paths`). `isStale`
+     * treats a missing path as stale so a deleted resource is restored by a
+     * plain `agents sync`, not only `--force` (#2398). An absent field means a
+     * pre-upgrade manifest: it reads as stale once, and the resulting full sync
+     * establishes the baseline — same migration precedent as the optional
+     * `workflows`/`plugins` maps above. An empty array is a valid baseline
+     * ("nothing recorded to verify"), never a migration trigger.
+     */
+    writtenTargets?: string[];
 }

package/dist/lib/staleness/writers/commands.js

@@ -25,7 +25,7 @@ import { supports } from '../../capabilities.js';
 import { safeJoin } from '../../paths.js';
 import { markdownToToml } from '../../convert.js';
 import { commandAppliesTo, parseCommandMetadata } from '../../commands.js';
-import { installCommandSkillToVersion, listCommandSkillsInVersion, removeCommandSkillFromVersion, shouldAlsoInstallCommandAsSkill, shouldInstallCommandAsSkill, } from '../../command-skills.js';
+import { commandSkillName, installCommandSkillToVersion, listCommandSkillsInVersion, removeCommandSkillFromVersion, shouldAlsoInstallCommandAsSkill, shouldInstallCommandAsSkill, } from '../../command-skills.js';
 import { installGooseCommandToVersion, listGooseCommandsInVersion, removeGooseCommandFromVersion, } from '../../goose-commands.js';
 import { resolveCommandSource, trustedSkillRoots } from './sources.js';
 import { lazyAgentMap } from './lazy-map.js';
@@ -50,6 +50,7 @@ function buildCommandsWriter(agent) {
                 fs.mkdirSync(commandsTarget, { recursive: true });
             }
             const synced = [];
+            const paths = [];
             for (const cmd of selection) {
                 const srcFile = resolveCommandSource(cmd);
                 if (!srcFile)
@@ -63,9 +64,13 @@ function buildCommandsWriter(agent) {
                     // which is a deliberate no-op, not a failure — the native file is still written.
                     if (!installed.success)
                         continue;
+                    if (!installed.skipped) {
+                        paths.push(safeJoin(path.join(agentDir, 'skills'), commandSkillName(cmd)));
+                    }
                 }
                 if (supportsCommands && agent === 'goose') {
                     // Goose: recipe YAML + config.yaml slash_commands entry, not a file copy.
+                    // No artifact path recorded — the recipe layout lives in goose-commands.ts.
                     const installed = installGooseCommandToVersion(versionHome, cmd, srcFile);
                     if (!installed.success)
                         continue;
@@ -73,14 +78,18 @@ function buildCommandsWriter(agent) {
                 else if (supportsCommands && agentConfig.format === 'toml') {
                     const content = fs.readFileSync(srcFile, 'utf-8');
                     const tomlContent = markdownToToml(cmd, content);
-                    fs.writeFileSync(safeJoin(commandsTarget, `${cmd}.toml`), tomlContent);
+                    const dest = safeJoin(commandsTarget, `${cmd}.toml`);
+                    fs.writeFileSync(dest, tomlContent);
+                    paths.push(dest);
                 }
                 else if (supportsCommands) {
-                    fs.copyFileSync(srcFile, safeJoin(commandsTarget, `${cmd}.md`));
+                    const dest = safeJoin(commandsTarget, `${cmd}.md`);
+                    fs.copyFileSync(srcFile, dest);
+                    paths.push(dest);
                 }
                 synced.push(cmd);
             }
-            return { synced };
+            return { synced, paths };
         },
         remove({ versionHome, name }) {
             const agentConfig = AGENTS[agent];

package/dist/lib/staleness/writers/hooks.js

@@ -75,6 +75,7 @@ function buildHooksWriter(agent) {
             const hooksTarget = path.join(agentDir, 'hooks');
             fs.mkdirSync(hooksTarget, { recursive: true });
             const synced = [];
+            const paths = [];
             for (const hook of selection) {
                 const srcFile = resolveHookSource(hook);
                 if (!srcFile)
@@ -82,6 +83,7 @@ function buildHooksWriter(agent) {
                 const destFile = safeJoin(hooksTarget, hook);
                 if (copyHookSource(srcFile, destFile)) {
                     synced.push(hook);
+                    paths.push(destFile);
                 }
             }
             // Native hook registration in settings.json/hooks.json. Grok is included
@@ -93,7 +95,7 @@ function buildHooksWriter(agent) {
             if (agent === 'claude' || agent === 'codex' || agent === 'antigravity' || agent === 'kimi' || agent === 'droid' || agent === 'copilot' || agent === 'kiro' || agent === 'goose' || agent === 'cursor' || agent === 'grok' || agent === 'hermes' || agent === 'muse') {
                 registerHooksToSettings(agent, versionHome);
             }
-            return { synced };
+            return { synced, paths };
         },
         remove({ versionHome, name }) {
             // Delete the copied hook artifact from `{agentDir}/hooks/<name>`. Native

package/dist/lib/staleness/writers/mcp.d.ts

@@ -1,10 +1,3 @@
-/**
- * MCP writer — thin dispatcher into `installMcpServers` from `lib/mcp.ts`.
- *
- * The per-agent format handling (Claude CLI, Codex TOML, Cursor JSON, etc.)
- * lives in lib/mcp.ts; we keep it there to avoid the import cycle with
- * `versions.ts`. The writer simply hands the selection to that function.
- */
 import type { AgentId } from '../../types.js';
 import type { ResourceWriter } from './types.js';
 export declare const mcpWriters: Partial<Record<AgentId, ResourceWriter<string[]>>>;

package/dist/lib/staleness/writers/mcp.js

@@ -1,5 +1,14 @@
+/**
+ * MCP writer — thin dispatcher into `installMcpServers` from `lib/mcp.ts`.
+ *
+ * The per-agent format handling (Claude CLI, Codex TOML, Cursor JSON, etc.)
+ * lives in lib/mcp.ts; we keep it there to avoid the import cycle with
+ * `versions.ts`. The writer simply hands the selection to that function.
+ */
+import * as fs from 'fs';
 import { capableAgents } from '../../capabilities.js';
 import { installMcpServers } from '../../mcp.js';
+import { getMcpConfigPathForHome } from '../../agents.js';
 import { lazyAgentMap } from './lazy-map.js';
 function buildMcpWriter(agent) {
     return {
@@ -9,7 +18,13 @@ function buildMcpWriter(agent) {
             const r = installMcpServers(agent, version, versionHome, selection, { cwd });
             // Forward r.errors: dropping them is what let a harness with no config
             // writer report a clean sync while writing nothing (RUSH-2677).
-            return { synced: r.applied, ...(r.errors.length ? { errors: r.errors } : {}) };
+            // All applied servers land in the one canonical config file — that file
+            // is the artifact whose deletion must read as stale (#2398). Recorded
+            // only when it verifiably exists after the write, so an agent whose CLI
+            // wrote elsewhere can never produce a perpetually-stale manifest.
+            const configPath = getMcpConfigPathForHome(agent, versionHome);
+            const paths = r.applied.length > 0 && fs.existsSync(configPath) ? [configPath] : [];
+            return { synced: r.applied, paths, ...(r.errors.length ? { errors: r.errors } : {}) };
         },
     };
 }

package/dist/lib/staleness/writers/rules.js

@@ -43,7 +43,7 @@ function buildRulesWriter(agent) {
             }
             catch { /* destination did not exist */ }
             fs.writeFileSync(destFile, composed.content);
-            return { synced: [targetName] };
+            return { synced: [targetName], paths: [destFile] };
         },
     };
 }

package/dist/lib/staleness/writers/skills.js

@@ -56,6 +56,7 @@ function buildSkillsWriter(agent) {
             catch { /* does not exist yet */ }
             fs.mkdirSync(skillsTarget, { recursive: true });
             const synced = [];
+            const paths = [];
             for (const skill of selection) {
                 const srcDir = resolveSkillSource(skill, { agent });
                 if (!srcDir)
@@ -64,8 +65,9 @@ function buildSkillsWriter(agent) {
                 removePath(destDir);
                 copyDir(srcDir, destDir);
                 synced.push(skill);
+                paths.push(destDir);
             }
-            return { synced };
+            return { synced, paths };
         },
         remove({ versionHome, name }) {
             const agentDir = path.join(versionHome, agentConfigDirName(agent));

package/dist/lib/staleness/writers/subagents.d.ts

@@ -1,12 +1,3 @@
-/**
- * Subagents writer. Every agent's on-disk layout (target dir, file/dir shape,
- * transform) is declared once in the subagent registry; this writer is generic
- * and iterates the registry instead of a per-agent `else if` chain.
- *
- * Source-side discovery is `listInstalledSubagents` from lib/subagents.ts —
- * it reads user + system layers only (project layer excluded for the same
- * defense as commands/skills/hooks).
- */
 import type { AgentId } from '../../types.js';
 import type { ResourceWriter } from './types.js';
 export declare const subagentsWriters: Partial<Record<AgentId, ResourceWriter<string[]>>>;

package/dist/lib/staleness/writers/subagents.js

@@ -1,3 +1,13 @@
+/**
+ * Subagents writer. Every agent's on-disk layout (target dir, file/dir shape,
+ * transform) is declared once in the subagent registry; this writer is generic
+ * and iterates the registry instead of a per-agent `else if` chain.
+ *
+ * Source-side discovery is `listInstalledSubagents` from lib/subagents.ts —
+ * it reads user + system layers only (project layer excluded for the same
+ * defense as commands/skills/hooks).
+ */
+import * as fs from 'fs';
 import { capableAgents } from '../../capabilities.js';
 import { listInstalledSubagents } from '../../subagents.js';
 import { subagentTarget } from '../../subagents-registry.js';
@@ -14,6 +24,7 @@ function buildSubagentsWriter(agent) {
             const map = new Map(all.map(s => [s.name, s]));
             const dir = target.dir(versionHome);
             const synced = [];
+            const paths = [];
             for (const name of selection) {
                 const sub = map.get(name);
                 if (!sub)
@@ -21,10 +32,16 @@ function buildSubagentsWriter(agent) {
                 try {
                     target.write(dir, sub);
                     synced.push(sub.name);
+                    // The registry owns the layout — record the artifact paths this
+                    // write occupies so a later deletion reads as stale (#2398).
+                    for (const entry of target.occupied(dir, sub.name)) {
+                        if (fs.existsSync(entry.path))
+                            paths.push(entry.path);
+                    }
                 }
                 catch { /* per-item sync failure: skip */ }
             }
-            return { synced };
+            return { synced, paths };
         },
     };
 }

package/dist/lib/staleness/writers/types.d.ts

@@ -28,6 +28,16 @@ export interface WriteArgs<Sel> {
 export interface WriteResult {
     /** Names actually written. Empty array = write produced nothing (not an error). */
     synced: string[];
+    /**
+     * Absolute on-disk paths of the artifacts this write materialized (a file or
+     * a dir root per resource, per the agent's layout). Recorded into the sync
+     * manifest as `writtenTargets` so `isStale` can flag a deleted artifact as
+     * stale with one existsSync per path (#2398) — no content reads, keeping the
+     * fast-guard budget (RUSH-2320). Optional: a writer whose artifact path is
+     * not cheaply known (goose recipe YAML, plugins) may omit entries; absence
+     * means "not verified", never a false stale.
+     */
+    paths?: string[];
     /**
      * Per-item failures the writer could not complete, as user-facing sentences.
      *

package/dist/lib/startup/command-registry.d.ts

@@ -21,7 +21,16 @@ export declare const KNOWN_TOP_LEVEL_COMMANDS: ReadonlySet<string>;
  * under `agents artifacts share` (RUSH-2580). login/logout/budget/bench/mine/
  * cost/output/profiles/snapshot/cp/resume/roster moved under nested homes
  * (cli-surface-consolidate). `timeline` was removed as a duplicated surface —
- * use `agents feed --filter updates` (RUSH-2692).
+ * use `agents feed --filter updates` (RUSH-2692). `status` moved under
+ * `agents sync status` (RUSH-2864). `tickets` was removed — use `linear`
+ * (linear-cli) (RUSH-2932). `alias` moved under `agents setup alias` (RUSH-2965).
+ * `inbox` was a pure alias of `agents feed` (RUSH-2984). `unshare` nested under
+ * `agents artifacts unshare` (RUSH-2989). `audit` nested under `agents events audit`.
+ * `trends` nested under `agents insights mix` / `insights trends`. `serve` (the
+ * read-only local web companion + `--control` anchor) was removed with the
+ * unshipped iOS Fleet Cockpit it existed for (RUSH-3001). `apply` nested under
+ * `agents fleet apply` / `agents devices apply`. `beta` nested under
+ * `agents setup beta` (RUSH-2981).
  */
 export declare const RETIRED_TOP_LEVEL_COMMANDS: ReadonlySet<string>;
 export declare function isKnownTopLevelCommand(name: string): boolean;

package/dist/lib/startup/command-registry.js

@@ -3,13 +3,13 @@ const LOADED_COMMAND_NAMES = [
     'permissions', 'mcp', 'clis', 'subagents', 'plugins', 'workflows', 'add', 'use', 'list',
     'remove', 'rm', 'purge', 'update', 'prune', 'import', 'registry', 'search', 'install',
     'routines', 'monitors', 'projects', 'run', 'open', 'reconnect', 'fork', 'config',
-    'models', 'modes', 'trash', 'restore', 'doctor', 'apply', 'status',
-    'route', 'harness', 'harnesses', 'secrets', 'menubar', 'beta', 'sync',
-    'refresh-rules', 'factory', 'usage', 'insights', 'perf', 'trends',
-    'alias', 'pty', 'tmux', 'watchdog', 'browser', 'computer', 'logs', 'events',
+    'models', 'modes', 'trash', 'restore', 'doctor',
+    'route', 'harness', 'harnesses', 'secrets', 'menubar', 'sync',
+    'refresh-rules', 'factory', 'usage', 'insights', 'perf',
+    'pty', 'tmux', 'watchdog', 'browser', 'computer', 'logs', 'events',
     'ssh', 'devices', 'fleet', 'repos', 'repo', 'setup', 'uninstall', 'upgrade', 'sessions',
-    'teams', 'tickets', 'cloud', 'message', 'send', 'notify', 'feed', 'inbox',
-    'mailboxes', 'mailbox', 'serve', 'artifacts', 'unshare', 'audit', 'webhooks',
+    'teams', 'cloud', 'message', 'send', 'notify', 'feed',
+    'mailboxes', 'mailbox', 'artifacts', 'webhooks',
     'humans', 'daemon',
 ];
 const INLINE_COMMAND_NAMES = [
@@ -41,10 +41,20 @@ export const KNOWN_TOP_LEVEL_COMMANDS = new Set([
  * under `agents artifacts share` (RUSH-2580). login/logout/budget/bench/mine/
  * cost/output/profiles/snapshot/cp/resume/roster moved under nested homes
  * (cli-surface-consolidate). `timeline` was removed as a duplicated surface —
- * use `agents feed --filter updates` (RUSH-2692).
+ * use `agents feed --filter updates` (RUSH-2692). `status` moved under
+ * `agents sync status` (RUSH-2864). `tickets` was removed — use `linear`
+ * (linear-cli) (RUSH-2932). `alias` moved under `agents setup alias` (RUSH-2965).
+ * `inbox` was a pure alias of `agents feed` (RUSH-2984). `unshare` nested under
+ * `agents artifacts unshare` (RUSH-2989). `audit` nested under `agents events audit`.
+ * `trends` nested under `agents insights mix` / `insights trends`. `serve` (the
+ * read-only local web companion + `--control` anchor) was removed with the
+ * unshipped iOS Fleet Cockpit it existed for (RUSH-3001). `apply` nested under
+ * `agents fleet apply` / `agents devices apply`. `beta` nested under
+ * `agents setup beta` (RUSH-2981).
  */
 export const RETIRED_TOP_LEVEL_COMMANDS = new Set([
     'webhook',
+    'serve',
     'login',
     'logout',
     'budget',
@@ -60,6 +70,15 @@ export const RETIRED_TOP_LEVEL_COMMANDS = new Set([
     'set',
     'share',
     'timeline',
+    'status',
+    'tickets',
+    'alias',
+    'inbox',
+    'unshare',
+    'audit',
+    'trends',
+    'apply',
+    'beta',
 ]);
 export function isKnownTopLevelCommand(name) {
     return KNOWN_TOP_LEVEL_COMMANDS.has(name);

package/dist/lib/startup/root-command.d.ts

@@ -1,3 +1,20 @@
 import type { Command } from 'commander';
-/** Configure the public root surface shared by the live CLI and reference generator. */
+/**
+ * Configure the public root surface shared by the live CLI and reference generator.
+ *
+ * Does NOT call `enablePositionalOptions()` — tried for RUSH-2687 (a subcommand
+ * option whose long name collides with an ancestor's is silently dropped at
+ * parse time) and reverted. Commander's `copyInheritedSettings()` copies
+ * `_enablePositionalOptions` onto every command created via `.command()` from
+ * that point on, so setting it here cascades to all ~552 registered commands,
+ * not just the root's own scan. That broke a real, load-bearing pattern used
+ * elsewhere in the tree: a parent command (e.g. `sessions`, which owns
+ * `--since`/`--json`/`--local`) whose LEAF subcommands declare none of their
+ * own options and read them back via `command.optsWithGlobals()` (e.g.
+ * `sessions backfill tools --since 7d --json --local`) — positional options
+ * makes the parent stop scanning at the first subcommand-shaped token, so it
+ * never sees the flags typed after it, and the leaf sees `unknown option`
+ * instead of a silent drop. RUSH-2687 was fixed per-surface in share.ts
+ * instead (renaming the colliding options), not with this global flag.
+ */
 export declare function configureRootCommand(program: Command, name: string, version: string): Command;

package/dist/lib/startup/root-command.js

@@ -1,4 +1,21 @@
-/** Configure the public root surface shared by the live CLI and reference generator. */
+/**
+ * Configure the public root surface shared by the live CLI and reference generator.
+ *
+ * Does NOT call `enablePositionalOptions()` — tried for RUSH-2687 (a subcommand
+ * option whose long name collides with an ancestor's is silently dropped at
+ * parse time) and reverted. Commander's `copyInheritedSettings()` copies
+ * `_enablePositionalOptions` onto every command created via `.command()` from
+ * that point on, so setting it here cascades to all ~552 registered commands,
+ * not just the root's own scan. That broke a real, load-bearing pattern used
+ * elsewhere in the tree: a parent command (e.g. `sessions`, which owns
+ * `--since`/`--json`/`--local`) whose LEAF subcommands declare none of their
+ * own options and read them back via `command.optsWithGlobals()` (e.g.
+ * `sessions backfill tools --since 7d --json --local`) — positional options
+ * makes the parent stop scanning at the first subcommand-shaped token, so it
+ * never sees the flags typed after it, and the leaf sees `unknown option`
+ * instead of a silent drop. RUSH-2687 was fixed per-surface in share.ts
+ * instead (renaming the colliding options), not with this global flag.
+ */
 export function configureRootCommand(program, name, version) {
     return program
         .name(name)

package/dist/lib/state.js

@@ -955,6 +955,13 @@ function serializeCentral(central) {
         // config data-loss bug). A known device key lingering in the synced file is
         // still removed — it belongs in the per-machine file, not here.
         if (!(k in central) && KNOWN_META_KEYS.has(k)) {
+            // RUSH-2837: a partial writeMeta (reconstructed Meta missing `share`)
+            // deleted the share endpoint from agents.yaml and synced that deletion
+            // fleet-wide. `share` is restored only by setup/join — never drop it
+            // just because this write omitted the key. Explicit `share: null` still
+            // goes through doc.set above.
+            if (k === 'share')
+                continue;
             doc.delete(k);
             changed = true;
         }

package/dist/lib/teams/placement-probe.js

@@ -7,9 +7,9 @@
  *
  *   - reachability + headroom + load  ← {@link probeFleetStats} (one parallel
  *     SSH fan-out over the pool; the local box is measured directly).
- *   - requested agent installed + signed in (when known) ← a one-shot readiness
- *     probe per remote device ({@link buildReadyProbeCommand} → `agents view`),
- *     the local box via {@link checkCliAvailable}/{@link checkCliSignedIn}.
+ *   - requested agent installed + account eligibility (when known) ← a one-shot
+ *     readiness probe per remote device ({@link buildReadyProbeCommand} →
+ *     `agents view`), with the same candidate-readiness gate evaluated locally.
  *
  * The result is cached briefly per (pool, agent-or-any) so a `teams start` wave that
  * places N teammates probes the pool ONCE, not N times — the roster-count part
@@ -25,10 +25,11 @@ import { execFile } from 'child_process';
 import { probeFleetStats, headroom } from '../devices/health.js';
 import { loadDevicesSync } from '../devices/registry.js';
 import { buildSshInvocation, writeAskpassShim } from '../devices/connect.js';
-import { buildReadyProbeCommand, parseReadyProbe, viewAgentSignedIn, viewHasAgent, } from '../hosts/ready.js';
-import { localMachineId } from '../session/origin-machine.js';
+import { buildReadyProbeCommand, parseReadyProbe, viewAgentAccountEligibility, viewHasAgent, } from '../hosts/ready.js';
+import { collectRunCandidates, isSignInRecoverable, readinessFromCandidate, } from '../accounting/rotate.js';
+import { localMachineId } from '../origin-machine.js';
 import { normalizeHost } from '../machine-id.js';
-import { checkCliAvailable, checkCliSignedIn } from './agents.js';
+import { checkCliAvailable } from './agents.js';
 /** Per-remote readiness probe budget — matches the health probe's short window
  * (`agents view` on a warm box is sub-second; a wedged one degrades to unknown). */
 export const READY_PROBE_TIMEOUT_MS = 8_000;
@@ -61,19 +62,22 @@ function probeRemoteReadiness(device, agent) {
         ({ args, env } = buildSshInvocation(device, [cmd], shim, {}, { agentOnly: true }));
     }
     catch {
-        return Promise.resolve({ installed: undefined, signedIn: undefined });
+        return Promise.resolve({ installed: undefined, signedIn: undefined, pickerEligible: undefined });
     }
     return new Promise((resolve) => {
         execFile('ssh', args, { encoding: 'utf-8', env: { ...process.env, ...env }, timeout: READY_PROBE_TIMEOUT_MS }, (err, stdout) => {
             if (err || !stdout)
-                return resolve({ installed: undefined, signedIn: undefined });
+                return resolve({ installed: undefined, signedIn: undefined, pickerEligible: undefined });
             const probe = parseReadyProbe(stdout);
             if (!probe.reachable)
-                return resolve({ installed: undefined, signedIn: undefined });
+                return resolve({ installed: undefined, signedIn: undefined, pickerEligible: undefined });
             if (!probe.version)
-                return resolve({ installed: false, signedIn: false });
+                return resolve({ installed: false, signedIn: false, pickerEligible: false });
             const installed = viewHasAgent(probe.view, agent);
-            resolve({ installed, signedIn: installed ? viewAgentSignedIn(probe.view, agent) : false });
+            const eligibility = installed
+                ? viewAgentAccountEligibility(probe.view, agent)
+                : { signedIn: false, pickerEligible: false };
+            resolve({ installed, ...eligibility });
         });
     });
 }
@@ -108,8 +112,18 @@ export async function probePoolSignals(pool, agent, opts = {}) {
             const isSelf = normalizeHost(d.name) === self;
             if (isSelf) {
                 const inst = checkCliAvailable(agent)[0];
-                const signedIn = inst ? await checkCliSignedIn(agent) : undefined;
-                return [d.name, { installed: inst, signedIn }];
+                if (!inst)
+                    return [d.name, { installed: false, signedIn: false, pickerEligible: false }];
+                const candidates = await collectRunCandidates(agent).catch(() => null);
+                if (!candidates) {
+                    return [d.name, { installed: true, signedIn: undefined, pickerEligible: undefined }];
+                }
+                const readiness = candidates.map(readinessFromCandidate);
+                return [d.name, {
+                        installed: true,
+                        signedIn: readiness.some((candidate) => candidate.ready),
+                        pickerEligible: readiness.some((candidate) => candidate.ready || isSignInRecoverable(candidate)),
+                    }];
             }
             return [d.name, await probeRemoteReadiness(d, agent)];
         }))
@@ -128,6 +142,7 @@ export async function probePoolSignals(pool, agent, opts = {}) {
             memPercent: s?.memPercent,
             installed: inst?.installed,
             signedIn: inst?.signedIn,
+            pickerEligible: inst?.pickerEligible,
         });
     }
     cache.set(key, { at: now, signals });

package/dist/lib/teams/scheduler.d.ts

@@ -18,8 +18,10 @@ export interface DevicePlacementSignal {
     memPercent?: number;
     /** Requested agent installed on the device. `false` → excluded (can't run). */
     installed?: boolean;
-    /** Requested agent signed in (best-effort). Ranks a signed-in device first. */
+    /** Requested agent has at least one launch-ready account. Ranks a ready device first. */
     signedIn?: boolean;
+    /** Requested agent has at least one row the interactive account picker can launch. */
+    pickerEligible?: boolean;
 }
 /** Team fields the placement cascade reads (a subset of TeamMeta). */
 export interface PlacementTeam {

package/dist/lib/teams/scheduler.js

@@ -34,7 +34,7 @@
  * resolves to a null placement so the existing local spawn path runs unchanged,
  * letting the local machine participate in a pool as just another member.
  */
-import { machineId } from '../session/sync/config.js';
+import { machineId } from '../machine-id.js';
 /**
  * No device in the pool can host the teammate. Carries the per-device reasons so
  * the caller can print exactly why the pool is unusable instead of silently

package/dist/lib/text/relative-time.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Human-readable "time since" formatting for session timestamps. Lives here (not
+ * inline in `sessions.ts`) so both the session list renderer and the remote
+ * offline-cache banner (`remote.ts`) share one formatter — `sessions.ts` imports
+ * `remote.ts`, so a back-import would cycle.
+ */
+export declare function formatRelativeTime(isoTimestamp: string): string;
+/**
+ * Compact age — `now`, `45m`, `3h`, `2d`, then the calendar date. This is the
+ * *creation* half of a session's time cell: it renders right next to the long
+ * last-activity label, and one row can afford one long form, not two.
+ */
+export declare function formatCompactAge(isoTimestamp: string): string;
+/** The two time fields a session listing shows for one row. */
+export interface SessionAgeParts {
+    /**
+     * Compact age of the session's creation, set only when the session ran long
+     * enough (>= a minute) for it to say something `last` does not.
+     */
+    created?: string;
+    /** Last-activity label — the long relative form the listing sorts by. */
+    last: string;
+}
+/**
+ * Split a session's timestamps into the two fields a listing renders: when it
+ * was created and when it was last active. One last-activity label answers
+ * neither "is this the old session I'm looking for" nor "how long did it run" —
+ * a session touched an hour ago may have started last week.
+ */
+export declare function sessionAgeParts(createdIso: string, lastActivityIso?: string): SessionAgeParts;
+/**
+ * Parse a time filter string (relative like '7d' or an ISO timestamp) into epoch
+ * milliseconds. Backs `--since` on `sessions`, `cost`, `teams`, and `output`, and
+ * `--unused` on `secrets list`.
+ *
+ * It lives here, in a module with no imports, rather than in `discover.ts` where
+ * it started: `discover.ts` loads `../sqlite.js`, so importing this one function
+ * from there pulls `node:sqlite` into the caller's module graph and Node prints
+ * `ExperimentalWarning: SQLite …` on stderr. That is invisible in a command that
+ * already touches the session DB, and a broken contract in one that doesn't —
+ * `monitors --json` asserts a clean stderr. `discover.ts` re-exports it, so
+ * existing importers are unaffected.
+ */
+export declare function parseTimeFilter(input: string): number;