@skrr-ai/cli 0.1.15 → 0.1.18

package/dist/commands/tasks/report.js

@@ -7,6 +7,7 @@ const api_fetch_1 = require("../../lib/api-fetch");
 const outbox_1 = require("../../lib/outbox");
 const task_report_1 = require("../../lib/task-report");
 const task_resolver_1 = require("../../lib/task-resolver");
+const tasks_1 = require("../../lib/tasks");
 const session_task_endpoints_1 = require("../../lib/session-task-endpoints");
 const web_url_1 = require("../../lib/web-url");
 /**
@@ -94,6 +95,29 @@ class TasksReport extends base_command_1.BaseCommand {
             ...(0, task_report_1.taskReportEventFields)(report),
             artifacts: flags.deliverable?.map((ref) => ({ label: 'deliverable', ref })),
         };
+        // THE SAME BRIDGE `tasks complete` CARRIES, for the same reason.
+        //
+        // `--deliverable` here is prose for a work event's `artifacts` list, and
+        // the ledger the completion gate reads is written by `tasks deliverable
+        // add`. Three commands in this CLI answer to the word and only one of them
+        // writes the ledger — and the project's own operating instructions teach
+        // this spelling. So a value that is unambiguously a coordinate is forwarded
+        // to the ledger too; prose is left exactly as it was, because guessing a
+        // coordinate out of prose fills the ledger with rows nobody can look up.
+        for (const ref of flags.deliverable ?? []) {
+            const parsed = (0, tasks_1.parseDeliverableCoordinate)(ref);
+            if (!parsed.ok) {
+                continue;
+            }
+            try {
+                await data_provider_1.dataService.addTaskDeliverable(task.id, parsed.value);
+            }
+            catch {
+                // Best-effort: a report must still be posted when the ledger write
+                // fails, and the completion gate's refusal names the command that
+                // writes it.
+            }
+        }
         const sessionPath = await (0, session_task_endpoints_1.sessionScopedTaskPath)('event');
         let result;
         try {

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

@@ -0,0 +1,35 @@
+import { BaseCommand } from '../../base-command';
+/**
+ * `skrr tasks trust <task> <expectation-id> --level <authority> --reason "<why>"`
+ *
+ * Move how much evidence one expectation demands.
+ *
+ * A DECISION, not an edit — which is why it is its own command rather than a
+ * field on `tasks update`. It is the one control that turns a refusal into a
+ * pass with no new work done, so a reader later has to be able to see that it
+ * happened and why. Buried in a list patch it would record neither.
+ *
+ * Lowering is the common direction and it is legitimate: a contract that cannot
+ * express "an agent's word is enough for this one" pushes its authors back to
+ * declaring nothing at all, which is the failure the whole feature exists to
+ * end. Raising takes the same reason and costs nothing to allow.
+ *
+ * The three levels, weakest first:
+ *   self_reported       whoever did the work says it is done
+ *   human_confirmed     someone else looked and said so
+ *   observation_backed  the platform saw it itself (a merge webhook, an upload)
+ */
+export default class TasksTrust extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        task: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+        expectation: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        level: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        reason: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/tasks/trust.js

@@ -0,0 +1,75 @@
+"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");
+/**
+ * `skrr tasks trust <task> <expectation-id> --level <authority> --reason "<why>"`
+ *
+ * Move how much evidence one expectation demands.
+ *
+ * A DECISION, not an edit — which is why it is its own command rather than a
+ * field on `tasks update`. It is the one control that turns a refusal into a
+ * pass with no new work done, so a reader later has to be able to see that it
+ * happened and why. Buried in a list patch it would record neither.
+ *
+ * Lowering is the common direction and it is legitimate: a contract that cannot
+ * express "an agent's word is enough for this one" pushes its authors back to
+ * declaring nothing at all, which is the failure the whole feature exists to
+ * end. Raising takes the same reason and costs nothing to allow.
+ *
+ * The three levels, weakest first:
+ *   self_reported       whoever did the work says it is done
+ *   human_confirmed     someone else looked and said so
+ *   observation_backed  the platform saw it itself (a merge webhook, an upload)
+ */
+class TasksTrust extends base_command_1.BaseCommand {
+    static description = 'Set how much evidence one expectation demands, with a stated reason';
+    static examples = [
+        '<%= config.bin %> tasks trust <task-id> e1 --level self_reported --reason "Internal draft; nobody else needs to check it."',
+        '<%= config.bin %> tasks trust <task-id> e2 --level observation_backed --reason "Customer-facing; I want the platform to see it land."',
+    ];
+    static args = {
+        task: core_1.Args.string({ description: 'Task id or ref', required: true, ignoreStdin: true }),
+        expectation: core_1.Args.string({
+            description: 'Expectation id (see `tasks expectations`)',
+            required: true,
+            ignoreStdin: true,
+        }),
+    };
+    static flags = {
+        level: core_1.Flags.string({
+            options: [...data_provider_1.DELIVERABLE_AUTHORITIES],
+            required: true,
+            description: 'How well evidenced the answer must be: self_reported (the doer says so), ' +
+                'human_confirmed (someone else looked), observation_backed (the platform saw it).',
+        }),
+        reason: core_1.Flags.string({
+            required: true,
+            description: 'Why this bar. Required — it is the record.',
+        }),
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(TasksTrust);
+        let result;
+        try {
+            result = await data_provider_1.dataService.setTaskExpectationTrust(args.task, {
+                expectationId: args.expectation,
+                level: flags.level,
+                reason: flags.reason,
+            });
+        }
+        catch (err) {
+            this.handleApiError(err);
+            return;
+        }
+        if (flags.json) {
+            this.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        this.log(`${args.expectation} now needs ${flags.level}: ${flags.reason}`);
+    }
+}
+exports.default = TasksTrust;

package/dist/commands/tasks/waive.js

@@ -22,7 +22,7 @@ class TasksWaive extends base_command_1.BaseCommand {
     static args = {
         task: core_1.Args.string({ description: 'Task id or ref', required: true, ignoreStdin: true }),
         expectation: core_1.Args.string({
-            description: 'Expectation id (see `tasks show`)',
+            description: 'Expectation id (see `tasks expectations`)',
             required: true,
             ignoreStdin: true,
         }),

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

@@ -16,11 +16,14 @@
  * Two `kind`s: `achieve` (bounded, deadline-bearing) and `maintain` (perpetual
  * "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 } from '@skrr-ai/data-provider';
-import type { CommitmentCheck, CommitmentChecksResponse, Commitment, CommitmentListResponse, CommitmentPlanResponse, CommitmentStatusResponse, CommitmentWorkLink } from '@skrr-ai/data-provider';
+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, 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
@@ -28,16 +31,31 @@ export type { CommitmentCheck, CommitmentChecksResponse, Commitment, CommitmentL
  * `_Exhaustive*` guards fail to resolve if a canonical value is missing.
  */
 export declare const COMMITMENT_STATUSES: readonly ["draft", "active", "paused", "completed", "cancelled", "archived"];
-/** Autonomy ladder — how much the commitment may act without asking. */
-export declare const COMMITMENT_AUTONOMY_MODES: readonly ["off", "suggestions_only", "ask_first", "auto_run_limited", "auto_run"];
+/**
+ * Autonomy ladder — how much the commitment may act without asking.
+ *
+ * Re-exported, not restated: `@skrr-ai/data-provider` owns the vocabulary, and
+ * a second literal here is how the CLI would silently drift from the server
+ * 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
+ * offers a value the API rejects is a silent drift.
+ */
+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;
@@ -50,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;
@@ -159,6 +178,7 @@ export type CommitmentPackLifecycleResponse = {
         title?: string;
         status?: string;
         policy?: Record<string, unknown>;
+        delivery?: Commitment['delivery'];
     };
     pack: {
         id: string;
@@ -210,6 +230,7 @@ export declare const commitmentApi: {
     get: (id: string) => Promise<CommitmentStatusResponse>;
     create: (body: Record<string, unknown>) => Promise<Commitment>;
     update: (id: string, body: Record<string, unknown>) => Promise<Commitment>;
+    draftPreflight: (body: Record<string, unknown>) => Promise<CommitmentPreflightReport>;
     workLinks: (id: string, includeInactive?: boolean) => Promise<{
         object: "commitment_work_link_list";
         data: CommitmentWorkLink[];
@@ -232,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>>;
@@ -324,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<{
@@ -346,7 +382,19 @@ 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.
+ *
+ * This deliberately uses a separate pair of names from Agent-level instruction
+ * commands: the result configures one Commitment run, not the Agent's global
+ * prompt. The explicit error also keeps shell users from accidentally masking
+ * a reviewed file with a short inline experiment.
+ */
+export declare function readCommitmentAgentDirective({ directive, file, }: {
+    directive?: string;
+    file?: string;
+}): Promise<string | undefined>;
 /**
  * Normalize a `--from-json` body into something the create endpoint accepts.
  *
@@ -357,8 +405,9 @@ export declare const COMMITMENT_CREATE_KEYS: readonly ["agentId", "kind", "compa
  *     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;
@@ -437,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.
  */