@phnx-labs/agents-cli 1.22.38 → 1.22.39

package/dist/lib/smart-launch.js

@@ -7,7 +7,8 @@
  */
 import { queryAffinityRollup } from './session/db.js';
 import { localMachineId } from './session/origin-machine.js';
-import { loadDevicesSync } from './devices/registry.js';
+import { isControlDevice, loadDevicesSync } from './devices/registry.js';
+import { describeAutoPool, filterAutoPool, isAutoPoolMember } from './devices/pool.js';
 import { normalizeHost } from './machine-id.js';
 import { probePoolSignals } from './teams/placement-probe.js';
 import { pickBestDevice } from './teams/scheduler.js';
@@ -45,7 +46,23 @@ export function sampleWeighted(candidates, rng = Math.random) {
     }
     return candidates[candidates.length - 1].key;
 }
-/** Online device names from the local registry (+ always include local). */
+/**
+ * Online device names from the local registry (+ local), narrowed to the
+ * automatic-placement pool.
+ *
+ * The pool rule lives in `devices/pool.ts` and is an allowlist once any device
+ * is marked `role=worker`: this is the single place both automatic-placement
+ * paths (`resolveDeviceAuto`, `resolveDeviceAffinity`) get their candidates, so
+ * marking workers moves every `--device auto` at once instead of one surface.
+ *
+ * Paired cockpits (`role: control` in the device registry) are dropped here,
+ * where the registry is already being read — they are control surfaces, not
+ * compute. It CAN return an empty list — a fleet where every marked worker is
+ * offline, or where this box is the only candidate and is marked `personal`. That is a
+ * real answer, and both callers fail loud on it rather than falling back to the
+ * local machine (which would be the exact box the operator marked personal to
+ * keep agents off).
+ */
 export function listOnlineDeviceNames(localName = localMachineId()) {
     const names = new Set([normalizeHost(localName)]);
     try {
@@ -57,13 +74,27 @@ export function listOnlineDeviceNames(localName = localMachineId()) {
             // No tailscale snapshot → treat as candidate (registry-only box).
             if (online === false)
                 continue;
+            // A paired cockpit (iPhone/iPad) is a control surface, not compute — it
+            // is never dialed for a session, so it is never a placement candidate.
+            if (isControlDevice(d))
+                continue;
             names.add(normalizeHost(name));
         }
     }
     catch {
         /* registry missing — local only */
     }
-    return [...names];
+    return filterAutoPool([...names]);
+}
+/**
+ * The error both automatic-placement resolvers raise when device roles leave no
+ * candidate at all. Fail loud: the alternative — quietly running on the local
+ * machine — puts the agent on the box the operator marked `personal`.
+ */
+export function formatEmptyAutoPoolError() {
+    const marked = describeAutoPool();
+    return (`agents: no device is eligible for automatic placement${marked ? ` (${marked})` : ''} — ` +
+        'mark one with `agents devices role <name> worker`, or widen the pool with `agents config set auto.pool all`.');
 }
 export function formatNoHealthyDeviceError(pool, signals, agent) {
     const excluded = pool.map((key) => {
@@ -78,7 +109,11 @@ export function formatNoHealthyDeviceError(pool, signals, agent) {
         return `${key} (${reason})`;
     }).join(', ');
     const target = agent ? `can run ${agent}` : "for 'run auto'";
-    return `agents: no healthy device ${target} — excluded: ${excluded}; earliest window resets unknown`;
+    // Name the role narrowing when there is one: a fleet where every box but two
+    // is filtered out by a worker mark reads as "the fleet is down" without it.
+    const marked = describeAutoPool();
+    const poolNote = marked ? ` [pool: ${marked}]` : '';
+    return `agents: no healthy device ${target}${poolNote} — excluded: ${excluded}; earliest window resets unknown`;
 }
 /**
  * Pick the least-loaded healthy device that can run `agent` when the harness is
@@ -90,8 +125,13 @@ export function formatNoHealthyDeviceError(pool, signals, agent) {
 export async function resolveDeviceAuto(agent, opts = {}) {
     const local = normalizeHost(opts.localMachine ?? localMachineId());
     const pool = [...new Set((opts.eligibleHosts ?? listOnlineDeviceNames(local)).map(normalizeHost))];
-    if (!pool.includes(local))
+    // The local machine participates in the same probe as every peer — unless a
+    // role excludes it. Adding it unconditionally would put agents back on the box
+    // the operator marked `personal` precisely to keep them off it.
+    if (!pool.includes(local) && isAutoPoolMember(local))
         pool.push(local);
+    if (pool.length === 0)
+        throw new Error(formatEmptyAutoPoolError());
     const signals = await (opts.probe ?? probePoolSignals)(pool, agent);
     if (!agent && !opts.probe) {
         const { collectFleetHarnesses } = await import('../commands/ssh.js');
@@ -135,6 +175,12 @@ export async function resolveDeviceAuto(agent, opts = {}) {
 }
 /**
  * Resolve host for `--device auto`. Does NOT pick harness or accounts.
+ *
+ * Draws from the same automatic-placement pool as {@link resolveDeviceAuto}, so
+ * `agents ssh auto`, the generic `--host auto` passthrough, and `matchHost`'s
+ * `auto` sentinel honour device roles too. Throws when roles leave the pool
+ * empty — a `null` host here means "run locally", which for a box marked
+ * `personal` is the outcome the mark exists to prevent.
  */
 export function resolveDeviceAffinity(opts = {}) {
     const local = normalizeHost(opts.localMachine ?? localMachineId());
@@ -142,9 +188,18 @@ export function resolveDeviceAffinity(opts = {}) {
     const rng = opts.rng ?? Math.random;
     const sinceDays = opts.sinceDays ?? 14;
     const sinceMs = Date.now() - sinceDays * 24 * 60 * 60 * 1000;
+    // `listOnlineDeviceNames` always contained the local machine before device
+    // roles existed, so an empty default list can only mean roles excluded
+    // everything — fail loud, exactly as resolveDeviceAuto does. An explicitly
+    // empty `eligibleHosts` is the caller's own list and keeps the historical
+    // degrade-to-local behavior.
+    const usingDefaultPool = opts.eligibleHosts === undefined;
     const eligible = new Set((opts.eligibleHosts ?? listOnlineDeviceNames(local)).map(normalizeHost));
-    if (eligible.size === 0)
+    if (eligible.size === 0) {
+        if (usingDefaultPool)
+            throw new Error(formatEmptyAutoPoolError());
         eligible.add(local);
+    }
     const deviceRows = opts.deviceAffinity ??
         queryAffinityRollup({
             groupBy: 'machine',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phnx-labs/agents-cli",
-  "version": "1.22.38",
+  "version": "1.22.39",
   "description": "One CLI for all your AI coding agents - versions, config, cloud dispatch, sessions, and teams (now with first-class Grok Build CLI support)",
   "type": "module",
   "main": "dist/index.js",