@skrr-ai/cli 0.1.36 → 0.1.38

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/memory/governance/index.d.ts

@@ -0,0 +1,21 @@
+import { BaseCommand } from '../../../base-command';
+/**
+ * An agent's memory POLICY: which pools its runtime may read and write, how long
+ * retained facts are governed, and what deletion means.
+ *
+ * Its own route rather than a corner of `PATCH /api/agents/:id`, and the CLI
+ * uses the same door the web does. The distinction the route draws — and this
+ * command surfaces — is between a policy an owner has DELIBERATELY saved and the
+ * defaults an unconfigured agent reads as. Mongoose materializes the leaf
+ * defaults on every new agent row, so "has a policy" cannot be answered by the
+ * field being present; only `updatedAt` says a human decided something.
+ */
+export default class MemoryGovernanceShow extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        agent: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/memory/governance/index.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const data_provider_1 = require("@skrr-ai/data-provider");
+const base_command_1 = require("../../../base-command");
+const agent_resolver_1 = require("../../../lib/agent-resolver");
+/**
+ * An agent's memory POLICY: which pools its runtime may read and write, how long
+ * retained facts are governed, and what deletion means.
+ *
+ * Its own route rather than a corner of `PATCH /api/agents/:id`, and the CLI
+ * uses the same door the web does. The distinction the route draws — and this
+ * command surfaces — is between a policy an owner has DELIBERATELY saved and the
+ * defaults an unconfigured agent reads as. Mongoose materializes the leaf
+ * defaults on every new agent row, so "has a policy" cannot be answered by the
+ * field being present; only `updatedAt` says a human decided something.
+ */
+class MemoryGovernanceShow extends base_command_1.BaseCommand {
+    static description = "Show an agent's memory governance policy";
+    static examples = [
+        '<%= config.bin %> memory governance --agent <agent-id>',
+        '<%= config.bin %> memory governance --agent <agent-id> --json',
+    ];
+    static flags = {
+        agent: core_1.Flags.string({
+            description: 'Agent ID (falls back to OVERSKY_AGENT_ID, then your primary agent)',
+        }),
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { flags } = await this.parse(MemoryGovernanceShow);
+        let agentId;
+        try {
+            agentId = await (0, agent_resolver_1.resolveAgentId)(flags.agent);
+        }
+        catch (err) {
+            this.error(err.message, { exit: 1 });
+        }
+        let policy;
+        try {
+            policy = await data_provider_1.dataService.getAgentMemoryGovernance(agentId);
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+        if (flags.json) {
+            this.log(this.agentJson(agentId, policy));
+            return;
+        }
+        const p = policy;
+        this.log(`Memory governance for agent ${agentId}`);
+        this.log(`  Read scopes:        ${(p.allowedReadScopes ?? []).join(', ') || '-'}`);
+        this.log(`  Write scopes:       ${(p.allowedWriteScopes ?? []).join(', ') || '-'}`);
+        this.log(`  Retention:          ${p.retentionDays ?? '-'} days`);
+        this.log(`  On deletion:        ${p.deletionMode ?? '-'}`);
+        this.log(`  Shared memory:      ${p.requireEvidenceForSharedMemory ? 'requires evidence' : 'no evidence required'}`);
+        this.log('');
+        this.log(p.updatedAt
+            ? `Configured ${String(p.updatedAt).slice(0, 10)}.`
+            : 'Never configured — these are the defaults a run reads, not a saved policy.');
+    }
+}
+exports.default = MemoryGovernanceShow;

package/dist/commands/memory/governance/set.d.ts

@@ -0,0 +1,24 @@
+import { BaseCommand } from '../../../base-command';
+/**
+ * Change an agent's memory policy. Requires EDIT on the agent.
+ *
+ * PARTIAL by design and worth being explicit about: the route merges over the
+ * leaves an owner has actually set, so omitting a flag leaves that leaf unset
+ * rather than freezing today's default into the row. That is why `--read-scope`
+ * REPLACES the list instead of adding to it — a list flag that appended would
+ * make "only agent memory" unreachable once anything wider had been granted.
+ */
+export default class MemoryGovernanceSet extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        agent: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'read-scope': import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'write-scope': import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'retention-days': import("@oclif/core/lib/interfaces").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'deletion-mode': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'require-evidence': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/memory/governance/set.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const data_provider_1 = require("@skrr-ai/data-provider");
+const base_command_1 = require("../../../base-command");
+const agent_resolver_1 = require("../../../lib/agent-resolver");
+const MEMORY_SCOPES = ['agent', 'user', 'workspace'];
+/**
+ * Change an agent's memory policy. Requires EDIT on the agent.
+ *
+ * PARTIAL by design and worth being explicit about: the route merges over the
+ * leaves an owner has actually set, so omitting a flag leaves that leaf unset
+ * rather than freezing today's default into the row. That is why `--read-scope`
+ * REPLACES the list instead of adding to it — a list flag that appended would
+ * make "only agent memory" unreachable once anything wider had been granted.
+ */
+class MemoryGovernanceSet extends base_command_1.BaseCommand {
+    static description = "Change an agent's memory governance policy (requires EDIT)";
+    static examples = [
+        '<%= config.bin %> memory governance set --agent <agent-id> --retention-days 90',
+        '<%= config.bin %> memory governance set --agent <agent-id> --read-scope agent --read-scope workspace',
+        '<%= config.bin %> memory governance set --agent <agent-id> --deletion-mode delete --no-require-evidence',
+    ];
+    static flags = {
+        agent: core_1.Flags.string({ description: 'Agent ID' }),
+        'read-scope': core_1.Flags.string({
+            description: 'Memory pool the runtime may READ (repeatable; replaces the list)',
+            options: [...MEMORY_SCOPES],
+            multiple: true,
+        }),
+        'write-scope': core_1.Flags.string({
+            description: 'Memory pool the runtime may WRITE (repeatable; replaces the list)',
+            options: [...MEMORY_SCOPES],
+            multiple: true,
+        }),
+        'retention-days': core_1.Flags.integer({
+            description: 'How long retained facts are governed (1-3650)',
+        }),
+        'deletion-mode': core_1.Flags.string({
+            description: 'What deletion means for this agent',
+            options: ['archive', 'delete'],
+        }),
+        'require-evidence': core_1.Flags.boolean({
+            description: 'Require evidence before a fact enters shared memory',
+            allowNo: true,
+        }),
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { flags } = await this.parse(MemoryGovernanceSet);
+        const patch = {
+            ...(flags['read-scope'] === undefined
+                ? {}
+                : { allowedReadScopes: flags['read-scope'] }),
+            ...(flags['write-scope'] === undefined
+                ? {}
+                : { allowedWriteScopes: flags['write-scope'] }),
+            ...(flags['retention-days'] === undefined ? {} : { retentionDays: flags['retention-days'] }),
+            ...(flags['deletion-mode'] === undefined
+                ? {}
+                : { deletionMode: flags['deletion-mode'] }),
+            ...(flags['require-evidence'] === undefined
+                ? {}
+                : { requireEvidenceForSharedMemory: flags['require-evidence'] }),
+        };
+        if (Object.keys(patch).length === 0) {
+            this.error('Nothing to change. Pass at least one of --read-scope, --write-scope, ' +
+                '--retention-days, --deletion-mode, --require-evidence.', { exit: 1 });
+        }
+        let agentId;
+        try {
+            agentId = await (0, agent_resolver_1.resolveAgentId)(flags.agent);
+        }
+        catch (err) {
+            this.error(err.message, { exit: 1 });
+        }
+        let policy;
+        try {
+            policy = await data_provider_1.dataService.updateAgentMemoryGovernance(agentId, patch);
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+        if (flags.json) {
+            this.log(this.agentJson(agentId, policy));
+            return;
+        }
+        this.log(`Updated memory governance for agent ${agentId}.`);
+        this.log(`  Read scopes:  ${(policy.allowedReadScopes ?? []).join(', ') || '-'}`);
+        this.log(`  Write scopes: ${(policy.allowedWriteScopes ?? []).join(', ') || '-'}`);
+        this.log(`  Retention:    ${policy.retentionDays ?? '-'} days`);
+    }
+}
+exports.default = MemoryGovernanceSet;

package/dist/commands/memory/provenance.d.ts

@@ -0,0 +1,18 @@
+import { BaseCommand } from '../../base-command';
+/**
+ * Where an agent's stored memories came from.
+ *
+ * The other half of governance: a policy says what a runtime MAY remember, and
+ * this says what it actually did and on whose evidence. Read-only, VIEW on the
+ * agent.
+ */
+export default class MemoryProvenance extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        agent: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        limit: import("@oclif/core/lib/interfaces").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/memory/provenance.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const data_provider_1 = require("@skrr-ai/data-provider");
+const base_command_1 = require("../../base-command");
+const agent_resolver_1 = require("../../lib/agent-resolver");
+const format_1 = require("../../lib/format");
+/**
+ * Where an agent's stored memories came from.
+ *
+ * The other half of governance: a policy says what a runtime MAY remember, and
+ * this says what it actually did and on whose evidence. Read-only, VIEW on the
+ * agent.
+ */
+class MemoryProvenance extends base_command_1.BaseCommand {
+    static description = "Show where an agent's stored memories came from";
+    static examples = [
+        '<%= config.bin %> memory provenance --agent <agent-id>',
+        '<%= config.bin %> memory provenance --agent <agent-id> --limit 50 --json',
+    ];
+    static flags = {
+        agent: core_1.Flags.string({ description: 'Agent ID' }),
+        limit: core_1.Flags.integer({ description: 'How many entries to return' }),
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { flags } = await this.parse(MemoryProvenance);
+        let agentId;
+        try {
+            agentId = await (0, agent_resolver_1.resolveAgentId)(flags.agent);
+        }
+        catch (err) {
+            this.error(err.message, { exit: 1 });
+        }
+        let response;
+        try {
+            response = await data_provider_1.dataService.getAgentMemoryProvenance(agentId, flags.limit === undefined ? undefined : { limit: flags.limit });
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+        if (flags.json) {
+            this.log(this.agentJson(agentId, response));
+            return;
+        }
+        const payload = response;
+        const entries = Array.isArray(response)
+            ? response
+            : (payload?.entries ?? []);
+        if (entries.length === 0) {
+            this.log(`No memory provenance recorded for agent ${agentId}.`);
+            return;
+        }
+        (0, format_1.renderTable)(entries.map((entry) => ({
+            key: String(entry.key ?? '-'),
+            source: String(entry.source ?? entry.origin ?? '-'),
+            at: entry.updated_at ? String(entry.updated_at).slice(0, 10) : '-',
+        })), [
+            { key: 'key', header: 'KEY', verbatim: true },
+            { key: 'source', header: 'SOURCE', maxWidth: 30 },
+            { key: 'at', header: 'UPDATED' },
+        ], (line) => this.log(line));
+    }
+}
+exports.default = MemoryProvenance;

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) => ({

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

@@ -8,5 +8,7 @@ export default class SkillsDetails extends BaseCommand {
     static flags: {
         json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
     };
+    /** A store 404 for a name that may be a skill on the caller's machine. */
+    private failOnStoreMiss;
     run(): Promise<void>;
 }