@skrr-ai/cli 0.1.19 → 0.1.21

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/decide.js

@@ -4,10 +4,14 @@ const core_1 = require("@oclif/core");
 const base_command_1 = require("../../../base-command");
 const commitments_1 = require("../../../lib/commitments");
 class CommitmentsActionProposalsDecide extends base_command_1.BaseCommand {
-    static description = 'Approve & run, or reject, one frozen prepared action';
+    static description = 'Approve & run, or reject, one frozen Action Bundle';
     static args = {
         commitmentId: core_1.Args.string({ description: 'Commitment ID', required: true, ignoreStdin: true }),
-        proposalId: core_1.Args.string({ description: 'Action Proposal ID', required: true, ignoreStdin: true }),
+        proposalId: core_1.Args.string({
+            description: 'Action Proposal ID',
+            required: true,
+            ignoreStdin: true,
+        }),
     };
     static flags = {
         json: core_1.Flags.boolean({ description: 'Output the decision and execution receipts as JSON' }),
@@ -19,7 +23,20 @@ class CommitmentsActionProposalsDecide extends base_command_1.BaseCommand {
         const decision = flags.decision;
         let result;
         try {
-            const decided = await commitments_1.commitmentApi.decideActionProposal(args.commitmentId, args.proposalId, decision);
+            const listed = await commitments_1.commitmentApi.actionProposals(args.commitmentId, { limit: 200 });
+            const proposal = listed.data.find((item) => item.id === args.proposalId);
+            if (!proposal)
+                this.error('Action Bundle not found.');
+            if (Number(proposal.bundleVersion) >= 2 && !proposal.snapshotDigest) {
+                this.error('Action Bundle has no review digest and cannot be decided safely.');
+            }
+            if (!flags.json && proposal.snapshotDigest) {
+                this.log(`Action Bundle digest: ${proposal.snapshotDigest}`);
+            }
+            const decided = await commitments_1.commitmentApi.decideActionProposal(args.commitmentId, args.proposalId, decision, {
+                snapshotDigest: proposal.snapshotDigest,
+                bundleVersion: proposal.bundleVersion,
+            });
             const execution = decision === 'approve' && decided.status === 'approved'
                 ? await commitments_1.commitmentApi.executeActionProposal(args.commitmentId, args.proposalId)
                 : undefined;
@@ -31,10 +48,10 @@ class CommitmentsActionProposalsDecide extends base_command_1.BaseCommand {
         if (flags.json)
             this.log(JSON.stringify(result, null, 2));
         else if (decision === 'approve') {
-            this.log('Prepared action approved and handed to the durable executor.');
+            this.log('Action Bundle approved and handed to the durable executor.');
         }
         else {
-            this.log('Prepared action rejected.');
+            this.log('Action Bundle rejected.');
         }
     }
 }

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

@@ -4,10 +4,14 @@ const core_1 = require("@oclif/core");
 const base_command_1 = require("../../../base-command");
 const commitments_1 = require("../../../lib/commitments");
 class CommitmentsActionProposalsExecute extends base_command_1.BaseCommand {
-    static description = 'Nudge an approved action now (recovery continues automatically)';
+    static description = 'Nudge an approved Action Bundle now (recovery continues automatically)';
     static args = {
         commitmentId: core_1.Args.string({ description: 'Commitment ID', required: true, ignoreStdin: true }),
-        proposalId: core_1.Args.string({ description: 'Action Proposal ID', required: true, ignoreStdin: true }),
+        proposalId: core_1.Args.string({
+            description: 'Action Proposal ID',
+            required: true,
+            ignoreStdin: true,
+        }),
     };
     static flags = { json: core_1.Flags.boolean({ description: 'Output as JSON' }) };
     async run() {
@@ -23,7 +27,7 @@ class CommitmentsActionProposalsExecute extends base_command_1.BaseCommand {
         if (flags.json)
             this.log(JSON.stringify(result, null, 2));
         else
-            this.log(`Prepared action is ${String(result.status || 'queued')}.`);
+            this.log(`Action Bundle is ${String(result.status || 'queued')}.`);
     }
 }
 exports.default = CommitmentsActionProposalsExecute;

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/action-proposals.js

@@ -5,7 +5,7 @@ const base_command_1 = require("../../base-command");
 const commitments_1 = require("../../lib/commitments");
 const format_1 = require("../../lib/format");
 class CommitmentsActionProposals extends base_command_1.BaseCommand {
-    static description = 'List frozen prepared actions and their recovery state';
+    static description = 'List frozen Action Bundles and their recovery state';
     static args = {
         id: core_1.Args.string({ description: 'Commitment ID', required: true, ignoreStdin: true }),
     };
@@ -35,18 +35,20 @@ class CommitmentsActionProposals extends base_command_1.BaseCommand {
             return;
         }
         if (!response.data.length) {
-            this.log('No prepared actions.');
+            this.log('No prepared Action Bundles.');
             return;
         }
         (0, format_1.renderTable)(response.data.map((proposal) => ({
             id: proposal.id,
-            action: String(proposal.actionSnapshot?.type || 'action').replace(/_/g, ' '),
+            actions: String(proposal.actionSnapshots?.length || 1),
+            digest: proposal.snapshotDigest || 'legacy',
             status: proposal.status,
             attempt: `${proposal.attempt || 0}/${proposal.maxAttempts || 3}`,
             expires: proposal.expiresAt || '—',
         })), [
             { key: 'id', header: 'PROPOSAL', verbatim: true },
-            { key: 'action', header: 'ACTION', maxWidth: 28 },
+            { key: 'actions', header: 'ACTIONS' },
+            { key: 'digest', header: 'DIGEST', maxWidth: 64, verbatim: true },
             { key: 'status', header: 'STATUS' },
             { key: 'attempt', header: 'ATTEMPT' },
             { key: 'expires', header: 'EXPIRES', maxWidth: 28 },

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