@skrr-ai/cli 0.1.36 → 0.1.38

package/dist/commands/skills/details.js

@@ -3,6 +3,7 @@ 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 local_skills_1 = require("../../lib/local-skills");
 class SkillsDetails extends base_command_1.BaseCommand {
     static description = 'Show full details for a skill';
     static examples = [
@@ -15,15 +16,37 @@ class SkillsDetails extends base_command_1.BaseCommand {
     static flags = {
         json: core_1.Flags.boolean({ description: 'Output as JSON' }),
     };
+    /** A store 404 for a name that may be a skill on the caller's machine. */
+    async failOnStoreMiss(err, id) {
+        if (err?.status === 404) {
+            this.failWithCliError({
+                message: (0, local_skills_1.describeStoreSkillMiss)(id, await (0, local_skills_1.findLocalSkillsNamed)(id), 'details'),
+                code: 'NOT_FOUND',
+                status: 404,
+                exit: 1,
+                retryable: false,
+            });
+        }
+        this.handleApiError(err);
+    }
     async run() {
         this.requireAuth();
         const { args, flags } = await this.parse(SkillsDetails);
+        // A path is never a store id: say so before asking the store (OSK-9412).
+        if ((0, local_skills_1.looksLikeSkillPath)(args.id)) {
+            this.failWithCliError({
+                message: (0, local_skills_1.describeStoreSkillMiss)(args.id, [], 'details'),
+                code: 'STORE_SKILL_ID_EXPECTED',
+                exit: 2,
+                retryable: false,
+            });
+        }
         let skill;
         try {
             skill = await data_provider_1.dataService.getSkill(args.id);
         }
         catch (err) {
-            this.handleApiError(err);
+            await this.failOnStoreMiss(err, args.id);
         }
         if (flags.json) {
             this.log(JSON.stringify(skill, null, 2));

package/dist/commands/skills/import-as-actions.d.ts

@@ -0,0 +1,32 @@
+import { BaseCommand } from '../../base-command';
+/**
+ * Import a machine's local skills into an agent, each as a quick action.
+ *
+ * `skrr skills local` listed these skills and nothing in the CLI could act on
+ * them: the server route and the web dialog existed, and a headless operator or
+ * a locally-running coding agent had no way in (OSK-9659).
+ *
+ * The whole selection goes in ONE request, as the route requires — the agent's
+ * action library is one document field, and one request per skill is the
+ * lost-update race the route was built to avoid. Each skill comes back with its
+ * own status, because partial success is the normal result.
+ */
+export default class SkillsImportAsActions extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static strict: boolean;
+    static args: {
+        skills: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        agent: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        daemon: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        scope: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        space: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        label: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        outcome: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'attach-to-space': 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/skills/import-as-actions.js

@@ -0,0 +1,175 @@
+"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_actions_1 = require("../../lib/agent-actions");
+const format_1 = require("../../lib/format");
+const local_skills_1 = require("../../lib/local-skills");
+/**
+ * Import a machine's local skills into an agent, each as a quick action.
+ *
+ * `skrr skills local` listed these skills and nothing in the CLI could act on
+ * them: the server route and the web dialog existed, and a headless operator or
+ * a locally-running coding agent had no way in (OSK-9659).
+ *
+ * The whole selection goes in ONE request, as the route requires — the agent's
+ * action library is one document field, and one request per skill is the
+ * lost-update race the route was built to avoid. Each skill comes back with its
+ * own status, because partial success is the normal result.
+ */
+class SkillsImportAsActions extends base_command_1.BaseCommand {
+    static description = "Import skills from a machine into an agent, each as a quick action (discover them with 'skills local')";
+    static examples = [
+        '<%= config.bin %> skills import-as-actions dogfood db-performance --agent <agent-id>',
+        '<%= config.bin %> skills import-as-actions dogfood --agent <agent-id> --space <space-id> --outcome durable',
+        '<%= config.bin %> skills import-as-actions dogfood --agent <agent-id> --label dogfood',
+    ];
+    static strict = false;
+    static args = {
+        skills: core_1.Args.string({
+            description: 'Skill name(s) as `skills local` lists them. Repeatable, 1-20.',
+            required: false,
+            ignoreStdin: true,
+        }),
+    };
+    static flags = {
+        agent: core_1.Flags.string({
+            description: 'Agent that will own the actions (needs EDIT)',
+            required: true,
+        }),
+        daemon: core_1.Flags.string({
+            description: 'Which machine to import from. Defaults to your only connected daemon.',
+        }),
+        scope: core_1.Flags.string({
+            description: 'Where the actions are offered. Implied by --space / --label.',
+            options: [...agent_actions_1.AGENT_ACTION_SCOPE_CHOICES],
+        }),
+        space: core_1.Flags.string({ description: 'Offer only in this space (implies --scope space)' }),
+        label: core_1.Flags.string({
+            description: 'Offer in every space carrying this Label — id or name (repeatable, any-of; implies --scope label)',
+            multiple: true,
+        }),
+        outcome: core_1.Flags.string({
+            description: "What a run leaves behind: 'durable' keeps its task on the board",
+            options: [...agent_actions_1.AGENT_ACTION_OUTCOME_CHOICES],
+        }),
+        'attach-to-space': core_1.Flags.string({
+            description: "Also add each imported skill to this space's skill library (needs EDIT)",
+        }),
+        json: core_1.Flags.boolean({ description: 'Output the per-skill results as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { argv, flags } = await this.parse(SkillsImportAsActions);
+        const names = [...new Set(argv.map((name) => name.trim()).filter(Boolean))];
+        if (names.length === 0) {
+            this.error('Name at least one skill. List them with: skills local', { exit: 1 });
+        }
+        if (names.length > 20) {
+            this.error(`At most 20 skills per import (got ${names.length}).`, { exit: 1 });
+        }
+        let daemonId = flags.daemon;
+        if (!daemonId) {
+            let daemons;
+            try {
+                daemons = await data_provider_1.dataService.getDaemons();
+            }
+            catch (err) {
+                this.handleApiError(err);
+                return;
+            }
+            const choice = (0, local_skills_1.chooseDaemon)(daemons.active ?? []);
+            if (!('daemonId' in choice)) {
+                const listed = choice.candidates.map((d) => `  --daemon ${d.daemonId}${d.deviceName ? `  (${d.deviceName})` : ''}`);
+                this.error([choice.problem, ...listed].join('\n'), { exit: 2 });
+            }
+            daemonId = choice.daemonId;
+        }
+        // Resolve each name against the machine's own listing. The listing's
+        // `pathHash` round-trips to the route so a skill renamed or replaced since
+        // it was listed is refused rather than silently importing something else,
+        // and an unknown name fails here with the list, not as a per-skill error.
+        let listing;
+        let version;
+        try {
+            const response = await data_provider_1.dataService.getDaemonSkills(daemonId);
+            listing = response.skills ?? [];
+            version = response.version;
+        }
+        catch (err) {
+            this.handleApiError(err);
+            return;
+        }
+        const byName = new Map(listing.map((skill) => [String(skill.name), skill]));
+        const unknown = names.filter((name) => !byName.has(name));
+        if (unknown.length > 0) {
+            const tooOld = (0, local_skills_1.daemonPredates)(version, local_skills_1.SKILL_CONVENTION_DISCOVERY_SINCE);
+            this.error(tooOld
+                ? `This daemon (${version}) cannot see skills in the conventions — discovery arrived in ${local_skills_1.SKILL_CONVENTION_DISCOVERY_SINCE}. Update it, run \`${this.config.bin} daemon restart\`, then try again.`
+                : `Not on ${daemonId}: ${unknown.join(', ')}. List what is there with: ${this.config.bin} skills local --daemon ${daemonId}`, { exit: 1 });
+        }
+        let scopeParams = {};
+        try {
+            const scope = await (0, agent_actions_1.resolveAgentActionScopeFlags)(flags);
+            if (scope?.kind === 'space')
+                scopeParams = { scope: 'space', spaceId: scope.spaceId };
+            else if (scope?.kind === 'label')
+                scopeParams = { scope: 'label', labelIds: scope.labelIds };
+            else if (scope?.kind === 'general')
+                scopeParams = { scope: 'general' };
+        }
+        catch (err) {
+            this.error(err.message, { exit: 1 });
+        }
+        let result;
+        try {
+            result = await data_provider_1.dataService.importDaemonSkillsAsActions({
+                daemonId,
+                targetAgentId: flags.agent,
+                skills: names.map((name) => {
+                    const pathHash = byName.get(name)?.pathHash;
+                    return pathHash ? { name, pathHash: String(pathHash) } : { name };
+                }),
+                ...scopeParams,
+                ...(flags.outcome ? { outcome: flags.outcome } : {}),
+                ...(flags['attach-to-space'] ? { attachToSpaceId: flags['attach-to-space'] } : {}),
+            });
+        }
+        catch (err) {
+            this.handleApiError(err);
+            return;
+        }
+        const failed = result.results.filter((r) => r.status === 'failed');
+        if (flags.json) {
+            this.log(JSON.stringify(result, null, 2));
+        }
+        else {
+            (0, format_1.renderTable)(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 ?? '',
+            })), [
+                { key: 'skill', header: 'SKILL' },
+                { key: 'import', header: 'IMPORT' },
+                { key: 'action', header: 'ACTION' },
+                { key: 'detail', header: 'DETAIL' },
+            ], (line) => this.log(line));
+            this.log(`${result.actionsCreated} action(s) created on ${result.targetAgentId}; ` +
+                `${failed.length} skill(s) failed.`);
+            if (result.actionsError) {
+                this.log(`The skills imported, but their actions could not be added: ${result.actionsError.message}`);
+            }
+        }
+        // Partial success is normal and reported above; exit non-zero only when
+        // something the caller asked for did not happen.
+        if (failed.length > 0 || result.actionsError)
+            this.exit(1);
+    }
+}
+exports.default = SkillsImportAsActions;

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

@@ -10,5 +10,7 @@ export default class SkillsInstall extends BaseCommand {
         agent: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         service: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
     };
+    /** A store 404 for a name that may be a skill on the caller's machine. */
+    private failOnStoreMiss;
     run(): Promise<void>;
 }

package/dist/commands/skills/install.js

@@ -3,6 +3,7 @@ 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 local_skills_1 = require("../../lib/local-skills");
 class SkillsInstall extends base_command_1.BaseCommand {
     static description = 'Install a skill from the store to a service (agent)';
     static examples = [
@@ -25,6 +26,19 @@ class SkillsInstall extends base_command_1.BaseCommand {
             hidden: true,
         }),
     };
+    /** A store 404 for a name that may be a skill on the caller's machine. */
+    async failOnStoreMiss(err, id) {
+        if (err?.status === 404) {
+            this.failWithCliError({
+                message: (0, local_skills_1.describeStoreSkillMiss)(id, await (0, local_skills_1.findLocalSkillsNamed)(id), 'install'),
+                code: 'NOT_FOUND',
+                status: 404,
+                exit: 1,
+                retryable: false,
+            });
+        }
+        this.handleApiError(err);
+    }
     async run() {
         this.requireAuth();
         const { args, flags } = await this.parse(SkillsInstall);
@@ -33,6 +47,15 @@ class SkillsInstall extends base_command_1.BaseCommand {
             process.stderr.write('[skrr] --service is deprecated for `skills install`; use --agent instead.\n');
         }
         const targetAgentId = flags.agent ?? flags.service ?? null;
+        // A path is never a store id: say so before asking the store (OSK-9412).
+        if ((0, local_skills_1.looksLikeSkillPath)(args.id)) {
+            this.failWithCliError({
+                message: (0, local_skills_1.describeStoreSkillMiss)(args.id, [], 'install'),
+                code: 'STORE_SKILL_ID_EXPECTED',
+                exit: 2,
+                retryable: false,
+            });
+        }
         let result;
         try {
             result = await data_provider_1.dataService.installSkill({
@@ -41,7 +64,7 @@ class SkillsInstall extends base_command_1.BaseCommand {
             });
         }
         catch (err) {
-            this.handleApiError(err);
+            await this.failOnStoreMiss(err, args.id);
         }
         if (flags.json) {
             this.log(JSON.stringify(result, null, 2));

package/dist/commands/skills/invocable.js

@@ -15,7 +15,7 @@ const format_1 = require("../../lib/format");
  *     The latter is what a chat user actually sees.
  */
 class SkillsInvocable extends base_command_1.BaseCommand {
-    static description = 'List skills callable via /skill-name (attached + accessible globals; broader than `agents skills list`)';
+    static description = 'List library skills callable via /skill-name (attached + accessible globals). Skills on your machine: `skrr skills local`';
     static examples = [
         '<%= config.bin %> skills invocable',
         '<%= config.bin %> skills invocable --agent <agent-id>',
@@ -51,7 +51,11 @@ class SkillsInvocable extends base_command_1.BaseCommand {
         const scope = flags.agent ? `agent ${flags.agent}` : 'your global scope';
         const attached = items.filter((s) => s.agentId != null).length;
         const globals = items.length - attached;
-        this.log(`Invocable set for ${scope}: ${items.length} total (${attached} attached + ${globals} accessible globals).`);
+        this.log(`Invocable library skills for ${scope}: ${items.length} total (${attached} attached + ${globals} accessible globals).`);
+        // Two kinds of skill answer to `/name`, and this counts only one. Said on
+        // every run, not just at zero: a non-empty library list read as "all my
+        // skills" hides the other kind just as well (OSK-9478).
+        this.log('Skills in your machine’s .claude/skills and sibling roots are listed by `skrr skills local`.');
         if (items.length === 0)
             return;
         const rows = items.map((s) => ({

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

@@ -0,0 +1,40 @@
+import { BaseCommand } from '../../base-command';
+/**
+ * The skills that are ON THIS MACHINE.
+ *
+ * Every other command under `skills` is about the STORE or a cloud scope —
+ * `browse`, `library`, `install`, `invocable`. Not one of them reads the
+ * filesystem, and the topic's own description ("Browse and install skills from
+ * the skill store") names the store, so the one topic named after the thing was
+ * about something else entirely. A machine with 79 discovered skills across
+ * seven roots could not show one line of them through `skrr`, and
+ * `skills invocable` — the command whose description promises breadth —
+ * answered `0 total` beside them.
+ *
+ * The inventory already existed and was already published: the daemon walks its
+ * roots at registration (`reportableSkills`), the row lands in
+ * `daemon:active:*`, and `GET /api/daemons/:id/skills` serves it. This reads
+ * that. Nothing new is collected.
+ *
+ * It is also the repo's own rule rather than a preference: "the CLI is how a
+ * headless operator and a locally-running coding agent touch the platform, so
+ * an endpoint the API exposes must be reachable from `skrr`."
+ *
+ * WHAT THIS IS NOT: the list a `/`-menu selection resolves against. That walk
+ * happens at session start from the SESSION's effective cwd, which may be a
+ * worktree or an ephemeral workspace; this one is the daemon's own cwd. They
+ * usually agree and are not required to, so the header says which machine and
+ * directory the answer is about rather than implying it is the only one.
+ */
+export default class SkillsLocal extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        quiet: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        daemon: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        root: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        triggers: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/skills/local.js

@@ -0,0 +1,160 @@
+"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 format_1 = require("../../lib/format");
+const local_skills_1 = require("../../lib/local-skills");
+/**
+ * The skills that are ON THIS MACHINE.
+ *
+ * Every other command under `skills` is about the STORE or a cloud scope —
+ * `browse`, `library`, `install`, `invocable`. Not one of them reads the
+ * filesystem, and the topic's own description ("Browse and install skills from
+ * the skill store") names the store, so the one topic named after the thing was
+ * about something else entirely. A machine with 79 discovered skills across
+ * seven roots could not show one line of them through `skrr`, and
+ * `skills invocable` — the command whose description promises breadth —
+ * answered `0 total` beside them.
+ *
+ * The inventory already existed and was already published: the daemon walks its
+ * roots at registration (`reportableSkills`), the row lands in
+ * `daemon:active:*`, and `GET /api/daemons/:id/skills` serves it. This reads
+ * that. Nothing new is collected.
+ *
+ * It is also the repo's own rule rather than a preference: "the CLI is how a
+ * headless operator and a locally-running coding agent touch the platform, so
+ * an endpoint the API exposes must be reachable from `skrr`."
+ *
+ * WHAT THIS IS NOT: the list a `/`-menu selection resolves against. That walk
+ * happens at session start from the SESSION's effective cwd, which may be a
+ * worktree or an ephemeral workspace; this one is the daemon's own cwd. They
+ * usually agree and are not required to, so the header says which machine and
+ * directory the answer is about rather than implying it is the only one.
+ */
+class SkillsLocal extends base_command_1.BaseCommand {
+    static description = 'List the skills discovered on a machine, from its daemon';
+    static examples = [
+        '<%= config.bin %> skills local',
+        '<%= config.bin %> skills local --daemon <daemon-id>',
+        '<%= config.bin %> skills local --root .claude/skills',
+        '<%= config.bin %> skills local --json',
+    ];
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+        quiet: core_1.Flags.boolean({ description: 'Suppress non-essential output' }),
+        daemon: core_1.Flags.string({
+            description: 'Which machine to ask. Defaults to your only connected daemon.',
+        }),
+        root: core_1.Flags.string({
+            description: 'Only skills found under this convention root, e.g. .claude/skills',
+        }),
+        triggers: core_1.Flags.string({
+            description: 'Only skills with this trigger',
+            options: ['user', 'model'],
+        }),
+    };
+    async run() {
+        this.requireAuth();
+        const { flags } = await this.parse(SkillsLocal);
+        let daemonId = flags.daemon;
+        if (!daemonId) {
+            // Resolve rather than guess. Naming the ambiguity beats picking one of
+            // several machines and reporting its skills as "the" answer.
+            let daemons;
+            try {
+                daemons = await data_provider_1.dataService.getDaemons();
+            }
+            catch (err) {
+                this.handleApiError(err);
+                return;
+            }
+            const choice = (0, local_skills_1.chooseDaemon)(daemons.active ?? []);
+            if (!('daemonId' in choice)) {
+                // A usage error, on stderr: printed to stdout it was the whole output of
+                // `--json`, which a caller then failed to parse.
+                const listed = choice.candidates.map((d) => `  --daemon ${d.daemonId}${d.deviceName ? `  (${d.deviceName})` : ''}`);
+                this.error([choice.problem, ...listed].join('\n'), { exit: 2 });
+            }
+            daemonId = choice.daemonId;
+        }
+        let response;
+        try {
+            response = await data_provider_1.dataService.getDaemonSkills(daemonId);
+        }
+        catch (err) {
+            this.handleApiError(err);
+            return;
+        }
+        let skills = response.skills ?? [];
+        if (flags.root)
+            skills = skills.filter((s) => s.source === flags.root);
+        if (flags.triggers) {
+            const want = flags.triggers;
+            // A skill with no declared triggers is invocable both ways — that is the
+            // walker's own default when frontmatter is silent, not an absence.
+            skills = skills.filter((s) => want === 'user' ? (0, local_skills_1.isUserInvocable)(s) : !s.triggers || s.triggers.includes(want));
+        }
+        if (flags.json) {
+            this.log(JSON.stringify({
+                daemonId,
+                online: response.online,
+                version: response.version ?? null,
+                // An empty `data` from a daemon too old to look is not "no skills".
+                discoversConventions: response.version
+                    ? !(0, local_skills_1.daemonPredates)(response.version, local_skills_1.SKILL_CONVENTION_DISCOVERY_SINCE)
+                    : null,
+                data: skills,
+            }, null, 2));
+            return;
+        }
+        if (flags.quiet)
+            return;
+        if (skills.length === 0) {
+            // Three different states, and a bare "none" would collapse them.
+            if (!response.online) {
+                this.log(`${daemonId} is not connected, so its inventory may be out of date. None listed.`);
+            }
+            else if ((0, local_skills_1.daemonPredates)(response.version, local_skills_1.SKILL_CONVENTION_DISCOVERY_SINCE)) {
+                // Checked before the filter and "add a SKILL.md" branches: from a daemon
+                // this old, an empty list says nothing about what is on the machine, and
+                // telling the user to add files it cannot see sent them in a circle
+                // (OSK-9630 — 20 SKILL.md files on disk, "No skills discovered").
+                this.log(`No skills listed — but this daemon (${response.version}) cannot see them. ` +
+                    `Discovery from .claude/skills, .agents/skills, .devin/skills, .windsurf/skills and ` +
+                    `~/.claude/skills arrived in ${local_skills_1.SKILL_CONVENTION_DISCOVERY_SINCE}. Update the daemon ` +
+                    `(one that came with the desktop app updates with the app), then run ` +
+                    `\`${this.config.bin} daemon restart\`.`);
+            }
+            else if (flags.root || flags.triggers) {
+                this.log('No skills match that filter on this machine.');
+            }
+            else {
+                this.log('No skills discovered on this machine. Put a SKILL.md in one of the conventions ' +
+                    '(.claude/skills, .agents/skills, .devin/skills, .windsurf/skills) and reconnect.');
+            }
+            return;
+        }
+        const rows = skills.map((s) => ({
+            name: String(s.name),
+            // Where it came from. Two skills of the same name in different roots are
+            // otherwise indistinguishable, which is the same gap the `/` menu had.
+            root: String(s.source ?? '-'),
+            scope: String(s.scope ?? '-'),
+            // `user` belongs in the `/` menu; `model` is the agent's to reach for.
+            triggers: (s.triggers ?? ['user', 'model']).join('+'),
+            description: String(s.description ?? ''),
+        }));
+        this.log(`${skills.length} skill${skills.length === 1 ? '' : 's'} on ${daemonId}` +
+            (response.deviceName ? ` (${response.deviceName})` : '') +
+            (response.online ? '' : ' — NOT CONNECTED, this inventory may be stale'));
+        (0, format_1.renderTable)(rows, [
+            { key: 'name', header: 'NAME' },
+            { key: 'root', header: 'ROOT' },
+            { key: 'scope', header: 'SCOPE' },
+            { key: 'triggers', header: 'TRIGGERS' },
+            { key: 'description', header: 'DESCRIPTION', maxWidth: 52 },
+        ], (line) => this.log(line));
+    }
+}
+exports.default = SkillsLocal;

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

@@ -2,9 +2,19 @@ import { BaseCommand } from '../../base-command';
 export default class SkillsSearch 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/skills/search.js

@@ -4,26 +4,47 @@ 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 SkillsSearch extends base_command_1.BaseCommand {
-    static description = 'Search skills in the store by keyword';
+    static description = 'Search skills in the skrr store by keyword (same as `search skills`)';
     static examples = [
-        '<%= config.bin %> skills search --query "summarize"',
-        '<%= config.bin %> skills search --query "image" --category creative',
-        '<%= config.bin %> skills search --query "data" --limit 10 --json',
+        '<%= config.bin %> skills search summarize',
+        '<%= config.bin %> skills search image --category creative',
+        '<%= config.bin %> skills search data --limit 10 --json',
+        '<%= config.bin %> skills search --query summarize',
     ];
+    /**
+     * `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' }),
-        query: core_1.Flags.string({ description: 'Search query', required: true }),
+        // No longer `required` — the positional satisfies it, and keeping the flag
+        // means every existing script and doc line stays valid. Same rule
+        // `messages list` adopted after `command messages:list:<id> not found`
+        // read like the command did not exist.
+        query: core_1.Flags.string({ char: 'q', description: 'Search query' }),
         category: core_1.Flags.string({ description: 'Filter by category' }),
         limit: core_1.Flags.integer({ description: 'Maximum number of results', default: 20 }),
     };
     async run() {
         this.requireAuth();
-        const { flags } = await this.parse(SkillsSearch);
+        const { args, flags } = await this.parse(SkillsSearch);
+        const query = (0, search_query_1.resolveSearchQuery)(this, args.query, flags.query, 'skills search');
         let response;
         try {
             response = await data_provider_1.dataService.getStoreSkills({
-                q: flags.query,
+                q: query,
                 category: flags.category,
                 limit: flags.limit,
             });
@@ -38,7 +59,7 @@ class SkillsSearch 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 matching '${flags.query}'.`);
+            this.log(`No skills found matching '${query}'.`);
             return;
         }
         const rows = items.map((s) => ({