@skrr-ai/cli 0.1.18 → 0.1.20

package/dist/base-command.d.ts

@@ -371,18 +371,21 @@ export declare function describeResourceNotFound(serverMessage: string | undefin
 export declare function describeAssigneeNotInSpace(serverMessage: string | undefined, bin?: string): string;
 export declare function describeForbidden(bodyMessage?: string | null, method?: string | null): string;
 /**
- * True when a credential is unmistakably machine/daemon authority rather
- * than a human CLI session. This is a diagnostic guard only, never an
- * authorization decision: the server remains authoritative for every token.
+ * Identify an authority that is unmistakably machine-only rather than a human
+ * CLI session. This is a diagnostic guard only, never an authorization
+ * decision: the server remains authoritative for every token.
  *
  * Opaque daemon access tokens have a stable public prefix. Legacy daemon JWTs
- * expose `scope: "daemon"`; decoding the unsigned payload lets the CLI give a
- * repair instruction instead of calling a predictable 403 a transient edge
- * failure. Malformed and unknown token shapes intentionally return false so a
- * generic authentication failure remains honest.
+ * expose `scope: "daemon"`; bootstrap-only JWTs use `"daemon-install"`. Both
+ * scopes are incompatible with human CLI commands, so identifying either lets
+ * the CLI give a repair instruction instead of describing a predictable 403 as
+ * a transient edge failure. Malformed and unknown token shapes intentionally
+ * return false so a generic authentication failure remains honest.
  */
+type IncompatibleCliCredentialScope = 'daemon' | 'daemon-install';
+/** Compatibility export for callers specifically distinguishing daemon scope. */
 export declare function isDaemonScopedCredential(token?: string | null): boolean;
-/** The one repair for a daemon token passed to a human CLI command. */
-export declare function describeDaemonScopedCredential(bin: string): string;
+/** The one repair for a machine-only token passed to a human CLI command. */
+export declare function describeDaemonScopedCredential(bin: string, scope?: IncompatibleCliCredentialScope, source?: ResolvedCredential['source']): string;
 export declare function isRetryableFailure(status: number | undefined, body: Record<string, unknown> | null): boolean;
 export { Flags };

package/dist/base-command.js

@@ -578,9 +578,10 @@ class BaseCommand extends core_1.Command {
                 retryable: false,
             });
         }
-        if (isDaemonScopedCredential(this.resolvedCredential.token)) {
+        const incompatibleScope = incompatibleCliCredentialScope(this.resolvedCredential.token);
+        if (incompatibleScope) {
             this.failWithCliError({
-                message: describeDaemonScopedCredential(this.config.bin),
+                message: describeDaemonScopedCredential(this.config.bin, incompatibleScope, this.resolvedCredential.source),
                 code: 'DAEMON_SCOPE_CREDENTIAL',
                 exit: 2,
                 retryable: false,
@@ -817,10 +818,10 @@ class BaseCommand extends core_1.Command {
             // request and a supplied `--token` can bypass their normal preflight.
             // A daemon credential reaching a human endpoint is deterministic, not
             // an edge outage; retrying only repeats the same 401/403.
-            if ((e.status === 401 || e.status === 403) &&
-                isDaemonScopedCredential(this.resolvedCredential?.token)) {
+            const incompatibleScope = incompatibleCliCredentialScope(this.resolvedCredential?.token);
+            if ((e.status === 401 || e.status === 403) && incompatibleScope) {
                 this.failWithCliError({
-                    message: say(describeDaemonScopedCredential(this.config.bin)),
+                    message: say(describeDaemonScopedCredential(this.config.bin, incompatibleScope, this.resolvedCredential?.source)),
                     code: 'DAEMON_SCOPE_CREDENTIAL',
                     status: e.status,
                     exit: 2,
@@ -1416,38 +1417,38 @@ function describeForbidden(bodyMessage, method) {
     }
     return `${lead}.`;
 }
-/**
- * True when a credential is unmistakably machine/daemon authority rather
- * than a human CLI session. This is a diagnostic guard only, never an
- * authorization decision: the server remains authoritative for every token.
- *
- * Opaque daemon access tokens have a stable public prefix. Legacy daemon JWTs
- * expose `scope: "daemon"`; decoding the unsigned payload lets the CLI give a
- * repair instruction instead of calling a predictable 403 a transient edge
- * failure. Malformed and unknown token shapes intentionally return false so a
- * generic authentication failure remains honest.
- */
-function isDaemonScopedCredential(token) {
+function incompatibleCliCredentialScope(token) {
     if (typeof token !== 'string' || token.length === 0)
-        return false;
+        return null;
     if (token.startsWith('osk_dmn_'))
-        return true;
+        return 'daemon';
     const payload = token.split('.')[1];
     if (!payload)
-        return false;
+        return null;
     try {
         const decoded = JSON.parse(Buffer.from(payload, 'base64url').toString('utf8'));
-        return (typeof decoded === 'object' &&
+        const scope = typeof decoded === 'object' &&
             decoded !== null &&
-            decoded.scope === 'daemon');
+            typeof decoded.scope === 'string'
+            ? decoded.scope
+            : null;
+        return scope === 'daemon' || scope === 'daemon-install' ? scope : null;
     }
     catch {
-        return false;
+        return null;
     }
 }
-/** The one repair for a daemon token passed to a human CLI command. */
-function describeDaemonScopedCredential(bin) {
-    return ('This command received a daemon-scoped credential, which cannot access user API commands. ' +
+/** Compatibility export for callers specifically distinguishing daemon scope. */
+function isDaemonScopedCredential(token) {
+    return incompatibleCliCredentialScope(token) === 'daemon';
+}
+/** The one repair for a machine-only token passed to a human CLI command. */
+function describeDaemonScopedCredential(bin, scope = 'daemon', source) {
+    const scopeLabel = scope === 'daemon-install' ? 'daemon-install-scoped' : 'daemon-scoped';
+    const subject = source === 'keychain' || source === 'file'
+        ? `The stored credential has ${scope === 'daemon-install' ? 'daemon-install' : 'daemon'} scope`
+        : `This command received a ${scopeLabel} credential`;
+    return (`${subject}, which cannot access user API commands. ` +
         `Run \`${bin} login\` to create a CLI credential. For the local runtime itself, use \`${bin} daemon login\`.`);
 }
 function isRetryableFailure(status, body) {

package/dist/commands/commitments/action-proposals/propose.d.ts

@@ -0,0 +1,32 @@
+import { BaseCommand } from '../../../base-command';
+/**
+ * Propose a prepared action against a commitment check.
+ *
+ * `decide` and `execute` shipped without this, so a headless operator could only
+ * ever REACT to proposals the server made. An agent that has investigated a
+ * commitment and knows what should be done had no way to say so — the domain
+ * was half-reachable in exactly the way the parity rule exists to catch.
+ *
+ * Nothing here executes. A proposal is FROZEN and waits for `decide`, which is
+ * the whole point of the two-step: the thing that decides what to do and the
+ * thing that authorizes it are deliberately different acts.
+ */
+export default class CommitmentsActionProposalsPropose extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        commitmentId: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        check: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        type: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        config: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        file: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        diagnosis: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        changes: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        verification: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        run: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/commitments/action-proposals/propose.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_fs_1 = require("node:fs");
+const core_1 = require("@oclif/core");
+const data_provider_1 = require("@skrr-ai/data-provider");
+const base_command_1 = require("../../../base-command");
+const commitments_1 = require("../../../lib/commitments");
+/**
+ * Propose a prepared action against a commitment check.
+ *
+ * `decide` and `execute` shipped without this, so a headless operator could only
+ * ever REACT to proposals the server made. An agent that has investigated a
+ * commitment and knows what should be done had no way to say so — the domain
+ * was half-reachable in exactly the way the parity rule exists to catch.
+ *
+ * Nothing here executes. A proposal is FROZEN and waits for `decide`, which is
+ * the whole point of the two-step: the thing that decides what to do and the
+ * thing that authorizes it are deliberately different acts.
+ */
+class CommitmentsActionProposalsPropose extends base_command_1.BaseCommand {
+    static description = 'Propose a prepared action for a commitment check (frozen until approved)';
+    static examples = [
+        '<%= config.bin %> commitments action-proposals propose cmt_123 --check chk_456 --type create_task --config \'{"title":"Roll back the deploy"}\'',
+        '<%= config.bin %> commitments action-proposals propose cmt_123 --check chk_456 --file proposal.json',
+    ];
+    static args = {
+        commitmentId: core_1.Args.string({ description: 'Commitment ID', required: true, ignoreStdin: true }),
+    };
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output the created proposal as JSON' }),
+        check: core_1.Flags.string({
+            description: 'The commitment check this responds to (see `commitments checks`)',
+            required: true,
+        }),
+        type: core_1.Flags.string({
+            description: 'Action type',
+            options: [...data_provider_1.COMMITMENT_PUBLIC_ACTION_BUNDLE_ACTION_TYPES],
+            exclusive: ['file'],
+        }),
+        config: core_1.Flags.string({ description: 'Action config as JSON', exclusive: ['file'] }),
+        file: core_1.Flags.string({
+            description: 'A JSON file holding the whole request body — for a multi-action bundle, or anything a flag cannot express',
+            exclusive: ['type', 'config'],
+        }),
+        diagnosis: core_1.Flags.string({ description: 'What you concluded is wrong' }),
+        changes: core_1.Flags.string({ description: 'What the action would change' }),
+        verification: core_1.Flags.string({ description: 'How to tell afterwards whether it worked' }),
+        run: core_1.Flags.string({ description: 'The autonomous run that produced this, if any' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(CommitmentsActionProposalsPropose);
+        let body;
+        if (flags.file) {
+            try {
+                body = JSON.parse((0, node_fs_1.readFileSync)(flags.file, 'utf8'));
+            }
+            catch (error) {
+                this.error(`Could not read ${flags.file} as JSON: ${error.message}`, {
+                    exit: 1,
+                });
+            }
+        }
+        else {
+            if (!flags.type) {
+                // Refused rather than defaulted: an action type the caller did not name
+                // is a decision nobody made, and this endpoint arms real work.
+                this.error('Supply --type (or --file for a multi-action bundle).', { exit: 1 });
+            }
+            let config;
+            if (flags.config) {
+                try {
+                    config = JSON.parse(flags.config);
+                }
+                catch (error) {
+                    this.error(`--config is not valid JSON: ${error.message}`, { exit: 1 });
+                }
+            }
+            body = { action: { type: flags.type, ...(config ? { config } : {}) } };
+        }
+        body.commitmentCheckId = flags.check;
+        if (flags.run) {
+            body.autonomousRunId = flags.run;
+        }
+        const bundle = {
+            ...(flags.diagnosis ? { diagnosis: flags.diagnosis } : {}),
+            ...(flags.changes ? { proposedChanges: flags.changes } : {}),
+            ...(flags.verification ? { verificationPlan: flags.verification } : {}),
+        };
+        if (Object.keys(bundle).length > 0) {
+            body.bundle = { ...(body.bundle ?? {}), ...bundle };
+        }
+        let result;
+        try {
+            result = await commitments_1.commitmentApi.proposeActionProposal(args.commitmentId, body);
+        }
+        catch (error) {
+            this.handleApiError(error);
+        }
+        if (flags.json) {
+            this.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        const proposal = result
+            ?.proposal;
+        this.log(`Proposed ${proposal?.id ?? ''} (${proposal?.status ?? 'proposed'}).`);
+        // Say the two-step out loud: proposing is not doing.
+        this.log(`Nothing runs until it is approved:  skrr commitments action-proposals decide ${args.commitmentId} ${proposal?.id ?? '<proposal>'} --decision approve`);
+    }
+}
+exports.default = CommitmentsActionProposalsPropose;

package/dist/commands/commitments/create.d.ts

@@ -76,6 +76,8 @@ export default class CommitmentsCreate extends BaseCommand {
         autonomy: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         isolation: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         'max-nudges': import("@oclif/core/lib/interfaces").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'max-concurrent-runs': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'concurrency-reason': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
     };
     run(): Promise<void>;
 }

package/dist/commands/commitments/create.js

@@ -288,6 +288,12 @@ class CommitmentsCreate extends base_command_1.BaseCommand {
             hidden: true,
         }),
         'max-nudges': core_1.Flags.integer({ description: 'Max user nudges per day (0..20)' }),
+        'max-concurrent-runs': core_1.Flags.string({
+            description: 'Owner concurrency policy: "unlimited" (default) or 1..100. Finite values require --concurrency-reason and cannot be activated by an autonomous Agent session.',
+        }),
+        'concurrency-reason': core_1.Flags.string({
+            description: 'Why the owner deliberately chose a finite Commitment concurrency cap',
+        }),
     };
     async run() {
         this.requireAuth();
@@ -366,7 +372,12 @@ class CommitmentsCreate extends base_command_1.BaseCommand {
             if (cadence)
                 payload.cadence = cadence;
             assertEventDrivenWatchedSource(payload);
-            const policy = {};
+            // `--from-json` may already carry a policy. Start from it so an explicit
+            // flag refines the submitted contract instead of replacing it.
+            const existingPolicy = payload.policy && typeof payload.policy === 'object' && !Array.isArray(payload.policy)
+                ? payload.policy
+                : {};
+            const policy = { ...existingPolicy };
             if (flags.autonomy)
                 policy.autonomyMode = flags.autonomy;
             if (flags.mode && flags.autonomy)
@@ -381,6 +392,18 @@ class CommitmentsCreate extends base_command_1.BaseCommand {
                 policy.executionIsolation = flags.isolation;
             if (flags['max-nudges'] !== undefined)
                 policy.maxUserNudgesPerDay = flags['max-nudges'];
+            const concurrencyPatch = (0, commitments_1.commitmentConcurrencyEnvelopePatch)({
+                rawValue: flags['max-concurrent-runs'],
+                reason: flags['concurrency-reason'],
+            });
+            if (concurrencyPatch) {
+                const existingEnvelope = policy.autonomyEnvelope &&
+                    typeof policy.autonomyEnvelope === 'object' &&
+                    !Array.isArray(policy.autonomyEnvelope)
+                    ? policy.autonomyEnvelope
+                    : {};
+                policy.autonomyEnvelope = { ...existingEnvelope, ...concurrencyPatch };
+            }
             if (Object.keys(policy).length)
                 payload.policy = policy;
             const payloadPolicy = payload.policy && typeof payload.policy === 'object' && !Array.isArray(payload.policy)
@@ -391,13 +414,30 @@ class CommitmentsCreate extends base_command_1.BaseCommand {
                 : typeof payloadPolicy.autonomyMode === 'string'
                     ? payloadPolicy.autonomyMode
                     : 'monitor';
-            if (payload.delivery && typeof payload.delivery === 'object' && !Array.isArray(payload.delivery)) {
+            if (payload.delivery &&
+                typeof payload.delivery === 'object' &&
+                !Array.isArray(payload.delivery)) {
                 const declared = payload.delivery;
                 const coherent = (0, commitment_product_1.deliveryForProductMode)(selectedMode, declared);
                 deliveryNormalizedForMonitor =
                     (0, commitment_product_1.productMode)(selectedMode) === 'monitor' && declared.mode !== 'report_only';
                 payload.delivery = coherent;
             }
+            if (payload.createdVia === undefined) {
+                payload.createdVia = process.env.OVERSKY_AUTONOMOUS_SESSION === '1' ? 'agent_cli' : 'cli';
+            }
+            // `--from-json` is intentionally powerful, but it must not be an escape
+            // hatch around the same authoring decision the explicit flag enforces.
+            const envelope = policy.autonomyEnvelope;
+            if (envelope && Object.prototype.hasOwnProperty.call(envelope, 'maxConcurrentRuns')) {
+                const value = envelope.maxConcurrentRuns;
+                if (process.env.OVERSKY_AUTONOMOUS_SESSION === '1' && value != null) {
+                    throw new Error('An autonomous Agent cannot activate a finite Commitment concurrency cap from --from-json. Omit it or set it to null; an owner may set it later.');
+                }
+                if (value != null && !String(envelope.maxConcurrentRunsReason || '').trim()) {
+                    throw new Error('A finite policy.autonomyEnvelope.maxConcurrentRuns in --from-json requires maxConcurrentRunsReason.');
+                }
+            }
         }
         catch (err) {
             this.error(err.message, { exit: 1 });

package/dist/commands/commitments/delivery.js

@@ -14,6 +14,7 @@ class CommitmentsDelivery extends base_command_1.BaseCommand {
         id: core_1.Args.string({ required: true, ignoreStdin: true }),
         mode: core_1.Args.string({
             required: true,
+            ignoreStdin: true,
             description: 'Delivery destination. Code destinations require Prepare or Execute (or a Pack Shadow promotion target).',
             options: [
                 ...commitment_product_1.COMMITMENT_DELIVERY_CHOICES,

package/dist/commands/commitments/doctor.js

@@ -18,6 +18,16 @@ function doctorVerdict(input) {
     if (operatingState.coverage && operatingState.coverage.complete === false) {
         return { verdict: 'degraded', next: 'Retry doctor; one or more operating-state projections are unavailable' };
     }
+    const autonomy = operatingState.autonomy;
+    const budget = autonomy?.budget;
+    const concurrentRuns = budget?.concurrentRuns;
+    const decision = concurrentRuns?.decision;
+    if (concurrentRuns?.mode === 'limited' && decision?.status === 'review_required') {
+        return {
+            verdict: 'policy_review_required',
+            next: 'Confirm the cap with --max-concurrent-runs <n> --concurrency-reason "...", or remove it with --max-concurrent-runs unlimited',
+        };
+    }
     if (operatingState.status && commitment.status === 'active') {
         const status = String(operatingState.status);
         return {
@@ -76,6 +86,7 @@ class CommitmentsDoctor extends base_command_1.BaseCommand {
             if (autonomy) {
                 this.log(`Mode:    ${(0, commitments_1.commitmentAutonomyLabel)(String(autonomy.declaredMode || ''))} → ${(0, commitments_1.commitmentAutonomyLabel)(String(autonomy.effectiveMode || ''))}`);
             }
+            this.log(`Concurrency: ${(0, commitments_1.describeCommitmentConcurrency)(commitment)}`);
             const approvals = operatingState.approvals;
             if (approvals?.pendingCount)
                 this.log(`Waiting approval: ${String(approvals.pendingCount)}`);

package/dist/commands/commitments/mode.js

@@ -12,6 +12,7 @@ class CommitmentsMode extends base_command_1.BaseCommand {
         id: core_1.Args.string({ required: true, ignoreStdin: true }),
         mode: core_1.Args.string({
             required: true,
+            ignoreStdin: true,
             options: [...commitment_product_1.COMMITMENT_PRODUCT_MODES],
         }),
     };

package/dist/commands/commitments/update.d.ts

@@ -47,6 +47,8 @@ export default class CommitmentsUpdate extends BaseCommand {
         'cadence-mode': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         timezone: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         isolation: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'max-concurrent-runs': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'concurrency-reason': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
     };
     run(): Promise<void>;
 }

package/dist/commands/commitments/update.js

@@ -105,6 +105,12 @@ class CommitmentsUpdate extends base_command_1.BaseCommand {
                 'capability.',
             options: [...commitments_1.COMMITMENT_EXECUTION_ISOLATION_MODES],
         }),
+        'max-concurrent-runs': core_1.Flags.string({
+            description: 'Set 1..100, or "unlimited" to remove the owner cap. Finite values require --concurrency-reason.',
+        }),
+        'concurrency-reason': core_1.Flags.string({
+            description: 'Why the owner deliberately chose a finite Commitment concurrency cap',
+        }),
     };
     async run() {
         this.requireAuth();
@@ -220,11 +226,40 @@ class CommitmentsUpdate extends base_command_1.BaseCommand {
                     cadence.timezone = flags.timezone;
                 payload.cadence = cadence;
             }
-            // A single key, deliberately. `mergePolicyPatch` on the server merges it
-            // into the stored policy, so naming only this field is what keeps the
-            // rest of the contract intact.
-            if (flags.isolation)
-                payload.policy = { executionIsolation: flags.isolation };
+            const concurrencyPatch = (0, commitments_1.commitmentConcurrencyEnvelopePatch)({
+                rawValue: flags['max-concurrent-runs'],
+                reason: flags['concurrency-reason'],
+            });
+            if (flags.isolation || concurrencyPatch) {
+                const existingPolicy = payload.policy && typeof payload.policy === 'object' && !Array.isArray(payload.policy)
+                    ? payload.policy
+                    : {};
+                const nextPolicy = { ...existingPolicy };
+                if (flags.isolation)
+                    nextPolicy.executionIsolation = flags.isolation;
+                if (concurrencyPatch) {
+                    const existingEnvelope = nextPolicy.autonomyEnvelope &&
+                        typeof nextPolicy.autonomyEnvelope === 'object' &&
+                        !Array.isArray(nextPolicy.autonomyEnvelope)
+                        ? nextPolicy.autonomyEnvelope
+                        : {};
+                    nextPolicy.autonomyEnvelope = { ...existingEnvelope, ...concurrencyPatch };
+                }
+                payload.policy = nextPolicy;
+            }
+            const finalPolicy = payload.policy && typeof payload.policy === 'object' && !Array.isArray(payload.policy)
+                ? payload.policy
+                : undefined;
+            const finalEnvelope = finalPolicy?.autonomyEnvelope &&
+                typeof finalPolicy.autonomyEnvelope === 'object' &&
+                !Array.isArray(finalPolicy.autonomyEnvelope)
+                ? finalPolicy.autonomyEnvelope
+                : undefined;
+            if (process.env.OVERSKY_AUTONOMOUS_SESSION === '1' &&
+                finalEnvelope &&
+                Object.prototype.hasOwnProperty.call(finalEnvelope, 'maxConcurrentRuns')) {
+                throw new Error('An autonomous Agent cannot change owner Commitment concurrency policy. Ask the owner to run this update outside the Agent session.');
+            }
         }
         catch (err) {
             this.error(err.message, { exit: 1 });

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

@@ -0,0 +1,14 @@
+import { BaseCommand } from '../../base-command';
+export default class StoreBrowse extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        q: 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>;
+        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>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/store/browse.js

@@ -0,0 +1,71 @@
+"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");
+class StoreBrowse extends base_command_1.BaseCommand {
+    static description = 'Browse published agents in the store';
+    static examples = [
+        '<%= config.bin %> store browse',
+        '<%= config.bin %> store browse --q "cost watchdog"',
+        '<%= config.bin %> store browse --category engineering --limit 10 --json',
+    ];
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+        q: core_1.Flags.string({ description: 'Search query' }),
+        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'] }),
+    };
+    async run() {
+        this.requireAuth();
+        const { flags } = await this.parse(StoreBrowse);
+        let response;
+        try {
+            response = await data_provider_1.dataService.getStoreAgents({
+                limit: flags.limit,
+                ...(flags.q ? { q: flags.q } : {}),
+                ...(flags.category ? { category: flags.category } : {}),
+                ...(flags.cursor ? { cursor: flags.cursor } : {}),
+                ...(flags.sort ? { sortBy: flags.sort } : {}),
+            });
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+        if (flags.json) {
+            this.log(JSON.stringify(response, null, 2));
+            return;
+        }
+        const r = response;
+        const items = r?.data ?? [];
+        if (items.length === 0) {
+            this.log('No agents found.');
+            return;
+        }
+        (0, format_1.renderTable)(items.map((a) => ({
+            id: String(a.id ?? '-'),
+            name: String(a.name ?? '-'),
+            // Price is a property of the LISTING, so it is read from the listing
+            // row rather than from anything the agent carries.
+            price: a.price ? String(a.price) : 'free',
+            rating: a.rating ? `${Number(a.rating).toFixed(1)} (${a.ratingCount ?? 0})` : '-',
+            installs: String(a.installCount ?? 0),
+            author: String(a.authorName ?? '-'),
+        })), [
+            { key: 'id', header: 'ID' },
+            { key: 'name', header: 'NAME', maxWidth: 30 },
+            { key: 'price', header: 'PRICE' },
+            { key: 'rating', header: 'RATING' },
+            { key: 'installs', header: 'INSTALLS' },
+            { key: 'author', header: 'PUBLISHER', maxWidth: 22 },
+        ], (line) => this.log(line));
+        if (r?.next_cursor) {
+            this.log('');
+            this.log(`Next page: --cursor ${r.next_cursor}`);
+        }
+    }
+}
+exports.default = StoreBrowse;

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

@@ -0,0 +1,16 @@
+import { BaseCommand } from '../../base-command';
+export default class StoreInstall extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        agentId: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        release: 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>;
+        'include-bootstrap': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'include-memory': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/store/install.js

@@ -0,0 +1,54 @@
+"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 StoreInstall extends base_command_1.BaseCommand {
+    static description = 'Install a published agent — you get your own copy of it';
+    static examples = [
+        '<%= config.bin %> store install agent_abc123',
+        '<%= config.bin %> store install agent_abc123 --release ar_def456',
+        '<%= config.bin %> store install agent_abc123 --json',
+    ];
+    static args = {
+        agentId: core_1.Args.string({ description: 'The store agent to install', required: true }),
+    };
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+        release: core_1.Flags.string({ description: 'Install a specific release (defaults to the latest)' }),
+        space: core_1.Flags.string({ description: 'Space to install into' }),
+        'include-bootstrap': core_1.Flags.boolean({
+            description: "Include the publisher's shared bootstrap files, if they published any",
+        }),
+        'include-memory': core_1.Flags.boolean({
+            description: "Include the publisher's shared memories, if they published any",
+        }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(StoreInstall);
+        let response;
+        try {
+            response = await data_provider_1.dataService.installStoreAgent({
+                agentId: args.agentId,
+                ...(flags.release ? { releaseId: flags.release } : {}),
+                ...(flags.space ? { spaceId: flags.space } : {}),
+                ...(flags['include-bootstrap'] ? { includeBootstrap: true } : {}),
+                ...(flags['include-memory'] ? { includeMemory: true } : {}),
+            });
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+        if (flags.json) {
+            this.log(JSON.stringify(response, null, 2));
+            return;
+        }
+        const installedId = response?.installedAgentId;
+        this.log(`Installed as ${installedId ?? '-'}.`);
+        // The thing worth saying once: this is a COPY, and it is yours. Edits you
+        // make to it survive the publisher's future updates.
+        this.log('This is your own copy. Edits you make to it are kept when the publisher ships an update.');
+    }
+}
+exports.default = StoreInstall;