@skrr-ai/cli 0.1.37 → 0.1.39

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

package/dist/commands/spaces/actions/add.js

@@ -1,10 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const node_crypto_1 = require("node:crypto");
 const core_1 = require("@oclif/core");
 const data_provider_1 = require("@skrr-ai/data-provider");
 const base_command_1 = require("../../../base-command");
 const prompt_1 = require("../../../lib/prompt");
 const space_output_1 = require("../../../lib/space-output");
+const space_custom_actions_1 = require("../../../lib/space-custom-actions");
 class SpacesActionsAdd extends base_command_1.BaseCommand {
     static description = 'Add a custom action to a space';
     static args = {
@@ -13,11 +15,11 @@ class SpacesActionsAdd extends base_command_1.BaseCommand {
     static flags = {
         json: core_1.Flags.boolean({ description: 'Output as JSON' }),
         'from-json': core_1.Flags.string({ description: 'JSON action body' }),
-        id: core_1.Flags.string({ description: 'Action ID' }),
-        label: core_1.Flags.string({ description: 'Button label' }),
+        id: core_1.Flags.string({ description: 'Action ID (generated when omitted)' }),
+        label: space_custom_actions_1.spaceCustomActionLabelFlag,
         prompt: core_1.Flags.string({ description: 'Prompt sent when the action runs' }),
         color: core_1.Flags.string({ description: 'Color hex' }),
-        icon: core_1.Flags.string({ description: 'Lucide icon name' }),
+        icon: space_custom_actions_1.spaceCustomActionIconFlag,
         skill: core_1.Flags.string({ description: 'Optional skill ID' }),
     };
     async run() {
@@ -31,7 +33,10 @@ class SpacesActionsAdd extends base_command_1.BaseCommand {
             this.error(err.message, { exit: 1 });
         }
         const payload = (0, prompt_1.mergeDefined)(body, {
-            id: flags.id,
+            // Generated when omitted, as `agents actions create` does. Demanding the
+            // caller invent an id — with only "Action id is required." to go on — was
+            // the one required field nothing else could supply.
+            id: flags.id ?? (typeof body.id === 'string' && body.id ? body.id : `act_${(0, node_crypto_1.randomUUID)()}`),
             label: flags.label,
             prompt: flags.prompt,
             color: flags.color,
@@ -41,6 +46,9 @@ class SpacesActionsAdd extends base_command_1.BaseCommand {
         for (const field of ['id', 'label', 'prompt', 'color'])
             if (!payload[field] || typeof payload[field] !== 'string')
                 this.error(`Action ${field} is required.`, { exit: 1 });
+        const iconProblem = (0, space_custom_actions_1.spaceCustomActionIconProblem)(payload.icon);
+        if (iconProblem)
+            this.error(iconProblem, { exit: 1 });
         let result;
         try {
             result = await data_provider_1.dataService.addSpaceCustomAction({
@@ -51,10 +59,20 @@ class SpacesActionsAdd extends base_command_1.BaseCommand {
         catch (err) {
             this.handleApiError(err);
         }
+        // `--json` returns the action that was added, not the whole Space. The
+        // server answers with the full Space document — 117 lines in which the
+        // five-field action is buried — while `agents actions create --json`
+        // returns just the action. A create returns the thing it created.
+        const stored = (result?.customActions ?? []).find((action) => action.id === payload.id) ?? payload;
         if (flags.json)
-            this.log(JSON.stringify((0, space_output_1.withSpaceResourceUrls)(this.cliConfig.baseURL, args.id, 'actions', result, ['id']), null, 2));
+            this.log(JSON.stringify((0, space_output_1.withSpaceResourceUrls)(this.cliConfig.baseURL, args.id, 'actions', stored, ['id']), null, 2));
         else
             this.log(`Added custom action ${String(payload.id)}.`);
+        // On stderr, so `--json` stays parseable: the action was saved, and still
+        // cannot run until the space has a Leader (OSK-9641).
+        const unrunnable = (0, space_custom_actions_1.spaceActionsNotRunnableReason)({ id: args.id, leadAgentId: result?.leadAgentId }, this.config.bin);
+        if (unrunnable)
+            this.warn(unrunnable);
     }
 }
 exports.default = SpacesActionsAdd;

package/dist/commands/spaces/actions/available.js

@@ -51,7 +51,10 @@ class SpacesActionsAvailable extends base_command_1.BaseCommand {
             { key: 'ref', header: 'REF (agentId:actionId)' },
         ], (line) => this.log(line));
         this.log('');
+        // The REF is for two commands, and they need different rights: attaching
+        // works for any space member, running needs VIEW on the agent (OSK-9663).
         this.log('Attach to a task: skrr tasks actions attach <task-id> <agentId>:<actionId>');
+        this.log(`Run one in this space: skrr spaces actions run ${args.id} <agentId>:<actionId> (needs access to the agent; see what you can run with: skrr spaces actions list ${args.id} --all)`);
     }
 }
 exports.default = SpacesActionsAvailable;

package/dist/commands/spaces/actions/list.d.ts

@@ -4,8 +4,13 @@ export default class SpacesActionsList extends BaseCommand {
     static args: {
         id: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
     };
+    static examples: string[];
     static flags: {
         json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        all: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;
+    /** Say, on stderr, when none of the listed space actions can run. */
+    private noteUnrunnable;
+    private listAll;
 }

package/dist/commands/spaces/actions/list.js

@@ -4,13 +4,23 @@ 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 space_custom_actions_1 = require("../../../lib/space-custom-actions");
 const space_output_1 = require("../../../lib/space-output");
 class SpacesActionsList extends base_command_1.BaseCommand {
     static description = 'List custom actions configured for a space';
     static args = {
         id: core_1.Args.string({ description: 'Space ID', required: true, ignoreStdin: true }),
     };
-    static flags = { json: core_1.Flags.boolean({ description: 'Output as JSON' }) };
+    static examples = [
+        '<%= config.bin %> spaces actions list <space-id>',
+        '<%= config.bin %> spaces actions list <space-id> --all',
+    ];
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+        all: core_1.Flags.boolean({
+            description: "Everything the space's action panel offers: its own actions and those of member agents you can view, each with the command that runs it",
+        }),
+    };
     async run() {
         this.requireAuth();
         const { args, flags } = await this.parse(SpacesActionsList);
@@ -22,12 +32,17 @@ class SpacesActionsList extends base_command_1.BaseCommand {
             this.handleApiError(err);
         }
         const actions = space.customActions ?? [];
+        if (flags.all)
+            return this.listAll(space, flags.json);
         if (flags.json)
             return void this.log(JSON.stringify((0, space_output_1.withSpaceResourceUrls)(this.cliConfig.baseURL, args.id, 'actions', { data: actions }, [
                 'id',
             ]), null, 2));
-        if (!actions.length)
-            return void this.log('No custom actions.');
+        if (!actions.length) {
+            this.log('No custom actions.');
+            this.log(`Agent actions offered here: ${this.config.bin} spaces actions list ${args.id} --all`);
+            return;
+        }
         (0, format_1.renderTable)(actions.map((a) => ({
             id: a.id,
             label: a.label,
@@ -41,6 +56,37 @@ class SpacesActionsList extends base_command_1.BaseCommand {
             { key: 'skill', header: 'SKILL' },
             { key: 'id', header: 'ID' },
         ], (line) => this.log(line));
+        this.noteUnrunnable(space);
+        this.log(`Agent actions offered here too: ${this.config.bin} spaces actions list ${args.id} --all`);
+    }
+    /** Say, on stderr, when none of the listed space actions can run. */
+    noteUnrunnable(space) {
+        const reason = (0, space_custom_actions_1.spaceActionsNotRunnableReason)(space, this.config.bin);
+        if (reason)
+            this.warn(reason);
+    }
+    async listAll(space, json) {
+        let members;
+        try {
+            members = await data_provider_1.dataService.listSpaceMemberActions(space.id);
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+        const rows = (0, space_custom_actions_1.spaceQuickActionRows)(space, members.agents, this.config.bin);
+        if (json)
+            return void this.log(JSON.stringify({ spaceId: space.id, data: rows }, null, 2));
+        if (!rows.length)
+            return void this.log('This space offers no quick actions.');
+        (0, format_1.renderTable)(rows, [
+            { key: 'source', header: 'SOURCE' },
+            { key: 'title', header: 'TITLE', maxWidth: 36 },
+            { key: 'owner', header: 'RUNS AS', maxWidth: 24 },
+            { key: 'type', header: 'TYPE' },
+            { key: 'run', header: 'RUN' },
+        ], (line) => this.log(line));
+        if (rows.some((row) => row.source === 'space'))
+            this.noteUnrunnable(space);
     }
 }
 exports.default = SpacesActionsList;

package/dist/commands/spaces/actions/run.d.ts

@@ -0,0 +1,28 @@
+import { BaseCommand } from '../../../base-command';
+/**
+ * Fire one of a space's quick actions, the way its Actions tab does.
+ *
+ * `spaces actions add` could create a space action and nothing on the CLI could
+ * run it (OSK-9641), and a space member handed `agentId:actionId` refs by
+ * `spaces actions available` had only `agents actions run`, which answers a
+ * member with 403 and opens a chat rather than working in the space (OSK-9663).
+ *
+ * The routing is the web runner's (`useSpaceQuickActionRunner`), not a new one:
+ * a prompt action runs as a task in this space, assigned to the Space Leader for
+ * a space's own action and to its agent for an agent's; a built-in action runs
+ * through the agent-action route. The task text comes from the same
+ * `spaceQuickActionTaskSpec` the web uses, so both surfaces hand the agent the
+ * same work.
+ */
+export default class SpacesActionsRun extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        space: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+        action: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/spaces/actions/run.js

@@ -0,0 +1,146 @@
+"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 space_custom_actions_1 = require("../../../lib/space-custom-actions");
+const web_url_1 = require("../../../lib/web-url");
+/**
+ * Fire one of a space's quick actions, the way its Actions tab does.
+ *
+ * `spaces actions add` could create a space action and nothing on the CLI could
+ * run it (OSK-9641), and a space member handed `agentId:actionId` refs by
+ * `spaces actions available` had only `agents actions run`, which answers a
+ * member with 403 and opens a chat rather than working in the space (OSK-9663).
+ *
+ * The routing is the web runner's (`useSpaceQuickActionRunner`), not a new one:
+ * a prompt action runs as a task in this space, assigned to the Space Leader for
+ * a space's own action and to its agent for an agent's; a built-in action runs
+ * through the agent-action route. The task text comes from the same
+ * `spaceQuickActionTaskSpec` the web uses, so both surfaces hand the agent the
+ * same work.
+ */
+class SpacesActionsRun extends base_command_1.BaseCommand {
+    static description = "Run a space quick action: the space's own (by id) or a member agent's (agentId:actionId)";
+    static examples = [
+        '<%= config.bin %> spaces actions run <space-id> <action-id>',
+        '<%= config.bin %> spaces actions run <space-id> <agent-id>:<action-id> --json',
+    ];
+    static args = {
+        space: core_1.Args.string({ description: 'Space ID', required: true, ignoreStdin: true }),
+        action: core_1.Args.string({
+            description: "A space action id from 'spaces actions list', or agentId:actionId, both as 'spaces actions list --all' prints them",
+            required: true,
+            ignoreStdin: true,
+        }),
+    };
+    static flags = { json: core_1.Flags.boolean({ description: 'Output as JSON' }) };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(SpacesActionsRun);
+        const bin = this.config.bin;
+        let space;
+        try {
+            space = await data_provider_1.dataService.getSpace(args.space);
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+        const colon = args.action.indexOf(':');
+        const agentRef = colon > 0 && !args.action.startsWith('space-custom:')
+            ? { agentId: args.action.slice(0, colon), actionId: args.action.slice(colon + 1) }
+            : null;
+        let action;
+        let assigneeAgentId;
+        if (!agentRef) {
+            const found = (0, space_custom_actions_1.findSpaceCustomAction)(space, args.action);
+            if ('problem' in found)
+                this.error(found.problem, { exit: 4 });
+            const leaderProblem = (0, space_custom_actions_1.spaceActionsNotRunnableReason)(space, bin);
+            if (leaderProblem || !space.leadAgentId)
+                this.error(leaderProblem ?? '', { exit: 1 });
+            action = (0, data_provider_1.spaceCustomActionToAgentAction)(found.customAction, space, found.index);
+            assigneeAgentId = space.leadAgentId;
+        }
+        else {
+            let members;
+            try {
+                members = await data_provider_1.dataService.listSpaceMemberActions(args.space);
+            }
+            catch (err) {
+                this.handleApiError(err);
+            }
+            const member = members.agents.find(({ agent }) => agent.id === agentRef.agentId);
+            if (!member) {
+                this.error(`Agent ${agentRef.agentId} is not a member of this space that you can view, so you cannot ` +
+                    `run its actions here. Attaching one to a task needs only the space: ` +
+                    `\`${bin} tasks actions attach <task-id> ${args.action}\`. To run it, its owner has to share the agent with you.`, { exit: 1 });
+            }
+            const found = (member.agent.agentActions ?? []).find((a) => a.id === agentRef.actionId);
+            if (!found) {
+                this.error(`No action ${agentRef.actionId} on agent ${agentRef.agentId}. List what this space offers: \`${bin} spaces actions list ${args.space} --all\`.`, { exit: 4 });
+            }
+            if (!(0, data_provider_1.isAgentActionAvailableInSpace)(found, { spaceId: space.id, labelIds: space.labelIds })) {
+                this.error(`Action ${found.title} is not offered in this space (its scope is another space or a Label this space does not carry).`, { exit: 1 });
+            }
+            action = found;
+            assigneeAgentId = agentRef.agentId;
+        }
+        if ((0, data_provider_1.isBuiltinAgentAction)(action)) {
+            // A built-in is a typed platform operation owned by its agent, and runs
+            // through the agent-action route exactly as the web runner sends it.
+            let result;
+            try {
+                result = await data_provider_1.dataService.runAgentAction({
+                    agent_id: assigneeAgentId,
+                    action_id: action.id,
+                });
+            }
+            catch (err) {
+                this.handleApiError(err);
+            }
+            if (flags.json)
+                return void this.log(JSON.stringify(result, null, 2));
+            if (!result.ok)
+                this.error(result.error || result.reason || 'Action failed.', { exit: 1 });
+            this.log(`${action.title} ran.`);
+            return;
+        }
+        const outcome = (0, data_provider_1.agentActionOutcome)(action);
+        const spec = (0, data_provider_1.spaceQuickActionTaskSpec)(action, { id: space.id, title: space.title });
+        let created;
+        try {
+            created = await data_provider_1.dataService.createAndStartTask({
+                ...spec,
+                spaceId: space.id,
+                assigneeAgentIds: [assigneeAgentId],
+            });
+        }
+        catch (err) {
+            this.handleApiError(err, { subject: `Action ${action.title}` });
+        }
+        const taskUrl = (0, web_url_1.taskUrlFrom)(this.cliConfig.baseURL, created.task);
+        if (flags.json) {
+            this.log(JSON.stringify({ ...created, outcome, assigneeAgentId, ...(taskUrl ? { taskUrl } : {}) }, null, 2));
+        }
+        else {
+            const identifier = created.task.identifier ?? created.task.id;
+            this.log(created.started
+                ? `Started ${action.title} as task ${identifier}.`
+                : `Created task ${identifier} for ${action.title}, but it did not start: ${created.startError ?? 'no reason given'}.`);
+            if (taskUrl)
+                this.log(`Task: ${taskUrl}`);
+            if (created.conversationId)
+                this.log(`Conversation: ${created.conversationId}`);
+            if (created.started && outcome === 'ephemeral') {
+                // The web hides an ephemeral action's task when the run finishes, from
+                // the tab that fired it. The CLI does not wait for the run, so say what
+                // will be different rather than let the task's staying look like a bug.
+                this.log(`This action is ephemeral. The web app hides its task when the run finishes; from the CLI it stays until you hide it: \`${bin} tasks move ${created.task.id} --status hidden\`.`);
+            }
+        }
+        if (!created.started)
+            this.exit(1);
+    }
+}
+exports.default = SpacesActionsRun;