@skrr-ai/cli 0.1.37 → 0.1.38

package/dist/commands/harnesses/usage.js

@@ -1,5 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.selectUsageRows = selectUsageRows;
+exports.usageRowHarnessCell = usageRowHarnessCell;
 exports.buildUsageTable = buildUsageTable;
 const core_1 = require("@oclif/core");
 const base_command_1 = require("../../base-command");
@@ -22,6 +24,26 @@ function count(value) {
     const n = Number(value);
     return Number.isFinite(n) ? n.toLocaleString('en-US') : '-';
 }
+/**
+ * The rows to render, whichever spelling the server used.
+ *
+ * `byHarness` is what it sends today. This reader asked only for `byRuntime` —
+ * the pre-rename spelling — so the fleet rollup was ALWAYS empty and the
+ * command always printed "No usage recorded.", while `--json` on the same call
+ * showed $24.93 across 46 sessions. A rollup cannot be empty while its own
+ * members are not, which is what made it findable.
+ *
+ * The old spellings stay as fallbacks, after the current one, so an older
+ * deployment still renders. They are not the primary, which is the whole bug.
+ */
+function selectUsageRows(payload) {
+    return payload?.byHarness ?? payload?.byRuntime ?? payload?.usage ?? [];
+}
+/** The HARNESS cell, under either spelling of the id. */
+function usageRowHarnessCell(row) {
+    const id = row.harnessId ?? row.runtimeId;
+    return id ? String(id).slice(0, 12) : '-';
+}
 const SHARED_COLUMNS = [
     { key: 'provider', header: 'PROVIDER' },
     { key: 'sessions', header: 'SESSIONS' },
@@ -66,7 +88,7 @@ function buildUsageTable(rows, perHarness) {
             ...SHARED_COLUMNS,
         ],
         rows: rows.map((r) => ({
-            harness: r.runtimeId ? String(r.runtimeId).slice(0, 12) : '-',
+            harness: usageRowHarnessCell(r),
             name: (0, format_1.formatCell)(r.name),
             ...shared(r),
         })),
@@ -105,7 +127,7 @@ class HarnessesUsage extends base_command_1.BaseCommand {
         // `{usage, totals}`. Neither is a superset, so read both rather than
         // assuming one and rendering a table of dashes for the other.
         const payload = report;
-        const rows = payload?.byRuntime ?? payload?.usage ?? [];
+        const rows = selectUsageRows(payload);
         const totals = payload?.grandTotals ?? payload?.totals;
         if (rows.length === 0) {
             this.log(args.harness ? 'No usage recorded for this harness.' : 'No usage recorded.');

package/dist/commands/instructions/status.js

@@ -29,6 +29,18 @@ class InstructionsStatus extends base_command_1.BaseCommand {
         // only `bundleId`, so join to the bundle list — including archived/deleted,
         // since a target can outlive its bundle. A failed lookup is non-fatal: the
         // column falls back to the full bundle id.
+        // The live daemons, so a stalled row can tell "this machine now starts its
+        // daemon a different way" from "the daemon is gone" — and only the second
+        // earns a destructive remedy. Non-fatal: an empty list degrades to the old
+        // wording, which is a guess, not a wrong claim about a daemon we checked.
+        let liveDaemonIds = [];
+        try {
+            const daemons = await data_provider_1.dataService.getDaemons();
+            liveDaemonIds = (daemons.active || []).map((d) => d.daemonId);
+        }
+        catch {
+            // Leave it empty.
+        }
         let bundleNames = new Map();
         try {
             const bundleResponse = await data_provider_1.dataService.listManagedInstructionBundles({
@@ -62,7 +74,7 @@ class InstructionsStatus extends base_command_1.BaseCommand {
                 (target.scope === 'global' ? 'global' : target.projectPath || 'project'),
             desired: target.desiredState,
             applied: target.appliedVersionNumber ? `v${target.appliedVersionNumber}` : '-',
-            status: (0, instruction_input_1.describeTargetSync)(target),
+            status: (0, instruction_input_1.describeTargetSync)(target, Date.now(), liveDaemonIds),
         })), [
             { key: 'id', header: 'TARGET ID' },
             // Wide enough for a prompt name (matches `instructions list`'s NAME

package/dist/commands/machines/dedicated/catalog.js

@@ -41,16 +41,8 @@ class DedicatedMachinesCatalog extends dedicated_lease_command_1.DedicatedLeaseC
         this.log('\nSizes (--size-preset)');
         if (catalog.sizes.length === 0)
             this.log('  none offered right now');
-        for (const size of catalog.sizes) {
-            const spec = [
-                size.vcpus ? `${size.vcpus} vCPU` : '',
-                size.memoryGiB ? `${size.memoryGiB} GiB RAM` : '',
-                size.accelerator || '',
-            ]
-                .filter(Boolean)
-                .join(' · ');
-            this.log(`  ${String(size.id).padEnd(14)}${spec}`);
-        }
+        for (const line of (0, dedicated_machines_1.dedicatedCatalogSizeLines)(catalog))
+            this.log(line);
         if (catalog.storage) {
             const { minGb, defaultGb, maxGb } = catalog.storage;
             this.log(`\nWorkspace (--storage-gb)\n  ${minGb}–${maxGb} GiB, default ${defaultGb}; grow later, never shrink`);
@@ -64,11 +56,8 @@ class DedicatedMachinesCatalog extends dedicated_lease_command_1.DedicatedLeaseC
         if (catalog.regionClasses.length) {
             this.log(`\nRegion (--region-class)\n  ${catalog.regionClasses.join(', ')}`);
         }
-        this.log('\nPrices');
-        if (catalog.priceLines.length === 0)
-            this.log('  not published by this server');
-        for (const line of catalog.priceLines) {
-            this.log(`  ${line.display || `${(0, dedicated_machines_1.formatUsdCents)(line.amountCents)} ${line.label || ''}`}`);
+        for (const line of (0, dedicated_machines_1.dedicatedCatalogPriceLineOutput)(catalog.priceLines, catalog.priceBookVersion)) {
+            this.log(line);
         }
     }
 }

package/dist/commands/machines/dedicated/create.d.ts

@@ -17,6 +17,14 @@ export default class DedicatedMachinesCreate extends DedicatedLeaseCommand {
         workspace: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         'request-id': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        yes: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'dry-run': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;
+    /**
+     * The catalog for the summary, or null. Not through `callDedicated`, which
+     * exits on an API error: an unreachable catalog must cost the summary its
+     * detail, not stop a create the user is about to confirm anyway.
+     */
+    private readCatalogForSummary;
 }

package/dist/commands/machines/dedicated/create.js

@@ -4,12 +4,14 @@ const core_1 = require("@oclif/core");
 const node_crypto_1 = require("node:crypto");
 const dedicated_lease_command_1 = require("../../../lib/dedicated-lease-command");
 const dedicated_machines_1 = require("../../../lib/dedicated-machines");
+const harnesses_1 = require("../../../lib/harnesses");
 class DedicatedMachinesCreate extends dedicated_lease_command_1.DedicatedLeaseCommand {
     static description = 'Request a Dedicated Runtime lease. See `machines dedicated catalog` for sizes, storage bounds and prices.';
     static examples = [
         '<%= config.bin %> machines dedicated create --name dev-box --size-preset standard',
         '<%= config.bin %> machines dedicated create --name dev-box --size-preset standard --spending-limit-cents 20000',
-        '<%= config.bin %> machines dedicated create --name dev-box --size-preset standard --spending-limit-cents 20000 --repository acme/app --wait --json',
+        '<%= config.bin %> machines dedicated create --name dev-box --size-preset standard --dry-run',
+        '<%= config.bin %> machines dedicated create --name dev-box --size-preset standard --spending-limit-cents 20000 --repository acme/app --yes --wait --json',
     ];
     static flags = {
         name: core_1.Flags.string({ description: 'Display name for the dedicated machine', required: true }),
@@ -55,6 +57,13 @@ class DedicatedMachinesCreate extends dedicated_lease_command_1.DedicatedLeaseCo
             description: 'Idempotency key. Reuse it to safely retry the same create request.',
         }),
         json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+        yes: core_1.Flags.boolean({
+            char: 'y',
+            description: 'Skip the confirmation. A create starts billing, so it asks first; required when not at a terminal.',
+        }),
+        'dry-run': core_1.Flags.boolean({
+            description: 'Show the size, price, storage, retention and cap this create would use, and create nothing',
+        }),
         ...dedicated_lease_command_1.dedicatedWaitFlags,
     };
     async run() {
@@ -76,6 +85,40 @@ class DedicatedMachinesCreate extends dedicated_lease_command_1.DedicatedLeaseCo
             repositoryRef: flags.repository,
             workspaceId: flags.workspace,
         });
+        // Say what is about to be bought before it is, in the catalog's own numbers.
+        // `destroy` has always asked first; the command that starts a meter did not
+        // (OSK-9592). A catalog read that fails only loses the summary's detail,
+        // never the confirmation itself.
+        if (flags['dry-run'] || !flags.yes) {
+            const catalog = await this.readCatalogForSummary();
+            const summary = (0, dedicated_machines_1.dedicatedCreateSummary)(catalog, {
+                name: flags.name,
+                sizePreset: flags['size-preset'],
+                storageGb: flags['storage-gb'],
+                retentionClass: flags['retention-class'],
+                spendingLimitCents: flags['spending-limit-cents'],
+            });
+            if (flags['dry-run']) {
+                if (flags.json) {
+                    this.log(JSON.stringify({ dryRun: true, request: body, summary }, null, 2));
+                }
+                else {
+                    for (const line of summary)
+                        this.log(line);
+                    this.log('Dry run: nothing was created.');
+                }
+                return;
+            }
+            if (!process.stdin.isTTY) {
+                this.error('Creating a Dedicated Runtime starts billing. Pass --yes to confirm when not at a terminal, or --dry-run to see what it would create.', { exit: 2 });
+            }
+            for (const line of summary)
+                this.log(line);
+            if (!(await this.confirm('Create it? [y/N] '))) {
+                this.log('Aborted. Nothing was created.');
+                this.exit(1);
+            }
+        }
         const response = await this.callDedicated(() => (0, dedicated_machines_1.createDedicatedRuntime)(body));
         const lease = response?.lease;
         const id = (0, dedicated_machines_1.dedicatedLeaseId)(lease);
@@ -97,6 +140,20 @@ class DedicatedMachinesCreate extends dedicated_lease_command_1.DedicatedLeaseCo
             this.log(`Poll: ${this.config.bin} machines dedicated show ${id}  (or pass --wait)`);
         }
     }
+    /**
+     * The catalog for the summary, or null. Not through `callDedicated`, which
+     * exits on an API error: an unreachable catalog must cost the summary its
+     * detail, not stop a create the user is about to confirm anyway.
+     */
+    async readCatalogForSummary() {
+        try {
+            return (0, dedicated_machines_1.dedicatedCatalogFromProducts)(await (0, harnesses_1.listHarnessProducts)());
+        }
+        catch (error) {
+            process.stderr.write(`Could not read the catalog for the summary (${error?.message || 'unknown error'}); showing what was passed.\n`);
+            return null;
+        }
+    }
 }
 exports.default = DedicatedMachinesCreate;
 function newRequestId() {

package/dist/commands/machines/dedicated/destroy.js

@@ -45,12 +45,17 @@ class DedicatedMachinesDestroy extends dedicated_lease_command_1.DedicatedLeaseC
         // so it does not ask. This mirrors the server's rule only to decide whether
         // to PROMPT; the server still decides what happens.
         let willPurge = Boolean(flags['purge-storage']);
+        // Read even under --yes when the workspace may be kept: whether a destroy
+        // keeps billing storage is worth saying afterwards, and only the lease as it
+        // stood before the destroy can say it.
+        const prior = willPurge
+            ? undefined
+            : (await this.callDedicated(() => (0, dedicated_machines_1.getDedicatedRuntime)(leaseId, this.scopeFrom(flags))))
+                ?.lease;
         if (!willPurge && !flags.yes) {
-            const current = await this.callDedicated(() => (0, dedicated_machines_1.getDedicatedRuntime)(leaseId, this.scopeFrom(flags)));
-            const lease = current?.lease;
             willPurge =
-                lease?.state === 'archived' ||
-                    (!flags['retain-storage'] && (lease?.storage?.retentionClass || 'none') === 'none');
+                prior?.state === 'archived' ||
+                    (!flags['retain-storage'] && (prior?.storage?.retentionClass || 'none') === 'none');
         }
         if (willPurge && !flags.yes) {
             if (!process.stdin.isTTY) {
@@ -69,6 +74,15 @@ class DedicatedMachinesDestroy extends dedicated_lease_command_1.DedicatedLeaseC
             retentionIntent = 'retain';
         const response = await this.callDedicated(() => (0, dedicated_machines_1.destroyDedicatedRuntime)(leaseId, { ...this.scopeFrom(flags), retentionIntent }));
         await this.reportLeaseAction(response, flags, { kind: 'destroyed' }, 'Destroying');
+        if (!flags.json) {
+            const note = (0, dedicated_machines_1.dedicatedDestroyRetentionNote)(prior, {
+                purge: Boolean(flags['purge-storage']),
+                retain: Boolean(flags['retain-storage']),
+                bin: this.config.bin,
+            });
+            if (note)
+                this.log(note);
+        }
     }
 }
 exports.default = DedicatedMachinesDestroy;

package/dist/commands/machines/dedicated/list.js

@@ -40,9 +40,14 @@ class DedicatedMachinesList extends dedicated_lease_command_1.DedicatedLeaseComm
             }
             return;
         }
+        const scopeSpendCents = (0, dedicated_machines_1.dedicatedScopeMonthSpendCents)(leases);
+        if (scopeSpendCents !== null) {
+            this.log(`Dedicated Runtime spend this month, across every machine listed: ${(0, dedicated_machines_1.formatUsdCents)(scopeSpendCents)}`);
+            this.log('');
+        }
         (0, format_1.renderTable)(leases.map((lease) => ({
             id: (0, format_1.formatCell)((0, dedicated_machines_1.dedicatedLeaseId)(lease)),
-            status: (0, format_1.formatCell)((0, dedicated_machines_1.dedicatedLeaseState)(lease)),
+            status: (0, format_1.formatCell)((0, dedicated_machines_1.dedicatedLeaseStatusCell)(lease)),
             name: (0, format_1.formatCell)((0, dedicated_machines_1.dedicatedLeaseDisplayName)(lease)),
             size: (0, format_1.formatCell)([
                 lease.resources?.sizePreset,
@@ -50,17 +55,15 @@ class DedicatedMachinesList extends dedicated_lease_command_1.DedicatedLeaseComm
             ]
                 .filter(Boolean)
                 .join(' ') || '-'),
-            spend: (0, format_1.formatCell)(lease.billing
-                ? `${(0, dedicated_machines_1.formatUsdCents)(lease.billing.currentMonthSpendCents)}/${(0, dedicated_machines_1.formatUsdCents)(lease.billing.monthlySpendLimitCents)}${lease.billing.spendingLimitExceeded ? ' OVER' : ''}`
-                : '-'),
+            cap: (0, format_1.formatCell)((0, dedicated_machines_1.dedicatedLeaseCapCell)(lease)),
             retention: (0, format_1.formatCell)(lease.storage?.retentionClass || '-'),
             backup: (0, format_1.formatCell)(lease.storage?.lastBackupAt || '-'),
         })), [
             { key: 'id', header: 'ID' },
-            { key: 'status', header: 'STATUS' },
+            { key: 'status', header: 'STATUS', maxWidth: 28 },
             { key: 'name', header: 'NAME', maxWidth: 28 },
             { key: 'size', header: 'SIZE', maxWidth: 18 },
-            { key: 'spend', header: 'MONTH/CAP', maxWidth: 24 },
+            { key: 'cap', header: 'MONTHLY CAP', maxWidth: 24 },
             { key: 'retention', header: 'RETENTION', maxWidth: 14 },
             { key: 'backup', header: 'LAST BACKUP', maxWidth: 24 },
         ], (line) => this.log(line));

package/dist/commands/machines/hosted/list.js

@@ -61,6 +61,18 @@ class HostedMachinesList extends base_command_1.BaseCommand {
             { key: 'repos', header: 'REPOS', maxWidth: 36 },
             { key: 'preview', header: 'PREVIEW', maxWidth: 48 },
         ], (line) => this.log(line));
+        // How to find the same box in the other list. `machines list` identifies a
+        // hosted machine by `lease:<leaseId>` — a different random string from the
+        // `sbs_` id in the ID column above — so side by side the two commands read
+        // as two unrelated machines. Saying the mapping once, where both values are
+        // already on screen, is cheaper than a column nobody can interpret.
+        const withLease = sessions.filter((session) => session.machineLeaseId);
+        if (withLease.length > 0) {
+            this.log('');
+            this.log(`In \`${this.config.bin} machines list\` these appear under their LEASE id as ` +
+                `\`lease:<lease>\` — e.g. \`lease:${String(withLease[0].machineLeaseId)}\`. ` +
+                `\`machines show\` takes either.`);
+        }
     }
     /**
      * OSK-2045 — this command lists Hosted Machine *sessions* and nothing else,

package/dist/commands/machines/list.js

@@ -78,6 +78,17 @@ class MachinesList extends base_command_1.BaseCommand {
             { key: 'platform', header: 'PLATFORM' },
             { key: 'seen', header: 'LAST SEEN' },
         ], (line) => this.log(line));
+        // Why a machine is not `online`, under the table. `degraded` on its own is
+        // unactionable — the dogfood note on this output was "I still do not know
+        // whether something is wrong with my laptop" — and it is usually one named
+        // row, not the machine.
+        const explained = shown.filter((m) => m.status !== 'online' && m.statusReason);
+        if (explained.length > 0) {
+            this.log('');
+            for (const m of explained) {
+                this.log(`  ${m.preferences?.name || m.name}: ${m.statusReason}`);
+            }
+        }
         const hidden = all.length - shown.length;
         if (hidden > 0) {
             this.log('');

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

@@ -8,6 +8,7 @@ export default class MachinesShow extends BaseCommand {
     };
     static flags: {
         json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        all: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;
 }

package/dist/commands/machines/show.js

@@ -9,6 +9,7 @@ class MachinesShow extends base_command_1.BaseCommand {
     static description = 'Show one machine — its identity, harnesses, and available actions';
     static examples = [
         '<%= config.bin %> machines show 03548116',
+        '<%= config.bin %> machines show 03548116 --all',
         '<%= config.bin %> machines show "frankdu@DS-3" --json',
     ];
     static args = {
@@ -18,7 +19,13 @@ class MachinesShow extends base_command_1.BaseCommand {
             required: true,
         }),
     };
-    static flags = { json: core_1.Flags.boolean({ description: 'Output as JSON' }) };
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+        all: core_1.Flags.boolean({
+            description: 'Include harness registrations superseded by newer ones',
+            default: false,
+        }),
+    };
     async run() {
         this.requireAuth();
         const { args, flags } = await this.parse(MachinesShow);
@@ -43,6 +50,10 @@ class MachinesShow extends base_command_1.BaseCommand {
         this.log(`  id           ${machine.id}`);
         this.log(`  identity     ${machine.identityKind}`);
         this.log(`  status       ${machine.status}`);
+        // The status alone does not say what to do. Naming the rows that decided it
+        // is the actionable half — bring that provider back, or forget the row.
+        if (machine.statusReason)
+            this.log(`  why          ${machine.statusReason}`);
         if (machine.machineUuid)
             this.log(`  machineUuid  ${machine.machineUuid}`);
         if (machine.daemonId)
@@ -60,20 +71,34 @@ class MachinesShow extends base_command_1.BaseCommand {
         const harnesses = machine.harnesses ?? [];
         const live = (0, machines_1.liveHarnessCount)(machine);
         const superseded = harnesses.length - live;
+        // Superseded registrations are history, not capabilities, and they are not
+        // counted as missing ones next to a status of `online`. They are hidden by
+        // default, the convention `machines list` already set for dead machines:
+        // printed, they were 35 of a machine's 42 rows, back two months, under a
+        // header whose count read like a summary of rows it then printed anyway
+        // (OSK-9389). `--all` shows them, and `--json` always carries every row.
+        const shown = flags.all ? harnesses : harnesses.filter((h) => !h.superseded);
         this.log('');
-        // The superseded rows are still listed — labelled, not dropped, so they can
-        // be seen and reaped — but they are not missing capabilities and must not
-        // be counted as such next to a status of `online`.
         this.log(`Harnesses (${machine.onlineHarnessCount}/${live} online` +
-            (superseded > 0 ? `, ${superseded} superseded by newer registrations` : '') +
+            (flags.all && superseded > 0 ? `, ${superseded} superseded by newer registrations` : '') +
             ')');
-        if (harnesses.length > 0) {
-            (0, format_1.renderTable)(harnesses.map((h) => ({
+        if (shown.length > 0) {
+            (0, format_1.renderTable)(shown.map((h) => ({
                 id: (0, format_1.formatCell)(h.id),
                 provider: (0, format_1.formatCell)(h.provider),
-                // A superseded row that merely says `offline` reads as a harness
-                // that went down. Naming it is what explains the count above.
-                status: h.superseded ? 'superseded' : (0, format_1.formatCell)(h.status),
+                // Liveness only. Whether a newer registration replaced the row is a
+                // different fact — a superseded row can have been online — so it
+                // gets its own column rather than overwriting this one.
+                status: (0, format_1.formatCell)(h.status),
+                registration: h.superseded ? 'superseded' : 'current',
+                // `authStatus` is the DAEMON's standing with skrr, not this
+                // provider's standing with its vendor. It is written across every row
+                // of a daemon at once (`HarnessService.markAuthOkAfterRegister` does
+                // one `updateMany({owner, daemonId})`), so it is structurally the
+                // same value for all of them and can never answer "is this harness
+                // signed in". Under a bare `AUTH` header it read as the second
+                // question and answered `ok` for a Devin whose own CLI said
+                // "Not logged in." The header now names what the value is.
                 auth: (0, format_1.formatCell)(h.authStatus),
                 seen: h.lastSeenAt
                     ? new Date(h.lastSeenAt).toISOString().slice(0, 16).replace('T', ' ')
@@ -82,10 +107,14 @@ class MachinesShow extends base_command_1.BaseCommand {
                 { key: 'id', header: 'HARNESS ID' },
                 { key: 'provider', header: 'PROVIDER' },
                 { key: 'status', header: 'STATUS' },
-                { key: 'auth', header: 'AUTH' },
+                ...(flags.all ? [{ key: 'registration', header: 'REGISTRATION' }] : []),
+                { key: 'auth', header: 'DAEMON AUTH' },
                 { key: 'seen', header: 'LAST SEEN' },
             ], (line) => this.log(`  ${line}`));
         }
+        if (!flags.all && superseded > 0) {
+            this.log(`  ${superseded} superseded registration(s) hidden — pass --all to include them.`);
+        }
         // Print what is PERMITTED, not the whole control map: a list of six
         // booleans mostly reading false is noise, and the useful question is
         // "what can I do to this machine right now".

package/dist/commands/profiles/list.d.ts

@@ -0,0 +1,23 @@
+import { BaseCommand } from '../../base-command';
+/**
+ * Which stored sessions exist on this machine.
+ *
+ * Every command advertises `--profile` and nothing could tell you what to pass
+ * it. Profiles are additive and stored on disk — the default at
+ * `<root>/cli-config.json`, named ones at `<root>/profiles/<name>/cli-config.json`
+ * — so the list was always knowable; there was simply no way to ask.
+ *
+ * That is not only a discoverability nit. A second profile is how one machine
+ * holds a second identity, which is what any test of a NON-OWNER path needs. A
+ * dogfood run of the `force`-past-a-required-Review flow stalled on exactly
+ * this: the flag was there, the second identity was reachable, and nothing named
+ * it.
+ */
+export default class ProfilesList extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/profiles/list.js

@@ -0,0 +1,96 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../../base-command");
+const config_1 = require("../../lib/config");
+const keychain_1 = require("../../lib/keychain");
+/**
+ * Which stored sessions exist on this machine.
+ *
+ * Every command advertises `--profile` and nothing could tell you what to pass
+ * it. Profiles are additive and stored on disk — the default at
+ * `<root>/cli-config.json`, named ones at `<root>/profiles/<name>/cli-config.json`
+ * — so the list was always knowable; there was simply no way to ask.
+ *
+ * That is not only a discoverability nit. A second profile is how one machine
+ * holds a second identity, which is what any test of a NON-OWNER path needs. A
+ * dogfood run of the `force`-past-a-required-Review flow stalled on exactly
+ * this: the flag was there, the second identity was reachable, and nothing named
+ * it.
+ */
+class ProfilesList extends base_command_1.BaseCommand {
+    static description = 'List the stored sessions (profiles) on this machine';
+    static examples = [
+        '<%= config.bin %> profiles list',
+        '<%= config.bin %> profiles list --json',
+        '<%= config.bin %> login --profile reviewer',
+    ];
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        const { flags } = await this.parse(ProfilesList);
+        const root = (0, config_1.configRoot)();
+        const active = (0, keychain_1.getActiveProfile)() || keychain_1.DEFAULT_PROFILE;
+        const rows = [];
+        const seen = new Set();
+        const describe = (name, configFile) => {
+            /*
+             * Deliberately NOT a "signed in" column.
+             *
+             * The credential does not live in `cli-config.json` — it is in the
+             * keychain — so this file can only report the deployment. A first draft
+             * inferred sign-in from a `token` key that is never there and printed
+             * `no` for the profile the caller was actively authenticated as: a
+             * confident wrong answer, which is worse than an absent one and exactly
+             * the failure this whole surface keeps making. Read the server, say the
+             * server.
+             */
+            if (seen.has(name))
+                return;
+            seen.add(name);
+            let server;
+            try {
+                const raw = JSON.parse(node_fs_1.default.readFileSync(configFile, 'utf8'));
+                server = typeof raw.baseURL === 'string' ? raw.baseURL : undefined;
+            }
+            catch {
+                // A profile directory with no readable config is still a profile; say
+                // so rather than hiding it, because a half-written one is exactly what
+                // someone would be trying to diagnose.
+            }
+            rows.push({ name, active: name === active, server });
+        };
+        describe(keychain_1.DEFAULT_PROFILE, node_path_1.default.join(root, 'cli-config.json'));
+        try {
+            for (const entry of node_fs_1.default.readdirSync(node_path_1.default.join(root, 'profiles'), { withFileTypes: true })) {
+                if (!entry.isDirectory())
+                    continue;
+                describe(entry.name, node_path_1.default.join(root, 'profiles', entry.name, 'cli-config.json'));
+            }
+        }
+        catch {
+            // No `profiles/` directory means no named profiles — not an error.
+        }
+        if (flags.json) {
+            this.log(JSON.stringify({ root, active, profiles: rows }, null, 2));
+            return;
+        }
+        // Width from the DATA, so a long profile name cannot run into the next
+        // column — `df-memory-verify-isolated` did exactly that at a fixed 24.
+        const width = Math.max(4, ...rows.map((row) => row.name.length)) + 2;
+        this.log('NAME'.padEnd(width) + 'ACTIVE'.padEnd(9) + 'SERVER');
+        for (const row of rows) {
+            this.log(row.name.padEnd(width) + (row.active ? 'yes' : '-').padEnd(9) + (row.server || '-'));
+        }
+        this.log('');
+        this.log(`Add one:  ${this.config.bin} login --profile <name>`);
+        this.log(`Use one:  ${this.config.bin} <command> --profile <name>   (or OVERSKY_PROFILE)`);
+    }
+}
+exports.default = ProfilesList;

package/dist/commands/search/skills.d.ts

@@ -2,9 +2,19 @@ import { BaseCommand } from '../../base-command';
 export default class SearchSkills extends BaseCommand {
     static description: string;
     static examples: string[];
+    /**
+     * `skills search` and `search skills` are the SAME search, and both spellings
+     * stay. Neither said so, their one-liners differed, and only one carried short
+     * flags — so a reader picked one at random with no way to tell whether they had
+     * picked a deprecated spelling. Duplication that is deliberate should say so;
+     * duplication that is silent reads as a mistake either way.
+     */
+    static args: {
+        query: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
     static flags: {
         json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
-        query: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        query: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         category: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         limit: import("@oclif/core/lib/interfaces").OptionFlag<number, import("@oclif/core/lib/interfaces").CustomOptions>;
     };

package/dist/commands/search/skills.js

@@ -4,19 +4,36 @@ const core_1 = require("@oclif/core");
 const data_provider_1 = require("@skrr-ai/data-provider");
 const base_command_1 = require("../../base-command");
 const format_1 = require("../../lib/format");
+const search_query_1 = require("../../lib/search-query");
 class SearchSkills extends base_command_1.BaseCommand {
-    static description = 'Search skills in the skrr store';
+    static description = 'Search skills in the skrr store by keyword (same as `skills search`)';
     static examples = [
-        '<%= config.bin %> search skills --query "web scraping"',
-        '<%= config.bin %> search skills --query summarize --category productivity',
-        '<%= config.bin %> search skills --query translate --limit 10 --json',
+        '<%= config.bin %> search skills "web scraping"',
+        '<%= config.bin %> search skills summarize --category productivity',
+        '<%= config.bin %> search skills translate --limit 10 --json',
+        '<%= config.bin %> search skills -q translate',
     ];
+    /**
+     * `skills search` and `search skills` are the SAME search, and both spellings
+     * stay. Neither said so, their one-liners differed, and only one carried short
+     * flags — so a reader picked one at random with no way to tell whether they had
+     * picked a deprecated spelling. Duplication that is deliberate should say so;
+     * duplication that is silent reads as a mistake either way.
+     */
+    static args = {
+        query: core_1.Args.string({
+            description: 'Search term (same value as --query; pass either, not both)',
+            required: false,
+            ignoreStdin: true,
+        }),
+    };
     static flags = {
         json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+        // See `skills search` — the positional satisfies it and the flag stays so
+        // existing scripts keep working.
         query: core_1.Flags.string({
             char: 'q',
             description: 'Search query',
-            required: true,
         }),
         category: core_1.Flags.string({
             char: 'c',
@@ -29,11 +46,12 @@ class SearchSkills extends base_command_1.BaseCommand {
     };
     async run() {
         this.requireAuth();
-        const { flags } = await this.parse(SearchSkills);
+        const { args, flags } = await this.parse(SearchSkills);
+        const query = (0, search_query_1.resolveSearchQuery)(this, args.query, flags.query, 'search skills');
         let response;
         try {
             response = await data_provider_1.dataService.getStoreSkills({
-                q: flags.query,
+                q: query,
                 category: flags.category,
                 limit: flags.limit,
             });
@@ -48,7 +66,7 @@ class SearchSkills extends base_command_1.BaseCommand {
         const r = response;
         const items = Array.isArray(r) ? r : (r?.data ?? []);
         if (items.length === 0) {
-            this.log('No skills found.');
+            this.log(`No skills found matching '${query}'.`);
             return;
         }
         const rows = items.map((s) => ({