@skrr-ai/cli 0.1.39 → 0.1.41

package/dist/lib/command-miss.js

@@ -22,10 +22,44 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.editDistance = editDistance;
 exports.nearestCommands = nearestCommands;
+exports.helpSubjectId = helpSubjectId;
 exports.describeCommandMiss = describeCommandMiss;
 exports.lookupFromConfig = lookupFromConfig;
 /** A uuid-ish token, which is what a stray space id looks like. */
 const LOOKS_LIKE_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const DAEMON_READINESS = [
+    {
+        id: 'harnesses:installers',
+        usage: 'harnesses installers --daemon <id>',
+        answers: 'whether each coding-agent CLI on that machine is installed, and signed in where the daemon can tell',
+    },
+    {
+        id: 'daemon:status',
+        usage: 'daemon status',
+        answers: 'whether the daemon itself is running and connected',
+    },
+];
+const ANSWERED_ELSEWHERE = {
+    daemon: {
+        health: DAEMON_READINESS,
+        readiness: DAEMON_READINESS,
+        ready: DAEMON_READINESS,
+        doctor: DAEMON_READINESS,
+        check: DAEMON_READINESS,
+    },
+};
+// `skrr daemons <sub>` is the same topic.
+const ANSWERED_ELSEWHERE_BY_COMMAND = { ...ANSWERED_ELSEWHERE, daemons: ANSWERED_ELSEWHERE.daemon };
+function describeAnsweredElsewhere(config, resolved, extras) {
+    if (extras.length !== 1)
+        return null;
+    const targets = (ANSWERED_ELSEWHERE_BY_COMMAND[resolved]?.[extras[0].toLowerCase()] ?? []).filter((target) => config.findCommand(target.id) !== undefined);
+    if (targets.length === 0)
+        return null;
+    const spoken = `${config.bin} ${resolved.split(':').join(' ')}`;
+    return (`\`${spoken}\` has no \`${extras[0]}\`. Depending on what you want to know:\n` +
+        targets.map((t) => `  \`${config.bin} ${t.usage}\` — ${t.answers}`).join('\n'));
+}
 /** Cheap edit distance, bounded — this runs only on a miss. */
 function editDistance(a, b) {
     const rows = a.length + 1;
@@ -60,6 +94,47 @@ function nearestCommands(id, all, limit = 3) {
         .slice(0, limit)
         .map(({ candidate }) => candidate));
 }
+/**
+ * The command id a `--help` request is about, resolved the way oclif resolves
+ * the same words when they are RUN.
+ *
+ * The help override used to join every leading word into the id, so
+ * `skrr harnesses install devin --help` asked for `harnesses:install:devin`,
+ * found no such command, and reported that `harnesses install` "does not take
+ * the positional argument `devin`" — the positional its own help lists
+ * (OSK-10099). Running the same words works, because oclif stops collecting id
+ * words at the first resolved command that takes arguments: from there on a
+ * word is an argument, not part of the name. Adding `--help` to a command you
+ * are about to run is the commonest way to check it, so the two must agree.
+ *
+ * Mirrors `collateSpacedCmdIDFromArgs` in `@oclif/core/lib/help/util` (not a
+ * public export): a word extends the id while the longer id is a command or a
+ * prefix of one; otherwise it is appended only when the id so far is not a
+ * command that accepts arguments, so a genuinely wrong word under a command
+ * that takes none (`daemon reload`) still reaches the miss message.
+ */
+function helpSubjectId(tokens, config) {
+    const usable = new Set();
+    for (const id of [...config.commandIDs, ...config.topicNames]) {
+        const parts = id.split(':');
+        for (let i = 1; i <= parts.length; i += 1)
+            usable.add(parts.slice(0, i).join(':'));
+    }
+    const taken = [];
+    for (const token of tokens) {
+        if (token.startsWith('-') || token.includes('='))
+            break;
+        if (usable.has([...taken, token].join(':'))) {
+            taken.push(token);
+            continue;
+        }
+        const current = taken.length > 0 ? config.findCommand(taken.join(':')) : undefined;
+        if (current && (current.strict === false || Object.keys(current.args ?? {}).length > 0))
+            break;
+        taken.push(token);
+    }
+    return taken.join(':');
+}
 /**
  * The message for a colon-joined id that did not resolve.
  *
@@ -81,6 +156,9 @@ function describeCommandMiss(config, id) {
         if (!found)
             continue;
         const extras = parts.slice(take);
+        const redirect = describeAnsweredElsewhere(config, parts.slice(0, take).join(':'), extras);
+        if (redirect)
+            return redirect;
         const spoken = `${config.bin} ${parts.slice(0, take).join(' ')}`;
         // Suggest the flag only when the command actually has it, so the hint can
         // never point at something that does not exist.

package/dist/lib/daemon-setup.js

@@ -62,7 +62,7 @@ async function offerDaemonSetup(opts = {}) {
     }
     const confirmImpl = opts.confirmImpl ?? prompt_1.confirm;
     log('');
-    log('  This machine has no skrr runtime. It is what lets your agents work here —');
+    log('  This computer has no skrr background service. It is what lets your agents work here —');
     log('  running commands, editing files, and driving a browser on this machine.');
     // This creates a persistent service with broad local capabilities, so a
     // bare Enter must visibly and behaviorally decline it. `confirm` names its
@@ -100,7 +100,7 @@ async function offerDaemonSetup(opts = {}) {
         if (err.message === 'runtime-binary-not-installed') {
             return {
                 status: 'failed',
-                detail: 'the runtime vanished between fetching and installing it',
+                detail: 'the background service vanished between fetching and installing it',
             };
         }
         return { status: 'failed', detail: err.message };

package/dist/lib/daemon-target.d.ts

@@ -99,5 +99,19 @@ export interface ResolveDaemonTargetInput {
     listActiveDaemons: () => Promise<ActiveDaemonRow[]>;
 }
 export declare function resolveDaemonTarget(input: ResolveDaemonTargetInput): Promise<DaemonTarget>;
+/**
+ * Daemons that are CONNECTED right now, under the id the daemon-control API
+ * takes (`daemon_…`, `dedicated-runtime-…`).
+ *
+ * `listActiveDaemons` returns Daemon RESOURCE rows: "active" means not revoked,
+ * and `id` is the resource's own id. The installer routes relay an RPC to a
+ * connected daemon by its connection id, so that list could not be used to pick
+ * one: its refusal counted 50 "active daemons" — most of them sandboxes gone for
+ * weeks — and suggested values like `d_69eb2d1e...` that `--daemon` then failed
+ * to find, and a single "active" daemon would have been auto-picked by an id no
+ * route accepts (OSK-9993). Online harness rows carry exactly the ids and the
+ * liveness needed, one row per (daemon, provider).
+ */
+export declare function listConnectedDaemons(credential: ResolvedCredential): Promise<ActiveDaemonRow[]>;
 /** The same list `skrr list-daemons` prints, so a refusal can name values that work. */
 export declare function listActiveDaemons(credential: ResolvedCredential): Promise<ActiveDaemonRow[]>;

package/dist/lib/daemon-target.js

@@ -45,6 +45,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.localMachine = localMachine;
 exports.resolveDaemonTarget = resolveDaemonTarget;
+exports.listConnectedDaemons = listConnectedDaemons;
 exports.listActiveDaemons = listActiveDaemons;
 const api_fetch_1 = require("./api-fetch");
 const daemonBroker_1 = require("./daemonBroker");
@@ -103,6 +104,37 @@ async function resolveDaemonTarget(input) {
         return { kind: 'none' };
     return { kind: 'ambiguous', daemons };
 }
+/**
+ * Daemons that are CONNECTED right now, under the id the daemon-control API
+ * takes (`daemon_…`, `dedicated-runtime-…`).
+ *
+ * `listActiveDaemons` returns Daemon RESOURCE rows: "active" means not revoked,
+ * and `id` is the resource's own id. The installer routes relay an RPC to a
+ * connected daemon by its connection id, so that list could not be used to pick
+ * one: its refusal counted 50 "active daemons" — most of them sandboxes gone for
+ * weeks — and suggested values like `d_69eb2d1e...` that `--daemon` then failed
+ * to find, and a single "active" daemon would have been auto-picked by an id no
+ * route accepts (OSK-9993). Online harness rows carry exactly the ids and the
+ * liveness needed, one row per (daemon, provider).
+ */
+async function listConnectedDaemons(credential) {
+    const res = await (0, api_fetch_1.apiFetch)('/api/harnesses?status=online', { credential });
+    const byDaemon = new Map();
+    for (const row of res.harnesses ?? []) {
+        if (row.status !== 'online' || !row.daemonId || byDaemon.has(row.daemonId))
+            continue;
+        // A harness is named "<provider> — <machine>"; the machine half names the daemon.
+        const separator = typeof row.name === 'string' ? row.name.indexOf(' — ') : -1;
+        byDaemon.set(row.daemonId, {
+            id: row.daemonId,
+            name: separator === -1 ? undefined : row.name.slice(separator + 3),
+            isActive: true,
+        });
+    }
+    // Stable order: the server returns rows most-recently-seen first, so two
+    // commands refusing one ambiguity listed the same daemons in different orders.
+    return [...byDaemon.values()].sort((a, b) => a.id.localeCompare(b.id));
+}
 /** The same list `skrr list-daemons` prints, so a refusal can name values that work. */
 async function listActiveDaemons(credential) {
     const res = await (0, api_fetch_1.apiFetch)('/api/daemon-resources?status=active&limit=50', { credential });

package/dist/lib/daemonBroker.js

@@ -311,7 +311,7 @@ async function attemptDaemonBrokerLogin(opts) {
             return {
                 ok: false,
                 reason: 'base_url_mismatch',
-                detail: `No local skrr runtime is logged in to ${opts.baseURL}; available daemon is logged in to ${mismatchedBootstrap.serverUrl}.`,
+                detail: `The skrr background service on this computer is not logged in to ${opts.baseURL}; it is logged in to ${mismatchedBootstrap.serverUrl}.`,
                 daemonServerUrl: mismatchedBootstrap.serverUrl,
             };
         }

package/dist/lib/daemonHandoff.js

@@ -208,7 +208,7 @@ async function handOffToLocalDaemon(env = process.env, opts = {}) {
         return {
             status: 'skipped',
             reason: 'legacy-binary',
-            detail: 'a legacy oversky runtime is installed; bootstrap a current skrr runtime',
+            detail: 'a legacy oversky background service is installed; bootstrap a current skrr one',
         };
     }
     // An older daemon has no `accept-handoff`, and spawning it would fail with

package/dist/lib/dedicated-lease-command.js

@@ -127,7 +127,10 @@ class DedicatedLeaseCommand extends base_command_1.BaseCommand {
             return await fn();
         }
         catch (err) {
-            const message = (0, dedicated_machines_1.formatDedicatedRuntimeApiError)(err);
+            const message = (0, dedicated_machines_1.formatDedicatedRuntimeApiError)(err, {
+                command: this.id,
+                bin: this.config.bin,
+            });
             if (message) {
                 this.failWithCliError({
                     message,

package/dist/lib/dedicated-machines.d.ts

@@ -643,5 +643,12 @@ export declare function dedicatedRuntimeApiErrorCode(err: unknown): string | und
  * second list would only drift from the first.
  */
 export declare function dedicatedRuntimeApiErrorDetails(err: unknown): Record<string, unknown> | undefined;
-export declare function formatDedicatedRuntimeApiError(err: unknown): string | null;
+/** What a refused command knows about itself, so advice can be one it can follow. */
+export interface DedicatedApiErrorContext {
+    /** oclif command id, e.g. `machines:dedicated:create`. */
+    command?: string;
+    bin?: string;
+    leaseId?: string;
+}
+export declare function formatDedicatedRuntimeApiError(err: unknown, context?: DedicatedApiErrorContext): string | null;
 export {};

package/dist/lib/dedicated-machines.js

@@ -1134,9 +1134,9 @@ function dedicatedRuntimeApiErrorDetails(err) {
  * say nothing to the person running it (OSK-8768); `--json` keeps them in
  * `error.details.reasons`.
  */
-function describeRefusalReasons(err) {
+function describeRefusalReasons(err, context = {}) {
     const details = dedicatedRuntimeApiErrorDetails(err);
-    const spend = describeSpendingCapRefusal(err.body, details);
+    const spend = describeSpendingCapRefusal(err.body, details, context);
     if (spend)
         return spend;
     const sentences = (0, harnesses_1.describeHealthReasonSentences)(details?.reasons, details?.state);
@@ -1148,7 +1148,7 @@ function describeRefusalReasons(err) {
  * the cap. Without them "would exceed the monthly cap" left a user guessing by
  * how much, and which cap (OSK-9552).
  */
-function describeSpendingCapRefusal(body, details) {
+function describeSpendingCapRefusal(body, details, context = {}) {
     let code;
     try {
         code = JSON.parse(body || '{}').code;
@@ -1172,9 +1172,25 @@ function describeSpendingCapRefusal(body, details) {
     ].filter(Boolean);
     if (parts.length === 0)
         return '';
-    return ` ${parts.join('; ')}. Raise the cap with \`machines dedicated spending-limit <lease-id> --cents <n>\`.`;
+    return ` ${parts.join('; ')}. ${raiseCapHint(context)}`;
 }
-function formatDedicatedRuntimeApiError(err) {
+/**
+ * How to get past a cap refusal, for the command that was refused. A create or
+ * a restore makes a NEW machine and takes its cap as a flag; only an existing
+ * machine has a lease id to raise. Every refusal used to say
+ * `machines dedicated spending-limit <lease-id>`, which a user refused on create
+ * had no lease id to run (OSK-9552).
+ */
+function raiseCapHint(context) {
+    const bin = context.bin || 'skrr';
+    const creates = context.command === 'machines:dedicated:create' ||
+        context.command === 'machines:dedicated:restore';
+    if (creates) {
+        return 'Pass a higher --spending-limit-cents: the cap is compared with the whole month, not with this machine alone.';
+    }
+    return `Raise the cap with \`${bin} machines dedicated spending-limit ${context.leaseId || '<lease-id>'} --cents <n>\`.`;
+}
+function formatDedicatedRuntimeApiError(err, context = {}) {
     if (!(err instanceof api_fetch_1.ApiFetchError) || !err.body) {
         return null;
     }
@@ -1202,7 +1218,7 @@ function formatDedicatedRuntimeApiError(err) {
         // Machine noun even though the caller named a Dedicated Runtime. Do not
         // repeat that contradictory product name while a mixed deployment rolls.
         const sentence = (parsed.message || parsed.error || parsed.code)?.replace(/(?:skrr )?Hosted Machine/g, 'Dedicated Runtime');
-        return sentence ? `${sentence}${describeRefusalReasons(err)}` : null;
+        return sentence ? `${sentence}${describeRefusalReasons(err, context)}` : null;
     }
     catch {
         return err.body.trim() || null;

package/dist/lib/dedicated-wait.js

@@ -17,8 +17,21 @@ function backupIsNewer(current, previous) {
     const b = Date.parse(previous);
     return Number.isFinite(a) && Number.isFinite(b) ? a > b : current !== previous;
 }
+/**
+ * `recovering` is also the state an image move replaces the machine through, on
+ * purpose. Reading every `recovering` as a failed action being retried told an
+ * owner watching an ordinary `update-image --wait` that destroy was available
+ * "if it never settles".
+ */
+const PLANNED_REPLACEMENT_PROGRESS = {
+    dedicated_runtime_image_update: 'replacing the machine',
+    dedicated_runtime_image_update_rolling_back: 'replacing the machine again',
+};
 function progressOf(lease) {
     const state = (0, dedicated_machines_1.dedicatedLeaseState)(lease);
+    const planned = lease.stateReason ? PLANNED_REPLACEMENT_PROGRESS[lease.stateReason] : undefined;
+    if (state === 'recovering' && planned)
+        return planned;
     if (state === 'recovering') {
         // `recovering` is where a failed provision or action lands, retried with
         // backoff. It can settle — or never, which is why destroy is allowed from it.

package/dist/lib/exec-runtime-binary.js

@@ -64,7 +64,7 @@ exports.RUNTIME_BINARY_NAMES = ['skrrd', 'oversky'];
  */
 function forwardedFlagsNote(verb, opts = {}) {
     const base = opts.bootstrapsRuntime
-        ? `If no local runtime exists, this command first fetches the signed release. After it is ` +
+        ? `If the background service is not on this computer yet, this command first fetches the signed release. After it is ` +
             `installed, flags are forwarded to \`skrrd ${verb}\` unchanged; run \`skrrd ${verb} --help\` ` +
             `for this verb's own flags, or \`skrrd --help\` for global ones such as \`--profile\`.`
         : `Flags are forwarded to \`skrrd ${verb}\` unchanged, so they are not listed here —` +
@@ -196,7 +196,7 @@ function isExecutable(p) {
  */
 function notInstalledMessage() {
     return [
-        'The skrr local runtime is not installed on this machine.',
+        'The skrr background service is not installed on this computer.',
         '',
         'Install:',
         '  macOS:   brew install dush1023/oversky/oversky',

package/dist/lib/followups.d.ts

@@ -1,6 +1,12 @@
 import { withQuery } from './triggers';
 type Query = Parameters<typeof withQuery>[1];
 type Json = Record<string, unknown>;
+/**
+ * The line a settle verb prints. A follow-up that had already ended is said to
+ * have ended, with the terminal it actually has, rather than reported as the
+ * thing this command would have done (OSK-10038).
+ */
+export declare function settledLine(id: string, result: Record<string, unknown>, done: string): string;
 /**
  * The `id` argument every follow-up command that addresses one takes.
  *
@@ -34,7 +40,13 @@ export interface FollowUpRow {
     terminal?: string | null;
     terminalAt?: string | null;
     terminalReason?: string | null;
+    /** Who settled it: `trigger_fire` for the runtime, otherwise the actor. */
+    terminalBy?: string | null;
     escalatedInitiativeId?: string | null;
+    /** The gate the fire passes: exempt_silent, exempt_user_directed, exempt_system, user_directed_guarded, autonomy_ladder, approval_ladder. */
+    gate?: string | null;
+    /** Set while its fire waits on an offline machine; it escalates after 60 minutes. */
+    parkedAt?: string | null;
     capsule?: unknown;
     nextRunAt?: string | null;
     deadlineAt?: string | null;
@@ -62,6 +74,12 @@ export interface FollowUpObservability {
             terminal: Record<string, number>;
             escalationRate: number | null;
             fires: number;
+            /** USD from the fires' UsageLog rows; null when the ledger could not be read. */
+            spend?: {
+                today: number;
+                total: number;
+                currency: string;
+            } | null;
             budget: {
                 pool: string | null;
                 used: number;

package/dist/lib/followups.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.followupsApi = exports.WATCH_WAIT_KINDS = exports.FOLLOWUP_RESOLVE_OUTCOMES = exports.FOLLOWUP_STATES = exports.FOLLOWUP_KINDS = exports.followUpIdArg = void 0;
+exports.settledLine = settledLine;
 exports.resolveFollowUpAgent = resolveFollowUpAgent;
 exports.parseSubjectRef = parseSubjectRef;
 exports.followupSummaryLine = followupSummaryLine;
@@ -26,6 +27,18 @@ const triggers_1 = require("./triggers");
 const agent_resolver_1 = require("./agent-resolver");
 const MOUNT = '/api/followups';
 const base = (id) => `${MOUNT}/${encodeURIComponent(id)}`;
+/**
+ * The line a settle verb prints. A follow-up that had already ended is said to
+ * have ended, with the terminal it actually has, rather than reported as the
+ * thing this command would have done (OSK-10038).
+ */
+function settledLine(id, result, done) {
+    const followup = result.followup;
+    if (result.alreadySettled === true) {
+        return `Follow-up ${id} was already settled${followup?.terminal ? ` (${followup.terminal})` : ''}; nothing changed.`;
+    }
+    return `Follow-up ${id} ${done}.`;
+}
 /**
  * The `id` argument every follow-up command that addresses one takes.
  *
@@ -79,7 +92,7 @@ function resolveFollowUpAgent(explicitAgentId, env = process.env) {
         if (explicitAgentId && explicitAgentId !== sessionAgent.id) {
             throw new agent_resolver_1.AgentResolutionError({
                 code: 'AGENT_CONTEXT_CONFLICT',
-                message: 'This local runtime is bound to a session agent. Do not override it with another agent ID.',
+                message: 'This session is bound to its session agent. Do not override it with another agent ID.',
                 suggestion: 'Use the bound session agent, or start a new daemon session for a different agent.',
                 details: { explicitAgentId, sessionAgentId: sessionAgent.id, source: sessionAgent.source },
             });

package/dist/lib/format.d.ts

@@ -78,6 +78,17 @@ export declare function renderTable<T extends Record<string, string>>(rows: T[],
  * should print it in the reader's zone and name that zone once.
  */
 export declare function localStamp(value: unknown): string;
+/**
+ * One timestamp that carries its own zone: `2026-08-21 17:54:03 PDT`.
+ *
+ * For key/value output and any row that cannot share a header naming the zone.
+ * About 25 commands formatted with `toISOString().slice(0, 19)` — UTC with no
+ * marker, which reads as local time — while `harnesses list` and `machines`
+ * printed local time with the zone named, so one CLI kept two clocks
+ * (OSK-10041). Seconds, because the commands that print these (task runs,
+ * activity, monitor) order events seconds apart. Never throws.
+ */
+export declare function localTime(value: unknown): string;
 /**
  * `PDT` — the zone `localStamp` renders in, to be named once per command
  * rather than repeated on every row.

package/dist/lib/format.js

@@ -7,6 +7,7 @@ exports.formatCell = formatCell;
 exports.collapseWhitespace = collapseWhitespace;
 exports.renderTable = renderTable;
 exports.localStamp = localStamp;
+exports.localTime = localTime;
 exports.localZone = localZone;
 /**
  * Code points that occupy TWO terminal columns (Unicode East Asian Wide and
@@ -212,6 +213,26 @@ function localStamp(value) {
     return (`${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ` +
         `${pad(date.getHours())}:${pad(date.getMinutes())}`);
 }
+/**
+ * One timestamp that carries its own zone: `2026-08-21 17:54:03 PDT`.
+ *
+ * For key/value output and any row that cannot share a header naming the zone.
+ * About 25 commands formatted with `toISOString().slice(0, 19)` — UTC with no
+ * marker, which reads as local time — while `harnesses list` and `machines`
+ * printed local time with the zone named, so one CLI kept two clocks
+ * (OSK-10041). Seconds, because the commands that print these (task runs,
+ * activity, monitor) order events seconds apart. Never throws.
+ */
+function localTime(value) {
+    if (value === null || value === undefined || value === '')
+        return '-';
+    const date = value instanceof Date ? value : new Date(typeof value === 'number' ? value : String(value));
+    if (Number.isNaN(date.getTime()))
+        return String(value);
+    const zone = localZone(date);
+    const seconds = `${date.getSeconds()}`.padStart(2, '0');
+    return `${localStamp(date)}:${seconds}${zone ? ` ${zone}` : ''}`;
+}
 /**
  * `PDT` — the zone `localStamp` renders in, to be named once per command
  * rather than repeated on every row.

package/dist/lib/harness-labels.d.ts

@@ -0,0 +1,39 @@
+/**
+ * How a harness row's provider and status read in human output — ONE rule for
+ * `harnesses list` and `harnesses show`.
+ *
+ * Both findings this closes were the same defect on two columns: the rule lived
+ * in one command and not the other.
+ *
+ *   - Status (OSK-9610): `list` printed `superseded` for a row a later
+ *     registration replaced; `show` printed `offline` for the same id. The server
+ *     sends `superseded` on both routes — `show` never read it.
+ *   - Provider (OSK-9649 / OSK-9290): the web renders the placeholder row of a
+ *     machine with no coding engine as "No coding agent installed" and folds the
+ *     first-party harness's older spelling into its current one. The CLI printed
+ *     the stored value — `oversky` on 111 rows, and the first-party harness's
+ *     older spelling beside its current one — so one product had three names here.
+ *
+ * `--json` keeps the stored values: it is the API contract, not a rendering.
+ */
+/** What the PROVIDER column says for a machine that has no coding engine. */
+export declare const NO_CODING_AGENT_PROVIDER_LABEL = "none";
+export declare function harnessStatusLabel(row: {
+    status?: string | null;
+    superseded?: boolean | null;
+}): string;
+export declare function isNoCodingAgentProvider(provider: string | null | undefined): boolean;
+export declare function harnessProviderLabel(provider: string | null | undefined): string;
+/**
+ * YOUR alias is what `name` shows and it differs from the name everyone else
+ * sees. The server sends both (`aliased`, `sharedName`); every human surface
+ * asks this one question of them, so `list`, `show` and `update --name` cannot
+ * disagree about whether a row is aliased (OSK-10004).
+ */
+export declare function isAliasCoveringSharedName(row: {
+    name?: string | null;
+    sharedName?: string | null;
+    aliased?: boolean | null;
+}): boolean;
+/** The longer phrase, for a single-row view with room for it. */
+export declare function harnessProviderDescription(provider: string | null | undefined): string;

package/dist/lib/harness-labels.js

@@ -0,0 +1,60 @@
+"use strict";
+/**
+ * How a harness row's provider and status read in human output — ONE rule for
+ * `harnesses list` and `harnesses show`.
+ *
+ * Both findings this closes were the same defect on two columns: the rule lived
+ * in one command and not the other.
+ *
+ *   - Status (OSK-9610): `list` printed `superseded` for a row a later
+ *     registration replaced; `show` printed `offline` for the same id. The server
+ *     sends `superseded` on both routes — `show` never read it.
+ *   - Provider (OSK-9649 / OSK-9290): the web renders the placeholder row of a
+ *     machine with no coding engine as "No coding agent installed" and folds the
+ *     first-party harness's older spelling into its current one. The CLI printed
+ *     the stored value — `oversky` on 111 rows, and the first-party harness's
+ *     older spelling beside its current one — so one product had three names here.
+ *
+ * `--json` keeps the stored values: it is the API contract, not a rendering.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NO_CODING_AGENT_PROVIDER_LABEL = void 0;
+exports.harnessStatusLabel = harnessStatusLabel;
+exports.isNoCodingAgentProvider = isNoCodingAgentProvider;
+exports.harnessProviderLabel = harnessProviderLabel;
+exports.isAliasCoveringSharedName = isAliasCoveringSharedName;
+exports.harnessProviderDescription = harnessProviderDescription;
+const data_provider_1 = require("@skrr-ai/data-provider");
+/** What the PROVIDER column says for a machine that has no coding engine. */
+exports.NO_CODING_AGENT_PROVIDER_LABEL = 'none';
+function harnessStatusLabel(row) {
+    if (row.superseded)
+        return 'superseded';
+    return typeof row.status === 'string' && row.status.length > 0 ? row.status : 'unknown';
+}
+function isNoCodingAgentProvider(provider) {
+    return typeof provider === 'string' && (0, data_provider_1.isManagedProductFallbackProvider)(provider);
+}
+function harnessProviderLabel(provider) {
+    if (typeof provider !== 'string' || provider.length === 0)
+        return 'unknown';
+    if (isNoCodingAgentProvider(provider))
+        return exports.NO_CODING_AGENT_PROVIDER_LABEL;
+    return String((0, data_provider_1.canonicalHarnessProvider)(provider) ?? provider);
+}
+/**
+ * YOUR alias is what `name` shows and it differs from the name everyone else
+ * sees. The server sends both (`aliased`, `sharedName`); every human surface
+ * asks this one question of them, so `list`, `show` and `update --name` cannot
+ * disagree about whether a row is aliased (OSK-10004).
+ */
+function isAliasCoveringSharedName(row) {
+    return Boolean(row.aliased && row.sharedName && row.sharedName !== row.name);
+}
+/** The longer phrase, for a single-row view with room for it. */
+function harnessProviderDescription(provider) {
+    if (isNoCodingAgentProvider(provider)) {
+        return `${exports.NO_CODING_AGENT_PROVIDER_LABEL} — ${(0, data_provider_1.managedProductFallbackLabel)().toLowerCase()} on this machine`;
+    }
+    return harnessProviderLabel(provider);
+}

package/dist/lib/harnesses.d.ts

@@ -51,6 +51,12 @@ export interface Harness {
     sharedName?: string;
     aliased?: boolean;
     status?: string;
+    /**
+     * A later registration on the same machine replaced this row. Sent by both
+     * the list and the single-row routes; human output shows it instead of the
+     * stored status (`harnessStatusLabel`, OSK-9610).
+     */
+    superseded?: boolean;
     harnessLocation?: 'local' | 'cloud';
     daemonId?: string;
     machineUuid?: string;

package/dist/lib/instruction-input.d.ts

@@ -76,3 +76,16 @@ export declare function describeTargetSync(target: {
     updatedAt?: string;
     driftCount?: number;
 }, now?: number, liveDaemonIds?: string[]): string;
+/**
+ * The command that re-binds a stalled target to the daemon now running on its
+ * machine, or null when no such daemon is live.
+ *
+ * A daemon started a different way on the same machine (launchd → cli) gets a
+ * new id, and a target stays bound to the old one. Placement is the machine, not
+ * the daemon, so the recovery is `update-target --daemon`, never a re-install,
+ * which the placement index refuses (OSK-9961).
+ */
+export declare function rebindCommandFor(target: {
+    id: string;
+    daemonId?: string | null;
+}, liveDaemonIds: readonly string[]): string | null;

package/dist/lib/instruction-input.js

@@ -7,6 +7,7 @@ exports.resolveBundleLabel = resolveBundleLabel;
 exports.parseDaemonId = parseDaemonId;
 exports.sameMachineDaemon = sameMachineDaemon;
 exports.describeTargetSync = describeTargetSync;
+exports.rebindCommandFor = rebindCommandFor;
 const promises_1 = require("node:fs/promises");
 async function readStdin() {
     const chunks = [];
@@ -180,7 +181,25 @@ function describeTargetSync(target, now = Date.now(), liveDaemonIds = []) {
         const live = parseDaemonId(elsewhere);
         const pinned = parseDaemonId(target.daemonId || '');
         // Kept under the STATUS column's `maxWidth: 78`, same constraint as below.
-        return `${base} — stalled ${days}d; daemon here now runs as ${live?.source}, not ${pinned?.source}: re-install`;
+        // Re-bind, not re-install: install refuses a second target on the same
+        // placement, so "re-install" was a remedy that could not succeed (OSK-9961).
+        // The full command does not fit the column; status prints it below.
+        return `${base} — stalled ${days}d; daemon here now runs as ${live?.source}, not ${pinned?.source}: re-bind below`;
     }
     return `${base} — stalled ${days}d; daemon may be gone: remove, then purge-target --force`;
 }
+/**
+ * The command that re-binds a stalled target to the daemon now running on its
+ * machine, or null when no such daemon is live.
+ *
+ * A daemon started a different way on the same machine (launchd → cli) gets a
+ * new id, and a target stays bound to the old one. Placement is the machine, not
+ * the daemon, so the recovery is `update-target --daemon`, never a re-install,
+ * which the placement index refuses (OSK-9961).
+ */
+function rebindCommandFor(target, liveDaemonIds) {
+    if (!target.daemonId || liveDaemonIds.includes(target.daemonId))
+        return null;
+    const live = sameMachineDaemon(target.daemonId, [...liveDaemonIds]);
+    return live ? `skrr instructions update-target ${target.id} --daemon ${live}` : null;
+}