@skrr-ai/cli 0.1.40 → 0.1.42

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;
+}

package/dist/lib/local-skills.d.ts

@@ -38,7 +38,23 @@ export declare function isUserInvocable(skill: Pick<DaemonLocalSkill, 'triggers'
  * dropped, because the server's own rule is that a skill the user picked and
  * the turn did not load must fail the turn rather than run without it.
  */
-export declare function resolveLocalSkillRefs(inventory: ReadonlyArray<DaemonLocalSkill>, requested: ReadonlyArray<string>): {
+/**
+ * The restart that refreshes THIS daemon's inventory. A daemon id is
+ * `daemon_<machine>_<source>_<profile>`; a bare `skrr daemon restart` restarts
+ * the default profile, so for any other profile the hint named a different
+ * daemon than the one whose list was stale (OSK-10080 verifier).
+ */
+export declare function daemonRestartCommand(daemonId: string | undefined): string;
+export declare function resolveLocalSkillRefs(inventory: ReadonlyArray<DaemonLocalSkill>, requested: ReadonlyArray<string>, options?: {
+    /**
+     * The inventory is what the daemon reported when it last registered, not a
+     * live read. A skill added since is missing from it — for up to an hour, until
+     * the daemon reconnects — so "not on this machine" would be false (OSK-10080).
+     */
+    snapshot?: boolean;
+    /** Whose snapshot, so the refresh hint restarts the right daemon. */
+    daemonId?: string;
+}): {
     refs: Array<{
         name: string;
         pathHash: string;
@@ -96,3 +112,30 @@ export declare const SKILL_CONVENTION_DISCOVERY_SINCE = "0.8.44";
  * add an explanation, and claiming an unknown daemon is old would be a guess.
  */
 export declare function daemonPredates(version: string | null | undefined, floor: string): boolean;
+/**
+ * The table, summary and exit decision for `skills import-as-actions`.
+ *
+ * A skill that imported without its action because the library was full used to
+ * show only `limit_reached`, an empty detail, "0 skill(s) failed" and exit 0, so
+ * a script or agent concluded every action it asked for was added (OSK-10185).
+ * `already_exists` stays a success: the action the caller wanted is there.
+ */
+export declare function summarizeSkillActionImport(result: {
+    targetAgentId: string;
+    actionsCreated: number;
+    results: Array<{
+        name: string;
+        status: string;
+        error?: string;
+        actionCreated?: boolean;
+        actionSkippedReason?: string;
+        actionError?: string;
+    }>;
+    actionsError?: {
+        message: string;
+    } | null;
+}): {
+    rows: Array<Record<string, string>>;
+    summary: string;
+    failed: boolean;
+};

package/dist/lib/local-skills.js

@@ -3,13 +3,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SKILL_CONVENTION_DISCOVERY_SINCE = void 0;
 exports.chooseDaemon = chooseDaemon;
 exports.isUserInvocable = isUserInvocable;
+exports.daemonRestartCommand = daemonRestartCommand;
 exports.resolveLocalSkillRefs = resolveLocalSkillRefs;
 exports.withSkillInvocations = withSkillInvocations;
 exports.looksLikeSkillPath = looksLikeSkillPath;
 exports.findLocalSkillsNamed = findLocalSkillsNamed;
 exports.describeStoreSkillMiss = describeStoreSkillMiss;
 exports.daemonPredates = daemonPredates;
+exports.summarizeSkillActionImport = summarizeSkillActionImport;
 const data_provider_1 = require("@skrr-ai/data-provider");
+const instruction_input_1 = require("./instruction-input");
 /**
  * Which machine to ask, or why there is no single answer.
  *
@@ -44,7 +47,19 @@ function isUserInvocable(skill) {
  * dropped, because the server's own rule is that a skill the user picked and
  * the turn did not load must fail the turn rather than run without it.
  */
-function resolveLocalSkillRefs(inventory, requested) {
+/**
+ * The restart that refreshes THIS daemon's inventory. A daemon id is
+ * `daemon_<machine>_<source>_<profile>`; a bare `skrr daemon restart` restarts
+ * the default profile, so for any other profile the hint named a different
+ * daemon than the one whose list was stale (OSK-10080 verifier).
+ */
+function daemonRestartCommand(daemonId) {
+    const profile = daemonId ? (0, instruction_input_1.parseDaemonId)(daemonId)?.profile : undefined;
+    return profile && profile !== 'default'
+        ? `skrr daemon restart --profile ${profile}`
+        : 'skrr daemon restart';
+}
+function resolveLocalSkillRefs(inventory, requested, options = {}) {
     const refs = [];
     const problems = [];
     const seen = new Set();
@@ -58,7 +73,11 @@ function resolveLocalSkillRefs(inventory, requested) {
         if (matches.length === 0) {
             problems.push(named.length > 0
                 ? `No skill "${name}" under ${root}. It is under: ${named.map((s) => s.source ?? '?').join(', ')}.`
-                : `No skill named "${name}" on this machine. See \`skrr skills local\`.`);
+                : options.snapshot
+                    ? `No skill named "${name}" in the list this machine's daemon reported when it last connected. ` +
+                        `A skill added since then appears after the daemon reconnects — run \`${daemonRestartCommand(options.daemonId)}\` on that machine. ` +
+                        'See `skrr skills local`.'
+                    : `No skill named "${name}" on this machine. See \`skrr skills local\`.`);
             continue;
         }
         if (matches.length > 1) {
@@ -193,3 +212,40 @@ function daemonPredates(version, floor) {
     }
     return false;
 }
+/** Why a skill imported but got no action, in words a person or an agent can act on. */
+const ACTION_SKIP_DETAIL = {
+    limit_reached: "this agent's action library is full; delete an action, then run the import again to add it",
+    already_exists: 'an action for this skill is already offered at this scope',
+};
+/**
+ * The table, summary and exit decision for `skills import-as-actions`.
+ *
+ * A skill that imported without its action because the library was full used to
+ * show only `limit_reached`, an empty detail, "0 skill(s) failed" and exit 0, so
+ * a script or agent concluded every action it asked for was added (OSK-10185).
+ * `already_exists` stays a success: the action the caller wanted is there.
+ */
+function summarizeSkillActionImport(result) {
+    const failed = result.results.filter((r) => r.status === 'failed');
+    const overCap = result.results.filter((r) => r.status !== 'failed' && r.actionSkippedReason === 'limit_reached');
+    const rows = result.results.map((r) => ({
+        skill: r.name,
+        import: r.status,
+        action: r.actionCreated
+            ? 'created'
+            : (r.actionSkippedReason ?? r.actionError ?? (r.status === 'failed' ? '-' : 'not added')),
+        detail: r.error ??
+            r.actionError ??
+            (r.actionSkippedReason ? (ACTION_SKIP_DETAIL[r.actionSkippedReason] ?? '') : ''),
+    }));
+    const summary = `${result.actionsCreated} action(s) created on ${result.targetAgentId}; ` +
+        `${failed.length} skill(s) failed` +
+        (overCap.length > 0
+            ? `; ${overCap.length} skill(s) imported without an action because the action library is full.`
+            : '.');
+    return {
+        rows,
+        summary,
+        failed: failed.length > 0 || overCap.length > 0 || Boolean(result.actionsError),
+    };
+}

package/dist/lib/login.js

@@ -84,7 +84,7 @@ async function cliLogin(opts = {}) {
         });
         if (brokerResult.ok) {
             console.log('');
-            console.log('  Authorized via the local skrr runtime (no browser needed).');
+            console.log('  Authorized via the skrr background service on this computer (no browser needed).');
             return {
                 token: brokerResult.accessToken,
                 refreshToken: brokerResult.refreshToken,
@@ -107,7 +107,7 @@ async function cliLogin(opts = {}) {
         // broker failures — missing bootstrap, network blip, server 5xx —
         // silently fall through to PKCE / device-code below.
         if (brokerResult.reason === 'ci_token_refused') {
-            throw new Error('The local skrr runtime is bootstrapped from a CI token, which cannot broker an interactive CLI login. ' +
+            throw new Error('The skrr background service on this computer is bootstrapped from a CI token, which cannot broker an interactive CLI login. ' +
                 'Use `skrr create-token --name <name>` to mint a long-lived CI credential directly, ' +
                 'or run `skrr login` on a machine where the daemon was authenticated interactively.');
         }
@@ -126,19 +126,19 @@ async function cliLogin(opts = {}) {
             brokerRateLimited = true;
             if (!(0, ssh_detect_1.isNonInteractive)()) {
                 console.log('');
-                console.log('  The local skrr runtime has brokered several logins recently and the server is ' +
+                console.log('  The skrr background service on this computer has brokered several logins recently and the server is ' +
                     'rate-limiting them. Falling back to the browser flow.');
             }
         }
         if (brokerResult.reason === 'base_url_mismatch' && brokerResult.daemonServerUrl) {
             console.log('');
-            console.log(`  The local skrr runtime is logged in to ${brokerResult.daemonServerUrl}, but skrr is configured for ${serverUrl}.`);
+            console.log(`  The skrr background service on this computer is logged in to ${brokerResult.daemonServerUrl}, but skrr is configured for ${serverUrl}.`);
             console.log(`  Skipping the daemon-broker handoff. Run \`skrr login --base-url ${brokerResult.daemonServerUrl}\` to use the daemon instead.`);
         }
     }
     if ((0, ssh_detect_1.isNonInteractive)()) {
         throw new Error(brokerRateLimited
-            ? 'The local skrr runtime is being rate-limited while brokering logins, and this ' +
+            ? 'The skrr background service on this computer is being rate-limited while brokering logins, and this ' +
                 'shell cannot run the browser flow instead. The limit is per 15-minute window — ' +
                 'retry shortly. For CI, use `skrr create-token` and set OVERSKY_TOKEN=osk_ci_...'
             : 'skrr login requires an interactive terminal or an SSH session. ' +

package/dist/lib/machines.d.ts

@@ -112,6 +112,12 @@ export interface Machine {
  * could come back says so, and a destroyed one cannot.
  */
 export declare function machineStateLabel(machine: Machine): string;
+/**
+ * What a list says it left out, by the label each hidden machine would have
+ * printed: `250 terminated, 5 offline, 1 paused`. "offline or terminated"
+ * called a paused machine offline after the table stopped doing so (OSK-9996).
+ */
+export declare function hiddenMachinesSummary(hidden: readonly Machine[]): string;
 /** Is this a machine a user could still use, or bring back? */
 export declare function isReachableMachine(machine: Machine): boolean;
 /** The user-editable slice. Identities, capabilities and lifecycle are not. */

package/dist/lib/machines.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.machineStateLabel = machineStateLabel;
+exports.hiddenMachinesSummary = hiddenMachinesSummary;
 exports.isReachableMachine = isReachableMachine;
 exports.liveHarnessCount = liveHarnessCount;
 exports.listMachines = listMachines;
@@ -30,8 +31,36 @@ function machineStateLabel(machine) {
     if (controls && controls.canResume === false && controls.canTerminate === false) {
         return 'terminated';
     }
+    // A leased machine at rest says WHICH rest. `machines hosted list` printed
+    // `paused` and this list printed `offline` for the same machine, with the
+    // reason only in `machines show` (OSK-9996). `offline` stays for a machine
+    // that simply is not connected.
+    const leaseState = machine.lease?.state;
+    if (leaseState === 'paused' || leaseState === 'stopped')
+        return leaseState;
+    // A lease the provider has ended cannot come back either; it read `offline`
+    // while an unleased dead sandbox read `terminated`, so the hidden-machine
+    // footer counted 95 ended leases as offline (OSK-9996 verifier).
+    if (leaseState === 'terminated')
+        return 'terminated';
     return 'offline';
 }
+/**
+ * What a list says it left out, by the label each hidden machine would have
+ * printed: `250 terminated, 5 offline, 1 paused`. "offline or terminated"
+ * called a paused machine offline after the table stopped doing so (OSK-9996).
+ */
+function hiddenMachinesSummary(hidden) {
+    const counts = new Map();
+    for (const machine of hidden) {
+        const label = machineStateLabel(machine);
+        counts.set(label, (counts.get(label) ?? 0) + 1);
+    }
+    return [...counts.entries()]
+        .sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]))
+        .map(([label, count]) => `${count} ${label}`)
+        .join(', ');
+}
 /** Is this a machine a user could still use, or bring back? */
 function isReachableMachine(machine) {
     return machineStateLabel(machine) !== 'terminated' && machine.status !== 'offline';
@@ -105,6 +134,22 @@ function hostedSandboxDaemonIds(ref) {
         return [];
     return [`hosted-machine-${ref}`, `hosted-job-machine-${ref}`];
 }
+/**
+ * An id with its identity-kind prefix removed: `lease:rtl_…` → `rtl_…`,
+ * `dedicated-runtime:rtl_…` → `rtl_…`, `machine:0354…` → `0354…`.
+ *
+ * Other commands print the bare form. `machines dedicated list` and the lease
+ * payloads name `rtl_…`, and `harnesses list`'s MACHINE column prints the head
+ * of the identifier after the kind — so the id a user has to hand often lacks
+ * the prefix this list keys on, and `machines show rtl_…` answered "No machine
+ * matches" for a machine it was listing as `lease:rtl_…` (OSK-9269, OSK-9290).
+ */
+function withoutIdentityKind(value) {
+    if (!value)
+        return undefined;
+    const separator = value.indexOf(':');
+    return separator === -1 ? undefined : value.slice(separator + 1);
+}
 function resolveMachineRef(machines, ref) {
     const needle = ref.trim();
     const lower = needle.toLowerCase();
@@ -121,13 +166,26 @@ function resolveMachineRef(machines, ref) {
         // two unrelated-looking ids, no way on screen to tell they are one
         // machine. Exact composition, not a substring search, so this cannot
         // match a machine that merely contains the text.
-        hostedSandboxDaemonIds(needle).some((candidate) => m.daemonId === candidate));
+        hostedSandboxDaemonIds(needle).some((candidate) => m.daemonId === candidate) ||
+        withoutIdentityKind(m.id) === needle ||
+        withoutIdentityKind(m.machineUuid) === needle ||
+        // A harness id names exactly one machine — the one it is registered on.
+        // Refusing it with "No machine matches" sent the user to a different
+        // command without saying which (OSK-9313).
+        (m.harnesses ?? []).some((h) => h.id === needle));
     if (exact.length === 1)
         return exact[0];
     const byName = machines.filter((m) => m.name?.toLowerCase() === lower);
     if (byName.length === 1)
         return byName[0];
-    const prefix = machines.filter((m) => [m.id, m.machineUuid, m.stableDaemonId, m.daemonId].some((candidate) => candidate && candidate.toLowerCase().startsWith(lower)));
+    const prefix = machines.filter((m) => [
+        m.id,
+        m.machineUuid,
+        m.stableDaemonId,
+        m.daemonId,
+        withoutIdentityKind(m.id),
+        withoutIdentityKind(m.machineUuid),
+    ].some((candidate) => candidate && candidate.toLowerCase().startsWith(lower)));
     if (prefix.length === 1)
         return prefix[0];
     if (prefix.length > 1) {
@@ -140,5 +198,13 @@ function resolveMachineRef(machines, ref) {
         throw new Error(`"${ref}" matches ${prefix.length} machines: ${shown.join(', ')}` +
             `${rest > 0 ? `, and ${rest} more` : ''}. Use a longer prefix or the full id.`);
     }
+    // A harness id prefix or a harness name is the other `show`'s input. Say so
+    // rather than only "no machine", which left the reader to guess that a
+    // sibling command takes it (OSK-9313).
+    const harnessMatch = machines.some((m) => (m.harnesses ?? []).some((h) => (lower.length >= 4 && h.id.toLowerCase().startsWith(lower)) ||
+        (typeof h.name === 'string' && h.name.toLowerCase() === lower)));
+    if (harnessMatch) {
+        throw new Error(`No machine matches "${ref}", but a harness does. \`skrr harnesses show ${ref}\` takes it.`);
+    }
     throw new Error(`No machine matches "${ref}". Run \`skrr machines list\` to see them.`);
 }

package/dist/lib/runtime-tool-support.d.ts

@@ -0,0 +1,34 @@
+import type { TPlugin } from '@skrr-ai/data-provider';
+/**
+ * What an agent turn can call, said where tools are configured.
+ *
+ * Plugin tools (`agents tools`, `--tools`) and OpenAPI actions
+ * (`agents api-actions add`) reach an agent turn through the runtime's
+ * `agent-tools` server (OSK-9750, OSK-9754). Two limits remain, and the CLI is
+ * where the tool is set up, so it says them there:
+ *  - image and file plugins save their output through a web request an agent
+ *    turn does not have, so they are stored but not loaded;
+ *  - an OAuth action runs only after the user authorizes it once, through a
+ *    link the agent hands over on its first call.
+ */
+/** The catalog's AGENT column. `?` for a server older than the `agentRuntime` field. */
+export declare function agentRuntimeLabel(tool: Pick<TPlugin, 'agentRuntime'>): string;
+export declare const AGENT_COLUMN_FOOTNOTE: string;
+/** Stored plugin keys the catalog says an agent turn does not load. */
+export declare function pluginKeysNotLoaded(keys: string[], catalog: TPlugin[]): string[];
+export declare function pluginsNotLoadedNotice(keys: string[]): string;
+/** Said after adding an OAuth action, since nothing works until both steps happen. */
+export declare function oauthActionNotice(redirectUrl: string): string;
+/** Split an agent's stored `tools` into plugin keys and OpenAPI action tool names. */
+export declare function splitStoredTools(tools: unknown): {
+    plugins: string[];
+    actions: string[];
+};
+/**
+ * After `--tools` is saved: warn about the plugin keys an agent turn will not load.
+ *
+ * Unknown keys are refused by the server (OSK-9545); this covers the known ones
+ * that are stored but skipped. Best effort: a catalog that cannot be read says
+ * nothing rather than failing a write that already succeeded.
+ */
+export declare function warnPluginsNotLoaded(tools: unknown, warn: (message: string) => void, fetchCatalog?: () => Promise<TPlugin[]>): Promise<void>;

package/dist/lib/runtime-tool-support.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AGENT_COLUMN_FOOTNOTE = void 0;
+exports.agentRuntimeLabel = agentRuntimeLabel;
+exports.pluginKeysNotLoaded = pluginKeysNotLoaded;
+exports.pluginsNotLoadedNotice = pluginsNotLoadedNotice;
+exports.oauthActionNotice = oauthActionNotice;
+exports.splitStoredTools = splitStoredTools;
+exports.warnPluginsNotLoaded = warnPluginsNotLoaded;
+const data_provider_1 = require("@skrr-ai/data-provider");
+/**
+ * What an agent turn can call, said where tools are configured.
+ *
+ * Plugin tools (`agents tools`, `--tools`) and OpenAPI actions
+ * (`agents api-actions add`) reach an agent turn through the runtime's
+ * `agent-tools` server (OSK-9750, OSK-9754). Two limits remain, and the CLI is
+ * where the tool is set up, so it says them there:
+ *  - image and file plugins save their output through a web request an agent
+ *    turn does not have, so they are stored but not loaded;
+ *  - an OAuth action runs only after the user authorizes it once, through a
+ *    link the agent hands over on its first call.
+ */
+/** The catalog's AGENT column. `?` for a server older than the `agentRuntime` field. */
+function agentRuntimeLabel(tool) {
+    if (tool.agentRuntime === undefined)
+        return '?';
+    return tool.agentRuntime ? 'yes' : 'no';
+}
+exports.AGENT_COLUMN_FOOTNOTE = 'AGENT says whether an agent turn can call the tool. Image and file tools (AGENT no) ' +
+    'save their output through a web request an agent turn does not have.';
+/** Stored plugin keys the catalog says an agent turn does not load. */
+function pluginKeysNotLoaded(keys, catalog) {
+    const byKey = new Map(catalog.map((tool) => [tool.pluginKey, tool]));
+    return keys.filter((key) => byKey.get(key)?.agentRuntime === false);
+}
+function pluginsNotLoadedNotice(keys) {
+    const [subject, verb] = keys.length === 1 ? ['it', 'saves'] : ['they', 'save'];
+    return (`Saved, but an agent turn cannot call ${keys.join(', ')}: ${subject} ${verb} ` +
+        'output through a web request an agent turn does not have.');
+}
+/** Said after adding an OAuth action, since nothing works until both steps happen. */
+function oauthActionNotice(redirectUrl) {
+    return (`Register ${redirectUrl} as the redirect URL with the OAuth provider. ` +
+        "The agent's first call to one of these operations returns a link for you to authorize; " +
+        'after you finish, ask it to try again.');
+}
+/** Split an agent's stored `tools` into plugin keys and OpenAPI action tool names. */
+function splitStoredTools(tools) {
+    const list = Array.isArray(tools) ? tools.map(String) : [];
+    return {
+        plugins: list.filter((name) => !name.includes(data_provider_1.actionDelimiter)),
+        actions: list.filter((name) => name.includes(data_provider_1.actionDelimiter)),
+    };
+}
+/**
+ * After `--tools` is saved: warn about the plugin keys an agent turn will not load.
+ *
+ * Unknown keys are refused by the server (OSK-9545); this covers the known ones
+ * that are stored but skipped. Best effort: a catalog that cannot be read says
+ * nothing rather than failing a write that already succeeded.
+ */
+async function warnPluginsNotLoaded(tools, warn, fetchCatalog = () => data_provider_1.dataService.getAvailableTools()) {
+    const { plugins } = splitStoredTools(tools);
+    if (plugins.length === 0)
+        return;
+    let catalog;
+    try {
+        catalog = await fetchCatalog();
+    }
+    catch {
+        return;
+    }
+    const skipped = pluginKeysNotLoaded(plugins, catalog);
+    if (skipped.length > 0) {
+        warn(pluginsNotLoadedNotice(skipped));
+    }
+}

package/dist/lib/share-rows.d.ts

@@ -0,0 +1,17 @@
+/**
+ * How an agent-share row names its share and the other person.
+ *
+ * The share routes answer `{ shareId, owner: { userId, name }, recipient:
+ * { userId, name } }`. The four `agent-shares` listings read `id`/`_id` and
+ * stringified the person object, so every row printed SHARE ID `-` and FROM/TO
+ * `[object Object]` (OSK-10043): the one id `respond`/`revoke` need was
+ * unreadable, and so was who the share was with.
+ */
+/** The share's id, whichever key the row carries it under. */
+export declare function shareIdOf(share: Record<string, unknown>): string;
+/**
+ * A person as `Name (userId)` — the name to recognise, the id that
+ * `agent-shares with <userId>` takes. Accepts a bare id string too, which older
+ * rows used.
+ */
+export declare function sharePartyLabel(value: unknown): string;