@phnx-labs/agents-cli 1.22.25 → 1.22.27

package/dist/commands/apply.js

@@ -15,6 +15,7 @@ import chalk from 'chalk';
 import { setHelpSections } from '../lib/help.js';
 import { machineId } from '../lib/session/sync/config.js';
 import { loadDevices, isControlDevice } from '../lib/devices/registry.js';
+import { isHostPinned, managedKnownHostsPath } from '../lib/devices/known-hosts.js';
 import { ensureDevicesRegistered } from '../lib/devices/sync.js';
 import { readFleetFile, resolveDesired } from '../lib/fleet/manifest.js';
 import { snapshotAuth, materializeAuth, parseAuthBundle, KEYCHAIN_BOUND_ON_MAC, isCredentialSafeToPropagate } from '../lib/fleet/auth-sync.js';
@@ -82,7 +83,10 @@ function renderPlan(plan) {
         }
         return chalk.cyan('↑ ' + acts.map((a) => a.agent ?? a.kind.replace('-cli', '')).join(','));
     };
-    const header = `  ${'device'.padEnd(nameWidth)}   ${'agents-cli'.padEnd(12)}${'agents'.padEnd(20)}${'config'.padEnd(10)}login`;
+    // Only show the secrets column when the manifest declares any — an all-`-`
+    // column on every fleet that uses no bundles is noise.
+    const anySecrets = rows.some((r) => r.actions.some((a) => a.kind === 'push-secret' || a.kind === 'needs-secret'));
+    const header = `  ${'device'.padEnd(nameWidth)}   ${'agents-cli'.padEnd(12)}${'agents'.padEnd(20)}${'config'.padEnd(10)}${anySecrets ? 'login'.padEnd(18) + 'secrets' : 'login'}`;
     console.log(chalk.gray(header));
     for (const row of rows) {
         const cli = row.probe.reachable
@@ -100,10 +104,33 @@ function renderPlan(plan) {
             ? (row.actions.some((a) => a.kind === 'sync-config') ? chalk.cyan('↑ sync') : chalk.green('ok'))
             : chalk.gray('-');
         const loginCell = cell(row, ['push-login', 'needs-login'], `${row.desired.agents.length}/${row.desired.agents.length}`);
-        console.log(`  ${row.device.padEnd(nameWidth)}   ${stripPad(cli, 12)}${stripPad(agentsCell, 20)}${stripPad(configCell, 10)}${loginCell}`);
+        const secretsCell = (() => {
+            if (!anySecrets)
+                return '';
+            if (!row.probe.reachable)
+                return chalk.gray('- offline');
+            const push = row.actions.filter((a) => a.kind === 'push-secret').length;
+            const blocked = row.actions.filter((a) => a.kind === 'needs-secret').length;
+            if (push === 0 && blocked === 0)
+                return chalk.green('ok');
+            if (push > 0 && blocked === 0)
+                return chalk.cyan(`↑ push ${push}`);
+            if (push === 0)
+                return chalk.yellow(`blocked ${blocked}`);
+            return chalk.yellow(`↑ push ${push} · blocked ${blocked}`);
+        })();
+        const loginPart = anySecrets ? stripPad(loginCell, 18) + secretsCell : loginCell;
+        console.log(`  ${row.device.padEnd(nameWidth)}   ${stripPad(cli, 12)}${stripPad(agentsCell, 20)}${stripPad(configCell, 10)}${loginPart}`);
     }
     console.log();
     console.log(chalk.gray(`  ${plan.actions.length} action(s) across ${rows.filter((r) => r.probe.reachable).length} reachable device(s)`));
+    // The capability is opt-in, so when it is OFF and the manifest declares
+    // bundles, say that it exists. Otherwise an operator reads "manual recreate"
+    // and concludes there is no supported path — which is exactly the conclusion
+    // that led to a master key being hand-exported across the fleet (RUSH-1968).
+    if (anySecrets && !rows.some((r) => r.actions.some((a) => a.kind === 'push-secret'))) {
+        console.log(chalk.gray('  secrets: not pushed. `--provision-secrets` pushes declared bundles to devices whose host key is pinned.'));
+    }
     // Distinguish *why* a login can't be propagated: macOS keychain-bound,
     // single-use rotating refresh token (never copied), or the source simply not
     // being signed in to that agent (no portable file).
@@ -130,14 +157,15 @@ function renderPlan(plan) {
     if (noToken.length > 0) {
         console.log(chalk.yellow(`  manual login needed (no portable token on source): ${noToken.join(', ')}`));
     }
-    // Secrets bundles are declared once for the fleet; surface the distinct set to
-    // recreate on any device missing them (values are keychain-local, never pushed).
+    // Secrets bundles are declared once for the fleet; surface the distinct set the
+    // gate did NOT push, so a refusal is never silent. "never pushed" used to be
+    // literally true here and no longer is — `--provision-secrets` pushes them.
     const bundles = [...new Set(rows.flatMap((r) => r.secretsNeeded))];
     if (bundles.length > 0) {
         const shown = bundles.slice(0, 12);
         const more = bundles.length - shown.length;
         const list = shown.join(', ') + (more > 0 ? `, +${more} more` : '');
-        console.log(chalk.yellow(`  ${bundles.length} secrets bundle(s) to recreate where missing (keychain-local, never pushed): ${list}`));
+        console.log(chalk.yellow(`  ${bundles.length} secrets bundle(s) not pushed — recreate where missing: ${list}`));
     }
 }
 /** padEnd on the visible width, ignoring chalk color codes. Exported for tests. */
@@ -218,11 +246,24 @@ async function runApply(opts) {
     // Probe every target device in parallel.
     const nameToProfile = new Map(desired.map((d) => [d.device, registry[d.device]]));
     const withVersions = rosterNeedsVersions(desired);
+    // One extra `secrets list --json` per device, and only when it can change the
+    // plan: the manifest declares bundles AND provisioning is on. Same cost
+    // discipline as `withVersions` — a fleet that uses no bundles never pays it.
+    const withSecrets = opts.provisionSecrets === true && (manifest.secrets?.bundles?.length ?? 0) > 0;
     console.log(chalk.gray(`Probing ${desired.length} device(s)…`));
-    const probeList = await pool(desired, 6, async (d) => probeDevice(nameToProfile.get(d.device), { withVersions }));
+    const probeList = await pool(desired, 6, async (d) => probeDevice(nameToProfile.get(d.device), { withVersions, withSecrets }));
     const probes = new Map(probeList.map((p) => [p.device, p]));
     const targetCliVersion = localCliVersion();
-    let plan = diffFleet(desired, probes, { targetCliVersion, sourceAuth, secretsBundles: manifest.secrets?.bundles });
+    let plan = diffFleet(desired, probes, {
+        targetCliVersion,
+        sourceAuth,
+        secretsBundles: manifest.secrets?.bundles,
+        provisionSecrets: opts.provisionSecrets === true,
+        forceSecrets: opts.force === true,
+        // Same bar as `exec --copy-creds` (EXEC-34): credential values only ever go
+        // to a host whose key we already pinned.
+        isHostPinned: (device) => isHostPinned(device, managedKnownHostsPath()),
+    });
     // --only filter.
     if (opts.only) {
         const keep = new Set();
@@ -242,7 +283,8 @@ async function runApply(opts) {
         return;
     // `needs-login`/`needs-secret` are surfaced manual reminders, not executable
     // mutations — exclude them so an otherwise-converged fleet still says "nothing
-    // to do" instead of looping forever on un-actionable surfacing.
+    // to do" instead of looping forever on un-actionable surfacing. `push-secret`
+    // IS executable and deliberately stays counted.
     if (plan.actions.filter((a) => a.kind !== 'needs-login' && a.kind !== 'needs-secret').length === 0) {
         console.log(chalk.green('\nNothing to do — fleet already matches the profile.'));
         return;
@@ -301,6 +343,8 @@ export function configureApplyCommand(cmd) {
         .option('--agent <specs...>', 'Override the roster for targeted device(s): install these specs instead of the manifest\'s. Use `claude@all` to replicate every version installed on this machine.')
         .option('--only <dims>', 'Limit to dimensions: comma list of agents,config,login')
         .option('--no-login', 'Do not propagate logins')
+        .option('--provision-secrets', "Push the manifest's declared secrets bundles to each device (OFF by default; moves credential values over SSH, and only to a device whose host key is already pinned)")
+        .option('--force', 'With --provision-secrets: re-push a bundle the device already has')
         .addOption(new Option('--recv-auth', 'internal: receive an auth bundle on stdin').hideHelp())
         .action(async (opts) => {
         try {

package/dist/commands/bench.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function registerBenchCommand(program: Command): void;

package/dist/commands/bench.js

@@ -0,0 +1,101 @@
+import * as fs from "fs";
+import * as path from "path";
+import { fileURLToPath } from "url";
+import { detectSignedInRuntimes } from "../lib/crabbox/runtimes.js";
+import { listRuns, loadRun, loadTask, runCells, saveRun, } from "../lib/bench/index.js";
+import { setHelpSections } from "../lib/help.js";
+const TASKS_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../bench/tasks");
+function csv(value) {
+    return (value
+        ?.split(",")
+        .map((item) => item.trim())
+        .filter(Boolean) ?? []);
+}
+function taskIds(root = TASKS_ROOT) {
+    if (!fs.existsSync(root))
+        return [];
+    return fs
+        .readdirSync(root, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory() &&
+        fs.existsSync(path.join(root, entry.name, "task.json")))
+        .map((entry) => entry.name)
+        .sort();
+}
+function renderResult(result) {
+    console.log(`Run ${result.run_id}${result.task_id ? ` · ${result.task_id}` : ""}`);
+    for (const cell of result.cells)
+        console.log(`${cell.status === "passed" ? "PASS" : "FAIL"}  ${cell.agent}${cell.model ? `/${cell.model}` : ""}  ${cell.wall_ms} ms  exit ${cell.exit ?? "spawn-error"}`);
+}
+export function registerBenchCommand(program) {
+    const bench = program
+        .command("bench")
+        .description("Run the same task across agent and model cells, with isolated fixtures and durable JSON results.");
+    setHelpSections(bench, {
+        examples: `agents bench list\nagents bench run hello-repo --agent claude,codex --model cheap,default\nagents bench results --json`,
+        notes: `Task definitions live under apps/cli/bench/tasks/<id>/task.json. Custom harness names accepted by agents run are valid --agent values.`,
+    });
+    bench
+        .command("list")
+        .description("List available benchmark tasks.")
+        .option("--json", "Emit JSON.")
+        .action((options) => {
+        const tasks = taskIds();
+        if (options.json)
+            console.log(JSON.stringify(tasks, null, 2));
+        else if (tasks.length === 0)
+            console.log("No benchmark tasks installed.");
+        else
+            tasks.forEach((id) => console.log(id));
+    });
+    bench
+        .command("results [run-id]")
+        .description("Show one saved run, or list saved runs newest first.")
+        .option("--json", "Emit JSON.")
+        .action((runId, options) => {
+        const value = runId ? loadRun(runId) : listRuns();
+        if (options.json)
+            console.log(JSON.stringify(value, null, 2));
+        else if (Array.isArray(value)) {
+            if (value.length === 0)
+                console.log("No benchmark results yet.");
+            else
+                value.forEach(renderResult);
+        }
+        else
+            renderResult(value);
+    });
+    bench
+        .command("run [task-id]")
+        .description("Run one task or prompt across an agent × model matrix.")
+        .option("--prompt <text>", "Prompt to benchmark instead of a house task.")
+        .option("--agent <names>", "Comma-separated native agents or custom harness names. Defaults to signed-in native agents.")
+        .option("--model <models>", "Comma-separated model tiers or concrete model ids.")
+        .option("--concurrency <n>", "Maximum cells running at once.", "3")
+        .option("--json", "Emit the saved JSON result.")
+        .action(async (taskId, options) => {
+        if (!!taskId === !!options.prompt)
+            throw new Error("Pass exactly one of <task-id> or --prompt.");
+        const task = taskId ? loadTask(taskId, TASKS_ROOT) : undefined;
+        const prompt = options.prompt ?? task.prompt;
+        let agents = csv(options.agent);
+        if (agents.length === 0)
+            agents = (await detectSignedInRuntimes())
+                .filter((runtime) => runtime.signedIn)
+                .map((runtime) => runtime.id);
+        if (agents.length === 0)
+            throw new Error("No signed-in native agents found. Pass --agent <name>.");
+        const models = csv(options.model);
+        const cells = agents.flatMap((agent) => models.length > 0
+            ? models.map((model) => ({ agent, model }))
+            : [{ agent }]);
+        const concurrency = Number(options.concurrency);
+        const result = await runCells({ task, prompt, cells, concurrency });
+        saveRun(result);
+        if (options.json)
+            console.log(JSON.stringify(result, null, 2));
+        else
+            renderResult(result);
+        if (result.cells.some((cell) => cell.status === "failed"))
+            process.exitCode = 1;
+    });
+}

package/dist/commands/browser.js

@@ -20,6 +20,7 @@ import { isInteractiveTerminal } from './utils.js';
 import { registerCommandGroups, setHelpSections } from '../lib/help.js';
 import { buildHar } from '../lib/browser/har.js';
 import { getCliVersion } from '../lib/version.js';
+import { runBrowserIPCStream } from '../lib/browser/stream.js';
 /**
  * Resolve which browser task a command targets. Order:
  *   1. `--task <name>` flag (explicit per-command override)
@@ -48,6 +49,7 @@ const TASK_OPTION_DESC = 'Task name (defaults to $AGENTS_BROWSER_TASK)';
 // trailing "Other commands" section automatically.
 const BROWSER_HELP_GROUPS = [
     { title: 'Session lifecycle', names: ['start', 'done', 'status'] },
+    { title: 'Fast action loop', names: ['stream'] },
     {
         title: 'Drive the page',
         names: ['navigate', 'tabs', 'screenshot', 'evaluate', 'click', 'type', 'press', 'wait'],
@@ -79,6 +81,9 @@ export function registerBrowserCommand(program) {
       agents browser navigate https://example.com
       agents browser screenshot
 
+      # Keep one process and daemon socket warm for repeated actions
+      agents browser stream --task "$AGENTS_BROWSER_TASK"
+
       # Drive another machine's browser (needs its consent — see remote-control)
       agents browser start --host zion
 
@@ -654,6 +659,36 @@ function registerTaskCommands(browser) {
             ? 'Other fleet machines can now drive this browser via `browser --host <this-device>`.'
             : 'Cross-machine `browser --host` drives to this machine are refused.');
     });
+    const stream = browser
+        .command('stream')
+        .description('Keep one process and daemon IPC socket open; read NDJSON requests from stdin and write NDJSON responses')
+        .option(TASK_OPTION_FLAG, 'Default task for requests that omit `task` (defaults to $AGENTS_BROWSER_TASK)')
+        .action(async (opts) => {
+        await runBrowserIPCStream({
+            input: process.stdin,
+            output: process.stdout,
+            task: opts.task ?? process.env.AGENTS_BROWSER_TASK,
+            actor: resolveActor().id,
+            launchId: process.env.AGENT_LAUNCH_ID,
+        });
+    });
+    setHelpSections(stream, {
+        examples: `
+      # Batch two warm actions through one process and one daemon connection
+      printf '%s\\n' \\
+        '{"action":"screenshot","path":"/tmp/page.jpg"}' \\
+        '{"action":"click","atX":320,"atY":540}' \\
+        | agents browser stream --task "$AGENTS_BROWSER_TASK"
+
+      # Keep the command open and send one JSON object per line from a long-lived shell
+      agents browser stream --task "$AGENTS_BROWSER_TASK"
+    `,
+        notes: `
+      stdout is protocol-only: one compact JSON response for each non-empty input line.
+      Malformed JSON returns an error response without closing the stream.
+      The first start response becomes the default task for later lines in the same stream.
+    `,
+    });
     browser
         .command('start')
         .description('Start a browser task. Pass --profile <name>; omit to use your configured default (`agents browser profiles set-default`), else auto-pick an installed Chromium-family browser.')

package/dist/commands/doctor.js

@@ -12,7 +12,8 @@ import { buildLocalFindings, fleetDivergenceToFindings, signInToFindings, render
 import { getCliVersion } from '../lib/version.js';
 import { resolveHost } from '../lib/hosts/registry.js';
 import { sshExecAsync } from '../lib/ssh-exec.js';
-import { sshTargetFor } from '../lib/hosts/types.js';
+import { hostIdentityArgs, sshTargetFor } from '../lib/hosts/types.js';
+import { deviceIdentityArgs } from '../lib/devices/connect.js';
 import { machineId, normalizeHost } from '../lib/session/sync/config.js';
 import { findAmbiguousDevicePins } from '../lib/routines.js';
 import chalk from 'chalk';
@@ -26,11 +27,14 @@ import { checkVersionHookWiring, inspectDuplicateVersionHooks, registerHooksToSe
 import { isVersionIsolated } from '../lib/versions.js';
 import { computeDrift, checkSyncStatus, countOrphans, computeSourceBehind } from '../lib/drift.js';
 import { readAuthHealthCache, summarizeHostAuth } from '../lib/auth-health.js';
+import { readMeta } from '../lib/state.js';
+import { probeOwnerSink } from '../lib/channels/owner-sink.js';
 import { unifiedDiff, colorizeUnifiedDiff } from '../lib/diff-text.js';
 import { listCliStatus, listCliStatusAsync } from '../lib/cli-resources.js';
 import { setHelpSections } from '../lib/help.js';
 import { heal, healChangedAnything } from '../lib/heal.js';
 import { getEffectiveExecutionPolicy } from '../lib/platform/winpath.js';
+import { auditWindowsSshEnrollment, diagnoseWindowsSshFailure } from '../lib/devices/windows-ssh-enrollment.js';
 import { scanUserRcFiles, masterPassphraseInEnv } from '../lib/secrets/rc-hygiene.js';
 import { terminalWidth, truncateToWidth, stringWidth, padToWidth } from '../lib/session/width.js';
 import { readRepoBehindMarkers } from '../lib/auto-pull.js';
@@ -81,14 +85,14 @@ function printWrappedLine(prefix, text) {
         console.log(chalk.gray(line));
 }
 /**
- * Narrow a remote `findings` array to the secret-hygiene rows, or `[]`.
+ * Narrow a remote `findings` array to rows only that device can observe.
  *
  * Deliberately NOT "forward every remote finding". The aggregator already
  * rebuilds a remote's sign-in rows from its inventory and its divergence rows
  * from the comparator, so forwarding wholesale would double them; and pulling a
  * remote's orphan/drift rows into a fleet readout is a much larger UX change
- * than this fix. The two secret kinds are the ones that are BOTH unrecomputable
- * centrally and security-relevant, which is exactly why they were being lost.
+ * than this fix. These kinds are unrecomputable centrally: shell/process secret
+ * hygiene and the Windows host's effective OpenSSH key path/content/ACL.
  *
  * **The remote contributes exactly one thing: the KIND.** Severity, message and
  * remediation are all generated HERE. That is not defensiveness for its own
@@ -109,13 +113,15 @@ function printWrappedLine(prefix, text) {
  * file and line. Run `agents doctor` on that box for the specifics — the
  * message says so.
  */
-const REMOTE_FORWARDED_KINDS = ['rc-secret-export', 'env-secret-export'];
+const REMOTE_FORWARDED_KINDS = ['rc-secret-export', 'env-secret-export', 'ssh-key-enrollment'];
 /** Canonical, locally-authored text for a forwarded kind. Never the remote's. */
 const REMOTE_SECRET_MESSAGE = {
     'rc-secret-export': 'a credential-shaped export was found in this box\'s shell rc files'
         + ' — run `agents doctor` there for the file and line',
     'env-secret-export': 'AGENTS_SECRETS_PASSPHRASE is set in this box\'s process environment'
         + ' — run `agents doctor` there for detail',
+    'ssh-key-enrollment': 'Windows OpenSSH key enrollment is invalid'
+        + ' — run `agents doctor` on this box for the effective path or ACL failure',
 };
 export function asRemoteSecretFindings(raw, device) {
     if (!Array.isArray(raw))
@@ -156,11 +162,12 @@ async function resolveFleetTargets(opts) {
                     name: deviceProfile.name,
                     sshTarget: deviceProfile.name,
                     os: deviceProfile.platform !== 'unknown' ? deviceProfile.platform : undefined,
+                    extraSshArgs: deviceIdentityArgs(deviceProfile),
                 }];
         }
         const host = await resolveHost(singleName);
         if (host) {
-            return [{ name: singleName, sshTarget: sshTargetFor(host), os: host.os }];
+            return [{ name: singleName, sshTarget: sshTargetFor(host), os: host.os, extraSshArgs: hostIdentityArgs(host) }];
         }
         console.error(chalk.red(`Unknown host or device '${singleName}'.`));
         process.exit(1);
@@ -178,6 +185,7 @@ async function resolveFleetTargets(opts) {
         name: d.name,
         sshTarget: d.name,
         os: d.platform !== 'unknown' ? d.platform : undefined,
+        extraSshArgs: deviceIdentityArgs(d),
     }));
 }
 async function probeFleetTarget(target) {
@@ -188,12 +196,14 @@ async function probeFleetTarget(target) {
     // has it via the install profile, and our single-quote escaping would
     // prevent $HOME expansion there, so skip the bootstrap on Windows.
     isWin ? undefined : { PATH: '$HOME/.agents/.cache/shims:$HOME/.local/bin:$PATH' });
-    const res = await sshExecAsync(target.sshTarget, remoteCmd, { timeoutMs: 30000, multiplex: true });
+    const res = await sshExecAsync(target.sshTarget, remoteCmd, { timeoutMs: 30000, multiplex: true, extraSshArgs: target.extraSshArgs });
     if (res.code !== 0) {
         return {
             name: target.name,
             online: false,
-            error: res.timedOut ? 'timed out' : (res.stderr || `exit ${res.code ?? 'unknown'}`),
+            error: isWin
+                ? diagnoseWindowsSshFailure(res.stderr, res.timedOut)
+                : res.timedOut ? 'timed out' : (res.stderr || `exit ${res.code ?? 'unknown'}`),
             agents: {},
         };
     }
@@ -236,7 +246,11 @@ export const FLEET_INVENTORY_TIMEOUT_MS = 180_000;
 async function probeFleetInventory(target) {
     const isWin = /^win/i.test((target.os ?? '').trim());
     const remoteCmd = buildRemoteAgentsInvocation(['doctor', '--json'], undefined, isWin ? 'windows' : undefined, isWin ? undefined : { PATH: '$HOME/.agents/.cache/shims:$HOME/.local/bin:$PATH' });
-    const res = await sshExecAsync(target.sshTarget, remoteCmd, { timeoutMs: FLEET_INVENTORY_TIMEOUT_MS, multiplex: true });
+    const res = await sshExecAsync(target.sshTarget, remoteCmd, {
+        timeoutMs: FLEET_INVENTORY_TIMEOUT_MS,
+        multiplex: true,
+        extraSshArgs: target.extraSshArgs,
+    });
     if (res.code !== 0)
         return null;
     try {
@@ -402,9 +416,13 @@ async function runDevicesDoctor(opts) {
                 execPolicy: process.platform === 'win32'
                     ? { platform: process.platform, policy: getEffectiveExecutionPolicy() }
                     : undefined,
+                windowsSshEnrollment: auditWindowsSshEnrollment(),
                 isolatedVersions: localReports
                     .filter((rep) => isVersionIsolated(rep.agent, rep.version))
                     .map((rep) => `${rep.agent}@${rep.version}`),
+                // Can the owner-delivery lane escalate a block from THIS box? Local only —
+                // remote boxes self-report it in their own `agents doctor --json`.
+                ownerSink: await probeOwnerSink(readMeta()),
             }));
             accounts[localName] = r.inventory?.signIn ?? {};
             continue;
@@ -1177,7 +1195,7 @@ function checkPayload(device, drift) {
 async function probeDeviceCheck(target) {
     const isWin = /^win/i.test((target.platform ?? '').trim());
     const remoteCmd = buildRemoteAgentsInvocation(['doctor', '--check', '--json'], undefined, isWin ? 'windows' : undefined, isWin ? undefined : { PATH: '$HOME/.agents/.cache/shims:$HOME/.local/bin:$PATH' });
-    const res = await sshExecAsync(target.dialTarget, remoteCmd, { timeoutMs: 30000, multiplex: true });
+    const res = await sshExecAsync(target.dialTarget, remoteCmd, { timeoutMs: 30000, multiplex: true, extraSshArgs: target.extraSshArgs });
     if (res.code !== 0 && !res.stdout.trim()) {
         throw new Error(res.timedOut ? 'timed out' : (res.stderr.trim() || `exit ${res.code ?? 'unknown'}`));
     }
@@ -1206,6 +1224,7 @@ async function runDevicesCheck(opts, cwd) {
         platform: t.device.platform,
         skip: t.skip,
         dialTarget: fleetDialTarget(t.device),
+        extraSshArgs: deviceIdentityArgs(t.device),
     }));
     const remote = await fanOutDevices(remoteTargets, probeDeviceCheck);
     const devices = [local];
@@ -1486,6 +1505,9 @@ export function registerDoctorCommand(program) {
                     ? { platform: process.platform, policy: getEffectiveExecutionPolicy() }
                     : undefined,
                 isolatedVersions,
+                // Can the owner-delivery lane (feed/notify) escalate a block from this
+                // box? A factory that cannot escalate is not healthy (RUSH-2262).
+                ownerSink: await probeOwnerSink(readMeta()),
             });
             if (opts.json) {
                 const overviewPayload = {

package/dist/commands/exec.js

@@ -554,7 +554,7 @@ export function registerRunCommand(program) {
         .option('--until <signal>', 'Loop stop condition. `signal` reads <runDir>/loop-signal.json {continue,reason} each iteration; absent or continue:false stops (fail-closed). Loop only.')
         .option('--interval <dur>', 'Loop delay between iterations ("0" back-to-back, "30m" paces). Loop only.')
         .option('--where <spec>', 'Where this run\'s body executes (one placement door): local | device:<name> | auto | lease[:backend] | cloud[:provider]. Expands to --host/--lease/--cloud. Do not combine with those flags. See docs/00-concepts.md#placement.')
-        .option('--host <name>', 'Offload this run onto another machine over SSH — a device name, registered host, or user@host. Pass "auto" to pick from 14d usage affinity (most-used online device has highest probability). Same as --where device:<name>. See `agents devices`.')
+        .option('--host <name>', 'Offload this run onto another machine over SSH — a device name, registered host, or user@host. Pass "auto" to pick the least-loaded reachable device where the requested agent is installed and signed in, keeping the run local when no remote is better. Same as --where device:<name>. See `agents devices`.')
         .option('--device <name>', 'Alias of --host. Pass "auto" for affinity-based device pick (same as --where auto).')
         .option('--remote-cwd <dir>', "Explicit host working directory for --host runs, used VERBATIM (overrides --cwd; usually --cwd suffices — it re-roots a local-home path onto the remote home). Pass a single-quoted '$HOME/…' or a valid remote absolute path; a local ~ expands here and won't exist there (/Users/you vs /home/you).")
         .option('--no-follow', 'With --host, dispatch detached and return immediately (track via `agents hosts ps/logs`).')
@@ -947,13 +947,18 @@ export function registerRunCommand(program) {
             if (!resolvedResumeSource && runAutoDefaultsToAffinity(options))
                 options.device = 'auto';
         }
-        // --device auto / --host auto (and deprecated --smart): affinity-pick host.
+        // --device auto / --host auto (and deprecated --smart): live fleet pick.
         // Harness is always the agent the user typed — never auto-picked.
         // Affinity failure degrades to local (does not kill the run).
         {
             const { applyDeviceAutoToOptions } = await import('../lib/smart-launch.js');
-            const result = applyDeviceAutoToOptions(options, {
+            const result = await applyDeviceAutoToOptions(options, {
                 accountPickerRequested,
+                // `run auto` selects its harness after placement, so do not filter
+                // candidates against an arbitrary proxy harness at this stage.
+                agent: normalizedAgentSpec.split('@')[0] === RUN_AUTO_KEYWORD
+                    ? undefined
+                    : (resolveAgentName(normalizedAgentSpec.split('@')[0]) ?? undefined),
             });
             if (!options.quiet && result.deprecationSmart) {
                 process.stderr.write(chalk.yellow('[agents] --smart is deprecated; use --device auto\n'));
@@ -964,7 +969,7 @@ export function registerRunCommand(program) {
             if (!options.quiet && result.banner) {
                 const { hostLabel, deviceHint, acctNote } = result.banner;
                 process.stderr.write(chalk.gray(`[agents] device=auto → ${hostLabel}` +
-                    (deviceHint ? ` (affinity ${deviceHint})` : '') +
+                    (deviceHint ? ` (load ${deviceHint})` : '') +
                     ` · ${acctNote}\n`));
             }
         }
@@ -2268,22 +2273,18 @@ export function registerRunCommand(program) {
                 process.exit(1);
             }
             version = resolvedRecoveryTarget.version;
-            const canResumeNatively = resolvedRecoveryTarget.mode === 'native';
-            if (canResumeNatively) {
+            if (resolvedRecoveryTarget.mode === 'native') {
                 version = session.version;
                 resumeNative = true;
                 resumeSessionId = session.id;
-                // Native `--resume` (claude/codex) resolves the transcript relative to the
-                // working directory (projects/<cwd-hash>/). The session may have been started
-                // in a different directory than we're standing in now — most importantly when a
-                // routine daemon fires `agents run --resume` from its own cwd. Spawn from the
-                // session's ORIGIN cwd so the resume actually finds it; otherwise the agent
-                // exits "No conversation found with session ID". Honor an explicit --cwd only if
-                // the caller passed one (they're overriding on purpose).
-                if (!options.cwd && session.cwd)
-                    options.cwd = session.cwd;
+                // The centralized recovery decision proves the transcript belongs to
+                // this exact isolated home and resolves any harness-specific launch cwd.
+                // Claude's indexed `session.cwd` is the first user-turn cwd, which may
+                // differ from the earlier cwd that selected projects/<cwd-key>.
+                if (!options.cwd && resolvedRecoveryTarget.cwd)
+                    options.cwd = resolvedRecoveryTarget.cwd;
                 if (!options.quiet)
-                    process.stderr.write(chalk.gray(`Resuming ${agent} ${session.shortId} (native)${version ? ` @${version}` : ''}${!options.cwd || options.cwd === session.cwd ? ` in ${session.cwd ?? cwd}` : ''}\n`));
+                    process.stderr.write(chalk.gray(`Resuming ${agent} ${session.shortId} (native)${version ? ` @${version}` : ''} in ${options.cwd ?? cwd}\n`));
             }
             else {
                 // Tier-2: launch fresh with a /continue <id> first message; the agent

package/dist/commands/insights.d.ts

@@ -1,23 +1,26 @@
 /**
- * Insights command — how you actually work, split by the account that did the work.
- *
- * The behavioural sibling of the existing rollups, and deliberately not a duplicate of
- * any of them:
- *
- *   agents cost      what you spent            ($ and duration)
- *   agents output    what shipped              (burn vs PRs and commits)
- *   agents usage     live quota headroom       (rate-limit windows, right now)
- *   agents trends    aggregate distributions   (harness mix, tools-per-session, token ratios)
- *   agents sessions  browse individual work    (search, resume, render)
- *   agents insights  HOW you work              (tools, friction, rhythm, per account)
- *
- * The closest neighbour is `agents trends`, and the boundary is the data path: trends
- * reads counters — `tool_scan_ledger` call counts and the analytics warehouse — to
- * produce distributions ("how many tool calls per session, by harness"). This reads
- * transcript CONTENT through `parseSession` to produce behaviour ("which tools, which
- * languages, where it went wrong, when you were working"), and splits all of it by
- * account, a dimension trends does not have. They overlap in spirit on tool and model
- * mix; they do not read the same store or answer the same question.
+ * Insights command — one observe verb for "how work looks".
+ *
+ * Two data paths under one name (do not re-split into peer top-level commands):
+ *
+ *   agents insights              HOW you work (transcript content: tools, friction,
+ *                                rhythm, edits) — split by Claude account by default
+ *   agents insights mix          COUNTERS (sessions index + usage.db recipes:
+ *                                harness/model mix, token ratios, secrets, browser)
+ *   agents insights <recipe>     One baked mix recipe (harness-mix, tools-per-session, …)
+ *   agents insights query        Raw usage.db rows
+ *
+ * Sibling observe verbs (stay separate — different questions):
+ *
+ *   agents cost       what you spent ($ and duration)
+ *   agents output     what shipped (burn vs PRs and commits)
+ *   agents usage      live quota headroom
+ *   agents perf       latency (hooks, CLI commands, agent.run) — not popularity
+ *   agents sessions stats  which skills/slash-commands were explicitly invoked
+ *
+ * Why mix lives here (not a second top-level `trends`): two abstract "analytics"
+ * nouns taught agents and humans to guess. One verb, two engines — cheap SQL mix
+ * vs transcript facets. Latency stays on `perf` so it is never confused with mix.
  *
  * Modelled on Claude Code's `/insights`, with the difference that motivated it: that
  * command reads one account's directory, while `balanced` rotation sprays sessions
@@ -27,6 +30,9 @@
  * The deterministic report makes zero network calls. `--narrative` is opt-in and adds
  * the coaching prose by piping the AGGREGATE (never raw transcripts) through a headless
  * `claude -p`.
+ *
+ * `agents trends` is a thin deprecated alias of the mix tree only (see commands/trends.ts).
  */
 import type { Command } from 'commander';
 export declare function registerInsightsCommand(program: Command): void;
+export declare function registerSessionsInsightsCommand(sessions: Command): void;