@skrr-ai/cli 0.1.17 → 0.1.18

package/dist/commands/commitments/show.js

@@ -4,6 +4,7 @@ const core_1 = require("@oclif/core");
 const base_command_1 = require("../../base-command");
 const commitments_1 = require("../../lib/commitments");
 const web_url_1 = require("../../lib/web-url");
+const commitment_product_1 = require("../../lib/commitment-product");
 /**
  * `skrr commitments show <id>` — the commitment's contract + live control-loop
  * state (health, last check, next check, unresolved-check streak), plus the most
@@ -23,6 +24,9 @@ class CommitmentsShow extends base_command_1.BaseCommand {
     };
     static flags = {
         json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+        verbose: core_1.Flags.boolean({
+            description: 'Include raw compatibility policy and check diagnostics',
+        }),
     };
     async run() {
         this.requireAuth();
@@ -46,13 +50,30 @@ class CommitmentsShow extends base_command_1.BaseCommand {
             return;
         }
         (0, commitments_1.renderCommitmentSummary)(response.commitment, (line) => this.log(line), response.latestCheck);
-        if (response.latestCheck) {
+        try {
+            const receipts = await commitments_1.commitmentApi.receipts(args.id, 1);
+            if (receipts.receipts[0]) {
+                this.log('');
+                (0, commitment_product_1.renderExecutionReceipt)(receipts.receipts[0], (line) => this.log(line), flags.verbose);
+            }
+            else
+                this.log('No wake has been observed yet.');
+        }
+        catch {
+            this.log('Execution receipt is unavailable. Retry with commitments receipt <id> --latest.');
+        }
+        if (flags.verbose && response.latestCheck) {
             this.log('');
             this.log('Latest check:');
             (0, commitments_1.renderCheckList)([response.latestCheck], (line) => this.log(line));
             this.log('');
             this.log(`Full history:  ${this.config.bin} commitments checks ${args.id}`);
         }
+        if (flags.verbose)
+            this.log(`Compatibility policy: ${JSON.stringify(response.commitment.policy)}`);
+        const url = (0, web_url_1.commitmentUrlFrom)(this.cliConfig.baseURL, response.commitment);
+        if (url)
+            this.log(`URL: ${url}`);
     }
 }
 exports.default = CommitmentsShow;

package/dist/commands/commitments/update.js

@@ -89,10 +89,12 @@ class CommitmentsUpdate extends base_command_1.BaseCommand {
             description: 'Signal Monitor id to watch (repeatable). Implies --watch monitor.',
             multiple: true,
         }),
-        cadence: core_1.Flags.string({ description: 'New check interval, e.g. "15m", "6h", "1d" (1m..30d)' }),
+        cadence: core_1.Flags.string({
+            description: 'New check interval, e.g. "15m", "6h", "30d" (1m..365d)',
+        }),
         'cadence-mode': core_1.Flags.string({
             description: 'Cadence mode',
-            options: [...commitments_1.COMMITMENT_CADENCE_MODES],
+            options: [...commitments_1.COMMITMENT_AUTHORABLE_CADENCE_MODES],
         }),
         timezone: core_1.Flags.string({ description: 'IANA timezone for the cadence' }),
         isolation: core_1.Flags.string({

package/dist/commands/commitments/wake-capabilities.d.ts

@@ -1,4 +1,7 @@
 import { BaseCommand } from '../../base-command';
+export declare function wakePolicyHeadline(result: {
+    workPromotionModel?: string;
+}): string;
 /**
  * `skrr commitments wake-capabilities <id>` — which wakes an Agent may pick.
  *
@@ -10,6 +13,7 @@ import { BaseCommand } from '../../base-command';
  * misconfiguration. Showing only one list would make those indistinguishable.
  */
 export default class CommitmentsWakeCapabilities extends BaseCommand {
+    static hidden: boolean;
     static description: string;
     static examples: string[];
     static args: {
@@ -17,6 +21,7 @@ export default class CommitmentsWakeCapabilities extends BaseCommand {
     };
     static flags: {
         json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        verbose: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;
 }

package/dist/commands/commitments/wake-capabilities.js

@@ -1,9 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.wakePolicyHeadline = wakePolicyHeadline;
 const core_1 = require("@oclif/core");
 const base_command_1 = require("../../base-command");
 const commitments_1 = require("../../lib/commitments");
 const format_1 = require("../../lib/format");
+function wakePolicyHeadline(result) {
+    return result.workPromotionModel === 'monitor_prepare_execute_v1'
+        ? 'Wake behavior: configured Commitment sources may wake it automatically; there is no separate permission level.'
+        : 'Compatibility wake policy is in use. Migrate the Commitment by choosing Monitor, Prepare, or Execute.';
+}
 /**
  * `skrr commitments wake-capabilities <id>` — which wakes an Agent may pick.
  *
@@ -15,7 +21,10 @@ const format_1 = require("../../lib/format");
  * misconfiguration. Showing only one list would make those indistinguishable.
  */
 class CommitmentsWakeCapabilities extends base_command_1.BaseCommand {
-    static description = 'List the wake capabilities an agent may select for a commitment';
+    // Compatibility/operator diagnostic. Product users configure sources and
+    // cadence directly; v2 has no separate wake-permission level.
+    static hidden = true;
+    static description = 'Inspect configured wake-source diagnostics for a commitment';
     static examples = [
         '<%= config.bin %> commitments wake-capabilities obj_abc123',
         '<%= config.bin %> commitments wake-capabilities obj_abc123 --json',
@@ -23,7 +32,10 @@ class CommitmentsWakeCapabilities extends base_command_1.BaseCommand {
     static args = {
         commitmentId: core_1.Args.string({ ignoreStdin: true, description: 'Commitment ID', required: true }),
     };
-    static flags = { json: core_1.Flags.boolean({ description: 'Output as JSON' }) };
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+        verbose: core_1.Flags.boolean({ description: 'Include raw legacy wake-policy values' }),
+    };
     async run() {
         this.requireAuth();
         const { args, flags } = await this.parse(CommitmentsWakeCapabilities);
@@ -38,11 +50,15 @@ class CommitmentsWakeCapabilities extends base_command_1.BaseCommand {
             this.log(JSON.stringify(result, null, 2));
             return;
         }
-        this.log(`Wake permission mode: ${result.mode}`);
+        const productModel = result.workPromotionModel === 'monitor_prepare_execute_v1';
+        this.log(wakePolicyHeadline(result));
         const selected = result.selectedCapabilityIds;
-        this.log(selected === undefined
-            ? 'Allowlist: not configured (pre-picker commitment — every visible capability is offered)'
-            : `Allowlist: ${selected.length ? selected.join(', ') : '(empty — no agent-selected wake may materialize)'}`);
+        if (flags.verbose) {
+            this.log(`Raw compatibility mode: ${result.mode}`);
+            this.log(selected === undefined
+                ? 'Raw allowlist: not configured'
+                : `Raw allowlist: ${selected.length ? selected.join(', ') : '(empty)'}`);
+        }
         this.log('');
         const visible = new Set(result.visibleCapabilities.map((item) => item.id));
         (0, format_1.renderTable)(result.eligibleCapabilities.map((item) => ({
@@ -54,7 +70,7 @@ class CommitmentsWakeCapabilities extends base_command_1.BaseCommand {
             { key: 'id', header: 'CAPABILITY' },
             { key: 'kind', header: 'KIND' },
             { key: 'source', header: 'SOURCE' },
-            { key: 'offered', header: 'OFFERED' },
+            { key: 'offered', header: productModel ? 'ACTIVE' : 'OFFERED' },
         ], (line) => this.log(line));
     }
 }

package/dist/commands/spaces/bootstrap.js

@@ -60,7 +60,7 @@ class SpacesBootstrap extends base_command_1.BaseCommand {
     // one. It names the scope now, and the command prints the server's own
     // contract so the boundary is visible at the point of use rather than buried
     // in a route comment.
-    static description = 'Fetch the Space first-paint payload (space, summary, permissions, and Live slices). ' +
+    static description = 'Fetch the Space first-paint payload (space, summary, and permissions). ' +
         'NOT a complete Space export — tasks, members, Room, files and wiki have their own commands; ' +
         'the printed contract names each one.';
     static examples = [

package/dist/lib/commitment-endpoints.d.ts

@@ -1,5 +1,6 @@
 import { withQuery } from './triggers';
 export declare const ENDPOINT_CAPABILITIES: readonly ["push", "reply", "structuredAsk"];
+export declare const COMMITMENT_ENDPOINT_DESTINATIONS: readonly ["slack_channel", "slack_owner_dm", "app_owner_dm"];
 export type EndpointCapability = (typeof ENDPOINT_CAPABILITIES)[number];
 export interface CommitmentEndpoint {
     id: string;
@@ -21,9 +22,9 @@ export declare const commitmentEndpointApi: {
         endpoints: CommitmentEndpoint[];
     }>;
     create: (body: Record<string, unknown>) => Promise<CommitmentEndpoint>;
-    /** May return `{authorizationUrl,…}` instead of a connected endpoint. */
+    /** Probes the native App/Slack transport and records current health. */
     connect: (id: string, body?: Record<string, unknown>) => Promise<Record<string, unknown>>;
-    /** Completes an OAuth handshake started by `connect`. */
+    /** Legacy compatibility call; new native endpoints do not use OAuth. */
     finalizeConnect: (id: string, body?: Record<string, unknown>) => Promise<Record<string, unknown>>;
     reconnect: (id: string, body?: Record<string, unknown>) => Promise<Record<string, unknown>>;
     health: (id: string, body?: Record<string, unknown>) => Promise<Record<string, unknown>>;

package/dist/lib/commitment-endpoints.js

@@ -1,36 +1,39 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.commitmentEndpointApi = exports.ENDPOINT_CAPABILITIES = void 0;
+exports.commitmentEndpointApi = exports.COMMITMENT_ENDPOINT_DESTINATIONS = exports.ENDPOINT_CAPABILITIES = void 0;
 exports.renderEndpointList = renderEndpointList;
 /**
  * commitment-endpoints.ts — client for `/api/commitment-endpoints`.
  *
  * A **commitment endpoint** is a channel-neutral DELIVERY TARGET: "this agent
- * can reach me on Slack DM / this channel / email", expressed as a connection
+ * can reach me on Slack DM / this channel / App DM", expressed as a connection
  * record with a readiness state. Commitments then declare report targets against
  * these, so a commitment never names a raw Slack channel id or a token.
  *
  * The lifecycle is the interesting part, and it is why this needs a CLI at all:
  *
- *   create → connect → (finalize) → connected → [health] → reconnect / revoke
+ *   create → connect/probe → connected → [health] → reconnect / revoke
  *
- * `connect` may return an OAuth authorization URL rather than a connected
- * endpoint. That is the normal path for a real provider, and it is exactly the
- * step that used to require a browser — which meant a headless operator could
- * not set up a commitment's reporting at all.
+ * OAuth connector metadata is deliberately absent: the delivery router uses
+ * the native Agent Slack installation or built-in App transport.
  */
 const data_provider_1 = require("@skrr-ai/data-provider");
 const format_1 = require("./format");
 const triggers_1 = require("./triggers");
 exports.ENDPOINT_CAPABILITIES = ['push', 'reply', 'structuredAsk'];
+exports.COMMITMENT_ENDPOINT_DESTINATIONS = [
+    'slack_channel',
+    'slack_owner_dm',
+    'app_owner_dm',
+];
 const MOUNT = '/api/commitment-endpoints';
 const base = (id) => `${MOUNT}/${encodeURIComponent(id)}`;
 exports.commitmentEndpointApi = {
     list: (query = {}) => data_provider_1.request.get((0, triggers_1.withQuery)(MOUNT, query)),
     create: (body) => data_provider_1.request.post(MOUNT, body),
-    /** May return `{authorizationUrl,…}` instead of a connected endpoint. */
+    /** Probes the native App/Slack transport and records current health. */
     connect: (id, body = {}) => data_provider_1.request.post(`${base(id)}/connect`, body),
-    /** Completes an OAuth handshake started by `connect`. */
+    /** Legacy compatibility call; new native endpoints do not use OAuth. */
     finalizeConnect: (id, body = {}) => data_provider_1.request.post(`${base(id)}/connect/finalize`, body),
     reconnect: (id, body = {}) => data_provider_1.request.post(`${base(id)}/reconnect`, body),
     health: (id, body = {}) => data_provider_1.request.post(`${base(id)}/health`, body),

package/dist/lib/commitment-product.d.ts

@@ -0,0 +1,14 @@
+import type { CommitmentDeliveryIntent, CommitmentExecutionReceipt } from '@skrr-ai/data-provider';
+export declare const COMMITMENT_PRODUCT_MODES: readonly ["monitor", "prepare", "execute"];
+export declare const COMMITMENT_DELIVERY_CHOICES: readonly ["report-only", "local-patch", "draft-pr", "push-branch", "direct-branch"];
+/** Compatibility is accepted at the input boundary; everyday output uses the product contract. */
+export declare function productMode(value?: string): 'monitor' | 'prepare' | 'execute';
+export declare function productModeLabel(value?: string): string;
+export declare function deliveryLabel(mode?: string): string;
+export declare function deliveryInput(mode: string, options?: {
+    repo?: string;
+    base?: string;
+}): CommitmentDeliveryIntent;
+/** Monitor is observation-only; retain report expectations, never repo coordinates. */
+export declare function deliveryForProductMode(mode: string | undefined, delivery?: CommitmentDeliveryIntent): CommitmentDeliveryIntent | undefined;
+export declare function renderExecutionReceipt(receipt: CommitmentExecutionReceipt, log: (line: string) => void, verbose?: boolean): void;

package/dist/lib/commitment-product.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.COMMITMENT_DELIVERY_CHOICES = exports.COMMITMENT_PRODUCT_MODES = void 0;
+exports.productMode = productMode;
+exports.productModeLabel = productModeLabel;
+exports.deliveryLabel = deliveryLabel;
+exports.deliveryInput = deliveryInput;
+exports.deliveryForProductMode = deliveryForProductMode;
+exports.renderExecutionReceipt = renderExecutionReceipt;
+exports.COMMITMENT_PRODUCT_MODES = ['monitor', 'prepare', 'execute'];
+exports.COMMITMENT_DELIVERY_CHOICES = [
+    'report-only',
+    'local-patch',
+    'draft-pr',
+    'push-branch',
+    'direct-branch',
+];
+/** Compatibility is accepted at the input boundary; everyday output uses the product contract. */
+function productMode(value) {
+    if (value === 'prepare' || value === 'ask_first')
+        return 'prepare';
+    if (['execute', 'auto_run', 'auto_run_limited'].includes(value || ''))
+        return 'execute';
+    return 'monitor';
+}
+function productModeLabel(value) {
+    if (value === 'off')
+        return 'Not running';
+    const mode = productMode(value);
+    return mode[0].toUpperCase() + mode.slice(1);
+}
+function deliveryLabel(mode) {
+    return ({
+        report_only: 'Report only',
+        local_patch: 'Local patch',
+        draft_pr: 'Draft PR',
+        push_branch: 'Push branch',
+        direct_branch: 'Direct branch',
+    }[mode || ''] || 'Not declared');
+}
+function deliveryInput(mode, options = {}) {
+    const normalized = mode.replace(/-/g, '_');
+    if (!exports.COMMITMENT_DELIVERY_CHOICES.some((choice) => choice.replace(/-/g, '_') === normalized)) {
+        throw new Error(`Unknown delivery. Choose ${exports.COMMITMENT_DELIVERY_CHOICES.join(', ')}.`);
+    }
+    return {
+        version: 1,
+        mode: normalized,
+        ...(options.repo ? { repo: options.repo } : {}),
+        ...(options.base ? { baseBranch: options.base } : {}),
+    };
+}
+/** Monitor is observation-only; retain report expectations, never repo coordinates. */
+function deliveryForProductMode(mode, delivery) {
+    if (productMode(mode) !== 'monitor')
+        return delivery;
+    return {
+        version: 1,
+        mode: 'report_only',
+        ...(delivery?.expectations ? { expectations: delivery.expectations } : {}),
+    };
+}
+function renderExecutionReceipt(receipt, log, verbose = false) {
+    log(receipt.summary);
+    log(`Mode: ${productModeLabel(receipt.mode)}`);
+    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}` : ''}`);
+        for (const evidence of phase.evidence) {
+            if (evidence.url)
+                log(`    ${evidence.label}: ${evidence.url}`);
+        }
+    }
+    if (receipt.nextActor)
+        log(`Next: ${receipt.nextActor.label || receipt.nextActor.kind}${receipt.nextActor.reason ? ` — ${receipt.nextActor.reason}` : ''}`);
+    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

@@ -17,10 +17,13 @@
  * "hold this state", derived from a Compass invariant — not authored here).
  */
 import { COMMITMENT_WATCHED_SOURCES, COMMITMENT_TEMPLATE_IDS, COMMITMENT_CADENCE_MODES, COMMITMENT_CADENCE_TIME_PATTERN, COMMITMENT_CADENCE_MAX_TIMES, COMMITMENT_AUTONOMY_MODES, COMMITMENT_EXECUTION_ISOLATION_MODES } from '@skrr-ai/data-provider';
-import type { CommitmentCheck, CommitmentChecksResponse, Commitment, CommitmentListResponse, CommitmentPlanResponse, CommitmentStatusResponse, CommitmentWorkLink } from '@skrr-ai/data-provider';
+import type { CommitmentCheck, CommitmentChecksResponse, Commitment, CommitmentActionProposal, CommitmentListResponse, CommitmentPlanResponse, CommitmentStatusResponse, CommitmentWorkLink, CommitmentExecutionReceiptListResponse, CommitmentCapabilitySource, CommitmentDeliveryPatchResponse, CommitmentDeliveryBundleResponse } from '@skrr-ai/data-provider';
 import { withQuery } from './triggers';
 export { COMMITMENT_WATCHED_SOURCES, COMMITMENT_TEMPLATE_IDS, COMMITMENT_CADENCE_MODES, COMMITMENT_CADENCE_TIME_PATTERN, COMMITMENT_CADENCE_MAX_TIMES, };
-export type { CommitmentCheck, CommitmentChecksResponse, Commitment, CommitmentListResponse, CommitmentPlanResponse, CommitmentStatusResponse, CommitmentWorkLink, };
+export type { CommitmentCheck, CommitmentChecksResponse, Commitment, CommitmentActionProposal, CommitmentListResponse, CommitmentPlanResponse, CommitmentStatusResponse, CommitmentWorkLink, };
+/** Derived from the installed compatibility vocabulary so the CLI remains
+ * safe even while data-provider and CLI packages roll out separately. */
+export declare const COMMITMENT_AUTHORABLE_CADENCE_MODES: ("manual" | "daily" | "interval" | "event_plus_interval")[];
 /**
  * oclif's `options:` needs runtime arrays, but data-provider models these two as
  * union TYPES only. The values live here — and both directions of drift are a
@@ -36,6 +39,11 @@ export declare const COMMITMENT_STATUSES: readonly ["draft", "active", "paused",
  * that rejects its values.
  */
 export { COMMITMENT_AUTONOMY_MODES };
+export declare const COMMITMENT_AUTHORABLE_AUTONOMY_MODES: readonly ["monitor", "prepare", "execute"];
+export type CommitmentAuthorableAutonomyMode = (typeof COMMITMENT_AUTHORABLE_AUTONOMY_MODES)[number];
+export declare function storedAutonomyModeForAuthoring(mode: CommitmentAuthorableAutonomyMode | string): 'suggestions_only' | 'ask_first' | 'auto_run';
+export declare function authoringAutonomyModeForStored(mode?: string | null): CommitmentAuthorableAutonomyMode;
+export declare function commitmentAutonomyLabel(mode?: string | null): string;
 /**
  * Where a Commitment's autonomous runs do their work. Re-exported for the same
  * reason as the ladder above: the vocabulary is the server's, and a picker that
@@ -45,11 +53,9 @@ export { COMMITMENT_EXECUTION_ISOLATION_MODES };
 /**
  * Interval bounds for `cadence.intervalMs`.
  *
- * The REST schema permits up to 30d, but the mirrored
- * `TriggerDefinition.schedule.intervalMs` is capped at 24h and
- * `CommitmentTriggerSync` swallows the resulting validation failure — so a cadence
- * over 24h yields a commitment whose control loop NEVER fires while every surface
- * reports success. Cap at 24h so that state is unreachable from the CLI.
+ * The Trigger schedule and Commitment contract now share the same one-year
+ * upper bound. Keep the CLI aligned so a valid long-interval contract does not
+ * get rejected only at this surface.
  */
 export declare const MIN_COMMITMENT_INTERVAL_MS = 60000;
 export declare const MAX_COMMITMENT_INTERVAL_MS: number;
@@ -62,6 +68,7 @@ export type CommitmentView = Partial<Commitment>;
 export type CommitmentCheckView = Partial<CommitmentCheck>;
 export type CommitmentPreflightReport = {
     verdict: 'ready' | 'needs_review' | 'blocked';
+    capabilities?: CommitmentCapabilitySource[];
     gates: Array<{
         id: string;
         label: string;
@@ -171,6 +178,7 @@ export type CommitmentPackLifecycleResponse = {
         title?: string;
         status?: string;
         policy?: Record<string, unknown>;
+        delivery?: Commitment['delivery'];
     };
     pack: {
         id: string;
@@ -245,12 +253,26 @@ export declare const commitmentApi: {
     actionHistory: (id: string, limit?: number) => Promise<{
         data: unknown[];
     }>;
+    actionProposals: (id: string, query?: {
+        status?: string;
+        limit?: number;
+    }) => Promise<{
+        object: "commitment_action_proposal_list";
+        data: CommitmentActionProposal[];
+    }>;
+    decideActionProposal: (id: string, proposalId: string, decision: "approve" | "reject") => 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>>;
     pause: (id: string) => Promise<Commitment>;
     resume: (id: string) => Promise<Commitment>;
     complete: (id: string) => Promise<Commitment>;
     autonomy: (id: string, body: Record<string, unknown>) => Promise<Commitment>;
+    mode: (id: string, body: Record<string, unknown>) => Promise<Commitment>;
+    delivery: (id: string, body: Record<string, unknown>) => Promise<Commitment>;
+    receipts: (id: string, limit?: number) => Promise<CommitmentExecutionReceiptListResponse>;
+    deliveryPatch: (id: string, taskId: string) => Promise<CommitmentDeliveryPatchResponse>;
+    deliveryBundle: (id: string, taskId: string) => Promise<CommitmentDeliveryBundleResponse>;
     operatingReview: (agentId: string) => Promise<Record<string, unknown>>;
     reflection: (id: string) => Promise<Record<string, unknown>>;
     decideReflectionProposal: (id: string, proposalKey: string, decision: "approve" | "reject") => Promise<Record<string, unknown>>;
@@ -337,6 +359,7 @@ export declare const commitmentApi: {
 };
 /** Shape of `GET /:id/wake-capabilities`. */
 export interface CommitmentWakeCapabilities {
+    workPromotionModel?: 'monitor_prepare_execute_v1';
     mode: string;
     selectedCapabilityIds?: string[];
     eligibleCapabilities: Array<{
@@ -359,7 +382,7 @@ export declare const COMMITMENT_FEEDBACK_KINDS: readonly ["useful", "noisy", "wr
  */
 export declare const COMMITMENT_REMEDIATION_ACTIONS: readonly ["pause_commitment", "mute_user_nudges", "reduce_nudge_frequency", "tighten_policy", "mark_noop"];
 /** The only keys `createBodySchema` (a `z.strictObject`) accepts. */
-export declare const COMMITMENT_CREATE_KEYS: readonly ["agentId", "kind", "compassId", "compassOrigin", "goalId", "title", "description", "agentDirective", "status", "target", "watchedSources", "policy", "cadence", "subject", "sensors", "grants", "reports", "createdVia"];
+export declare const COMMITMENT_CREATE_KEYS: readonly ["mode", "agentId", "kind", "compassId", "compassOrigin", "goalId", "title", "description", "agentDirective", "status", "target", "watchedSources", "policy", "delivery", "cadence", "subject", "sensors", "grants", "reports", "createdVia"];
 /**
  * Read the per-Commitment domain policy from an inline flag or a text file.
  *
@@ -382,8 +405,9 @@ export declare function readCommitmentAgentDirective({ directive, file, }: {
  *     contract dumped from `list --json` carries id/version/state/ownerUserId/…
  *     — drop everything the schema does not declare.
  *
- * `status` is additionally narrowed: create only permits `draft|active`, but a
- * dumped contract may carry `paused`/`completed`.
+ * `status` is additionally narrowed: create only permits `draft`; activation
+ * is the separate resume + preflight boundary. A dumped contract may carry an
+ * 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 parseIntervalToMs(input: string): number;
@@ -462,13 +486,11 @@ export declare function renderCommitmentList(commitments: CommitmentView[], log:
  * The autonomy mode a check ACTUALLY ran at, read from its policy trace
  * (OSK-4881).
  *
- * A commitment's STATED autonomy (`policy.autonomyMode`) is only a ceiling: the
- * arbiter clamps it to the stricter of the agent's initiative policy and the
- * workspace's governance, then records the mode it settled on in the check's
- * `decision.policyTrace`. The arbiter's own decision carries it as
- * `autonomyMode`; the workspace-governance entry carries the clamped ceiling as
- * `effectiveAutonomyMode`. Either answers "what governed this run". Returns the
- * effective mode when the trace carries one, else undefined.
+ * A check records the Mode it actually used in `decision.policyTrace`. For the
+ * v2 product contract, only an explicit Workspace-admin constraint may lower
+ * the declared Mode; legacy checks may still carry older effective-mode traces.
+ * Either `autonomyMode` or `effectiveAutonomyMode` answers what governed that
+ * particular run. Returns undefined when the trace carries neither.
  *
  * Exported for tests.
  */