@skrr-ai/cli 0.1.28 → 0.1.29

package/dist/base-command.d.ts

@@ -367,6 +367,21 @@ export declare function withSubject(subject: string | undefined, message: string
  * Exported for tests.
  */
 export declare function describeHarnessUnavailable(body: Record<string, unknown> | null, bin?: string): string;
+/**
+ * Frame a typed `GITHUB_UNAVAILABLE` failure as GitHub being unreachable rather
+ * than as a control-plane outage.
+ *
+ * The CLI's own sentence, keyed on the code, because the server's cannot be
+ * relied on: in production the 5xx redaction boundary keeps `code` and replaces
+ * the message with "An unexpected error occurred." Same meaning as the web's
+ * copy for this code (`hostedJobTaskFailureMessage`) — GitHub, not skrr, and
+ * waiting is the fix.
+ *
+ * Exported for tests.
+ */
+export declare function describeGitHubUnavailable(): string;
+/** A deployment setting cannot recover through a client retry. */
+export declare function describeGitHubAppNotConfigured(): string;
 export declare function describeResourceNotFound(serverMessage: string | undefined, bin?: string, baseURL?: string): string | null;
 export declare function describeAssigneeNotInSpace(serverMessage: string | undefined, bin?: string): string;
 export declare function describeForbidden(bodyMessage?: string | null, method?: string | null): string;

package/dist/base-command.js

@@ -5,6 +5,8 @@ exports.assigneePayloadNeedsResolution = assigneePayloadNeedsResolution;
 exports.parseGlobalFlags = parseGlobalFlags;
 exports.withSubject = withSubject;
 exports.describeHarnessUnavailable = describeHarnessUnavailable;
+exports.describeGitHubUnavailable = describeGitHubUnavailable;
+exports.describeGitHubAppNotConfigured = describeGitHubAppNotConfigured;
 exports.describeResourceNotFound = describeResourceNotFound;
 exports.describeAssigneeNotInSpace = describeAssigneeNotInSpace;
 exports.describeForbidden = describeForbidden;
@@ -851,6 +853,32 @@ class BaseCommand extends core_1.Command {
                     details: body ?? undefined,
                 });
             }
+            else if (bodyCode === 'GITHUB_APP_NOT_CONFIGURED') {
+                this.failWithCliError({
+                    message: say(describeGitHubAppNotConfigured()),
+                    code: bodyCode,
+                    status: e.status,
+                    exit: 2,
+                    retryable: false,
+                    details: body ?? undefined,
+                });
+            }
+            else if (bodyCode === 'GITHUB_UNAVAILABLE') {
+                // GitHub could not be reached — also a 503, also not a platform outage:
+                // the API answered, with a typed code. The body has no `cause` or
+                // `retryable: false`, so without this it reached the outage branch and
+                // told the user skrr was down, and recorded an incident saying so.
+                // Unlike an offline runtime, retrying IS the remedy, so the outage
+                // branch's exit code and verdict stay.
+                this.failWithCliError({
+                    message: say(describeGitHubUnavailable()),
+                    code: bodyCode,
+                    status: e.status,
+                    exit: 5,
+                    retryable: true,
+                    details: body ?? undefined,
+                });
+            }
             else if (bodyCode === 'ASSIGNEE_NOT_IN_SPACE') {
                 // Code-specific enrichment takes precedence over the status heuristic:
                 // the server rejects a non-member assignee by id with no next step, so
@@ -1325,6 +1353,27 @@ function describeHarnessUnavailable(body, bin = 'skrr') {
             `\`${bin} agents attach-harness\`.`;
     return `${lead}\n  → ${fix}`;
 }
+/**
+ * Frame a typed `GITHUB_UNAVAILABLE` failure as GitHub being unreachable rather
+ * than as a control-plane outage.
+ *
+ * The CLI's own sentence, keyed on the code, because the server's cannot be
+ * relied on: in production the 5xx redaction boundary keeps `code` and replaces
+ * the message with "An unexpected error occurred." Same meaning as the web's
+ * copy for this code (`hostedJobTaskFailureMessage`) — GitHub, not skrr, and
+ * waiting is the fix.
+ *
+ * Exported for tests.
+ */
+function describeGitHubUnavailable() {
+    return ('GitHub is temporarily unreachable, so this request could not be completed. ' +
+        'skrr itself answered, so this is not a skrr outage — try again shortly.');
+}
+/** A deployment setting cannot recover through a client retry. */
+function describeGitHubAppNotConfigured() {
+    return ('The GitHub App is not configured on this deployment. ' +
+        'Retrying will not help — ask the deployment operator to configure it.');
+}
 /**
  * Enrich the server's `ASSIGNEE_NOT_IN_SPACE` rejection with the same
  * copy-pasteable remedy the by-name resolution failure already gives (OSK-4864).

package/dist/commands/agents/chat.d.ts

@@ -43,6 +43,8 @@ export declare const STREAM_LOST_EXIT_CODE = 75;
 export declare function interruptedDetachMessage(input: {
     sessionId: string;
     conversationId?: string | null;
+    /** The second Ctrl-C: the CLI stopped waiting rather than running out the grace period. */
+    forced?: boolean;
 }): string;
 /**
  * What the durable record says about a turn, read from its messages.

package/dist/commands/agents/chat.js

@@ -7,6 +7,7 @@ exports.inspectTurnCommand = inspectTurnCommand;
 exports.noOutputFailureMessage = noOutputFailureMessage;
 exports.noStreamJsonPayload = noStreamJsonPayload;
 exports.chatStreamHeaderLines = chatStreamHeaderLines;
+const node_fs_1 = require("node:fs");
 const core_1 = require("@oclif/core");
 const data_provider_1 = require("@skrr-ai/data-provider");
 const base_command_1 = require("../../base-command");
@@ -53,8 +54,12 @@ exports.STREAM_LOST_EXIT_CODE = 75;
  * cancelled. This says what was asked, what is not guaranteed, and how to look.
  */
 function interruptedDetachMessage(input) {
-    return (`Cancel requested for run ${input.sessionId}, but no terminal event arrived before the ` +
-        'grace period ended. The runtime MAY STILL BE EXECUTING — a tool call already running on ' +
+    const waited = input.forced
+        ? `Cancel requested for run ${input.sessionId}; stopped waiting for it on the second Ctrl-C. `
+        : `Cancel requested for run ${input.sessionId}, but no terminal event arrived before the ` +
+            'grace period ended. ';
+    return (waited +
+        'The runtime MAY STILL BE EXECUTING — a tool call already running on ' +
         'your machine is not guaranteed to stop. ' +
         `Check what it did with: ${inspectTurnCommand(input.conversationId)}` +
         (process.platform === 'win32'
@@ -454,12 +459,20 @@ class AgentsChat extends base_command_1.BaseCommand {
         // event, and if it does not arrive detach explicitly while naming the
         // session so the run can be re-attached or cancelled. A second Ctrl-C
         // detaches immediately rather than being a blind kill.
+        //
+        // None of this ran until OSK-8708: auth-core's lock handler, installed
+        // before any command, exited the process on the FIRST Ctrl-C. It now defers
+        // to this listener — and exits the process itself on a SECOND signal, as
+        // soon as that signal's listeners have run. So the second Ctrl-C's detach
+        // notice is written here, synchronously, straight to the descriptor: the
+        // probe and the message the detach path prints after it would never happen.
         const CANCEL_GRACE_MS = 10_000;
         let detach = null;
         const detached = new Promise((resolve) => {
             detach = () => resolve('detached');
         });
         let interrupts = 0;
+        let forcedDetachAnnounced = false;
         let graceTimer = null;
         const onInterrupt = () => {
             interrupts += 1;
@@ -474,6 +487,27 @@ class AgentsChat extends base_command_1.BaseCommand {
                 graceTimer.unref?.();
                 return;
             }
+            if (!forcedDetachAnnounced) {
+                forcedDetachAnnounced = true;
+                const message = interruptedDetachMessage({
+                    sessionId: started.sessionId,
+                    conversationId: started.conversationId,
+                    forced: true,
+                });
+                if (flags.jsonl) {
+                    (0, node_fs_1.writeSync)(process.stdout.fd, `${JSON.stringify({
+                        type: 'run.detached',
+                        sessionId: started.sessionId,
+                        conversationId: started.conversationId,
+                        interrupted: true,
+                        message,
+                    })}\n`);
+                }
+                else {
+                    (0, node_fs_1.writeSync)(process.stderr.fd, `\n${message}\n`);
+                }
+                process.exitCode = exports.DETACH_EXIT_CODE;
+            }
             detach?.();
         };
         process.on('SIGINT', onInterrupt);
@@ -495,6 +529,10 @@ class AgentsChat extends base_command_1.BaseCommand {
             // turns the server had already finalised as errors — "it may still be
             // executing" is the most expensive thing to be wrong about here, because
             // it is what stops a caller retrying or alerting (OSK-7595, OSK-7660).
+            if (outcome === 'detached' && forcedDetachAnnounced) {
+                // Already said, and the exit code already set, on the second Ctrl-C.
+                return;
+            }
             let reconciled = null;
             if (outcome === 'detached') {
                 if (await client.probeTerminal('detach'))

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

@@ -3,9 +3,8 @@ import { type RuntimeMonthlySpend } from '../../lib/harnesses';
 /**
  * The hosted-runtime monthly cap rows, as lines.
  *
- * Pure so it can be tested the way `renderUsageSummary` is: this screen's job
- * is to stop a user reading headroom off the wrong cap, and the wording is the
- * fix, so the wording is what gets pinned.
+ * Pure because this screen must stop a user reading headroom off the wrong cap;
+ * the wording is part of the observable contract and is pinned directly.
  */
 export declare function renderRuntimeSpend(spend: RuntimeMonthlySpend[], log: (line: string) => void): void;
 /**

package/dist/commands/balance/show.js

@@ -10,9 +10,8 @@ const usd = (cents) => (typeof cents === 'number' ? `$${(cents / 100).toFixed(2)
 /**
  * The hosted-runtime monthly cap rows, as lines.
  *
- * Pure so it can be tested the way `renderUsageSummary` is: this screen's job
- * is to stop a user reading headroom off the wrong cap, and the wording is the
- * fix, so the wording is what gets pinned.
+ * Pure because this screen must stop a user reading headroom off the wrong cap;
+ * the wording is part of the observable contract and is pinned directly.
  */
 function renderRuntimeSpend(spend, log) {
     const capped = spend.filter((row) => row.hasLimit);

package/dist/commands/balance/usage.d.ts

@@ -1,10 +1,7 @@
+import type { TSkyCodeUsageSnapshot } from '@skrr-ai/data-provider';
 import { BaseCommand } from '../../base-command';
 /**
- * Aggregate usage summary.
- *
- * The shape is owned server-side by `getUsageSummary` and is not a stable
- * contract this command should reshape, so the default output pretty-prints
- * what the server sent rather than inventing a table over fields that may move.
+ * Sky Code's versioned monthly and five-hour usage snapshot.
  */
 export default class BalanceUsage extends BaseCommand {
     static description: string;
@@ -14,9 +11,4 @@ export default class BalanceUsage extends BaseCommand {
     };
     run(): Promise<void>;
 }
-export declare function renderUsageSummary(summary: Record<string, unknown>, log: (line: string) => void): void;
-/**
- * Why `--workspace` is refused here rather than silently dropped, and where a
- * workspace's figures actually live.
- */
-export declare function usageNotWorkspaceScopedMessage(workspaceId: string, bin: string): string;
+export declare function renderSkyCodeUsage(usage: TSkyCodeUsageSnapshot, log: (line: string) => void): void;

package/dist/commands/balance/usage.js

@@ -1,16 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.renderUsageSummary = renderUsageSummary;
-exports.usageNotWorkspaceScopedMessage = usageNotWorkspaceScopedMessage;
+exports.renderSkyCodeUsage = renderSkyCodeUsage;
 const core_1 = require("@oclif/core");
 const base_command_1 = require("../../base-command");
 const balance_1 = require("../../lib/balance");
 /**
- * Aggregate usage summary.
- *
- * The shape is owned server-side by `getUsageSummary` and is not a stable
- * contract this command should reshape, so the default output pretty-prints
- * what the server sent rather than inventing a table over fields that may move.
+ * Sky Code's versioned monthly and five-hour usage snapshot.
  */
 class BalanceUsage extends base_command_1.BaseCommand {
     static description = 'Usage summary against your hosted usage balance';
@@ -19,24 +14,10 @@ class BalanceUsage extends base_command_1.BaseCommand {
     async run() {
         this.requireAuth();
         const { flags } = await this.parse(BalanceUsage);
-        // `--workspace` is a global flag, so it parsed here and was then ignored:
-        // `balance usage --workspace <id>` printed the caller's PERSONAL summary
-        // with exit 0, which a member following a workspace refusal read as the
-        // workspace's (OSK-4820). There is no workspace-scoped usage read behind
-        // this command, so the honest answer is a refusal that names the reads
-        // that do exist.
         const workspaceId = flags.workspace;
-        if (workspaceId) {
-            this.failWithCliError({
-                message: usageNotWorkspaceScopedMessage(workspaceId, this.config.bin),
-                code: 'BALANCE_USAGE_NOT_WORKSPACE_SCOPED',
-                exit: 2,
-                retryable: false,
-            });
-        }
         let summary;
         try {
-            summary = await (0, balance_1.getBalanceUsage)();
+            summary = await (0, balance_1.getSkyCodeUsage)(workspaceId);
         }
         catch (err) {
             this.handleApiError(err);
@@ -49,58 +30,24 @@ class BalanceUsage extends base_command_1.BaseCommand {
             this.log('No usage recorded.');
             return;
         }
-        renderUsageSummary(summary, (line) => this.log(line));
+        renderSkyCodeUsage(summary, (line) => this.log(line));
     }
 }
 exports.default = BalanceUsage;
-/**
- * Every monetary field here is in the credit/micros unit (CREDITS_PER_USD),
- * despite names like `tokenLimit` — a limit of 10,000,000 is $10.00 per period,
- * not ten million tokens (see lib/balance.ts, OSK-4664). The command used to
- * dump the raw response, so those figures printed unitless and `tokenLimit`
- * read as tokens — the single most misleading number on the surface (OSK-4826).
- * Known money fields are formatted with credits + USD; anything unrecognised is
- * still printed raw so a server-side field addition is never hidden.
- */
-const MONEY_FIELDS = {
-    creditBalance: 'Ledger balance (before holds)',
-    monthlyUsage: 'Used this month',
-    monthlyAllowance: 'Monthly allowance',
-    tokenLimit: 'Period limit',
-    periodTokensUsed: 'Used this period',
-    projectedPeriodUsage: 'Projected period usage',
-};
-function renderUsageSummary(summary, log) {
-    const label = (key) => (MONEY_FIELDS[key] ?? key).padEnd(24);
-    for (const [key, value] of Object.entries(summary)) {
-        if (key === 'runRateNudge' && value != null && typeof value === 'object') {
-            log('  Run-rate nudge');
-            for (const [k, v] of Object.entries(value)) {
-                const rendered = k === 'projectedPeriodUsage' && typeof v === 'number'
-                    ? (0, balance_1.formatCreditsWithUsd)(v)
-                    : String(v ?? '-');
-                log(`    ${k.padEnd(22)} ${rendered}`);
-            }
-            continue;
-        }
-        if (key in MONEY_FIELDS && typeof value === 'number') {
-            log(`  ${label(key)} ${(0, balance_1.formatCreditsWithUsd)(value)}`);
-            continue;
-        }
-        const rendered = value != null && typeof value === 'object' ? JSON.stringify(value) : String(value ?? '-');
-        log(`  ${label(key)} ${rendered}`);
+function renderSkyCodeUsage(usage, log) {
+    log(`Sky Code ${usage.plan ?? 'current'} plan · ${usage.ownerType} ${usage.ownerId}`);
+    log(`  Monthly used            ${(0, balance_1.formatCreditsWithUsd)(usage.monthly.usedUsageMicros)}`);
+    log(`  Monthly reserved        ${(0, balance_1.formatCreditsWithUsd)(usage.monthly.reservedUsageMicros)}`);
+    log(`  Monthly remaining       ${(0, balance_1.formatCreditsWithUsd)(usage.monthly.remainingUsageMicros)}`);
+    log(`  Monthly reset           ${usage.monthly.resetsAt ?? 'unavailable'}`);
+    log(`  5-hour used             ${(0, balance_1.formatCreditsWithUsd)(usage.fiveHour.usedUsageMicros)}`);
+    log(`  5-hour reserved         ${(0, balance_1.formatCreditsWithUsd)(usage.fiveHour.reservedUsageMicros)}`);
+    log(`  5-hour limit            ${(0, balance_1.formatCreditsWithUsd)(usage.fiveHour.limitUsageMicros)}`);
+    log(`  5-hour reset            ${usage.fiveHour.resetsAt ?? 'unavailable'}`);
+    log(`  Concurrent sessions     ${usage.fiveHour.activeSessions}/${usage.fiveHour.maxConcurrentSessions}`);
+    log(`  Available overage       ${(0, balance_1.formatCreditsWithUsd)(usage.balance.availableMicros)}`);
+    log(`  Overage consent         ${usage.overageEnabled ? 'enabled' : 'disabled'}`);
+    if (usage.dataStatus === 'partial') {
+        log(`  Reconciliation          partial (${usage.unresolvedUsageCount} unresolved)`);
     }
-    log('');
-    log('Figures are in credits, with the dollar value alongside.');
-    log('`skrr balance show` reports the authoritative available balance used to admit a turn (holds excluded).');
-}
-/**
- * Why `--workspace` is refused here rather than silently dropped, and where a
- * workspace's figures actually live.
- */
-function usageNotWorkspaceScopedMessage(workspaceId, bin) {
-    return (`\`${bin} balance usage\` summarises your PERSONAL account and cannot be scoped to ` +
-        `workspace ${workspaceId} — it would have shown your own figures under that id. ` +
-        `For the workspace, use \`${bin} balance show --workspace ${workspaceId}\` (any member) ` +
-        `or \`${bin} balance statement --workspace ${workspaceId}\` (owner).`);
 }

package/dist/commands/code/index.d.ts

@@ -25,6 +25,10 @@ export default class Code extends Command {
  * engine exit into a generic CLI failure would make "the task failed" and "the
  * CLI could not start it" indistinguishable in CI.
  *
+ * So the codes this function owns are the ones where no engine ran: `127`, the
+ * engine is not installed, and `77`, the account was refused before the engine
+ * could start (OSK-8822).
+ *
  * ── Why `managed` is opt-IN per command ────────────────────────────────────
  *
  * `skrr code acp` must NOT take the managed path: the daemon that drives it already

package/dist/commands/code/index.js

@@ -63,6 +63,10 @@ exports.default = Code;
  * engine exit into a generic CLI failure would make "the task failed" and "the
  * CLI could not start it" indistinguishable in CI.
  *
+ * So the codes this function owns are the ones where no engine ran: `127`, the
+ * engine is not installed, and `77`, the account was refused before the engine
+ * could start (OSK-8822).
+ *
  * ── Why `managed` is opt-IN per command ────────────────────────────────────
  *
  * `skrr code acp` must NOT take the managed path: the daemon that drives it already
@@ -107,6 +111,11 @@ async function forwardToEngine(cmd, subcommand, passthrough, options = {}) {
             cmd.exit(code);
     }
     catch (err) {
+        if (err instanceof sky_code_1.EngineStartRefusedError) {
+            // The engine never ran, so there is no engine code to pass through (OSK-8822).
+            // Silent here: the hook that refused already said why, once, on stderr.
+            cmd.exit(sky_code_1.ENGINE_START_REFUSED_EXIT_CODE);
+        }
         if (err instanceof Error && err.message === 'sky-code-not-installed') {
             cmd.log((0, sky_code_1.notInstalledMessage)());
             cmd.exit(127); // conventional "command not found"

package/dist/commands/code/install.d.ts

@@ -31,15 +31,23 @@ export default class CodeInstall extends BaseCommand {
         json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;
+    /** Which daemon the install targets, by the rule every daemon-picking command shares. */
+    private resolveTarget;
     /**
-     * Which daemon does the install.
+     * The daemon id to install through, or the refusal.
      *
      * Refuses rather than guessing when several are active. Picking one would mean
      * installing a hundred megabytes onto a machine the user was not thinking
      * about, and the list this reads is the same one `skrr list-daemons` prints —
      * so the error can name the exact values that work.
+     *
+     * A Dedicated Runtime's own machine is refused here, before any request. The
+     * daemon and the API refuse it too; saying so locally is what keeps the answer
+     * the same whether or not this machine's daemon is reachable, and whether or
+     * not it has published its id. Another of the owner's machines, named with
+     * `--daemon`, is not this machine and goes to the API like anywhere else.
      */
-    private resolveDaemon;
+    private installTarget;
     /**
      * What the daemon says about this provider, when it started no job.
      *

package/dist/commands/code/install.js

@@ -4,6 +4,7 @@ const core_1 = require("@oclif/core");
 const base_command_1 = require("../../base-command");
 const api_fetch_1 = require("../../lib/api-fetch");
 const daemon_ref_1 = require("../../lib/daemon-ref");
+const daemon_target_1 = require("../../lib/daemon-target");
 const sky_code_1 = require("../../lib/sky-code");
 /**
  * `skrr code install` — install the engine from the terminal.
@@ -37,7 +38,7 @@ class CodeInstall extends base_command_1.BaseCommand {
     ];
     static flags = {
         daemon: core_1.Flags.string({
-            description: 'Which daemon installs it. Defaults to the only active one; required when you have several.',
+            description: 'Which daemon installs it. Defaults to this machine on a Dedicated Runtime, otherwise to the only active one; required when you have several.',
         }),
         wait: core_1.Flags.boolean({
             default: true,
@@ -48,19 +49,7 @@ class CodeInstall extends base_command_1.BaseCommand {
     };
     async run() {
         const { flags } = await this.parse(CodeInstall);
-        // Refused locally, before choosing a daemon. The daemon and the API refuse
-        // too, but with several active daemons this command would first ask which
-        // one — and "pick a machine" is the wrong question to put to someone whose
-        // answer is "none of them can do this here".
-        if ((0, sky_code_1.isDedicatedRuntimeWorkload)()) {
-            this.failWithCliError({
-                message: sky_code_1.DEDICATED_RUNTIME_ENGINE_MESSAGE,
-                code: 'DEDICATED_RUNTIME_ENGINE_SHIPS_WITH_IMAGE',
-                exit: 1,
-                retryable: false,
-            });
-        }
-        const daemonId = await this.resolveDaemon(flags.daemon);
+        const daemonId = this.installTarget(await this.resolveTarget(flags.daemon));
         let started;
         try {
             started = await (0, api_fetch_1.apiFetch)(`/api/daemons/${encodeURIComponent(daemonId)}/cli-installers/${PROVIDER}/install`, { method: 'POST', body: {}, credential: this.resolvedCredential });
@@ -136,28 +125,48 @@ class CodeInstall extends base_command_1.BaseCommand {
             this.log(`skrr Code installed. Run \`${this.config.bin} code\` to start it.`);
         }
     }
+    /** Which daemon the install targets, by the rule every daemon-picking command shares. */
+    async resolveTarget(explicit) {
+        try {
+            return await (0, daemon_target_1.resolveDaemonTarget)({
+                explicit,
+                local: (0, daemon_target_1.localMachine)({ baseURL: this.cliConfig?.baseURL }),
+                listActiveDaemons: () => (0, daemon_target_1.listActiveDaemons)(this.resolvedCredential),
+            });
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+    }
     /**
-     * Which daemon does the install.
+     * The daemon id to install through, or the refusal.
      *
      * Refuses rather than guessing when several are active. Picking one would mean
      * installing a hundred megabytes onto a machine the user was not thinking
      * about, and the list this reads is the same one `skrr list-daemons` prints —
      * so the error can name the exact values that work.
+     *
+     * A Dedicated Runtime's own machine is refused here, before any request. The
+     * daemon and the API refuse it too; saying so locally is what keeps the answer
+     * the same whether or not this machine's daemon is reachable, and whether or
+     * not it has published its id. Another of the owner's machines, named with
+     * `--daemon`, is not this machine and goes to the API like anywhere else.
      */
-    async resolveDaemon(explicit) {
-        if (explicit)
-            return (0, daemon_ref_1.normalizeDaemonRef)(explicit);
-        let res;
-        try {
-            res = await (0, api_fetch_1.apiFetch)('/api/daemon-resources?status=active&limit=50', { credential: this.resolvedCredential });
-        }
-        catch (err) {
-            this.handleApiError(err);
+    installTarget(target) {
+        if (target.kind === 'daemon')
+            return target.daemonId;
+        if (target.kind === 'this-machine') {
+            this.failWithCliError({
+                message: target.explicit
+                    ? sky_code_1.DEDICATED_RUNTIME_ENGINE_MESSAGE
+                    : `${sky_code_1.DEDICATED_RUNTIME_ENGINE_MESSAGE} This command installs on the machine it runs on; ` +
+                        'to install on another of your machines, name it with --daemon.',
+                code: 'DEDICATED_RUNTIME_ENGINE_SHIPS_WITH_IMAGE',
+                exit: 1,
+                retryable: false,
+            });
         }
-        const daemons = (res.daemons ?? []).filter((d) => d.isActive !== false);
-        if (daemons.length === 1)
-            return daemons[0].id;
-        if (daemons.length === 0) {
+        if (target.kind === 'none') {
             this.failWithCliError({
                 message: 'No active daemon is registered for this account, so nothing can perform the install. ' +
                     `Start the local runtime with \`${this.config.bin} daemon start\`, then run this again.`,
@@ -166,6 +175,7 @@ class CodeInstall extends base_command_1.BaseCommand {
                 retryable: false,
             });
         }
+        const { daemons } = target;
         const choices = daemons
             .slice(0, 10)
             .map((d) => `  ${(0, daemon_ref_1.formatDaemonRef)(d.id)}  ${d.name || '—'}`)

package/dist/commands/harnesses/leases/show.js

@@ -68,12 +68,15 @@ class HarnessesLeasesShow extends base_command_1.BaseCommand {
         if (os || arch)
             line('Resources:', [os, arch].filter(Boolean).join('/'));
         // `assignable` is the question a reader has about health, and the reasons
-        // are why — a bare status word would drop the actionable half.
+        // are why — a bare status word would drop the actionable half. The reasons
+        // are printed as sentences, judged against the lease state, in the words the
+        // machine page uses; `--json` keeps the codes (OSK-8768).
         const assignable = nested(lease.health, 'assignable');
         if (assignable !== undefined) {
-            const reasons = lease.health?.reasons;
-            const why = Array.isArray(reasons) && reasons.length > 0 ? ` (${reasons.join(', ')})` : '';
-            line('Assignable:', `${assignable === true ? 'yes' : 'no'}${why}`);
+            const why = assignable === true
+                ? ''
+                : (0, harnesses_1.describeHealthReasonSentences)(lease.health?.reasons, lease.state);
+            line('Assignable:', `${assignable === true ? 'yes' : 'no'}${why ? ` — ${why}` : ''}`);
         }
         line('Created:', lease.createdAt);
         line('Updated:', lease.updatedAt);

package/dist/commands/inbox/index.d.ts

@@ -1,4 +1,19 @@
 import { BaseCommand } from '../../base-command';
+/**
+ * Stop `--follow` on Ctrl-C or SIGTERM, and end with the status a shell
+ * reports for that signal (130 / 143).
+ *
+ * The listener only started running with OSK-8708 — auth-core's lock handler
+ * used to exit the process first, with 130 for SIGINT. Now the follow loop
+ * stops and the command returns normally, which on its own would report
+ * success (0) for an interrupted follow and change what a script reads.
+ */
+export declare function listenForFollowStop(proc?: Pick<NodeJS.Process, 'once' | 'removeListener'> & {
+    exitCode?: number | string;
+}): {
+    stopped: () => boolean;
+    dispose: () => void;
+};
 /**
  * `skrr inbox` / `skrr inbox --follow` — what have my agents said to me?
  *