@skrr-ai/cli 0.1.37 → 0.1.39

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

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