@phnx-labs/agents-cli 1.22.26 → 1.22.27

package/dist/lib/bench/runner.js

@@ -0,0 +1,111 @@
+import { spawn } from "child_process";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { getCliLaunch } from "../cli-entry.js";
+export function extractTokenCount(stdout, stderr) {
+    const matches = [
+        ...`${stdout}\n${stderr}`.matchAll(/(?:tokens used|total tokens|token usage)\s*[:=]?\s*([\d,]+)/gi),
+    ];
+    const raw = matches.at(-1)?.[1];
+    if (!raw)
+        return undefined;
+    const tokens = Number(raw.replaceAll(",", ""));
+    return Number.isSafeInteger(tokens) && tokens >= 0 ? tokens : undefined;
+}
+export async function executeCellViaAgentsRun(request) {
+    const args = [
+        "run",
+        request.agent,
+        request.prompt,
+        "--cwd",
+        request.cwd,
+        "--headless",
+        "--no-tmux",
+    ];
+    if (request.model)
+        args.push("--model", request.model);
+    const launch = getCliLaunch(args);
+    return await new Promise((resolve, reject) => {
+        const child = spawn(launch.command, launch.args, {
+            cwd: request.cwd,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let stdout = "";
+        let stderr = "";
+        child.stdout.on("data", (chunk) => {
+            stdout += chunk.toString();
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr += chunk.toString();
+        });
+        child.on("error", reject);
+        child.on("close", (code) => resolve({
+            exit: code,
+            stdout,
+            stderr,
+            tokens: extractTokenCount(stdout, stderr),
+        }));
+    });
+}
+function copyFixture(task, cellIndex, runRoot) {
+    const cwd = path.join(runRoot, `cell-${cellIndex}`);
+    fs.mkdirSync(cwd, { recursive: true });
+    if (fs.existsSync(task.fixtureDir))
+        fs.cpSync(task.fixtureDir, cwd, { recursive: true });
+    return cwd;
+}
+export async function runCells(options) {
+    if (!Number.isInteger(options.concurrency) || options.concurrency < 1)
+        throw new Error("concurrency must be a positive integer");
+    if (options.cells.length === 0)
+        throw new Error("at least one bench cell is required");
+    const runId = `${new Date().toISOString().replace(/[-:.TZ]/g, "")}-${process.pid}`;
+    const startedAt = new Date();
+    const runRoot = fs.mkdtempSync(path.join(options.tempRoot ?? os.tmpdir(), `agents-bench-${runId}-`));
+    const results = new Array(options.cells.length);
+    const execute = options.execute ?? executeCellViaAgentsRun;
+    let next = 0;
+    const worker = async () => {
+        for (;;) {
+            const index = next++;
+            if (index >= options.cells.length)
+                return;
+            const cell = options.cells[index];
+            const cwd = options.task
+                ? copyFixture(options.task, index, runRoot)
+                : path.join(runRoot, `cell-${index}`);
+            fs.mkdirSync(cwd, { recursive: true });
+            const started = performance.now();
+            try {
+                const output = await execute({ ...cell, prompt: options.prompt, cwd });
+                results[index] = {
+                    ...cell,
+                    ...output,
+                    wall_ms: Math.round(performance.now() - started),
+                    status: output.exit === 0 ? "passed" : "failed",
+                };
+            }
+            catch (error) {
+                results[index] = {
+                    ...cell,
+                    exit: null,
+                    stdout: "",
+                    stderr: error instanceof Error ? error.message : String(error),
+                    wall_ms: Math.round(performance.now() - started),
+                    status: "failed",
+                };
+            }
+        }
+    };
+    await Promise.all(Array.from({ length: Math.min(options.concurrency, options.cells.length) }, worker));
+    return {
+        schema_version: 1,
+        run_id: runId,
+        ...(options.task ? { task_id: options.task.id } : {}),
+        prompt: options.prompt,
+        started_at: startedAt.toISOString(),
+        finished_at: new Date().toISOString(),
+        cells: results,
+    };
+}

package/dist/lib/bench/schema.d.ts

@@ -0,0 +1,5 @@
+import type { BenchRunResult, BenchTask } from "./types.js";
+export declare function parseTask(raw: unknown, sourcePath: string): BenchTask;
+export declare function parseRunResult(raw: unknown): BenchRunResult;
+export declare function validateRunId(runId: string): string;
+export declare function loadTask(taskId: string, tasksRoot: string): BenchTask;

package/dist/lib/bench/schema.js

@@ -0,0 +1,91 @@
+import * as fs from "fs";
+import * as path from "path";
+function object(value, label) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error(`${label} must be an object`);
+    return value;
+}
+function string(value, label) {
+    if (typeof value !== "string" || value.trim() === "")
+        throw new Error(`${label} must be a non-empty string`);
+    return value;
+}
+export function parseTask(raw, sourcePath) {
+    const value = object(raw, "task.json");
+    const id = string(value.id, "task.id");
+    const prompt = string(value.prompt, "task.prompt");
+    if (!Array.isArray(value.pass) || value.pass.length === 0)
+        throw new Error("task.pass must be a non-empty array");
+    const pass = value.pass.map((item, index) => {
+        const criterion = object(item, `task.pass[${index}]`);
+        const type = string(criterion.type, `task.pass[${index}].type`);
+        if (type === "exit_zero")
+            return { type };
+        if (type === "file_exists")
+            return { type, path: string(criterion.path, `task.pass[${index}].path`) };
+        if (type === "stdout_contains")
+            return {
+                type,
+                value: string(criterion.value, `task.pass[${index}].value`),
+            };
+        if (type === "command_succeeds")
+            return {
+                type,
+                command: string(criterion.command, `task.pass[${index}].command`),
+            };
+        throw new Error(`task.pass[${index}].type is unsupported: ${type}`);
+    });
+    const taskDir = path.dirname(sourcePath);
+    return {
+        id,
+        prompt,
+        pass,
+        fixtureDir: path.join(taskDir, "fixture"),
+        sourcePath,
+    };
+}
+export function parseRunResult(raw) {
+    const value = object(raw, "bench result");
+    if (value.schema_version !== 1)
+        throw new Error("bench result schema_version must be 1");
+    string(value.run_id, "bench result run_id");
+    string(value.prompt, "bench result prompt");
+    string(value.started_at, "bench result started_at");
+    string(value.finished_at, "bench result finished_at");
+    if (value.task_id !== undefined)
+        string(value.task_id, "bench result task_id");
+    if (!Array.isArray(value.cells))
+        throw new Error("bench result cells must be an array");
+    value.cells.forEach((rawCell, index) => {
+        const cell = object(rawCell, `bench result cells[${index}]`);
+        string(cell.agent, `bench result cells[${index}].agent`);
+        if (cell.model !== undefined)
+            string(cell.model, `bench result cells[${index}].model`);
+        if (cell.status !== "passed" && cell.status !== "failed")
+            throw new Error(`bench result cells[${index}].status must be passed or failed`);
+        if (cell.exit !== null &&
+            (!Number.isInteger(cell.exit) || cell.exit < 0))
+            throw new Error(`bench result cells[${index}].exit must be a non-negative integer or null`);
+        if (typeof cell.wall_ms !== "number" ||
+            !Number.isFinite(cell.wall_ms) ||
+            cell.wall_ms < 0)
+            throw new Error(`bench result cells[${index}].wall_ms must be a non-negative number`);
+        if (cell.tokens !== undefined &&
+            (!Number.isSafeInteger(cell.tokens) || cell.tokens < 0))
+            throw new Error(`bench result cells[${index}].tokens must be a non-negative integer`);
+        if (typeof cell.stdout !== "string" || typeof cell.stderr !== "string")
+            throw new Error(`bench result cells[${index}] stdout and stderr must be strings`);
+    });
+    return value;
+}
+export function validateRunId(runId) {
+    if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(runId))
+        throw new Error(`Invalid run id: ${runId}`);
+    return runId;
+}
+export function loadTask(taskId, tasksRoot) {
+    if (!/^[a-z0-9][a-z0-9-]*$/.test(taskId))
+        throw new Error(`Invalid task id: ${taskId}`);
+    const sourcePath = path.join(tasksRoot, taskId, "task.json");
+    return parseTask(JSON.parse(fs.readFileSync(sourcePath, "utf8")), sourcePath);
+}

package/dist/lib/bench/storage.d.ts

@@ -0,0 +1,5 @@
+import type { BenchRunResult } from "./types.js";
+export declare function benchHistoryDir(): string;
+export declare function saveRun(result: BenchRunResult, root?: string): string;
+export declare function loadRun(runId: string, root?: string): BenchRunResult;
+export declare function listRuns(root?: string): BenchRunResult[];

package/dist/lib/bench/storage.js

@@ -0,0 +1,32 @@
+import * as fs from "fs";
+import * as path from "path";
+import { getUserAgentsDir } from "../state.js";
+import { parseRunResult, validateRunId } from "./schema.js";
+export function benchHistoryDir() {
+    return path.join(getUserAgentsDir(), ".history", "bench");
+}
+export function saveRun(result, root = benchHistoryDir()) {
+    parseRunResult(result);
+    validateRunId(result.run_id);
+    fs.mkdirSync(root, { recursive: true });
+    const target = path.join(root, `${result.run_id}.json`);
+    const temporary = `${target}.${process.pid}.tmp`;
+    fs.writeFileSync(temporary, `${JSON.stringify(result, null, 2)}\n`, {
+        mode: 0o600,
+    });
+    fs.renameSync(temporary, target);
+    return target;
+}
+export function loadRun(runId, root = benchHistoryDir()) {
+    validateRunId(runId);
+    return parseRunResult(JSON.parse(fs.readFileSync(path.join(root, `${runId}.json`), "utf8")));
+}
+export function listRuns(root = benchHistoryDir()) {
+    if (!fs.existsSync(root))
+        return [];
+    return fs
+        .readdirSync(root)
+        .filter((name) => name.endsWith(".json"))
+        .map((name) => parseRunResult(JSON.parse(fs.readFileSync(path.join(root, name), "utf8"))))
+        .sort((a, b) => b.started_at.localeCompare(a.started_at));
+}

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

@@ -0,0 +1,40 @@
+export type BenchPassCriterion = {
+    type: "file_exists";
+    path: string;
+} | {
+    type: "exit_zero";
+} | {
+    type: "stdout_contains";
+    value: string;
+} | {
+    type: "command_succeeds";
+    command: string;
+};
+export interface BenchTask {
+    id: string;
+    prompt: string;
+    pass: BenchPassCriterion[];
+    fixtureDir: string;
+    sourcePath: string;
+}
+export interface BenchCell {
+    agent: string;
+    model?: string;
+}
+export interface BenchCellResult extends BenchCell {
+    status: "passed" | "failed";
+    exit: number | null;
+    wall_ms: number;
+    tokens?: number;
+    stdout: string;
+    stderr: string;
+}
+export interface BenchRunResult {
+    schema_version: 1;
+    run_id: string;
+    task_id?: string;
+    prompt: string;
+    started_at: string;
+    finished_at: string;
+    cells: BenchCellResult[];
+}

package/dist/lib/bench/types.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/claude-account-token.d.ts

@@ -1,3 +1,5 @@
+/** True only for a clean, single-line `sk-ant-oat01-…` token — see {@link SETUP_TOKEN_RE}. */
+export declare function isValidClaudeSetupToken(value: string): boolean;
 /** The per-account key an email maps to inside the `auth` bundle. */
 export declare function claudeAccountTokenKey(account: string): string;
 /** Signed-in account email for a version home, from `.claude.json` (no keychain). */

package/dist/lib/claude-account-token.js

@@ -11,6 +11,24 @@ import { bundleBackend, bundleExists, readAndResolveBundleEnv } from './secrets/
  * multi-account fleet.
  */
 const AUTH_BUNDLE = 'auth';
+/**
+ * A well-formed Claude OAuth setup-token: the `sk-ant-oat01-` prefix followed by
+ * token-safe characters only, on a single line. `claude setup-token` mints exactly
+ * this; nothing else is a token.
+ *
+ * The provisioning capture bug behind #1767 stored the raw `claude setup-token`
+ * TTY stream — the welcome banner, ANSI control sequences, box-drawing art, and the
+ * token buried inside — under a per-account key instead of the parsed value. That
+ * blob is not a token: injected as `Authorization: Bearer <blob>` it made Anthropic
+ * reject every request and the run crash. agents-cli only *consumes* these tokens
+ * (the mint itself is the Rush Cloud / mint-auth path), so this is the boundary
+ * where a corrupt bundle entry must be caught before it reaches the auth header.
+ */
+const SETUP_TOKEN_RE = /^sk-ant-oat01-[A-Za-z0-9_-]+$/;
+/** True only for a clean, single-line `sk-ant-oat01-…` token — see {@link SETUP_TOKEN_RE}. */
+export function isValidClaudeSetupToken(value) {
+    return SETUP_TOKEN_RE.test(value);
+}
 /** The per-account key an email maps to inside the `auth` bundle. */
 export function claudeAccountTokenKey(account) {
     const slug = account
@@ -55,7 +73,15 @@ export function resolveClaudeSetupToken(home) {
             return null;
         const { env } = readAndResolveBundleEnv(AUTH_BUNDLE, { caller: 'usage', agentOnly: true });
         const v = (env[claudeAccountTokenKey(email)] ?? '').trim();
-        return v.length > 0 ? v : null;
+        if (v.length === 0)
+            return null;
+        // Reject a malformed stored value (e.g. a captured setup-token TTY blob, #1767)
+        // rather than let it become an `Authorization: Bearer <blob>` header that
+        // Anthropic rejects and crashes the run. A corrupt entry is treated as no
+        // usable file-based token, so the caller falls back to the normal login.
+        if (!isValidClaudeSetupToken(v))
+            return null;
+        return v;
     }
     catch {
         return null;

package/dist/lib/crabbox/cli.d.ts

@@ -186,6 +186,8 @@ export interface CrabboxRunOptions extends CrabboxOptions {
     onData?: (chunk: string) => void;
     /** Force a full remote resync before running. */
     fullResync?: boolean;
+    /** Refresh an existing lease with this idle window before running. */
+    renewIdleTimeoutSecs?: number;
 }
 /**
  * Run `remoteCmd` on the leased box via `crabbox run` (crabbox syncs the dirty

package/dist/lib/crabbox/cli.js

@@ -485,6 +485,8 @@ export function crabboxRun(slug, remoteCmd, opts = {}) {
 export function crabboxRunScript(slug, script, opts = {}) {
     findCrabbox();
     const args = ['run', '--id', slug, '--reclaim'];
+    if (opts.renewIdleTimeoutSecs !== undefined)
+        args.push('--idle-timeout', `${opts.renewIdleTimeoutSecs}s`);
     if (opts.fullResync)
         args.push('--full-resync');
     args.push('--script-stdin');

package/dist/lib/crabbox/lease.js

@@ -233,7 +233,9 @@ export function isExpiredPoolStray(box, opts) {
         return false;
     if (box.expiresAt === null || box.expiresAt > nowSecs)
         return false; // unexpired ⇒ reusable
-    if (box.lastTouchedAt !== null && nowSecs - box.lastTouchedAt < graceSecs)
+    if (box.lastTouchedAt === null)
+        return false; // unknown age is never reap-safe
+    if (nowSecs - box.lastTouchedAt < graceSecs)
         return false; // maybe active
     return true;
 }
@@ -329,9 +331,13 @@ export async function leaseAndRun(opts) {
     let exitCode = null;
     let toreDown = false;
     try {
+        const renewIdleTimeoutSecs = reused && !opts.reuseBox && box.idleTimeoutSecs !== null
+            ? box.idleTimeoutSecs
+            : undefined;
         exitCode = await crabboxRunScript(box.slug, script, {
             secretsBundle: opts.secretsBundle,
             onData: opts.onData,
+            renewIdleTimeoutSecs,
         });
     }
     finally {

package/dist/lib/daemon.js

@@ -20,6 +20,7 @@ import { executeJobDetached, monitorRunningJobs } from './runner.js';
 import { detectOverdueJobs, notifyOverdue } from './overdue.js';
 import { runCatchup } from './catchup.js';
 import { notifyRoutineStart, notifyRoutineFinish, notifyRoutineStartFailed } from './routine-notify.js';
+import { notifyOwnerRoutineFinish, notifyOwnerRoutineStartFailed } from './routine-notify-owner.js';
 import { BrowserService } from './browser/service.js';
 import { BrowserIPCServer } from './browser/ipc.js';
 import { redactSecrets } from './redact.js';
@@ -516,6 +517,16 @@ export async function runDaemon() {
                         notifyRoutineFinish(final);
                     }
                     catch { /* best-effort */ }
+                    // RUSH-2288: a failed/timed-out routine also reaches the OWNER's phone
+                    // (in-process owner channel stack), not just the local desktop. Green
+                    // runs are silent — the builder returns early. Async + swallowed so a
+                    // delivery hiccup never blocks the finish path.
+                    void notifyOwnerRoutineFinish(final)
+                        .then((r) => {
+                        if (r.attempts.length && !r.delivered)
+                            log('WARN', `Owner failure-notify for '${config.name}' reached no channel (tried: ${r.attempts.map((a) => a.channel).join(', ')})`);
+                    })
+                        .catch(() => { });
                 },
             });
             log('INFO', `Job '${config.name}' spawned (run: ${meta.runId}, PID: ${meta.pid})`);
@@ -531,6 +542,15 @@ export async function runDaemon() {
                 notifyRoutineStartFailed(config, message);
             }
             catch { /* best-effort */ }
+            // RUSH-2288: the pre-spawn failure (e.g. auth_failed) is exactly the one the
+            // per-routine `agents notify` prompt can never send — its agent never ran —
+            // so the daemon reaches the owner directly.
+            void notifyOwnerRoutineStartFailed(config, message)
+                .then((r) => {
+                if (r.attempts.length && !r.delivered)
+                    log('WARN', `Owner start-failure notify for '${config.name}' reached no channel (tried: ${r.attempts.map((a) => a.channel).join(', ')})`);
+            })
+                .catch(() => { });
         }
     };
     let scheduler = null;

package/dist/lib/devices/connect.d.ts

@@ -50,6 +50,8 @@ export interface SshHostKeyOptions {
     /** Managed known_hosts path override (tests). Defaults to the CLI-managed store. */
     knownHostsFile?: string;
 }
+/** OpenSSH argv that makes an explicit device key authoritative. */
+export declare function deviceIdentityArgs(device: DeviceProfile): string[];
 /**
  * Build the argv (after the `ssh` program name) and the environment overlay
  * for connecting to a device. For password auth this points `SSH_ASKPASS` at

package/dist/lib/devices/connect.js

@@ -82,6 +82,12 @@ export function wrapRemoteCommand(device, cmd) {
     }
     return joined;
 }
+/** OpenSSH argv that makes an explicit device key authoritative. */
+export function deviceIdentityArgs(device) {
+    return device.auth?.method === 'key' && device.auth.identityFile
+        ? ['-i', device.auth.identityFile, '-o', 'IdentitiesOnly=yes']
+        : [];
+}
 /**
  * Build the argv (after the `ssh` program name) and the environment overlay
  * for connecting to a device. For password auth this points `SSH_ASKPASS` at
@@ -118,6 +124,7 @@ export function buildSshInvocation(device, cmd, askpassShimPath, hostKey = {}, o
     }
     else {
         args.push('-o', 'BatchMode=yes');
+        args.push(...deviceIdentityArgs(device));
     }
     // An interactive login (no remote command) needs a real tty.
     if (!remote)

package/dist/lib/devices/doctor-findings.d.ts

@@ -2,6 +2,7 @@ import type { AgentId } from '../types.js';
 import type { DuplicateVersionHook } from '../hooks.js';
 import type { RcSecretFinding } from '../secrets/rc-hygiene.js';
 import type { OwnerSinkStatus } from '../channels/owner-sink.js';
+import { type WindowsSshEnrollmentAudit } from './windows-ssh-enrollment.js';
 import type { SyncStatusRow, OrphanRow } from '../drift.js';
 import type { FetchStatusMarker } from '../auto-pull.js';
 import type { VersionResourceReport } from '../doctor-diff.js';
@@ -11,7 +12,7 @@ export type FindingSeverity = 'critical' | 'warning';
  *  the JSON consumer group by kind. */
 /** Every finding class. Severity is NOT annotated here — {@link FINDING_SEVERITY}
  *  below owns it, and a second copy in these comments is a fourth place to drift. */
-export declare const ALL_FINDING_KINDS: readonly ["logged-out", "logout-unprovable", "missing-hook", "missing-plugin", "unwired-hook", "cli-missing", "missing-resource", "content-drift", "never-synced", "stale", "repo-behind", "repo-drift", "fleet-resource-gap", "host-cli-missing", "host-cli-invalid", "version-skew", "orphan", "duplicate-hook", "duplicate-hook-drift", "rc-secret-export", "env-secret-export", "exec-policy", "stale-cli", "owner-sink-unreachable"];
+export declare const ALL_FINDING_KINDS: readonly ["logged-out", "logout-unprovable", "missing-hook", "missing-plugin", "unwired-hook", "cli-missing", "missing-resource", "content-drift", "never-synced", "stale", "repo-behind", "repo-drift", "fleet-resource-gap", "host-cli-missing", "host-cli-invalid", "version-skew", "orphan", "duplicate-hook", "duplicate-hook-drift", "rc-secret-export", "env-secret-export", "exec-policy", "ssh-key-enrollment", "stale-cli", "owner-sink-unreachable"];
 /**
  * The severity each kind is emitted with - the SINGLE source of truth, read by
  * the builders below and asserted against both prose rubrics by
@@ -102,6 +103,8 @@ export interface LocalFindingInputs {
         platform: NodeJS.Platform;
         policy: string | null;
     };
+    /** Read-only Windows OpenSSH AuthorizedKeysFile/content/ACL audit. */
+    windowsSshEnrollment?: WindowsSshEnrollmentAudit | null;
     /** `<agent>@<version>` keys whose home is an isolated copy. Their findings are
      *  never collapsed across versions: the agent-wide `agents doctor <agent> --fix`
      *  sweep deliberately skips isolated copies, so a collapsed row would print a

package/dist/lib/devices/doctor-findings.js

@@ -18,7 +18,7 @@
  * with. Keep this list exhaustive; a kind missing from it is a doc that lies.
  *   CRITICAL — logged-out (provable) · missing-hook · missing-plugin ·
  *              unwired-hook (a hook on disk that settings.json never fires) ·
- *              cli-missing · owner-sink-unreachable (the feed/notify owner lane
+ *              cli-missing · ssh-key-enrollment · owner-sink-unreachable (the feed/notify owner lane
  *              cannot reach the owner from this box).
  *   WARNING  — logout-unprovable (hedged) · missing-resource · content-drift ·
  *              never-synced · stale · repo-behind · repo-drift · version-skew ·
@@ -40,6 +40,7 @@ import { blocksLocalScripts } from '../platform/winpath.js';
 import { loginHint } from '../signin-badge.js';
 import { CONFIG_ENV_ISOLATED_AGENTS } from '../shims.js';
 import { padToWidth, stringWidth } from '../session/width.js';
+import { windowsSshEnrollmentProblem } from './windows-ssh-enrollment.js';
 const AGENT_NAMES = Object.fromEntries(ALL_AGENT_IDS.map((id) => [id, AGENTS[id].name]));
 /** Agents with NO per-version credential isolation: their login is shared across
  *  every installed version, so a "log into THIS version" remediation would be a
@@ -97,6 +98,7 @@ export const ALL_FINDING_KINDS = [
     'rc-secret-export', // credential-shaped export in a shell rc file
     'env-secret-export', // the file-store master key live in THIS process's env
     'exec-policy', // Windows execution policy blocks agents.ps1
+    'ssh-key-enrollment', // Windows OpenSSH public-key path/content/ACL is invalid
     'stale-cli',
     'owner-sink-unreachable', // the feed/notify owner-delivery lane can't reach the owner from this box
 ];
@@ -141,6 +143,7 @@ export const FINDING_SEVERITY = {
     'rc-secret-export': 'warning',
     'env-secret-export': 'warning',
     'exec-policy': 'warning',
+    'ssh-key-enrollment': 'critical',
     'stale-cli': 'warning',
 };
 function agentName(agent) {
@@ -254,6 +257,8 @@ export function remediationFor(finding) {
             return 'unset at the source, then restart every process that inherited it (shells, editor, tmux, agents daemon)';
         case 'exec-policy':
             return 'Set-ExecutionPolicy -Scope CurrentUser RemoteSigned';
+        case 'ssh-key-enrollment':
+            return 'repair the reported AuthorizedKeysFile, then rerun agents doctor';
         case 'stale-cli':
             return 'upgrade';
         case 'owner-sink-unreachable':
@@ -493,6 +498,15 @@ export function buildLocalFindings(input) {
     const policyFinding = execPolicyFinding(device, input.execPolicy);
     if (policyFinding)
         out.push(policyFinding);
+    if (input.windowsSshEnrollment) {
+        const problem = windowsSshEnrollmentProblem(input.windowsSshEnrollment);
+        if (problem) {
+            out.push(finding({
+                severity: FINDING_SEVERITY['ssh-key-enrollment'], kind: 'ssh-key-enrollment', device,
+                message: problem,
+            }));
+        }
+    }
     // Per-version sign-in → logged-out (critical, provable) / logout-unprovable
     // (warning). Signed-in versions produce no finding — the accounts line shows
     // them. Agents that can't be inspected never yield a logout finding.

package/dist/lib/devices/harness-inventory.d.ts

@@ -0,0 +1,97 @@
+import type { AgentId } from '../types.js';
+import { type UsageSnapshot } from '../usage.js';
+/** An account's usage headroom rolled into one glanceable summary. */
+export interface QuotaSummary {
+    /**
+     * `available` / `rate_limited` from the live usage windows, or `null` when
+     * there is no snapshot at all (no data yet, or the agent has no usage source).
+     */
+    status: 'available' | 'rate_limited' | null;
+    /** Max utilization across blocking windows (0-100, rounded), or null when unknown. */
+    usedPercent: number | null;
+    /** True when the snapshot is a cached `last_seen`, not a fresh `live` read. */
+    stale: boolean;
+}
+/** One installed (agent, version) on a host, fully resolved. */
+export interface HarnessRow {
+    agent: AgentId;
+    version: string;
+    /** Account display label (email / id), or null when signed out or unidentifiable. */
+    account: string | null;
+    signedIn: boolean;
+    quota: QuotaSummary;
+    /** signed in AND not rate-limited — usable for a run right now. */
+    ready: boolean;
+    /** When `!ready`, a short reason ("signed out" / "rate-limited"). */
+    reason?: string;
+}
+/** One host's rows, or the reason it produced none. */
+export interface HostHarnessResult {
+    host: string;
+    rows: HarnessRow[];
+    /** Set when the host failed to probe (offline / error). */
+    error?: string;
+    /** Set when the host was skipped (control / offline). */
+    skipped?: string;
+}
+/** An account collapsed across the installs on one host that share it. */
+export interface AccountGroup {
+    /** Account display label, or null for the signed-out bucket. */
+    account: string | null;
+    /** Distinct agent ids using this account, sorted. */
+    agents: AgentId[];
+    /** How many (agent, version) installs share this account. */
+    installs: number;
+    /** True when at least one install under this account is signed in. */
+    signedIn: boolean;
+    /** Representative quota — an account maps to one provider identity, so its usage is shared. */
+    quota: QuotaSummary;
+    ready: boolean;
+    reason?: string;
+}
+/**
+ * Roll one usage snapshot into a {@link QuotaSummary}. Mirrors the blocking-window
+ * selection of {@link deriveUsageStatusFromSnapshot} (the model-specific
+ * `sonnet_week` sub-limit is excluded so hitting it doesn't read as a throttled
+ * account) and takes the highest utilization across those windows. Pure.
+ */
+export declare function summarizeQuota(snapshot: UsageSnapshot | null | undefined): QuotaSummary;
+/**
+ * "Ready" = signed in AND not rate-limited. A missing quota snapshot does NOT
+ * block readiness: the account is signed in and usable, we just have no live
+ * utilization to show. Pure.
+ */
+export declare function computeReady(signedIn: boolean, quota: QuotaSummary): {
+    ready: boolean;
+    reason?: string;
+};
+/**
+ * Enumerate every installed (agent, version) on THIS host, resolve account +
+ * sign-in + quota + ready, and return the rows. Signed-out installs are kept
+ * (they are the actionable ones), unlike the auth-health probe which drops
+ * `unconfigured`. Quota is cache-only unless `refresh` is set.
+ */
+export declare function collectLocalHarnessInventory(opts?: {
+    agents?: readonly AgentId[];
+    refresh?: boolean;
+}): Promise<HarnessRow[]>;
+/**
+ * Collapse a host's rows into one {@link AccountGroup} per distinct account (the
+ * signed-out installs fall into the `null` bucket). Because an account label maps
+ * to a single provider identity, every install sharing it shares one quota, so
+ * the group's quota is taken from the first row carrying real data (preferring a
+ * `rate_limited` row so a throttle is never hidden). Pure.
+ */
+export declare function groupByAccount(rows: HarnessRow[]): AccountGroup[];
+/** Short human quota cell: "12%", "limited", or "—" when no data. */
+export declare function formatQuota(quota: QuotaSummary): string;
+/**
+ * Render the device × harness table: one block per device, one row per installed
+ * (agent, version) with account / signed-in / quota / ready. Pure.
+ */
+export declare function renderHarnessMatrix(results: HostHarnessResult[]): string[];
+/**
+ * Render the device × account table: one block per device, one row per distinct
+ * account (installs sharing it collapsed), showing which harnesses use it. Pure.
+ */
+export declare function renderAccountsMatrix(results: HostHarnessResult[]): string[];

package/dist/lib/devices/registry.d.ts

@@ -26,6 +26,8 @@ export interface DeviceAddress {
 /** Authentication settings for a device. */
 export interface DeviceAuth {
     method: DeviceAuthMethod;
+    /** Explicit private-key path passed to OpenSSH for key authentication. */
+    identityFile?: string;
     /** Secrets bundle holding the password (when method === 'password'). */
     bundle?: string;
     /** Key within the bundle whose value is the password. Defaults to 'password'. */