@skrr-ai/cli 0.1.19 → 0.1.21

package/dist/commands/subscriptions/status.d.ts

@@ -0,0 +1,12 @@
+import { BaseCommand } from '../../base-command';
+export default class SubscriptionsStatus 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>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/subscriptions/status.js

@@ -0,0 +1,49 @@
+"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 SubscriptionsStatus extends base_command_1.BaseCommand {
+    static description = 'Show whether a service subscription is live, and until when';
+    static examples = [
+        '<%= config.bin %> subscriptions status agent_abc123',
+        '<%= config.bin %> subscriptions status agent_abc123 --json',
+    ];
+    static args = {
+        agentId: core_1.Args.string({ description: 'The service to check', required: true }),
+    };
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(SubscriptionsStatus);
+        let response;
+        try {
+            response = await data_provider_1.dataService.getStoreAgentSubscriptionStatus(args.agentId);
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+        if (flags.json) {
+            this.log(JSON.stringify(response, null, 2));
+            return;
+        }
+        if (!response?.subscribed) {
+            // The two reasons want different next actions, so they are printed
+            // differently rather than collapsed into "not subscribed".
+            this.log(response?.reason === 'expired'
+                ? 'Not live — the subscription expired. Renewing resumes it.'
+                : 'Not subscribed.');
+            return;
+        }
+        this.log(`Live. Entitlement ${response.entitlementId} (v${response.version})`);
+        this.log(`Your instance: ${response.instanceAgentId ?? '-'}`);
+        this.log(`Compute paid by: ${response.billingMode}`);
+        this.log(`Expires: ${response.expiresAt ? String(response.expiresAt) : 'no end date'}`);
+        if (response.commitmentId) {
+            this.log(`Obligation: ${response.commitmentId}`);
+        }
+    }
+}
+exports.default = SubscriptionsStatus;

package/dist/commands/subscriptions/subscribe.d.ts

@@ -0,0 +1,15 @@
+import { BaseCommand } from '../../base-command';
+export default class SubscriptionsSubscribe 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>;
+        'billing-mode': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'expires-at': 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>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/subscriptions/subscribe.js

@@ -0,0 +1,59 @@
+"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 SubscriptionsSubscribe extends base_command_1.BaseCommand {
+    static description = 'Subscribe to a published service — installs your own managed instance and opens the obligation it is delivered through';
+    static examples = [
+        '<%= config.bin %> subscriptions subscribe agent_abc123',
+        '<%= config.bin %> subscriptions subscribe agent_abc123 --billing-mode per-user',
+        '<%= config.bin %> subscriptions subscribe agent_abc123 --space space_xyz --json',
+    ];
+    static args = {
+        agentId: core_1.Args.string({ description: 'The published service to subscribe to', required: true }),
+    };
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+        'billing-mode': core_1.Flags.string({
+            description: 'Who pays for the inference this service consumes',
+            options: ['owner', 'per-user', 'shared'],
+        }),
+        'expires-at': core_1.Flags.string({ description: 'Paid-through date (ISO 8601)' }),
+        space: core_1.Flags.string({ description: 'Space the service should work in' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(SubscriptionsSubscribe);
+        let response;
+        try {
+            response = await data_provider_1.dataService.subscribeToStoreAgent(args.agentId, {
+                ...(flags['billing-mode']
+                    ? { billingMode: flags['billing-mode'] }
+                    : {}),
+                ...(flags['expires-at'] ? { expiresAt: flags['expires-at'] } : {}),
+                ...(flags.space ? { spaceId: flags.space } : {}),
+            });
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+        if (flags.json) {
+            this.log(JSON.stringify(response, null, 2));
+            return;
+        }
+        this.log(`Subscribed. Entitlement ${response?.entitlementId}`);
+        this.log(`Your instance: ${response?.instanceAgentId ?? '-'}`);
+        this.log(`Compute paid by: ${response?.billingMode}`);
+        if (response?.commitmentId) {
+            // The commitment is the thing you can hold the service to — surface it,
+            // because "is it working" is answered there and nowhere else.
+            this.log(`Obligation: ${response.commitmentId}`);
+        }
+        if (response?.degraded === 'commitment_pending') {
+            this.log('');
+            this.log('Note: the subscription is live but its obligation has not been created yet. It is resumable and refundable; retry to finish opening it.');
+        }
+    }
+}
+exports.default = SubscriptionsSubscribe;

package/dist/commands/tasks/complete.d.ts

@@ -6,12 +6,19 @@ type CompletionStatus = 'completed' | 'failed';
 type TaskCommentResult = Awaited<ReturnType<typeof dataService.addTaskComment>>;
 type MovedTaskResult = Awaited<ReturnType<typeof dataService.moveTask>>;
 /** Wire shape of POST /api/tasks/:taskId/complete (OSK-1969). */
+/** One thing a completion did not have. Never a refusal — `done` has none. */
+export interface CompletionAdvisory {
+    code: string;
+    message: string;
+}
 export interface CompleteEndpointResponse {
     task: MovedTaskResult | null;
     comment: TaskCommentResult | null;
     commentFailed?: boolean;
-    deliveryHeld?: boolean;
-    deliveryReason?: string;
+    /** What the completion was missing. `done` has no preconditions, so every
+     *  condition that used to refuse one now travels with it instead. The task
+     *  reached the requested terminal state regardless. */
+    advisories?: CompletionAdvisory[];
 }
 export interface CompleteTransport {
     /** POST /api/tasks/:taskId/complete — atomic move + TASK_OUTPUT comment. */
@@ -35,8 +42,7 @@ export interface DurableCompletionResult {
     movedTask: MovedTaskResult | null;
     moved: boolean;
     commentFailed: boolean;
-    deliveryHeld?: boolean;
-    deliveryReason?: string;
+    advisories?: CompletionAdvisory[];
     /** true when the atomic /complete endpoint handled the finalization. */
     usedAtomicEndpoint: boolean;
 }

package/dist/commands/tasks/complete.js

@@ -194,8 +194,7 @@ async function completeTaskDurably(opts) {
             movedTask: response.task ?? null,
             moved: true,
             commentFailed: response.commentFailed === true,
-            ...(response.deliveryHeld ? { deliveryHeld: true } : {}),
-            ...(response.deliveryReason ? { deliveryReason: response.deliveryReason } : {}),
+            ...(response.advisories?.length ? { advisories: response.advisories } : {}),
             usedAtomicEndpoint: true,
         };
     }
@@ -611,7 +610,7 @@ class TasksComplete extends base_command_1.BaseCommand {
                 ...(report ? { report } : {}),
                 body,
             },
-            ...(result.deliveryHeld ? { deliveryHeld: true, deliveryReason: result.deliveryReason } : {}),
+            ...(result.advisories?.length ? { advisories: result.advisories } : {}),
         };
         if (flags.json) {
             const url = movedTask
@@ -634,8 +633,11 @@ class TasksComplete extends base_command_1.BaseCommand {
                 ? `Task ${completedTaskId} was already ${newStatus}; the outcome was amended.`
                 : `Moved task ${completedTaskId} to ${newStatus}`);
         }
-        if (result.deliveryHeld) {
-            this.warn('Delivery is not verified on the default branch; the task was held at in_review instead of done.');
+        for (const advisory of result.advisories ?? []) {
+            // One warn per unmet condition. Each already reads as an observation —
+            // the completion happened — so the CLI relays them rather than
+            // re-wording them into something that sounds like a failure.
+            this.warn(advisory.message);
         }
         if (report) {
             const url = (0, web_url_1.taskUrlFrom)(this.cliConfig.baseURL, movedTask ?? { id: completedTaskId });

package/dist/commands/tasks/self-schedule.d.ts

@@ -0,0 +1,30 @@
+import { BaseCommand } from '../../base-command';
+/**
+ * `skrr tasks self-schedule` — park a task for a self-initiated return.
+ *
+ * Distinct from `skrr tasks schedule`, and the distinction is the point.
+ * `schedule` writes the AUTHOR's calendar (`scheduledFor` + `recurrence`), the
+ * thing the scheduler consumes and re-arms and every calendar surface renders.
+ * This writes a separate `self_scheduled` trigger row, so an agent working the
+ * task can say "come back in two hours" without editing the human's Monday-9am
+ * recurrence to mean something the human never asked for.
+ *
+ * Both can be set at once. Neither erases the other.
+ */
+export default class TasksSelfSchedule extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        at: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        in: 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>;
+        'max-per-day': import("@oclif/core/lib/interfaces").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        show: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        clear: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/tasks/self-schedule.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../../base-command");
+const task_extras_1 = require("../../lib/task-extras");
+/**
+ * `skrr tasks self-schedule` — park a task for a self-initiated return.
+ *
+ * Distinct from `skrr tasks schedule`, and the distinction is the point.
+ * `schedule` writes the AUTHOR's calendar (`scheduledFor` + `recurrence`), the
+ * thing the scheduler consumes and re-arms and every calendar surface renders.
+ * This writes a separate `self_scheduled` trigger row, so an agent working the
+ * task can say "come back in two hours" without editing the human's Monday-9am
+ * recurrence to mean something the human never asked for.
+ *
+ * Both can be set at once. Neither erases the other.
+ */
+class TasksSelfSchedule extends base_command_1.BaseCommand {
+    static description = "Park a task for a self-initiated return — separate from the author's schedule";
+    static examples = [
+        '<%= config.bin %> tasks self-schedule <task-id> --in 2h --note "check whether the deploy settled"',
+        '<%= config.bin %> tasks self-schedule <task-id> --at 2026-09-09T14:00:00Z',
+        '<%= config.bin %> tasks self-schedule <task-id> --show',
+        '<%= config.bin %> tasks self-schedule <task-id> --clear',
+    ];
+    static args = {
+        id: core_1.Args.string({ description: 'Task ID', required: true, ignoreStdin: true }),
+    };
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+        at: core_1.Flags.string({ description: 'Absolute return time (ISO-8601 UTC)' }),
+        in: core_1.Flags.string({ description: 'Relative return time such as 90m, 2h, 3d' }),
+        note: core_1.Flags.string({
+            // Was "handed to the agent as the return prompt", which is not true:
+            // `task_execute` builds the run's prompt from the Task, so this string is
+            // recorded and never read by the run. See `TaskScheduler/selfSchedule.js`.
+            description: 'Why you are coming back — recorded on the return for you to read back',
+        }),
+        'max-per-day': core_1.Flags.integer({
+            description: 'Cap on self-initiated returns per day (1-24, default 4)',
+        }),
+        show: core_1.Flags.boolean({ description: 'Print the pending return without changing it' }),
+        clear: core_1.Flags.boolean({ description: 'Cancel the pending return' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(TasksSelfSchedule);
+        if (flags.show && flags.clear) {
+            this.error('Pass at most one of --show or --clear.', { exit: 1 });
+        }
+        let result;
+        try {
+            if (flags.show) {
+                result = await task_extras_1.taskSelfScheduleApi.get(args.id);
+            }
+            else if (flags.clear) {
+                result = await task_extras_1.taskSelfScheduleApi.clear(args.id);
+            }
+            else {
+                const runAt = resolveRunAt(flags.at, flags.in);
+                if (!runAt) {
+                    this.error('Pass --at <ISO-8601>, --in <duration>, or one of --show / --clear.', {
+                        exit: 1,
+                    });
+                }
+                result = await task_extras_1.taskSelfScheduleApi.park(args.id, {
+                    runAt,
+                    ...(flags.note ? { note: flags.note } : {}),
+                    ...(flags['max-per-day'] ? { maxFiresPerDay: flags['max-per-day'] } : {}),
+                });
+            }
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+        if (flags.json) {
+            this.log(JSON.stringify(result ?? {}, null, 2));
+            return;
+        }
+        const runAt = result?.runAt;
+        if (!runAt) {
+            this.log(`Task ${args.id} has no pending return.`);
+            return;
+        }
+        // `pending` is derived server-side: a return that has already fired keeps
+        // its instant on the row, and printing that verbatim would report a return
+        // as upcoming an hour after it happened.
+        const spent = result?.pending === false;
+        this.log(`Task ${args.id} ${spent ? 'last returned at' : 'returns at'} ${runAt}`);
+        if (result?.note)
+            this.log(`Note: ${result.note}`);
+        if (!spent && result?.maxFiresPerDay) {
+            this.log(`Cap: ${result.maxFiresPerDay} self-initiated returns/day`);
+        }
+    }
+}
+exports.default = TasksSelfSchedule;
+/** `90m` / `2h` / `3d`, or an absolute instant. Absolute wins when both are given. */
+function resolveRunAt(at, relative) {
+    if (at)
+        return at;
+    if (!relative)
+        return undefined;
+    const match = /^(\d+)\s*(m|min|mins|h|hr|hrs|d)$/i.exec(relative.trim());
+    if (!match)
+        return undefined;
+    const value = Number(match[1]);
+    const unit = match[2].toLowerCase();
+    const MS_PER_UNIT = { m: 60_000, h: 3_600_000, d: 86_400_000 };
+    // `min`/`mins`/`hr`/`hrs` collapse onto their first character, which is
+    // unambiguous across the three units this accepts.
+    const ms = value * (MS_PER_UNIT[unit[0]] ?? MS_PER_UNIT.h);
+    return new Date(Date.now() + ms).toISOString();
+}

package/dist/commands/triggers/disable.js

@@ -26,7 +26,9 @@ class TriggersDisable extends base_command_1.BaseCommand {
             return;
         }
         this.log('Disabled trigger:');
-        (0, triggers_1.renderTriggerSummary)(trigger, (line) => this.log(line));
+        (0, triggers_1.renderTriggerSummary)(trigger, (line) => this.log(line), {
+            baseURL: this.cliConfig.baseURL,
+        });
     }
 }
 exports.default = TriggersDisable;

package/dist/commands/triggers/enable.js

@@ -26,7 +26,9 @@ class TriggersEnable extends base_command_1.BaseCommand {
             return;
         }
         this.log('Enabled trigger:');
-        (0, triggers_1.renderTriggerSummary)(trigger, (line) => this.log(line));
+        (0, triggers_1.renderTriggerSummary)(trigger, (line) => this.log(line), {
+            baseURL: this.cliConfig.baseURL,
+        });
     }
 }
 exports.default = TriggersEnable;

package/dist/commands/triggers/rotate-secret.js

@@ -30,6 +30,11 @@ class TriggersRotateSecret extends base_command_1.BaseCommand {
             return;
         }
         this.log(`Secret: ${String(result.secret ?? '-')}`);
+        // The secret alone does not let anyone call in. This command was the natural
+        // place to learn the endpoint and printed everything except it, so building
+        // the integration meant reading the API source or guessing the path.
+        this.log(`URL:    POST ${(0, triggers_1.webhookIngestUrl)(this.cliConfig.baseURL, args.id)}`);
+        this.log('Sign with header x-trigger-signature; send x-trigger-timestamp alongside it.');
         this.log(String(result.note ?? 'Save this secret now; it cannot be retrieved later.'));
         if (result.lastRotatedAt)
             this.log(`Rotated at: ${String(result.lastRotatedAt)}`);

package/dist/commands/triggers/show.js

@@ -29,7 +29,9 @@ class TriggersShow extends base_command_1.BaseCommand {
             this.log(JSON.stringify(trigger, null, 2));
             return;
         }
-        (0, triggers_1.renderTriggerSummary)(trigger, (line) => this.log(line));
+        (0, triggers_1.renderTriggerSummary)(trigger, (line) => this.log(line), {
+            baseURL: this.cliConfig.baseURL,
+        });
     }
 }
 exports.default = TriggersShow;

package/dist/lib/commitment-product.js

@@ -63,6 +63,10 @@ function deliveryForProductMode(mode, delivery) {
 function renderExecutionReceipt(receipt, log, verbose = false) {
     log(receipt.summary);
     log(`Mode: ${productModeLabel(receipt.mode)}`);
+    if (receipt.runtime) {
+        const identity = receipt.runtime.name || receipt.runtime.id || 'the selected runtime';
+        log(`Runtime: ${identity}${receipt.runtime.kind ? ` · ${receipt.runtime.kind}` : ''}${receipt.runtime.provider ? ` · ${receipt.runtime.provider}` : ''}`);
+    }
     for (const phase of receipt.phases) {
         const mark = { done: '✓', working: '→', waiting: '…', failed: '×', skipped: '–' }[phase.status];
         log(`  ${mark} ${phase.phase[0].toUpperCase() + phase.phase.slice(1)}: ${phase.summary}${phase.at ? ` · ${phase.at}` : ''}`);
@@ -73,6 +77,11 @@ function renderExecutionReceipt(receipt, log, verbose = false) {
     }
     if (receipt.nextActor)
         log(`Next: ${receipt.nextActor.label || receipt.nextActor.kind}${receipt.nextActor.reason ? ` — ${receipt.nextActor.reason}` : ''}`);
+    if (receipt.blocker) {
+        log(`Blocker: ${receipt.blocker.code}`);
+        for (const evidenceRef of receipt.blocker.evidenceRefs || [])
+            log(`  Evidence: ${evidenceRef}`);
+    }
     if (verbose)
         log(`Diagnostics:\n${JSON.stringify({ id: receipt.id, revision: receipt.revision, evidence: receipt.evidence, diagnostics: receipt.diagnostics }, null, 2)}`);
 }

package/dist/lib/commitments.d.ts

@@ -260,7 +260,20 @@ export declare const commitmentApi: {
         object: "commitment_action_proposal_list";
         data: CommitmentActionProposal[];
     }>;
-    decideActionProposal: (id: string, proposalId: string, decision: "approve" | "reject") => Promise<Record<string, unknown>>;
+    /**
+     * Propose a prepared action for a check.
+     *
+     * The half that was missing. `decide` and `execute` were both reachable, so a
+     * headless operator could only ever REACT to proposals the server made — an
+     * asymmetry that leaves the domain half-usable in exactly the way the parity
+     * rule exists to catch. A locally-running agent that has investigated a
+     * commitment and knows what should be done had no way to say so.
+     */
+    proposeActionProposal: (id: string, body: Record<string, unknown>) => Promise<Record<string, unknown>>;
+    decideActionProposal: (id: string, proposalId: string, decision: "approve" | "reject", snapshot?: {
+        snapshotDigest?: string;
+        bundleVersion?: number;
+    }) => Promise<Record<string, unknown>>;
     executeActionProposal: (id: string, proposalId: string) => Promise<Record<string, unknown>>;
     preflight: (id: string, nextRunCount?: number) => Promise<CommitmentPreflightReport>;
     effectivePolicy: (id: string) => Promise<Record<string, unknown>>;
@@ -410,6 +423,13 @@ export declare function readCommitmentAgentDirective({ directive, file, }: {
  * active or terminal state, but importing it must still create a draft.
  */
 export declare function normalizeCreateBody(input: Record<string, unknown>): Record<string, unknown>;
+export declare function parseCommitmentConcurrencyLimit(input: string | undefined): number | null | undefined;
+export declare function commitmentConcurrencyEnvelopePatch({ rawValue, reason, autonomous, }: {
+    rawValue?: string;
+    reason?: string;
+    autonomous?: boolean;
+}): Record<string, unknown> | undefined;
+export declare function describeCommitmentConcurrency(commitment: CommitmentView): string;
 export declare function parseIntervalToMs(input: string): number;
 /**
  * Assemble the `watchedSources` array from CLI flags — one place, so `create`

package/dist/lib/commitments.js

@@ -6,6 +6,9 @@ exports.authoringAutonomyModeForStored = authoringAutonomyModeForStored;
 exports.commitmentAutonomyLabel = commitmentAutonomyLabel;
 exports.readCommitmentAgentDirective = readCommitmentAgentDirective;
 exports.normalizeCreateBody = normalizeCreateBody;
+exports.parseCommitmentConcurrencyLimit = parseCommitmentConcurrencyLimit;
+exports.commitmentConcurrencyEnvelopePatch = commitmentConcurrencyEnvelopePatch;
+exports.describeCommitmentConcurrency = describeCommitmentConcurrency;
 exports.parseIntervalToMs = parseIntervalToMs;
 exports.buildWatchedSources = buildWatchedSources;
 exports.describeEvidenceHealth = describeEvidenceHealth;
@@ -153,8 +156,20 @@ exports.commitmentApi = {
     checks: (id, limit) => data_provider_1.request.get((0, triggers_1.withQuery)(`${base(id)}/checks`, { limit })),
     actionHistory: (id, limit) => data_provider_1.request.get((0, triggers_1.withQuery)(`${base(id)}/action-history`, { limit })),
     actionProposals: (id, query = {}) => data_provider_1.request.get((0, triggers_1.withQuery)(`${base(id)}/action-proposals`, query)),
-    decideActionProposal: (id, proposalId, decision) => data_provider_1.request.post(`${base(id)}/action-proposals/${encodeURIComponent(proposalId)}/decision`, {
+    /**
+     * Propose a prepared action for a check.
+     *
+     * The half that was missing. `decide` and `execute` were both reachable, so a
+     * headless operator could only ever REACT to proposals the server made — an
+     * asymmetry that leaves the domain half-usable in exactly the way the parity
+     * rule exists to catch. A locally-running agent that has investigated a
+     * commitment and knows what should be done had no way to say so.
+     */
+    proposeActionProposal: (id, body) => data_provider_1.request.post(`${base(id)}/action-proposals`, body),
+    decideActionProposal: (id, proposalId, decision, snapshot) => data_provider_1.request.post(`${base(id)}/action-proposals/${encodeURIComponent(proposalId)}/decision`, {
         decision,
+        ...(snapshot?.snapshotDigest ? { snapshotDigest: snapshot.snapshotDigest } : {}),
+        ...(snapshot?.bundleVersion ? { bundleVersion: snapshot.bundleVersion } : {}),
     }),
     executeActionProposal: (id, proposalId) => data_provider_1.request.post(`${base(id)}/action-proposals/${encodeURIComponent(proposalId)}/execute`, {}),
     preflight: (id, nextRunCount) => data_provider_1.request.post(`${base(id)}/preflight`, {
@@ -321,6 +336,51 @@ function normalizeCreateBody(input) {
     }
     return out;
 }
+function parseCommitmentConcurrencyLimit(input) {
+    if (input === undefined)
+        return undefined;
+    const raw = String(input).trim().toLowerCase();
+    if (['unlimited', 'unbounded', 'none', 'null'].includes(raw))
+        return null;
+    const value = Number(raw);
+    if (!Number.isSafeInteger(value) || value < 1 || value > 100) {
+        throw new Error('--max-concurrent-runs must be "unlimited" or an integer from 1 to 100.');
+    }
+    return value;
+}
+function commitmentConcurrencyEnvelopePatch({ rawValue, reason, autonomous = process.env.OVERSKY_AUTONOMOUS_SESSION === '1', }) {
+    const value = parseCommitmentConcurrencyLimit(rawValue);
+    const normalizedReason = reason?.trim();
+    if (value === undefined) {
+        if (normalizedReason) {
+            throw new Error('--concurrency-reason requires --max-concurrent-runs.');
+        }
+        return undefined;
+    }
+    if (autonomous && value !== null) {
+        throw new Error('An autonomous Agent may suggest a finite Commitment concurrency cap, but cannot activate owner policy. Omit the field or use unlimited; an owner can set the cap later.');
+    }
+    if (value !== null && !normalizedReason) {
+        throw new Error('A finite --max-concurrent-runs value requires --concurrency-reason.');
+    }
+    return {
+        maxConcurrentRuns: value,
+        ...(normalizedReason ? { maxConcurrentRunsReason: normalizedReason } : {}),
+    };
+}
+function describeCommitmentConcurrency(commitment) {
+    const envelope = commitment.policy?.autonomyEnvelope;
+    const limit = envelope?.maxConcurrentRuns;
+    const decision = envelope?.maxConcurrentRunsDecision;
+    if (limit == null) {
+        const source = decision?.mode === 'unlimited' ? decision.source : 'default';
+        return `unlimited (${source})`;
+    }
+    const authority = decision?.authority || 'unknown';
+    const source = decision?.source || 'legacy';
+    const review = authority === 'unknown' ? ' — review required' : '';
+    return `${limit} (${authority}/${source}${review})`;
+}
 /**
  * Parse a human interval ("15m", "6h", "1d", or a bare number of minutes) into
  * milliseconds. Throws on unparseable input, on trailing junk, and on values
@@ -672,6 +732,7 @@ latestCheck) {
         log(`Next check:${` ${commitment.cadence.nextCheckAt}`}`);
     log(`Mode:      ${describeAutonomyLine(commitment, latestCheck)}`);
     log(`Delivery:  ${(0, commitment_product_1.deliveryLabel)(commitment.delivery?.mode)}${commitment.delivery?.repo ? ` · ${commitment.delivery.repo}` : ''}${commitment.delivery?.baseBranch ? ` → ${commitment.delivery.baseBranch}` : ''}`);
+    log(`Concurrency: ${describeCommitmentConcurrency(commitment)}`);
     const criteria = commitment.target?.successCriteria || [];
     const evidenceHealth = latestCheck?.inputs?.evidenceHealth;
     const evidenceLine = describeEvidenceHealth(evidenceHealth, criteria.length);

package/dist/lib/node-adapter.js

@@ -79,6 +79,10 @@ function createNodeAdapter(opts = {}) {
         const { token } = currentCredential();
         const headers = {
             Accept: 'application/json',
+            // Server-side authoring provenance. This is attribution, not authority;
+            // owner/admin decisions are still authenticated and validated at the
+            // route boundary.
+            'X-Skrr-Client': 'cli',
             ...(extra ?? {}),
         };
         if (token) {

package/dist/lib/task-extras.d.ts

@@ -32,6 +32,24 @@ export declare const taskLookupApi: {
     treePosition: (id: string, body: Json) => Promise<Json>;
     createAndStart: (body: Json) => Promise<Json>;
 };
+/**
+ * Self-schedule — "come back to this task at T", owned by whoever is working it.
+ *
+ * A different resource from `/schedule`, not a variant of it. `/schedule` writes
+ * `Task.scheduledFor` + `recurrence` (the author's calendar, which the scheduler
+ * consumes and re-arms); this writes a `kind:'self_scheduled'` trigger row. Both
+ * can be set on one task and neither erases the other, so a headless agent can
+ * defer itself without editing the human's recurrence to mean something the
+ * human never asked for.
+ *
+ * PUT, not POST: a task has at most one pending return and parking again
+ * replaces it.
+ */
+export declare const taskSelfScheduleApi: {
+    get: (id: string) => Promise<Json>;
+    park: (id: string, body: Json) => Promise<Json>;
+    clear: (id: string) => Promise<Json>;
+};
 /**
  * The completion URL as a STRING.
  *

package/dist/lib/task-extras.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.taskChatApi = exports.taskLookupApi = exports.taskWorkflowApi = void 0;
+exports.taskChatApi = exports.taskSelfScheduleApi = exports.taskLookupApi = exports.taskWorkflowApi = void 0;
 exports.taskCompletePath = taskCompletePath;
 /**
  * task-extras.ts — the `/api/tasks` endpoints that have no `dataService.*`
@@ -51,6 +51,24 @@ exports.taskLookupApi = {
     treePosition: (id, body) => data_provider_1.request.patch(`${base(id)}/tree-position`, body),
     createAndStart: (body) => data_provider_1.request.post(`${MOUNT}/create-and-start`, body),
 };
+/**
+ * Self-schedule — "come back to this task at T", owned by whoever is working it.
+ *
+ * A different resource from `/schedule`, not a variant of it. `/schedule` writes
+ * `Task.scheduledFor` + `recurrence` (the author's calendar, which the scheduler
+ * consumes and re-arms); this writes a `kind:'self_scheduled'` trigger row. Both
+ * can be set on one task and neither erases the other, so a headless agent can
+ * defer itself without editing the human's recurrence to mean something the
+ * human never asked for.
+ *
+ * PUT, not POST: a task has at most one pending return and parking again
+ * replaces it.
+ */
+exports.taskSelfScheduleApi = {
+    get: (id) => data_provider_1.request.get(`${base(id)}/self-schedule`),
+    park: (id, body) => data_provider_1.request.put(`${base(id)}/self-schedule`, body),
+    clear: (id) => data_provider_1.request.delete(`${base(id)}/self-schedule`),
+};
 /**
  * The completion URL as a STRING.
  *