@skrr-ai/cli 0.1.60 → 0.1.62

package/dist/commands/store/artifacts/release.js

@@ -0,0 +1,31 @@
+"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");
+class StoreArtifactsRelease extends base_command_1.BaseCommand {
+    static description = 'Publish an immutable dependency release for your own skill or action';
+    static args = {
+        entityType: core_1.Args.string({ required: true, ignoreStdin: true }),
+        entityId: core_1.Args.string({ required: true, ignoreStdin: true }),
+    };
+    static flags = {
+        versionLabel: core_1.Flags.string({ required: true }),
+        artifactRef: core_1.Flags.string({ required: true }),
+        price: core_1.Flags.integer({ description: 'Price in micro-USD; omit for zero-price' }),
+        workspaceId: core_1.Flags.string({ description: 'Publish as this workspace' }),
+        json: core_1.Flags.boolean({ description: 'Output JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(StoreArtifactsRelease);
+        const result = await data_provider_1.dataService.publishStoreArtifactRelease(args.entityType, args.entityId, {
+            versionLabel: flags.versionLabel,
+            artifactRef: flags.artifactRef,
+            ...(flags.price !== undefined ? { price: flags.price } : {}),
+            ...(flags.workspaceId ? { publishAs: { workspaceId: flags.workspaceId } } : {}),
+        });
+        this.log(JSON.stringify(result, null, 2));
+    }
+}
+exports.default = StoreArtifactsRelease;

package/dist/commands/store/artifacts/used-by.d.ts

@@ -0,0 +1,12 @@
+import { BaseCommand } from '../../../base-command';
+export default class StoreArtifactsUsedBy extends BaseCommand {
+    static description: string;
+    static args: {
+        entityType: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+        entityId: 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/store/artifacts/used-by.js

@@ -0,0 +1,20 @@
+"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");
+class StoreArtifactsUsedBy extends base_command_1.BaseCommand {
+    static description = 'Reverse dependency index — public releases declaring this artifact';
+    static args = {
+        entityType: core_1.Args.string({ required: true, ignoreStdin: true }),
+        entityId: core_1.Args.string({ required: true, ignoreStdin: true }),
+    };
+    static flags = { json: core_1.Flags.boolean({ description: 'Output JSON' }) };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(StoreArtifactsUsedBy);
+        const result = await data_provider_1.dataService.getStoreArtifactUsedBy(args.entityType, args.entityId);
+        this.log(JSON.stringify(result, null, 2));
+    }
+}
+exports.default = StoreArtifactsUsedBy;

package/dist/commands/store/browse.d.ts

@@ -9,6 +9,11 @@ export default class StoreBrowse extends BaseCommand {
         limit: import("@oclif/core/lib/interfaces").OptionFlag<number, import("@oclif/core/lib/interfaces").CustomOptions>;
         cursor: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         sort: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        pricing: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        capability: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        permission: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        placement: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'max-run-cost': import("@oclif/core/lib/interfaces").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
     };
     run(): Promise<void>;
 }

package/dist/commands/store/browse.js

@@ -10,6 +10,7 @@ class StoreBrowse extends base_command_1.BaseCommand {
         '<%= config.bin %> store browse',
         '<%= config.bin %> store browse --q "cost watchdog"',
         '<%= config.bin %> store browse --category engineering --limit 10 --json',
+        '<%= config.bin %> store browse --sort top --pricing free',
     ];
     static flags = {
         json: core_1.Flags.boolean({ description: 'Output as JSON' }),
@@ -17,7 +18,28 @@ class StoreBrowse extends base_command_1.BaseCommand {
         category: core_1.Flags.string({ description: 'Filter by category' }),
         limit: core_1.Flags.integer({ description: 'Max results', default: 20 }),
         cursor: core_1.Flags.string({ description: 'Pagination cursor from a previous page' }),
-        sort: core_1.Flags.string({ description: 'Sort order', options: ['popular', 'newest', 'rating'] }),
+        sort: core_1.Flags.string({
+            description: 'Sort order. newest = latest release first; top = server ranking that weighs ratings as much as installs and excludes the author’s own',
+            options: [...data_provider_1.STORE_AGENT_SORT_OPTIONS],
+        }),
+        pricing: core_1.Flags.string({
+            description: 'Only free or only paid listings (by the latest release’s price)',
+            options: [...data_provider_1.STORE_AGENT_PRICING_FILTERS],
+        }),
+        // DIS02 facets — what the release connects to, where it runs, what it costs to run.
+        capability: core_1.Flags.string({
+            description: 'Only listings whose latest release declares this capability or tool',
+        }),
+        permission: core_1.Flags.string({
+            description: 'Only listings whose permission manifest covers this key (e.g. network:api.github.com)',
+        }),
+        placement: core_1.Flags.string({
+            description: 'Only listings runnable in this placement',
+            options: ['cloud', 'local'],
+        }),
+        'max-run-cost': core_1.Flags.integer({
+            description: 'Only listings whose measured per-run cost ceiling is ≤ this many micros (1,000,000 = $1)',
+        }),
     };
     async run() {
         this.requireAuth();
@@ -30,6 +52,11 @@ class StoreBrowse extends base_command_1.BaseCommand {
                 ...(flags.category ? { category: flags.category } : {}),
                 ...(flags.cursor ? { cursor: flags.cursor } : {}),
                 ...(flags.sort ? { sortBy: flags.sort } : {}),
+                ...(flags.pricing ? { pricing: flags.pricing } : {}),
+                ...(flags.capability ? { capability: flags.capability } : {}),
+                ...(flags.permission ? { permission: flags.permission } : {}),
+                ...(flags.placement ? { placement: flags.placement } : {}),
+                ...(flags['max-run-cost'] != null ? { maxRunCostMicros: flags['max-run-cost'] } : {}),
             });
         }
         catch (err) {

package/dist/commands/store/channel.d.ts

@@ -0,0 +1,21 @@
+import { BaseCommand } from '../../base-command';
+/**
+ * The buyer's update channel for one installed copy (OSK-12288).
+ *
+ * `manual` waits for `skrr store update`; `auto_minor` rolls forward inside the
+ * installed major; `beta` does the same and takes `beta`-visibility releases —
+ * the channel is the access control on them, so setting it is the opt-in.
+ * No channel crosses a major: a new major is a purchase, never an update.
+ */
+export default class StoreChannel extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        agentId: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+        channel: 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/store/channel.js

@@ -0,0 +1,62 @@
+"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");
+/**
+ * The buyer's update channel for one installed copy (OSK-12288).
+ *
+ * `manual` waits for `skrr store update`; `auto_minor` rolls forward inside the
+ * installed major; `beta` does the same and takes `beta`-visibility releases —
+ * the channel is the access control on them, so setting it is the opt-in.
+ * No channel crosses a major: a new major is a purchase, never an update.
+ */
+class StoreChannel extends base_command_1.BaseCommand {
+    static description = 'Set the update channel of an installed store copy';
+    static examples = [
+        '<%= config.bin %> store channel agent_abc123 auto_minor',
+        '<%= config.bin %> store channel agent_abc123 beta',
+        '<%= config.bin %> store channel agent_abc123 manual',
+    ];
+    static args = {
+        agentId: core_1.Args.string({
+            description: 'The store agent or your installed copy',
+            required: true,
+            ignoreStdin: true,
+        }),
+        channel: core_1.Args.string({
+            description: `One of ${data_provider_1.STORE_UPDATE_CHANNELS.join(', ')}`,
+            required: true,
+            ignoreStdin: true,
+            options: [...data_provider_1.STORE_UPDATE_CHANNELS],
+        }),
+    };
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(StoreChannel);
+        const channel = (0, data_provider_1.normalizeStoreUpdateChannel)(args.channel);
+        if (!channel) {
+            this.error(`Unknown channel "${args.channel}" — one of ${data_provider_1.STORE_UPDATE_CHANNELS.join(', ')}`, {
+                exit: 2,
+            });
+        }
+        try {
+            const result = await data_provider_1.dataService.setStoreAgentUpdatePolicy({
+                agentId: args.agentId,
+                channel,
+            });
+            if (flags.json) {
+                this.log(JSON.stringify(result, null, 2));
+                return;
+            }
+            this.log(`${args.agentId} now follows the ${result.updatePolicy} channel.`);
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+    }
+}
+exports.default = StoreChannel;

package/dist/commands/store/follow.d.ts

@@ -0,0 +1,14 @@
+import { BaseCommand } from '../../base-command';
+/** Follow a public publisher by canonical handle, never its raw account id. */
+export default class StoreFollow extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        handle: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        undo: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/store/follow.js

@@ -0,0 +1,45 @@
+"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");
+/** Follow a public publisher by canonical handle, never its raw account id. */
+class StoreFollow extends base_command_1.BaseCommand {
+    static description = 'Follow a public publisher by canonical handle — or unfollow with --undo. Following is an intent signal, not a notification subscription.';
+    static examples = [
+        '<%= config.bin %> store follow @acme',
+        '<%= config.bin %> store follow acme --undo',
+    ];
+    static args = {
+        handle: core_1.Args.string({
+            description: 'The public publisher handle (with or without @)',
+            required: true,
+            ignoreStdin: true,
+        }),
+    };
+    static flags = {
+        undo: core_1.Flags.boolean({ description: 'Unfollow the publisher' }),
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(StoreFollow);
+        try {
+            const result = flags.undo
+                ? await data_provider_1.dataService.unfollowStorePublisherByHandle(args.handle)
+                : await data_provider_1.dataService.followStorePublisherByHandle(args.handle);
+            if (flags.json) {
+                this.log(JSON.stringify(result, null, 2));
+                return;
+            }
+            const handle = args.handle.startsWith('@') ? args.handle : `@${args.handle}`;
+            this.log(flags.undo
+                ? `Unfollowed ${handle}.`
+                : `Following ${handle}. This is an intent signal, not a notification subscription.`);
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+    }
+}
+exports.default = StoreFollow;

package/dist/commands/store/governance/policy.d.ts

@@ -1,12 +1,24 @@
 import { BaseCommand } from '../../../base-command';
 /**
- * `skrr store governance policy` — which releases a workspace may run at all.
+ * `skrr store governance policy` — which Store releases a workspace may
+ * install and run.
  *
- * `deny_all` and `allowlist` are the two modes the server accepts, and the
- * command refuses an allowlist with nothing in it: an empty allowlist and
+ * Three modes, the ones the server's single evaluator honours (OSK-12252):
+ * `open` admits every listing and is also what a workspace with no policy
+ * means, `deny_all` admits none, `allowlist` admits the named releases. It is
+ * enforced on every real install path and again when an installed Store copy
+ * runs.
+ *
+ * The command refuses an allowlist with nothing in it: an empty allowlist and
  * `deny_all` have the same effect but say different things, and a workspace
  * that reads "allowlist" while permitting nothing is a policy nobody can
- * explain six months later. If you mean deny everything, say `deny_all`.
+ * explain six months later. If you mean deny everything, say `deny_all`. For
+ * the same reason `--release` is refused beside `open` or `deny_all`, where a
+ * stored list would govern nothing.
+ *
+ * What it governs is PROVENANCE, not behaviour: which Store sources a
+ * workspace accepts. Copying a listing's prompt into a self-built Agent is not
+ * a Store install, and no policy here reaches it.
  */
 export default class StoreGovernancePolicy extends BaseCommand {
     static description: string;
@@ -15,7 +27,8 @@ export default class StoreGovernancePolicy extends BaseCommand {
         workspace: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
     };
     static flags: {
-        mode: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        mode: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        ceiling: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         release: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         'policy-id': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         'expect-revision': import("@oclif/core/lib/interfaces").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;

package/dist/commands/store/governance/policy.js

@@ -4,31 +4,47 @@ const core_1 = require("@oclif/core");
 const base_command_1 = require("../../../base-command");
 const governed_store_1 = require("../../../lib/governed-store");
 /**
- * `skrr store governance policy` — which releases a workspace may run at all.
+ * `skrr store governance policy` — which Store releases a workspace may
+ * install and run.
  *
- * `deny_all` and `allowlist` are the two modes the server accepts, and the
- * command refuses an allowlist with nothing in it: an empty allowlist and
+ * Three modes, the ones the server's single evaluator honours (OSK-12252):
+ * `open` admits every listing and is also what a workspace with no policy
+ * means, `deny_all` admits none, `allowlist` admits the named releases. It is
+ * enforced on every real install path and again when an installed Store copy
+ * runs.
+ *
+ * The command refuses an allowlist with nothing in it: an empty allowlist and
  * `deny_all` have the same effect but say different things, and a workspace
  * that reads "allowlist" while permitting nothing is a policy nobody can
- * explain six months later. If you mean deny everything, say `deny_all`.
+ * explain six months later. If you mean deny everything, say `deny_all`. For
+ * the same reason `--release` is refused beside `open` or `deny_all`, where a
+ * stored list would govern nothing.
+ *
+ * What it governs is PROVENANCE, not behaviour: which Store sources a
+ * workspace accepts. Copying a listing's prompt into a self-built Agent is not
+ * a Store install, and no policy here reaches it.
  */
 class StoreGovernancePolicy extends base_command_1.BaseCommand {
-    static description = 'Set which governed releases a workspace may run. `deny_all`, or an allowlist of release ids.';
+    static description = "Set which Store releases a workspace may install and run: `open`, `deny_all`, or an allowlist of release ids. It governs where an Agent comes from, not what it does — copying a listing's prompt into a self-built Agent is not a Store install and is not covered.";
     static examples = [
+        '<%= config.bin %> store governance policy <workspace-id> --mode open',
         '<%= config.bin %> store governance policy <workspace-id> --mode deny_all',
         '<%= config.bin %> store governance policy <workspace-id> --mode allowlist --release <id> --release <id>',
+        `<%= config.bin %> store governance policy <workspace-id> --ceiling '{"delegation":"specific","proactive":false}'`,
     ];
     static args = {
         workspace: core_1.Args.string({ description: 'Workspace id', required: true, ignoreStdin: true }),
     };
     static flags = {
         mode: core_1.Flags.string({
-            description: 'deny_all, or allowlist the releases named by --release',
-            options: ['deny_all', 'allowlist'],
-            required: true,
+            description: 'open (every listing), deny_all (none), or allowlist (only the releases named by --release)',
+            options: ['open', 'deny_all', 'allowlist'],
+        }),
+        ceiling: core_1.Flags.string({
+            description: 'Capability ceiling as JSON (OSK-12262): facet names from the release capability manifest — builtinTools, platformCapabilities, delegation, proactive, firstContact, sharedData, permissions. "{}" clears it. Applied with --mode, or alone to keep the current mode.',
         }),
         release: core_1.Flags.string({
-            description: 'Release id to allow (repeatable). Required with --mode allowlist.',
+            description: 'Release id to allow (repeatable; --mode allowlist only). An Agent is named by its published Agent release id; a Team, Service, Skill, Action or template by its Store release id.',
             multiple: true,
         }),
         'policy-id': core_1.Flags.string({ description: 'Policy id, when replacing a specific one' }),
@@ -40,15 +56,67 @@ class StoreGovernancePolicy extends base_command_1.BaseCommand {
     async run() {
         this.requireAuth();
         const { args, flags } = await this.parse(StoreGovernancePolicy);
+        // Read: no --mode and no --ceiling asks for the policy a workspace already
+        // has — the same endpoint the web settings page writes.
+        if (!flags.mode && flags.ceiling === undefined) {
+            const read = await (0, governed_store_1.getWorkspaceStorePolicy)(args.workspace);
+            if (flags.json) {
+                this.log(JSON.stringify(read, null, 2));
+                return;
+            }
+            const policy = read.policy;
+            this.log(`mode: ${policy.mode ?? 'open'}`);
+            if (policy.allowedReleaseIds?.length) {
+                for (const releaseId of policy.allowedReleaseIds)
+                    this.log(`  allow: ${releaseId}`);
+            }
+            if (policy.capabilityCeiling && Object.keys(policy.capabilityCeiling).length) {
+                this.log(`ceiling: ${JSON.stringify(policy.capabilityCeiling)}`);
+            }
+            this.log(`revision: ${policy.revision ?? 0}`);
+            return;
+        }
         const releases = flags.release ?? [];
-        if (flags.mode === 'allowlist' && releases.length === 0) {
+        const mode = flags.mode;
+        if (mode === 'allowlist' && releases.length === 0) {
             this.error('An allowlist with no --release permits nothing, which is what --mode deny_all says plainly. Pass at least one release, or say deny_all.', { exit: 2 });
         }
+        if (mode !== 'allowlist' && releases.length > 0) {
+            this.error(`--mode ${mode} ignores every release, so a --release list would be stored and govern nothing. Drop --release, or use --mode allowlist.`, { exit: 2 });
+        }
+        let capabilityCeiling;
+        if (flags.ceiling !== undefined) {
+            try {
+                const parsed = JSON.parse(flags.ceiling);
+                capabilityCeiling =
+                    parsed && typeof parsed === 'object' && Object.keys(parsed).length > 0
+                        ? parsed
+                        : null;
+            }
+            catch {
+                this.error(`--ceiling must be valid JSON, e.g. '{"delegation":"none"}'`, { exit: 2 });
+            }
+        }
         let result;
         try {
+            // A write under an existing policy keeps the mode and releases it has
+            // unless new ones were named; the server's revision check then stands.
+            let body;
+            if (mode) {
+                body = { mode, allowedReleaseIds: releases };
+            }
+            else {
+                const current = (await (0, governed_store_1.getWorkspaceStorePolicy)(args.workspace)).policy;
+                body = {
+                    mode: current.mode ?? 'open',
+                    allowedReleaseIds: releases.length ? releases : (current.allowedReleaseIds ?? []),
+                    expectedRevision: current.revision,
+                };
+            }
+            if (capabilityCeiling !== undefined)
+                body.capabilityCeiling = capabilityCeiling;
             result = await (0, governed_store_1.setWorkspaceStorePolicy)(args.workspace, {
-                mode: flags.mode,
-                allowedReleaseIds: releases,
+                ...body,
                 ...(flags['policy-id'] ? { policyId: flags['policy-id'] } : {}),
                 ...(flags['expect-revision'] !== undefined
                     ? { expectedRevision: flags['expect-revision'] }

package/dist/commands/store/governance/requests.d.ts

@@ -0,0 +1,28 @@
+import { BaseCommand } from '../../../base-command';
+/**
+ * `skrr store governance requests` — the queue a member's install request
+ * lands in and the owner answers (OSK-12262).
+ *
+ * A member asks for a release the workspace policy refuses. An owner
+ * approving only admits the release to the allowlist — the install still runs
+ * through the same evaluator, so the queue grants review, not a bypass.
+ *
+ * Members see their own requests; owners see the whole queue (`--status`
+ * narrows it; the default is `pending`, the part that needs an answer).
+ */
+export default class StoreGovernanceRequests extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        workspace: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        status: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        release: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        note: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        approve: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        decline: 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/store/governance/requests.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../../../base-command");
+const governed_store_1 = require("../../../lib/governed-store");
+/**
+ * `skrr store governance requests` — the queue a member's install request
+ * lands in and the owner answers (OSK-12262).
+ *
+ * A member asks for a release the workspace policy refuses. An owner
+ * approving only admits the release to the allowlist — the install still runs
+ * through the same evaluator, so the queue grants review, not a bypass.
+ *
+ * Members see their own requests; owners see the whole queue (`--status`
+ * narrows it; the default is `pending`, the part that needs an answer).
+ */
+class StoreGovernanceRequests extends base_command_1.BaseCommand {
+    static description = 'List workspace Store install requests — or submit / answer one with --release, --approve or --decline';
+    static examples = [
+        '<%= config.bin %> store governance requests <workspace-id>',
+        '<%= config.bin %> store governance requests <workspace-id> --release <release-id> --note "for the support queue"',
+        '<%= config.bin %> store governance requests <workspace-id> --approve <request-id>',
+        '<%= config.bin %> store governance requests <workspace-id> --decline <request-id>',
+    ];
+    static args = {
+        workspace: core_1.Args.string({ description: 'Workspace id', required: true, ignoreStdin: true }),
+    };
+    static flags = {
+        status: core_1.Flags.string({
+            description: 'Filter the queue by status (owner: all requests; member: yours)',
+            options: ['pending', 'approved', 'declined'],
+        }),
+        release: core_1.Flags.string({
+            description: 'Submit a request for this release id (member action)',
+        }),
+        note: core_1.Flags.string({ description: 'Why you need the release (with --release)' }),
+        approve: core_1.Flags.string({ description: 'Approve this pending request id (owner)' }),
+        decline: core_1.Flags.string({ description: 'Decline this pending request id (owner)' }),
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(StoreGovernanceRequests);
+        if (flags.release && (flags.approve || flags.decline)) {
+            this.error('Use either --release to submit, or --approve/--decline to answer — not both', {
+                exit: 2,
+            });
+        }
+        if (flags.approve && flags.decline) {
+            this.error('--approve and --decline answer the same request differently; pick one', {
+                exit: 2,
+            });
+        }
+        if (flags.release) {
+            try {
+                const result = await (0, governed_store_1.submitStoreInstallRequest)(args.workspace, {
+                    releaseId: flags.release,
+                    ...(flags.note ? { note: flags.note } : {}),
+                });
+                if (flags.json) {
+                    this.log(JSON.stringify(result, null, 2));
+                    return;
+                }
+                const request = result.request;
+                this.log(`Requested ${request.releaseId ?? flags.release} — a workspace owner can approve it.`);
+                this.log(`  request: ${request.requestId}`);
+                return;
+            }
+            catch (error) {
+                this.handleApiError(error);
+                return;
+            }
+        }
+        if (flags.approve || flags.decline) {
+            const requestId = flags.approve || flags.decline;
+            const decision = flags.approve ? 'approve' : 'decline';
+            try {
+                const result = await (0, governed_store_1.decideStoreInstallRequest)(args.workspace, requestId, decision);
+                if (flags.json) {
+                    this.log(JSON.stringify(result, null, 2));
+                    return;
+                }
+                const request = result.request;
+                this.log(decision === 'approve'
+                    ? `Approved — ${request.releaseId ?? ''} is on the workspace allowlist now.`
+                    : `Declined ${request.releaseId ?? ''}.`);
+                return;
+            }
+            catch (error) {
+                this.handleApiError(error);
+                return;
+            }
+        }
+        try {
+            const { requests } = await (0, governed_store_1.listStoreInstallRequests)(args.workspace, flags.status ?? 'pending');
+            if (flags.json) {
+                this.log(JSON.stringify(requests, null, 2));
+                return;
+            }
+            const rows = requests;
+            if (rows.length === 0) {
+                this.log('No requests in that state.');
+                return;
+            }
+            for (const request of rows) {
+                this.log(`${request.requestId}  ${request.releaseId}  ${request.status}  by ${request.requesterId}`);
+                if (request.note)
+                    this.log(`    note: ${request.note}`);
+            }
+        }
+        catch (error) {
+            this.handleApiError(error);
+        }
+    }
+}
+exports.default = StoreGovernanceRequests;

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

@@ -11,6 +11,9 @@ export default class StoreInstall extends BaseCommand {
         space: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         'include-bootstrap': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         'include-memory': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        yes: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'run-on': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'share-outcomes': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;
 }