@phnx-labs/agents-cli 1.22.42 → 1.22.44

package/dist/lib/menubar/install-menubar.js

@@ -24,7 +24,7 @@ import { getRuntimeStateDir, getHelpersDir } from '../state.js';
 import { getCliVersion, resolveAgentsBin, resolveInstalledLayout } from '../version.js';
 import { copyAppBundle, withInstallLock } from '../app-bundle-install.js';
 import { compareVersions } from '../agent-spec/primitives.js';
-import { namespacedServiceLabel, serviceManifestHomeEnv } from '../service-manifest.js';
+import { namespacedServiceLabel, serviceManifestHomeEnv, serviceManagerRegistrationAllowed } from '../service-manifest.js';
 const APP_BUNDLE_NAME = 'MenubarHelper.app';
 const INSTALL_DIR_NAME = 'agents-cli';
 const SERVICE_LABEL_BASE = 'com.phnx-labs.agents-menubar';
@@ -333,6 +333,11 @@ ${envXml}
  * is the only sequence that reliably re-attaches the status item.
  */
 export function restartMenubarLaunchAgent(uid, plist, exec = execFileSync) {
+    const reg = serviceManagerRegistrationAllowed();
+    if (!reg.allowed) {
+        process.stderr.write(`[agents] ${reg.reason}\n`);
+        return;
+    }
     const serviceTarget = `gui/${uid}/${serviceLabel()}`;
     const opts = { stdio: ['ignore', 'ignore', 'ignore'] };
     try {
@@ -348,6 +353,45 @@ export function restartMenubarLaunchAgent(uid, plist, exec = execFileSync) {
     }
     catch { /* best effort */ }
 }
+/**
+ * Force a running helper off the binary that was just swapped underneath it.
+ *
+ * `installMenubarLaunchAgentOnUpgrade()` calls this after a heal actually
+ * replaces the on-disk bundle (a version bump or the ad-hoc -> Developer ID
+ * transition — see `menubarHealReplacedBundle`). `restartMenubarLaunchAgent`
+ * (run moments earlier via `installAndStartService`) already attempts
+ * bootout+bootstrap+kickstart, but that targets the GUI launchd domain and
+ * fails silently — `launchctl kickstart -k gui/<uid>/<label>` prints "Could not
+ * find service ... in domain for user gui" — from a shell with no Aqua session,
+ * which is the ordinary case for `agents` invoked from a terminal/tmux/ssh
+ * session rather than literally the login item (verified live). When that
+ * happens the plist and on-disk bundle are current but the LIVE process is
+ * still the old binary, so it requests Accessibility under the OLD code
+ * identity and the grant never sticks.
+ *
+ * `kickstart -k` (force-restart, unlike the bare kickstart already tried) is
+ * attempted first since it is the clean launchd-native path when it works. If
+ * launchd has no record of the service in this context either, fall back to
+ * ending the specific pid(s) already confirmed to be running the installed
+ * bundle (`ownProcesses`, resolved by the caller via `liveMenubarProcesses`) —
+ * never a broad pkill. The launchd plist has `KeepAlive=true`, so the ended
+ * process is relaunched from the swapped binary within seconds.
+ */
+export function restartMenubarHelperAfterSwap(uid, ownProcesses, exec = execFileSync, kill = endProcess) {
+    const reg = serviceManagerRegistrationAllowed();
+    if (!reg.allowed)
+        return;
+    const target = `gui/${uid}/${serviceLabel()}`;
+    const opts = { stdio: ['ignore', 'ignore', 'ignore'] };
+    try {
+        exec('launchctl', ['kickstart', '-k', target], opts);
+        return;
+    }
+    catch {
+        for (const p of ownProcesses)
+            kill(p.pid);
+    }
+}
 /**
  * Install + start the menu-bar helper as a launchd user service (idempotent).
  * Clears the sticky opt-out, installs the .app, writes the plist, and
@@ -420,6 +464,22 @@ function menubarSetupStale() {
         execExists: fs.existsSync(installedExecutablePath()),
     });
 }
+/**
+ * Pure decision (no I/O): did THIS heal actually replace bundle content a live
+ * process could be running stale, as opposed to a plist-only repoint?
+ *
+ * `stale` (version bump or missing exec) and `needsDevIdHeal` (ad-hoc ->
+ * Developer ID) both mean the shipped `.app` differs from what is already
+ * installed — the exact condition under which a running helper can be left on
+ * an old code identity after `enableMenubarService` swaps the bundle. A
+ * repoint-only heal (`menubarSetupNeedsRepoint()` alone, same version, same
+ * signing identity) does NOT count: RUSH-3005 already owns the churn from
+ * mixed-Node-interpreter repoints, and restarting the helper on every one of
+ * those would double that churn rather than fix this bug.
+ */
+export function menubarHealReplacedBundle(opts) {
+    return opts.stale || opts.needsDevIdHeal;
+}
 /**
  * Pure re-point decision (no I/O): the plist's baked interpreter/entry no longer
  * match the install that is now running `agents`. This catches DUAL-INSTALL skew
@@ -435,7 +495,12 @@ export function menubarPlistNeedsRepoint(opts) {
         return false; // can't resolve the running install — don't churn
     if (opts.plistEntry !== opts.activeEntry)
         return true;
-    if (opts.activeNode && opts.plistNode !== opts.activeNode)
+    // The entry path owns the helper. The same installed CLI may be invoked through
+    // several compatible Node interpreters (nvm, Homebrew, a parent process's
+    // process.execPath). Re-pointing merely because those valid interpreter paths
+    // differ makes every invocation replace and relaunch the shared helper. Keep the
+    // recorded interpreter until it disappears; then repoint to the active one.
+    if (opts.activeNode && (!opts.plistNode || !opts.plistNodeExists))
         return true;
     return false;
 }
@@ -452,9 +517,11 @@ function readPlistEnvValue(key) {
 }
 /** True when the installed plist points at a different install than the active one. */
 function menubarSetupNeedsRepoint() {
+    const plistNode = readPlistEnvValue('AGENTS_NODE');
     return menubarPlistNeedsRepoint({
         plistEntry: readPlistEnvValue('AGENTS_ENTRY'),
-        plistNode: readPlistEnvValue('AGENTS_NODE'),
+        plistNode,
+        plistNodeExists: Boolean(plistNode) && fs.existsSync(plistNode),
         activeEntry: resolveCliEntry(),
         activeNode: process.execPath,
     });
@@ -467,15 +534,21 @@ export function disableMenubarService() {
     if (!onDarwin())
         return;
     const plist = servicePlistPath();
-    const uid = process.getuid?.() ?? 0;
-    try {
-        execFileSync('launchctl', ['bootout', `gui/${uid}/${serviceLabel()}`], { stdio: ['ignore', 'ignore', 'ignore'] });
-    }
-    catch {
+    const reg = serviceManagerRegistrationAllowed();
+    if (reg.allowed) {
+        const uid = process.getuid?.() ?? 0;
         try {
-            execFileSync('launchctl', ['unload', '-w', plist], { stdio: ['ignore', 'ignore', 'ignore'] });
+            execFileSync('launchctl', ['bootout', `gui/${uid}/${serviceLabel()}`], { stdio: ['ignore', 'ignore', 'ignore'] });
+        }
+        catch {
+            try {
+                execFileSync('launchctl', ['unload', '-w', plist], { stdio: ['ignore', 'ignore', 'ignore'] });
+            }
+            catch { /* not loaded */ }
         }
-        catch { /* not loaded */ }
+    }
+    else {
+        process.stderr.write(`[agents] ${reg.reason}\n`);
     }
     try {
         fs.unlinkSync(plist);
@@ -639,7 +712,8 @@ export function installMenubarLaunchAgentOnUpgrade() {
         // installed copy is still ad-hoc while the shipped source is Developer ID
         // (older heal path; Accessibility re-prompts until the identity is restored).
         const needsDevIdHeal = installedNeedsDevIdHeal();
-        if (!(menubarSetupStale() || menubarSetupNeedsRepoint() || needsDevIdHeal))
+        const stale = menubarSetupStale();
+        if (!(stale || menubarSetupNeedsRepoint() || needsDevIdHeal))
             return;
         // ...but a copy that does not own the helper only gets to act on that drift
         // once per cooldown. Without the gate every coexisting install recopies the
@@ -650,8 +724,22 @@ export function installMenubarLaunchAgentOnUpgrade() {
         // false without installing when the bundle fails the Gatekeeper check, and
         // stamping first would spend the shared cooldown on a no-op — locking every
         // non-owner out for another hour while nothing had been fixed.
-        if (enableMenubarService({ clearOptOut: false }))
+        if (enableMenubarService({ clearOptOut: false })) {
             stampMenubarHeal();
+            // One-time: the ad-hoc -> Developer ID transition leaves a dead TCC row
+            // under the old identity (tccutil on zion reset it 11 times across
+            // machines that made this jump) — clear it so the fresh grant sticks.
+            if (shouldMigrateMenubarTcc({ needsDevIdHeal, alreadyMigrated: menubarTccAlreadyMigrated() })) {
+                resetMenubarAccessibilityTcc();
+            }
+            // Only a REAL content swap (version bump or the Dev-ID transition) can
+            // leave a running process on stale code — a plist-only repoint (handled
+            // above by menubarSetupNeedsRepoint alone) is RUSH-3005's churn to own,
+            // not this heal's to restart on top of.
+            if (menubarHealReplacedBundle({ stale, needsDevIdHeal })) {
+                restartMenubarHelperAfterSwap(process.getuid?.() ?? 0, liveMenubarProcesses().own);
+            }
+        }
     }
     catch {
         /* never block startup on the menu bar */
@@ -666,6 +754,46 @@ function installedNeedsDevIdHeal() {
         return false;
     return hasDeveloperIdSignature(src);
 }
+/** Marker written once the one-time ad-hoc -> Developer ID TCC migration has
+ *  run on this machine, next to the version/heal stamps. */
+function tccMigrationMarkerPath() {
+    return path.join(installDir(), '.menubar-tcc-migrated');
+}
+function menubarTccAlreadyMigrated() {
+    return fs.existsSync(tccMigrationMarkerPath());
+}
+/**
+ * Pure decision (no I/O): run the one-time `tccutil reset Accessibility` only
+ * on a real ad-hoc -> Developer ID transition, and only once ever. A machine
+ * that was always Developer ID never accumulated a dead TCC row under an
+ * ad-hoc identity, so resetting there would just force a needless re-prompt;
+ * a machine that already migrated must not be reset again on every heal.
+ */
+export function shouldMigrateMenubarTcc(opts) {
+    return opts.needsDevIdHeal && !opts.alreadyMigrated;
+}
+/**
+ * Reset the stale Accessibility grant TCC recorded against the pre-migration
+ * ad-hoc identity, then stamp the marker so this never runs again on this
+ * machine. Targets `SERVICE_LABEL_BASE` — the bundle's actual
+ * `CFBundleIdentifier`/codesign `--identifier` (menubar/scripts/build.sh) that
+ * TCC keys grants to — not the namespaced `serviceLabel()`, which exists only
+ * to keep launchd job labels apart under a redirected HOME (RUSH-2639) and is
+ * never the app's real identity. Best-effort: a missing/failing `tccutil`
+ * (older macOS, a sandboxed test HOME) must never block the heal that just
+ * fixed the signing identity itself.
+ */
+export function resetMenubarAccessibilityTcc(exec = execFileSync) {
+    try {
+        exec('tccutil', ['reset', 'Accessibility', SERVICE_LABEL_BASE], { stdio: ['ignore', 'ignore', 'ignore'] });
+    }
+    catch { /* best effort — a missing/failing tccutil must not block the heal */ }
+    try {
+        fs.mkdirSync(installDir(), { recursive: true });
+        fs.writeFileSync(tccMigrationMarkerPath(), new Date().toISOString());
+    }
+    catch { /* best effort */ }
+}
 /**
  * Decide which live helper processes must be ended so exactly one status item
  * survives. Pure so the choice is unit-testable without a live menu bar.
@@ -856,3 +984,81 @@ export function getMenubarStatus() {
         disabledByUser: menubarDisabledByUser(),
     };
 }
+/**
+ * Pure comparison (no I/O) behind the stale-process check: a helper pid that
+ * started before the bundle on disk was last written is still running the
+ * PREVIOUS binary — the exact condition `restartMenubarHelperAfterSwap` exists
+ * to fix. Millisecond epoch timestamps in, so the truth table is unit-testable
+ * without a live process or filesystem.
+ */
+export function isMenubarProcessStaleAgainstBundle(pidStartedAtMs, bundleMtimeMs) {
+    return pidStartedAtMs < bundleMtimeMs;
+}
+/** Wall-clock start time of a live pid via `ps`, or null if it can't be read. */
+function pidStartTimeMs(pid) {
+    const r = spawnSync('ps', ['-o', 'lstart=', '-p', String(pid)], {
+        stdio: ['ignore', 'pipe', 'ignore'],
+        encoding: 'utf-8',
+    });
+    if (r.status !== 0)
+        return null;
+    const raw = (r.stdout || '').trim();
+    if (!raw)
+        return null;
+    const t = new Date(raw).getTime();
+    return Number.isNaN(t) ? null : t;
+}
+/**
+ * `agents menubar doctor` — everything a human needs to tell "why did
+ * Accessibility ask again" apart from "the helper is genuinely broken":
+ * install path, version skew, whether the signing identity is update-stable,
+ * and whether a live process predates the bundle it's supposed to be running.
+ * Read-only: no install, no restart, no TCC reset — `agents menubar setup`
+ * remains the command that fixes what this reports.
+ */
+export function buildMenubarDoctorReport() {
+    if (!onDarwin()) {
+        return {
+            platform: process.platform,
+            installPath: null,
+            installedVersion: null,
+            currentVersion: getCliVersion(),
+            versionMatches: false,
+            signingIdentity: 'unknown',
+            running: false,
+            staleRunningProcess: [],
+            accessibilityHintNeeded: false,
+        };
+    }
+    const status = getMenubarStatus();
+    const appPath = status.installedApp;
+    const signingIdentity = appPath
+        ? (hasDeveloperIdSignature(appPath) ? 'developer-id' : 'ad-hoc')
+        : 'unknown';
+    let staleRunningProcess = [];
+    if (appPath && status.instances.length > 0) {
+        try {
+            const bundleMtimeMs = fs.statSync(installedExecutablePath()).mtimeMs;
+            staleRunningProcess = status.instances
+                .map((p) => {
+                const startedAt = pidStartTimeMs(p.pid);
+                return startedAt === null
+                    ? null
+                    : { pid: p.pid, stale: isMenubarProcessStaleAgainstBundle(startedAt, bundleMtimeMs) };
+            })
+                .filter((p) => p !== null);
+        }
+        catch { /* exec vanished mid-check — report no staleness rather than throw */ }
+    }
+    return {
+        platform: process.platform,
+        installPath: appPath,
+        installedVersion: status.installedVersion,
+        currentVersion: status.currentVersion,
+        versionMatches: status.installedVersion === status.currentVersion,
+        signingIdentity,
+        running: status.running,
+        staleRunningProcess,
+        accessibilityHintNeeded: signingIdentity === 'ad-hoc' || staleRunningProcess.some((p) => p.stale),
+    };
+}

package/dist/lib/monitors/config.d.ts

@@ -68,8 +68,8 @@ export type MonitorActionType = 'run' | 'routine' | 'notify' | 'webhook-out';
  */
 export interface ActionConfig {
     type: MonitorActionType;
-    /** run: which agent to spawn. */
-    agent?: AgentId;
+    /** run: which agent to spawn — a native harness id or a custom harness name (agents harness list). */
+    agent?: AgentId | (string & {});
     /** run: the prompt; `{event}` is replaced with the fired event summary. */
     prompt?: string;
     /** run: execution mode (shared with routines). */

package/dist/lib/monitors/config.js

@@ -17,6 +17,7 @@ import { safeJoin, isSafeSegmentName } from '../paths.js';
 import { atomicWriteFileSync } from '../fs-atomic.js';
 import { machineId, normalizeHost } from '../machine-id.js';
 import { ALL_AGENT_IDS } from '../agents.js';
+import { isCustomHarnessName } from '../profiles.js';
 /** Default values applied to every monitor config when fields are omitted. */
 const MONITOR_DEFAULTS = {
     enabled: true,
@@ -215,8 +216,8 @@ export function validateMonitor(config) {
             errors.push(`action has conflicting fields (${populatedAct.join(', ')}); specify exactly one action`);
         }
         if (action.type === 'run') {
-            if (action.agent && !ALL_AGENT_IDS.includes(action.agent)) {
-                errors.push(`action.agent must be one of: ${ALL_AGENT_IDS.join(', ')}`);
+            if (action.agent && !ALL_AGENT_IDS.includes(action.agent) && !isCustomHarnessName(action.agent)) {
+                errors.push(`action.agent must be one of: ${ALL_AGENT_IDS.join(', ')}, or a custom harness (agents harness list)`);
             }
             if (!action.prompt || typeof action.prompt !== 'string') {
                 errors.push("action.type 'run' requires action.prompt");

package/dist/lib/origin-machine.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Resolve which machine a session transcript originated on.
+ *
+ * Cross-machine sync mirrors a remote transcript to
+ * `backups/<agent>/<machine>/<subdir>/…`. Every other transcript is a live-home
+ * file on this box, so the origin is the local machine id.
+ *
+ * Kept in a leaf module (no session/db imports) so both discovery and the
+ * sessions DB upsert path can stamp `machine` without circular deps.
+ */
+/** Local machine id, cached for the process lifetime. */
+export declare function localMachineId(): string;
+/**
+ * The machine a discovered session originated on.
+ * When the path sits under the agent's backups root, the first segment below it
+ * is the origin machine id; otherwise it's the local machine.
+ */
+export declare function machineForSessionFile(filePath: string, agent: string): string;

package/dist/lib/origin-machine.js

@@ -0,0 +1,34 @@
+/**
+ * Resolve which machine a session transcript originated on.
+ *
+ * Cross-machine sync mirrors a remote transcript to
+ * `backups/<agent>/<machine>/<subdir>/…`. Every other transcript is a live-home
+ * file on this box, so the origin is the local machine id.
+ *
+ * Kept in a leaf module (no session/db imports) so both discovery and the
+ * sessions DB upsert path can stamp `machine` without circular deps.
+ */
+import * as path from 'path';
+import { getHistoryDir } from './state.js';
+import { machineId } from './machine-id.js';
+let _localMachineId;
+/** Local machine id, cached for the process lifetime. */
+export function localMachineId() {
+    return (_localMachineId ??= machineId());
+}
+/**
+ * The machine a discovered session originated on.
+ * When the path sits under the agent's backups root, the first segment below it
+ * is the origin machine id; otherwise it's the local machine.
+ */
+export function machineForSessionFile(filePath, agent) {
+    if (!filePath)
+        return localMachineId();
+    const base = path.join(getHistoryDir(), 'backups', agent) + path.sep;
+    if (filePath.startsWith(base)) {
+        const seg = filePath.slice(base.length).split(path.sep)[0];
+        if (seg)
+            return seg;
+    }
+    return localMachineId();
+}

package/dist/lib/perf/db.js

@@ -8,7 +8,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 import Database from '../sqlite.js';
 import { getPerfDbPath, getPerfDir } from '../state.js';
-import { localMachineId } from '../session/origin-machine.js';
+import { localMachineId } from '../origin-machine.js';
 import { resolveProjectKey } from '../project-key.js';
 import { percentile } from '../percentile.js';
 import { resolveSpoolPath, shortSessionId, _resetPerfSpoolForTest } from './spool.js';

package/dist/lib/perf/spool.js

@@ -9,7 +9,7 @@ import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
 import { getPerfSpoolPath } from '../state.js';
-import { localMachineId } from '../session/origin-machine.js';
+import { localMachineId } from '../origin-machine.js';
 let _spoolOverride = null;
 let _disabled = false;
 /** Test seam — pair with db._resetPerfDbForTest. */

package/dist/lib/prix-account.d.ts

@@ -1,6 +1,7 @@
 /**
  * Client for the Rush account layer (`api.prix.dev`) — backs `agents auth` and
- * `agents org`. `agents org` maps to `/api/v1/spaces`, not `/api/v1/orgs`: spaces
+ * `agents auth space` (canonical) / `agents org` (deprecated alias). `agents auth space`
+ * maps to `/api/v1/spaces`, not `/api/v1/orgs`: spaces
  * already carry the free-tier caps (1 owned space, 3 members) and can exist
  * standalone with no parent organization, matching a "just want a team" CLI flow
  * better than the heavier enterprise-tenancy `orgs` routes (domain, SSO). See

package/dist/lib/prix-account.js

@@ -1,6 +1,7 @@
 /**
  * Client for the Rush account layer (`api.prix.dev`) — backs `agents auth` and
- * `agents org`. `agents org` maps to `/api/v1/spaces`, not `/api/v1/orgs`: spaces
+ * `agents auth space` (canonical) / `agents org` (deprecated alias). `agents auth space`
+ * maps to `/api/v1/spaces`, not `/api/v1/orgs`: spaces
  * already carry the free-tier caps (1 owned space, 3 members) and can exist
  * standalone with no parent organization, matching a "just want a team" CLI flow
  * better than the heavier enterprise-tenancy `orgs` routes (domain, SSO). See

package/dist/lib/profiles.d.ts

@@ -96,6 +96,13 @@ export declare function getProfilePath(name: string): string;
 export declare function validateProfileName(name: string): void;
 /** Check whether a profile YAML file exists on disk. */
 export declare function profileExists(name: string): boolean;
+/**
+ * True when `name` is a custom harness (a profile that is not shadowing a
+ * native agent id) — the predicate routines/monitors use to accept an
+ * `agent:` value that `agents run` will resolve as a profile. A native id
+ * always reads as native, matching exec's resolution order.
+ */
+export declare function isCustomHarnessName(name: string): boolean;
 /** Read and parse a profile from disk. Throws if not found or malformed. */
 export declare function readProfile(name: string): Profile;
 /** Write a profile to disk atomically (write-to-tmp then rename). */

package/dist/lib/profiles.js

@@ -9,6 +9,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 import * as crypto from 'node:crypto';
 import * as yaml from 'yaml';
+import { ALL_AGENT_IDS } from './agents.js';
 import { getUserAgentsDir } from './state.js';
 import { deleteKeychainToken, getKeychainToken, hasKeychainToken, keychainItemName } from './secrets/profiles.js';
 import { getPreset } from './profiles-presets.js';
@@ -39,6 +40,17 @@ export function validateProfileName(name) {
 export function profileExists(name) {
     return fs.existsSync(profilePath(name));
 }
+/**
+ * True when `name` is a custom harness (a profile that is not shadowing a
+ * native agent id) — the predicate routines/monitors use to accept an
+ * `agent:` value that `agents run` will resolve as a profile. A native id
+ * always reads as native, matching exec's resolution order.
+ */
+export function isCustomHarnessName(name) {
+    if (!PROFILE_NAME_PATTERN.test(name))
+        return false;
+    return !ALL_AGENT_IDS.includes(name) && profileExists(name);
+}
 /** Read and parse a profile from disk. Throws if not found or malformed. */
 export function readProfile(name) {
     validateProfileName(name);
@@ -77,7 +89,11 @@ function migrateLegacyProfileAuth(profile, file) {
     }
     const migratedAccount = findAccount(accountName);
     const oldItem = profile.auth.keychainItem;
-    profile.account = migratedAccount.id;
+    // Reference by NAME, not id: profiles sync fleet-wide with `agents repo push`
+    // while account ids are minted per-device, so an id ref breaks on every other
+    // machine ("Unknown account '<uuid>'"). Names are the portable handle — the
+    // registry resolves both, and `accounts rename` already rewrites name refs.
+    profile.account = migratedAccount.name;
     profile.provider = provider;
     delete profile.auth;
     delete profile.authOptional;
@@ -477,6 +493,15 @@ export function renameProfile(oldName, newName) {
 export function resolveProfileEnv(profile) {
     const env = { ...profile.env };
     if (profile.account) {
+        if (!findAccount(profile.account)) {
+            // The commonest cause: the profile synced here via `agents repo push/pull`
+            // but its account ref was minted on another device (legacy id refs), so
+            // the bare "Unknown account" from the registry gives the user nothing to
+            // act on. Name the harness and the repair.
+            throw new Error(`Harness '${profile.name}' references account '${profile.account}', which does not exist on this device. ` +
+                `Accounts are per-machine; pick one from 'agents accounts list' and repoint with ` +
+                `'agents harness edit ${profile.name} --account <name>', or add it with 'agents accounts add'.`);
+        }
         const account = resolveCredentialAccount(profile.account, profile.host.agent, profile.provider);
         Object.assign(env, account.env);
     }

package/dist/lib/remote-agents-json.js

@@ -12,7 +12,7 @@ import chalk from 'chalk';
 import { SSH_OPTS, controlOpts, assertValidSshTarget, shellQuote, REMOTE_STDOUT_MAX_BYTES, RemoteUtf8Accumulator, } from './ssh-exec.js';
 import { deviceIdentityArgs, sshTargetFor } from './devices/connect.js';
 import { resolveExplicitTargets } from './devices/resolve-target.js';
-import { loadDevices, isControlDevice, isDialableDevice } from './devices/registry.js';
+import { loadDevices, isDialableDevice } from './devices/registry.js';
 import { remoteShellFor, buildWindowsAgentsCommand, stripClixml } from './hosts/remote-cmd.js';
 import { machineId, normalizeHost } from './machine-id.js';
 const REMOTE_TIMEOUT_MS = 12_000;
@@ -117,12 +117,6 @@ export async function gatherRemoteAgentsJson(options, deps = {}) {
                 continue;
             if (normalizeHost(device.name) === self)
                 continue;
-            // Control-only devices (a phone/tablet cockpit) drive the fleet but never
-            // run agents — never dial them, whatever their platform reads as. Keyed on
-            // role, not platform, so this holds even for a control device that carries
-            // a real OS value (mirrors the skip in session/remote-list.ts).
-            if (isControlDevice(device))
-                continue;
             if (!['windows', 'linux', 'macos'].includes(device.platform))
                 continue;
             try {

package/dist/lib/routines-placement.d.ts

@@ -29,7 +29,7 @@ export type PlacementTarget = {
  * `config.devices` is the *firing* allowlist only (which daemon may fire the
  * job). It is intentionally NOT used as an execution pool filter — otherwise
  * the double-fire pin (`devices: [self]`) would collapse fleet placement to
- * always-local. Control / offline / no-address devices are never chosen.
+ * always-local. Offline / no-address devices are never chosen.
  */
 export declare function pickFleetDevice(_config?: Pick<JobConfig, 'devices'>, platform?: DevicePlatform): string | null;
 /**

package/dist/lib/routines-placement.js

@@ -23,7 +23,7 @@ import { planFleetTargets } from './devices/fleet.js';
  * `config.devices` is the *firing* allowlist only (which daemon may fire the
  * job). It is intentionally NOT used as an execution pool filter — otherwise
  * the double-fire pin (`devices: [self]`) would collapse fleet placement to
- * always-local. Control / offline / no-address devices are never chosen.
+ * always-local. Offline / no-address devices are never chosen.
  */
 export function pickFleetDevice(_config, platform) {
     let reg;

package/dist/lib/sandbox.d.ts

@@ -7,6 +7,14 @@
  * access to explicitly allowed paths.
  */
 import type { JobConfig } from './scheduling/routines.js';
+/**
+ * Absolute path to this host's `gh` config directory (`hosts.yml` + `config.yml`),
+ * or null when the host has never run `gh auth login`. Prefer `GH_CONFIG_DIR` when
+ * the parent already pinned one; otherwise `$XDG_CONFIG_HOME/gh` or `~/.config/gh`.
+ */
+export declare function resolveHostGhConfigDir(): string | null;
+/** True when this host holds usable GitHub CLI auth (hosts.yml or a token env). */
+export declare function hostHasGhAuth(): boolean;
 /** Build a restricted environment for a sandboxed process, setting HOME to the overlay. */
 export declare function buildSpawnEnv(overlayHome: string, extraEnv?: Record<string, string>): Record<string, string>;
 /**
@@ -21,6 +29,22 @@ export declare function buildSpawnEnv(overlayHome: string, extraEnv?: Record<str
 export declare function getJobHomePath(name: string): string;
 /** Create a fresh overlay HOME for a job, including agent config and allowed-dir symlinks. */
 export declare function prepareJobHome(config: JobConfig): string;
+/**
+ * Link this host's `gh` config directory into the disposable overlay so
+ * `$HOME/.config/gh` resolves even when `GH_CONFIG_DIR` is unset. Mirrors
+ * `generateCursorConfig`: same-host credentials, never copied to another box.
+ */
+export declare function linkHostGhConfig(overlayHome: string): void;
+/**
+ * Refuse to launch a sandboxed child when THIS host holds GitHub auth but the
+ * spawn env would hide it. The RUSH-2860 failure mode was silent: the monitor
+ * fire recorded `ok` (spawn succeeded) while every `gh` call inside the child
+ * failed. Prefer forwarding (buildSpawnEnv / linkHostGhConfig); this assert is
+ * the regression tripwire — if forwarding ever regresses, fail loud at spawn
+ * instead of recording a hollow success. No-ops when the host has no gh auth
+ * (jobs that do not need GitHub still run).
+ */
+export declare function assertSandboxForwardsHostGhAuth(spawnEnv: Record<string, string>): void;
 /** Link this host's Cursor login and CLI config into the disposable overlay. */
 export declare function generateCursorConfig(overlayHome: string): void;
 /** Remove a job's overlay HOME directory entirely. */