@skrr-ai/cli 0.1.40 → 0.1.41

package/dist/commands/harnesses/list.js

@@ -1,18 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.HARNESS_STATUS_FILTERS = exports.ALIAS_MARKER = void 0;
 exports.shortMachineLabel = shortMachineLabel;
 exports.emptyListMessage = emptyListMessage;
+exports.harnessNameCell = harnessNameCell;
 exports.defaultMarker = defaultMarker;
+exports.serverStatusParam = serverStatusParam;
 exports.isLocalHarnessRow = isLocalHarnessRow;
 exports.selectHarnessRows = selectHarnessRows;
 exports.buildHarnessesJson = buildHarnessesJson;
+exports.readinessFootnotes = readinessFootnotes;
 exports.canonicalHarnessRows = canonicalHarnessRows;
 const core_1 = require("@oclif/core");
 const auth_core_1 = require("@skrr-ai/auth-core");
 const base_command_1 = require("../../base-command");
 const api_fetch_1 = require("../../lib/api-fetch");
+const cli_installers_1 = require("../../lib/cli-installers");
 const format_1 = require("../../lib/format");
 const harness_provider_input_1 = require("../../lib/harness-provider-input");
+const data_provider_1 = require("@skrr-ai/data-provider");
+const harness_labels_1 = require("../../lib/harness-labels");
 /**
  * Products skrr provisions and owns. A row that says it is one of these is
  * cloud, whatever `harnessLocation` reads.
@@ -50,17 +57,48 @@ function shortMachineLabel(machineUuid) {
  * pointing at the one command that shows which providers actually exist.
  */
 function emptyListMessage(input) {
+    if (input.provider) {
+        const known = input.accountProviders;
+        // A provider that appears on no row of the account — a typo, or a harness
+        // never registered — is a different fact from one whose rows are merely
+        // hidden by a filter. Both used to print the same sentence (OSK-9285).
+        if (known && !known.includes(input.provider)) {
+            return known.length > 0
+                ? `No harness on this account has provider "${input.provider}". Providers here: ${known.join(', ')}.`
+                : `No harness on this account has provider "${input.provider}", and the account has no harnesses yet.`;
+        }
+        const lifts = [];
+        if (!input.all)
+            lifts.push('offline rows are hidden by default (--all shows them)');
+        if (input.local)
+            lifts.push('hosted rows are excluded (--no-local includes them)');
+        const liftText = lifts.join('; ');
+        return (`No harnesses with provider "${input.provider}" match these filters.` +
+            (liftText ? ` ${liftText.charAt(0).toUpperCase()}${liftText.slice(1)}.` : '') +
+            (known
+                ? ''
+                : ' Run `skrr harnesses list --all` without --provider to see which providers this account has registered.'));
+    }
     const hiddenByDefault = input.local
         ? ' Offline rows are hidden by default (--all shows them) and hosted rows are excluded (--no-local includes them).'
         : '';
-    if (input.provider) {
-        return (`No harnesses with provider "${input.provider}".${hiddenByDefault}` +
-            ' Run `skrr harnesses list --all` without --provider to see which providers this account has registered.');
-    }
     return input.local
         ? `No harnesses found. Is your daemon connected?${hiddenByDefault}`
         : 'No harnesses found.';
 }
+/**
+ * The NAME cell. `show` and `--json` said when YOUR alias covers the shared
+ * name; this table printed the alias as if it were the name everyone sees
+ * (OSK-10004). The marker leads because the column truncates from the right,
+ * and a trailing one is the first thing a long name would cut.
+ */
+exports.ALIAS_MARKER = '*';
+function harnessNameCell(row) {
+    // The same rule the web sidebar renders (OSK-9290): a name stored under an
+    // older spelling or `oversky …` name is not a second product.
+    const name = row.name ? (0, data_provider_1.canonicalizeHarnessLabel)(row.name) : (0, format_1.formatCell)(row.name);
+    return (0, harness_labels_1.isAliasCoveringSharedName)(row) ? `${exports.ALIAS_MARKER} ${name}` : name;
+}
 /**
  * What the DEFAULT column says for one row.
  *
@@ -84,6 +122,26 @@ const MANAGED_REGISTRATION_SOURCES = new Set([
     'hosted-job-machine',
     'cloud-coding',
 ]);
+/**
+ * What `--status` accepts: exactly what the STATUS column prints (OSK-10005).
+ *
+ * The column says `superseded` for a row a later registration on the same
+ * machine replaced; the filter accepted only online|offline, so the one value
+ * that says "never coming back" could be read and never selected.
+ */
+exports.HARNESS_STATUS_FILTERS = ['online', 'offline', 'superseded'];
+/**
+ * The status to ask the SERVER for. Only `online` narrows there.
+ *
+ * Supersession is judged among the rows in one response — a row is superseded
+ * when a newer row for the same provider on the same machine exists. Asked for
+ * `offline` only, the server cannot see the live row that replaced an offline
+ * one, so it labelled that row `offline` while `--all` called it `superseded`.
+ * Online rows are never superseded, so that one filter is safe to push down.
+ */
+function serverStatusParam(status) {
+    return status === 'online' ? 'online' : undefined;
+}
 /**
  * Harness rows created before `harnessLocation` was introduced do not carry that
  * field.  A daemon id is the durable discriminator for those legacy rows:
@@ -155,6 +213,16 @@ function selectHarnessRows(rows, options) {
         const needle = options.daemon.toLowerCase();
         filtered = filtered.filter((r) => (r.daemonId ?? '').toLowerCase().includes(needle));
     }
+    let hiddenSuperseded = 0;
+    if (options.status) {
+        const wanted = options.status;
+        filtered = filtered.filter((r) => {
+            const label = (0, harness_labels_1.harnessStatusLabel)(r);
+            if (label !== wanted && label === 'superseded')
+                hiddenSuperseded += 1;
+            return label === wanted;
+        });
+    }
     const sorted = [...filtered].sort(compareHarnessRows);
     const shown = options.onlineOnly ? sorted.filter((r) => r.status === 'online') : sorted;
     const limited = options.limit != null && options.limit > 0 ? shown.slice(0, options.limit) : shown;
@@ -163,6 +231,7 @@ function selectHarnessRows(rows, options) {
         hiddenByLocal,
         hiddenOffline: sorted.length - shown.length,
         hiddenByLimit: shown.length - limited.length,
+        hiddenSuperseded,
         matched: sorted.length,
     };
 }
@@ -178,9 +247,13 @@ function selectHarnessRows(rows, options) {
  * (`compareHarnessRows`), not in server order. Round 1 introduced that sort;
  * it is deliberate, so `.harnesses[0]` is the row you almost always want.
  */
-function buildHarnessesJson(selection, filters, defaults = {}) {
+function buildHarnessesJson(selection, filters, defaults = {}, readiness) {
     return {
-        harnesses: selection.visible,
+        // `readiness` is the per-provider answer the READINESS column prints —
+        // `null` where no daemon answered for that row, never a guess (OSK-10100).
+        harnesses: readiness
+            ? selection.visible.map((row) => ({ ...row, readiness: readiness(row) ?? null }))
+            : selection.visible,
         filters,
         defaults: {
             effectiveDefaultHarnessId: defaults.effectiveDefaultHarnessId ?? null,
@@ -193,10 +266,61 @@ function buildHarnessesJson(selection, filters, defaults = {}) {
             matched: selection.matched,
             hiddenByLocal: selection.hiddenByLocal,
             hiddenByLimit: selection.hiddenByLimit,
+            hiddenSuperseded: selection.hiddenSuperseded,
             online: selection.visible.filter((r) => r.status === 'online').length,
         },
     };
 }
+/**
+ * What the READINESS column's non-answers mean, counted from the rows shown.
+ *
+ * Each footnote names a different next step, so they are not merged: a `-` on
+ * an offline row wants `--all`/a started daemon, a `-` on a provider the daemon
+ * does not manage (hermes, gemini) wants nothing, `unknown` is installed but
+ * unverifiable, and only a definite not-ready label (interactive-required,
+ * not-installed, …) has something to fix. Counting `unknown` as not ready
+ * would send the reader to fix eleven rows that are fine as far as anyone can
+ * tell.
+ */
+function readinessFootnotes(rows, readiness) {
+    const lines = [];
+    let notLive = 0;
+    let unmanaged = 0;
+    let noAnswer = 0;
+    let unknown = 0;
+    let notReady = 0;
+    for (const row of rows) {
+        const verdict = readiness.lookup(row);
+        if (verdict) {
+            if (verdict.label === 'unknown')
+                unknown += 1;
+            else if (!verdict.ok)
+                notReady += 1;
+        }
+        else if (row.status !== 'online' || row.superseded)
+            notLive += 1;
+        else if (readiness.daemonAnswered(row))
+            unmanaged += 1;
+        else
+            noAnswer += 1;
+    }
+    const dash = [];
+    if (notLive > 0)
+        dash.push(`${notLive} offline or superseded`);
+    if (unmanaged > 0)
+        dash.push(`${unmanaged} a provider its daemon does not report on`);
+    if (noAnswer > 0)
+        dash.push(`${noAnswer} whose daemon did not answer in time`);
+    if (dash.length > 0)
+        lines.push(`(READINESS -: ${dash.join('; ')}.)`);
+    if (unknown > 0) {
+        lines.push(`(READINESS unknown: ${unknown} installed, but the daemon cannot read that provider's sign-in state.)`);
+    }
+    if (notReady > 0) {
+        lines.push(`(${notReady} not ready — \`skrr harnesses show <id>\` says what each needs.)`);
+    }
+    return lines;
+}
 /**
  * Rows with the provider in its CANONICAL spelling.
  *
@@ -253,8 +377,8 @@ class HarnessesList extends base_command_1.BaseCommand {
     static flags = {
         json: core_1.Flags.boolean({ description: 'Output as JSON' }),
         status: core_1.Flags.string({
-            description: 'Filter by harness status.',
-            options: ['online', 'offline'],
+            description: 'Filter by the STATUS column. `offline` leaves out superseded rows — a later registration on the same machine replaced them — and `superseded` lists only those.',
+            options: [...exports.HARNESS_STATUS_FILTERS],
             exclusive: ['online', 'all'],
         }),
         online: core_1.Flags.boolean({
@@ -284,6 +408,11 @@ class HarnessesList extends base_command_1.BaseCommand {
             default: true,
             allowNo: true,
         }),
+        readiness: core_1.Flags.boolean({
+            description: 'Ask each connected daemon whether its coding-agent CLIs are installed and signed in (the READINESS column; `readiness` in --json). One request per daemon. On by default — pass --no-readiness to skip it.',
+            default: true,
+            allowNo: true,
+        }),
     };
     async run() {
         this.requireAuth();
@@ -296,8 +425,9 @@ class HarnessesList extends base_command_1.BaseCommand {
         // asked for the canonical one, which it matches against every stored spelling.
         const provider = flags.provider ? (0, harness_provider_input_1.canonicalHarnessInput)(flags.provider) : undefined;
         const params = new URLSearchParams();
-        if (status)
-            params.set('status', status);
+        const serverStatus = serverStatusParam(status);
+        if (serverStatus)
+            params.set('status', serverStatus);
         if (provider)
             params.set('provider', provider);
         const query = params.toString() ? `?${params.toString()}` : '';
@@ -312,16 +442,36 @@ class HarnessesList extends base_command_1.BaseCommand {
             local: flags.local,
             daemon: flags.daemon,
             limit: flags.limit,
+            status,
             onlineOnly: false,
         });
+        // STATUS is the daemon's socket, not the coding agent: a Devin that needs
+        // sign-in read `online` exactly like a ready one, and `list` is where a
+        // user picks a harness (OSK-10100). One read per connected daemon, bounded;
+        // a daemon that cannot answer leaves its rows unknown rather than failing
+        // the list.
+        const readiness = flags.readiness
+            ? await (0, cli_installers_1.readinessForRows)(selection.visible, this.resolvedCredential)
+            : null;
         if (flags.json) {
+            // A provider no row on the account has is a typo (or a harness never
+            // registered), and a script that got an empty list and exit 0 could not
+            // tell it from a filter that hid real rows — the silent failure OSK-9285
+            // describes. Refused exactly as the table refuses it; a real provider
+            // whose rows a filter hid still gets its empty list.
+            if (provider && selection.visible.length === 0) {
+                const accountProviders = await this.accountProviders();
+                if (accountProviders && !accountProviders.includes(provider)) {
+                    this.error(emptyListMessage({ provider, local: flags.local, all: flags.all, accountProviders }), { exit: 1 });
+                }
+            }
             const payload = buildHarnessesJson(selection, {
                 local: flags.local,
                 status: status ?? null,
                 provider: provider ?? null,
                 daemon: flags.daemon ?? null,
                 limit: flags.limit ?? null,
-            }, res);
+            }, res, readiness ? readiness.lookup : () => undefined);
             this.log(JSON.stringify(payload, null, 2));
             return;
         }
@@ -338,18 +488,39 @@ class HarnessesList extends base_command_1.BaseCommand {
             if (selection.hiddenByLocal > 0) {
                 hidden.push(`${selection.hiddenByLocal} hosted (--no-local)`);
             }
+            if (selection.hiddenSuperseded > 0) {
+                hidden.push(`${selection.hiddenSuperseded} superseded (--status superseded)`);
+            }
             if (hidden.length > 0) {
                 this.log(`No harnesses match the default filters. Hidden: ${hidden.join(', ')}.`);
                 return;
             }
-            this.log(emptyListMessage({ provider: provider ?? null, local: flags.local }));
+            if (!provider) {
+                this.log(emptyListMessage({ provider: null, local: flags.local, all: flags.all }));
+                return;
+            }
+            const accountProviders = await this.accountProviders();
+            const message = emptyListMessage({
+                provider,
+                local: flags.local,
+                all: flags.all,
+                accountProviders,
+            });
+            if (accountProviders && !accountProviders.includes(provider)) {
+                // Nothing on the account answers to this name: exit non-zero so a script
+                // cannot mistake a typo for an empty-but-valid filter. `--json` refuses it
+                // the same way (above).
+                this.error(message, { exit: 1 });
+            }
+            this.log(message);
             return;
         }
         const tableRows = selection.visible.map((r) => ({
             id: (0, format_1.formatCell)(r._id),
-            name: (0, format_1.formatCell)(r.name),
-            provider: (0, format_1.formatCell)(r.provider),
-            status: r.superseded ? 'superseded' : (0, format_1.formatCell)(r.status),
+            name: harnessNameCell(r),
+            provider: (0, harness_labels_1.harnessProviderLabel)(r.provider),
+            status: (0, harness_labels_1.harnessStatusLabel)(r),
+            readiness: readiness?.lookup(r)?.label ?? '-',
             default: defaultMarker(r._id, res),
             daemon: (0, format_1.formatCell)(r.daemonId),
             model: (0, format_1.formatCell)(r.model),
@@ -363,6 +534,7 @@ class HarnessesList extends base_command_1.BaseCommand {
         // only inside a third command (`machines show`). Now that the server labels
         // supersession here too, say it where the rows are.
         const supersededShown = selection.visible.filter((r) => r.superseded).length;
+        const aliasedShown = selection.visible.filter((r) => (0, harness_labels_1.isAliasCoveringSharedName)(r)).length;
         (0, format_1.renderTable)(tableRows, [
             { key: 'id', header: 'HARNESS ID' },
             // `harnesses alias` exists to make a row recognisable in a LIST. Without
@@ -371,6 +543,11 @@ class HarnessesList extends base_command_1.BaseCommand {
             { key: 'name', header: 'NAME', maxWidth: 22 },
             { key: 'provider', header: 'PROVIDER' },
             { key: 'status', header: 'STATUS' },
+            // Whether the coding agent itself can run — installed, signed in — as
+            // opposed to STATUS, which is only whether its daemon is connected.
+            ...(readiness && readiness.answered > 0
+                ? [{ key: 'readiness', header: 'READINESS' }]
+                : []),
             // `set-default` had no reader anywhere in the CLI. This is it.
             { key: 'default', header: 'DEFAULT' },
             { key: 'daemon', header: 'DAEMON ID', verbatim: true },
@@ -378,11 +555,28 @@ class HarnessesList extends base_command_1.BaseCommand {
             { key: 'machine', header: 'MACHINE' },
             { key: 'seen', header: `LAST SEEN (${(0, format_1.localZone)()})` },
         ], (line) => this.log(line));
+        if (readiness && readiness.answered > 0) {
+            for (const line of readinessFootnotes(selection.visible, readiness))
+                this.log(line);
+        }
+        else if (readiness && readiness.asked > 0) {
+            this.log('(Readiness not reported — no connected daemon answered. `skrr harnesses installers --daemon <DAEMON ID>` asks one directly.)');
+        }
+        const noCodingAgentShown = selection.visible.filter((r) => (0, harness_labels_1.isNoCodingAgentProvider)(r.provider)).length;
+        if (noCodingAgentShown > 0) {
+            this.log(`(provider ${harness_labels_1.NO_CODING_AGENT_PROVIDER_LABEL}: ${noCodingAgentShown} shown are machines with no coding agent installed — the row is how the machine is listed, not a harness named for a provider.)`);
+        }
+        if (aliasedShown > 0) {
+            this.log(`(${exports.ALIAS_MARKER} your alias — everyone else this harness is shared with sees its shared name. \`skrr harnesses show <id>\` prints both.)`);
+        }
         if (supersededShown > 0) {
             // This is the sentence that makes `machines list`'s fraction derivable
             // from here: live = printed − superseded.
             this.log(`(${supersededShown} of ${selection.visible.length} shown are superseded — a later registration on the same machine replaced them, so they will not come back. ${selection.visible.length - supersededShown} live.)`);
         }
+        if (selection.hiddenSuperseded > 0) {
+            this.log(`(${selection.hiddenSuperseded} superseded hidden — \`--status superseded\` lists them.)`);
+        }
         if (selection.hiddenByLocal > 0) {
             // Same reason as the JSON `counts` block: the `--local` default is the
             // single biggest source of "the list is shorter than I expected".
@@ -397,5 +591,27 @@ class HarnessesList extends base_command_1.BaseCommand {
             this.log(`(showing ${selection.visible.length} of ${selection.visible.length + selection.hiddenByLimit} — raise --limit for the rest)`);
         }
     }
+    /**
+     * The canonical providers this account has any row for, or null when that
+     * cannot be read. Asked only when a --provider filter came back empty, so
+     * the ordinary path pays nothing for it.
+     */
+    async accountProviders() {
+        try {
+            const all = await (0, api_fetch_1.apiFetch)('/api/harnesses', {
+                credential: this.resolvedCredential,
+            });
+            const providers = new Set();
+            for (const row of canonicalHarnessRows(all.harnesses ?? [])) {
+                if (typeof row.provider === 'string' && !(0, harness_labels_1.isNoCodingAgentProvider)(row.provider)) {
+                    providers.add(row.provider);
+                }
+            }
+            return [...providers].sort();
+        }
+        catch {
+            return null;
+        }
+    }
 }
 exports.default = HarnessesList;

package/dist/commands/harnesses/ping.d.ts

@@ -19,4 +19,6 @@ export default class HarnessesPing extends BaseCommand {
         timeout: import("@oclif/core/lib/interfaces").OptionFlag<number, import("@oclif/core/lib/interfaces").CustomOptions>;
     };
     run(): Promise<void>;
+    /** Best-effort: never turns a successful ping into a failure. */
+    private logReadiness;
 }

package/dist/commands/harnesses/ping.js

@@ -4,6 +4,7 @@ exports.isPingSuccess = isPingSuccess;
 const core_1 = require("@oclif/core");
 const base_command_1 = require("../../base-command");
 const harnesses_1 = require("../../lib/harnesses");
+const cli_installers_1 = require("../../lib/cli-installers");
 /**
  * Is this machine actually reachable right now?
  *
@@ -84,6 +85,9 @@ class HarnessesPing extends base_command_1.BaseCommand {
                     this.log(result.latencyMs != null
                         ? `Answered in ${result.latencyMs}ms.`
                         : 'Answered (no latency reported).');
+                    // Answering proves the daemon is reachable, not that this harness can
+                    // run a turn — a signed-out Devin answers too (OSK-9263).
+                    await this.logReadiness(args.harness);
                 }
                 else {
                     this.log(`Ping ${result.status}${result.error ? `: ${result.error}` : ''}.`);
@@ -104,5 +108,22 @@ class HarnessesPing extends base_command_1.BaseCommand {
             await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
         }
     }
+    /** Best-effort: never turns a successful ping into a failure. */
+    async logReadiness(harnessId) {
+        try {
+            const response = await (0, harnesses_1.getHarness)(harnessId);
+            const harness = response?.harness ??
+                response;
+            if (!harness?.daemonId)
+                return;
+            const readiness = await (0, cli_installers_1.readinessByProvider)(harness.daemonId, this.resolvedCredential);
+            const verdict = readiness?.get((0, cli_installers_1.readinessKey)(harness.provider));
+            if (verdict)
+                this.log(`Readiness: ${verdict.label} — ${verdict.detail}`);
+        }
+        catch {
+            // A readiness read is extra information; the ping already answered.
+        }
+    }
 }
 exports.default = HarnessesPing;

package/dist/commands/harnesses/show.d.ts

@@ -25,3 +25,25 @@ export default class HarnessesShow extends BaseCommand {
  * still falls through to the general answer rather than being guessed at.
  */
 export declare function describeWrongHarnessRef(ref: string): string;
+type HarnessRefResolution = {
+    kind: 'harness';
+    id: string;
+} | {
+    kind: 'message';
+    message: string;
+} | {
+    kind: 'none';
+};
+/**
+ * Resolve a reference that is not a full harness id against this account's
+ * rows: a unique id prefix or a unique name selects the harness; a machine uuid
+ * prefix or an ambiguous match explains itself. `none` falls through to the
+ * shape-based message.
+ */
+export declare function resolveHarnessRef(ref: string): Promise<HarnessRefResolution>;
+export declare function pickHarnessRef(rows: Array<{
+    _id: string;
+    name?: string;
+    machineUuid?: string;
+}>, ref: string): HarnessRefResolution;
+export {};

package/dist/commands/harnesses/show.js

@@ -1,11 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.describeWrongHarnessRef = describeWrongHarnessRef;
+exports.resolveHarnessRef = resolveHarnessRef;
+exports.pickHarnessRef = pickHarnessRef;
 const core_1 = require("@oclif/core");
 const base_command_1 = require("../../base-command");
 const harness_provider_input_1 = require("../../lib/harness-provider-input");
 const harnesses_1 = require("../../lib/harnesses");
+const harness_labels_1 = require("../../lib/harness-labels");
+const cli_installers_1 = require("../../lib/cli-installers");
 const api_fetch_1 = require("../../lib/api-fetch");
+const data_provider_1 = require("@skrr-ai/data-provider");
 class HarnessesShow extends base_command_1.BaseCommand {
     static description = 'Show one harness — one provider on one machine';
     static examples = [
@@ -29,20 +34,30 @@ class HarnessesShow extends base_command_1.BaseCommand {
         }
         catch (err) {
             // The server answers a malformed id with "Invalid harness ID", which says
-            // nothing about what a valid one IS or where to get one. The sibling
-            // `machines show` already sets the expectation by accepting what its own
-            // list prints, so failing here with no pointer is the odd one out.
-            // The readable text lives in `body`, not `message` — `message` is
-            // "HTTP 400 Bad Request — GET /api/harnesses/<id>". Any 400 on this
-            // lookup is the id being wrong, so branch on the status.
-            if (err instanceof api_fetch_1.ApiFetchError && err.status === 400) {
-                this.error(`Not a harness id: ${args.harness}\n${describeWrongHarnessRef(args.harness)}`, {
-                    exit: 1,
-                });
+            // nothing about what a valid one IS or where to get one. The readable
+            // text lives in `body`, not `message`, and any 400 on this lookup is the
+            // id being wrong, so branch on the status.
+            if (!(err instanceof api_fetch_1.ApiFetchError && err.status === 400)) {
+                this.handleApiError(err);
+                return;
+            }
+            // Before refusing, try what other commands PRINT: the head of a harness
+            // id, a harness name, or a machine uuid. `machines show` accepts prefixes
+            // and names; this sibling answered the same input with a generic "24
+            // hexadecimal characters" (OSK-9313).
+            const resolved = await resolveHarnessRef(args.harness);
+            if (resolved.kind !== 'harness') {
+                const why = resolved.kind === 'message' ? resolved.message : describeWrongHarnessRef(args.harness);
+                this.error(`Not a harness id: ${args.harness}\n${why}`, { exit: 1 });
+                return;
+            }
+            try {
+                response = await (0, harnesses_1.getHarness)(resolved.id);
+            }
+            catch (retryErr) {
+                this.handleApiError(retryErr);
                 return;
             }
-            this.handleApiError(err);
-            return;
         }
         const stored = response?.harness;
         // Canonical spelling in every output, whichever spelling the row was stored under.
@@ -53,13 +68,30 @@ class HarnessesShow extends base_command_1.BaseCommand {
             this.error(`No harness ${args.harness}.`, { exit: 1 });
             return;
         }
+        // `status online` is a heartbeat, not "this harness can run a turn": a
+        // Devin that is installed and not signed in read as fully usable (OSK-9263).
+        // Asked of the daemon, so only for a live local row; best-effort.
+        const readiness = harness.daemonId &&
+            harness.harnessLocation === 'local' &&
+            harness.status === 'online' &&
+            !harness.superseded
+            ? await (0, cli_installers_1.readinessByProvider)(harness.daemonId, this.resolvedCredential)
+            : null;
+        const verdict = readiness?.get((0, cli_installers_1.readinessKey)(harness.provider));
         if (flags.json) {
-            this.log(JSON.stringify(harness, null, 2));
+            // `authStatus` is the DAEMON's sign-in to skrr, the same on every row of a
+            // daemon, so a script read a signed-out Devin as "ok" (OSK-9263/OSK-9265
+            // verifiers). `readiness` is the per-provider answer the text prints;
+            // null when it was not asked (not a live local row) or not reported.
+            this.log(JSON.stringify({ ...harness, readiness: verdict ?? null }, null, 2));
             return;
         }
-        this.log(`${harness.name || harness._id}`);
+        // The same rule the list applies (OSK-9649): a no-engine placeholder's
+        // stored name is "oversky — <machine>", which headed this view with a
+        // provider name that is not one.
+        this.log(`${harness.name ? (0, data_provider_1.canonicalizeHarnessLabel)(harness.name) : harness._id}`);
         this.log(`  id          ${harness._id}`);
-        this.log(`  provider    ${harness.provider}`);
+        this.log(`  provider    ${(0, harness_labels_1.harnessProviderDescription)(harness.provider)}`);
         // `harnessLocation` is the difference between "your laptop" and "a cloud row",
         // and it decides which verbs apply: ping and claudeEngine are local-only.
         // When YOUR alias is covering the shared name, say so and show both. The
@@ -67,11 +99,11 @@ class HarnessesShow extends base_command_1.BaseCommand {
         // value `harnesses update --name` just wrote appears on no surface at all,
         // and you cannot tell you are reading your own label rather than the one
         // everyone else sees.
-        if (harness.aliased && harness.sharedName && harness.sharedName !== harness.name) {
+        if ((0, harness_labels_1.isAliasCoveringSharedName)(harness)) {
             this.log(`  shared name ${harness.sharedName}  (your alias is showing instead)`);
         }
         this.log(`  mode        ${harness.harnessLocation ?? 'unknown'}`);
-        this.log(`  status      ${harness.status ?? 'unknown'}`);
+        this.log(`  status      ${(0, harness_labels_1.harnessStatusLabel)(harness)}`);
         // Only for the claude provider. The daemon stamps `claudeEngine` on every
         // harness it registers, so printing it whenever it is set labels a
         // first-party harness or `codex` row with how CLAUDE Code would run — a fact about a
@@ -81,6 +113,12 @@ class HarnessesShow extends base_command_1.BaseCommand {
         }
         if (harness.daemonId)
             this.log(`  daemon      ${harness.daemonId}`);
+        if (verdict) {
+            this.log(`  readiness   ${verdict.label} — ${verdict.detail}`);
+        }
+        else if (readiness) {
+            this.log('  readiness   not reported — this daemon does not track credentials for this provider');
+        }
         if (harness.lastSeenAt)
             this.log(`  last seen   ${harness.lastSeenAt}`);
     }
@@ -105,6 +143,14 @@ function describeWrongHarnessRef(ref) {
     if (/^daemon_/.test(ref)) {
         return `That is a daemon id. \`skrr machines show ${ref}\` takes those. ${seeIds}`;
     }
+    if (/^(dedicated-runtime-|hosted-machine-|hosted-runtime-)/.test(ref)) {
+        // Printed in the DAEMON ID column for a rented machine, so it is the same
+        // redirect as `daemon_…`, not a malformed harness id (OSK-9313).
+        return `That is a daemon id. \`skrr machines show ${ref}\` takes those. ${seeIds}`;
+    }
+    if (/^sbs_/.test(ref)) {
+        return `That is a hosted machine id. \`skrr machines show ${ref}\` takes those. ${seeIds}`;
+    }
     if (/^machine:/.test(ref)) {
         return `That is a machine id. \`skrr machines show ${ref}\` takes those. ${seeIds}`;
     }
@@ -118,3 +164,56 @@ function describeWrongHarnessRef(ref) {
     }
     return `A harness id is 24 hexadecimal characters. ${seeIds}`;
 }
+/**
+ * Resolve a reference that is not a full harness id against this account's
+ * rows: a unique id prefix or a unique name selects the harness; a machine uuid
+ * prefix or an ambiguous match explains itself. `none` falls through to the
+ * shape-based message.
+ */
+async function resolveHarnessRef(ref) {
+    if (!ref.trim())
+        return { kind: 'none' };
+    let rows;
+    try {
+        const res = await (0, api_fetch_1.apiFetch)('/api/harnesses');
+        rows = res.harnesses ?? [];
+    }
+    catch {
+        return { kind: 'none' };
+    }
+    return pickHarnessRef(rows, ref);
+}
+function pickHarnessRef(rows, ref) {
+    const typed = ref.trim();
+    const needle = typed.toLowerCase();
+    const byId = rows.filter((r) => r._id.toLowerCase().startsWith(needle));
+    if (byId.length === 1)
+        return { kind: 'harness', id: byId[0]._id };
+    const byName = rows.filter((r) => typeof r.name === 'string' &&
+        (r.name.toLowerCase() === needle ||
+            (0, data_provider_1.canonicalizeHarnessLabel)(r.name).toLowerCase() === needle));
+    if (byName.length === 1)
+        return { kind: 'harness', id: byName[0]._id };
+    const ambiguous = byId.length > 1 ? byId : byName;
+    if (ambiguous.length > 1) {
+        const shown = ambiguous
+            .slice(0, 5)
+            .map((r) => `${r._id}${r.name ? ` (${(0, data_provider_1.canonicalizeHarnessLabel)(r.name)})` : ''}`);
+        return {
+            kind: 'message',
+            message: `"${typed}" matches ${ambiguous.length} harnesses: ${shown.join(', ')}${ambiguous.length > shown.length ? `, and ${ambiguous.length - shown.length} more` : ''}. Use a longer prefix or the full id.`,
+        };
+    }
+    const machine = rows.find((r) => {
+        const uuid = (r.machineUuid ?? '').toLowerCase();
+        const tail = uuid.includes(':') ? uuid.slice(uuid.indexOf(':') + 1) : uuid;
+        return uuid.startsWith(needle) || tail.startsWith(needle);
+    });
+    if (machine) {
+        return {
+            kind: 'message',
+            message: `That is a machine. \`skrr machines show ${typed}\` takes those; its harnesses are listed there.`,
+        };
+    }
+    return { kind: 'none' };
+}