@skrr-ai/cli 0.1.92 → 0.1.94

package/dist/lib/agent-ref.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentRefError = void 0;
+exports.cliFirstPartyHosts = cliFirstPartyHosts;
+exports.resolveAgentRef = resolveAgentRef;
+exports.attributedListingUrl = attributedListingUrl;
+exports.installAttribution = installAttribution;
+exports.shellQuote = shellQuote;
+const data_provider_1 = require("@skrr-ai/data-provider");
+const http_error_1 = require("./http-error");
+const web_url_1 = require("./web-url");
+class AgentRefError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = 'AgentRefError';
+    }
+}
+exports.AgentRefError = AgentRefError;
+/**
+ * An agent id is a single opaque token (`agent_…` today). Anything with a
+ * slash, a colon, whitespace or a dot is a link, a path or a typo — none of
+ * which may be sent to the API as if it were an id, because the server would
+ * answer "not found" and the person would conclude the agent does not exist.
+ */
+const AGENT_ID_TOKEN = /^[A-Za-z0-9_-]+$/;
+function hostOf(origin) {
+    try {
+        return new URL(origin).host.toLowerCase();
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * The built-in first-party hosts plus every origin the configured deployment
+ * serves (a dev or self-hosted `baseURL` is first-party for its own user).
+ */
+function cliFirstPartyHosts(baseURL) {
+    const hosts = new Set(data_provider_1.FIRST_PARTY_HOSTS.map((host) => host.toLowerCase()));
+    if (baseURL) {
+        for (const origin of [baseURL, ...(0, web_url_1.firstPartyWebOrigins)(baseURL)]) {
+            const host = hostOf(origin);
+            if (host) {
+                hosts.add(host);
+                if (!host.startsWith('www.'))
+                    hosts.add(`www.${host}`);
+            }
+        }
+    }
+    return [...hosts];
+}
+async function defaultResolveCode(code) {
+    try {
+        return await data_provider_1.dataService.resolveDistributionCode(code);
+    }
+    catch (err) {
+        if ((0, http_error_1.httpStatusOf)(err) === 404)
+            return null;
+        throw err;
+    }
+}
+async function defaultResolveVanity(handle, slug) {
+    try {
+        return await data_provider_1.dataService.resolveAgentVanity({ handle, slug });
+    }
+    catch (err) {
+        if ((0, http_error_1.httpStatusOf)(err) === 404)
+            return null;
+        throw err;
+    }
+}
+async function resolveByVanity(value, handle, slug, attribution, options) {
+    const resolved = await (options.resolveVanity ?? defaultResolveVanity)(handle, slug);
+    if (resolved?.entity?.kind !== 'agent' || !resolved.entity.id) {
+        throw new AgentRefError(`No public agent answers to "${value}". The publisher may have unpublished it; their ` +
+            `page lists what they publish: skrr open ${(0, data_provider_1.entityPath)({ kind: 'publisher', handle })}`, 'AGENT_REF_VANITY_UNRESOLVED');
+    }
+    // An alias is an address, not a share: it carries no attribution of its own.
+    return { agentId: resolved.entity.id, source: 'vanity', attribution };
+}
+function withChannel(attribution, channel) {
+    if (attribution.channel)
+        return attribution;
+    const normalized = (0, data_provider_1.normalizeDistributionChannel)(channel);
+    return normalized ? { ...attribution, channel: normalized } : attribution;
+}
+async function resolveByCode(value, attribution, options) {
+    const code = attribution.code;
+    const resolved = await (options.resolveCode ?? defaultResolveCode)(code);
+    if (!resolved?.entity) {
+        throw new AgentRefError(`The share code in "${value}" does not point at a public agent: it may have been ` +
+            'unpublished, or the link was copied incompletely.', 'AGENT_REF_CODE_UNRESOLVED');
+    }
+    if (resolved.entity.kind !== 'agent') {
+        throw new AgentRefError(`"${value}" is a link to a ${resolved.entity.kind.replace(/_/g, ' ')}, not an agent.`, 'AGENT_REF_NOT_AN_AGENT');
+    }
+    return {
+        agentId: resolved.entity.id,
+        source: 'code',
+        // The link's own `ch` wins; the code's minted channel fills a link without one.
+        attribution: withChannel(attribution, resolved.channel),
+    };
+}
+async function resolveAgentRef(input, options = {}) {
+    const value = String(input ?? '').trim();
+    if (!value) {
+        throw new AgentRefError(`Name the agent: pass its id (agent_…) or a ${data_provider_1.BRAND.displayName} link to it.`, 'AGENT_REF_EMPTY');
+    }
+    if (AGENT_ID_TOKEN.test(value)) {
+        return { agentId: value, source: 'id', attribution: {} };
+    }
+    const inspected = (0, data_provider_1.inspectSkrrLink)(value, {
+        firstPartyHosts: cliFirstPartyHosts(options.baseURL),
+    });
+    if (!inspected) {
+        throw /^[a-z][a-z0-9+.-]*:\/\//i.test(value)
+            ? new AgentRefError(`"${value}" is not a ${data_provider_1.BRAND.displayName} link, so it was not followed. Pass an agent ` +
+                `id or a link on ${data_provider_1.BRAND.displayName}'s own site.`, 'AGENT_REF_FOREIGN')
+            : unsupported(value);
+    }
+    const { link, attribution } = inspected;
+    switch (link.kind) {
+        case 'agent':
+        case 'store_agent':
+        case 'agent_owner':
+            return { agentId: link.agentId, source: 'link', attribution };
+        case 'agent_vanity':
+            // A code on the link names the agent exactly; a bare alias is resolved
+            // by the server's vanity store.
+            if (attribution.code)
+                return resolveByCode(value, attribution, options);
+            return resolveByVanity(value, link.handle, link.slug, attribution, options);
+        case 'unknown':
+            if (attribution.code)
+                return resolveByCode(value, attribution, options);
+            throw unsupported(value);
+        default:
+            throw new AgentRefError(`"${value}" is a link to a ${link.kind.replace(/_/g, ' ')}, not an agent.`, 'AGENT_REF_NOT_AN_AGENT');
+    }
+}
+function unsupported(value) {
+    return new AgentRefError(`"${value}" is not an agent id or a link to an agent. Pass the id (agent_…) or its ` +
+        'listing link (…/a/<id>).', 'AGENT_REF_UNSUPPORTED');
+}
+/**
+ * The canonical public address of a resolved agent, keeping the attribution it
+ * arrived with — what a command prints when it echoes a link back (an install
+ * command, an `open`), so following the echo credits the same share.
+ */
+function attributedListingUrl(baseURL, ref) {
+    return (0, data_provider_1.buildShareUrl)((0, web_url_1.webOrigin)(baseURL), { kind: 'agent', id: ref.agentId }, {
+        code: ref.attribution.code,
+        channel: ref.attribution.channel,
+    });
+}
+/** The install body fields an attribution maps to; empty for an unattributed ref. */
+function installAttribution(attribution) {
+    return {
+        ...(attribution.code ? { distributionCode: attribution.code } : {}),
+        ...(attribution.channel ? { channel: attribution.channel } : {}),
+    };
+}
+/** Quote a URL for a POSIX shell: `?` and `&` in an attributed link are metacharacters. */
+function shellQuote(value) {
+    return /^[A-Za-z0-9_@%+=:,./-]+$/.test(value) ? value : `'${value.replace(/'/g, `'\\''`)}'`;
+}

package/dist/lib/api-fetch.d.ts

@@ -37,6 +37,8 @@ export declare class ApiFetchError extends Error {
      * attributed by guesswork — see `node-adapter.ts`.
      */
     readonly requestId?: string;
+    /** Milliseconds the server asked us to wait (`Retry-After`) on a 429. */
+    retryAfterMs?: number;
     /**
      * Set on a 401 when this CLI's own refresh was refused AND the local
      * daemon, asked for a hand-off, refused too (OSK-12474). The daemon's reason

package/dist/lib/api-fetch.js

@@ -47,6 +47,7 @@ const daemonBroker_1 = require("./daemonBroker");
 const dpop_auth_1 = require("./dpop-auth");
 const workspace_header_1 = require("./workspace-header");
 const non_json_response_1 = require("./non-json-response");
+const rate_limit_retry_1 = require("./rate-limit-retry");
 class ApiFetchError extends Error {
     status;
     body;
@@ -63,6 +64,8 @@ class ApiFetchError extends Error {
      * attributed by guesswork — see `node-adapter.ts`.
      */
     requestId;
+    /** Milliseconds the server asked us to wait (`Retry-After`) on a 429. */
+    retryAfterMs;
     /**
      * Set on a 401 when this CLI's own refresh was refused AND the local
      * daemon, asked for a hand-off, refused too (OSK-12474). The daemon's reason
@@ -186,13 +189,19 @@ async function apiFetch(pathOrUrl, opts = {}) {
         // OSK-12020 — a fresh proof per attempt for a DPoP-bound hand-off token
         // (the 401 retry below re-enters here and gets its own). No-op otherwise.
         Object.assign(headers, await (0, dpop_auth_1.dpopHeadersFor)(credential.token, method, url));
-        return fetch(url, {
+        const sent = (0, workspace_header_1.withWorkspaceHeader)(headers);
+        // E6: a 429 on a GET or an idempotency-keyed write is retried (bounded,
+        // jittered, honouring Retry-After). The last 429's wait is kept for the error.
+        const { response, retryAfterMs } = await (0, rate_limit_retry_1.fetchWithRateLimitRetry)(() => fetch(url, {
             method,
-            headers: (0, workspace_header_1.withWorkspaceHeader)(headers),
+            headers: sent,
             body,
             ...(opts.signal ? { signal: opts.signal } : {}),
-        });
+        }), { method, headers: sent, signal: opts.signal });
+        lastRetryAfterMs = retryAfterMs;
+        return response;
     };
+    let lastRetryAfterMs;
     let res = await fetchWithCredential(cred);
     let brokerFailure = null;
     if (res.status === 401 && delegatedCli) {
@@ -271,6 +280,8 @@ async function apiFetch(pathOrUrl, opts = {}) {
         const error = new ApiFetchError(`HTTP ${res.status} ${res.statusText} — ${method} ${pathOrUrl}`, res.status, text, code, method, res.headers.get('x-request-id') || undefined);
         if (brokerFailure)
             error.brokerFailure = brokerFailure;
+        if (res.status === 429 && lastRetryAfterMs !== undefined)
+            error.retryAfterMs = lastRetryAfterMs;
         throw error;
     }
     // 204/205 carry no body by definition; an empty body has no content-type

package/dist/lib/command-hygiene.d.ts

@@ -26,6 +26,8 @@ export type CommandHygieneReport = {
         domains: number;
         budgetErrors: number;
     };
+    /** The verb rules the findings below are measured against (P8). */
+    namingGrammar: readonly string[];
     issues: CommandHygieneIssue[];
 };
 export declare function auditCommands({ rootDir, manifest, }: {
@@ -37,3 +39,14 @@ export declare function auditCommands({ rootDir, manifest, }: {
      */
     manifest?: CommandManifest;
 }): CommandHygieneReport;
+/**
+ * The domains an agent drives most. A missing description or `--json` output
+ * here is a build error (P10); elsewhere it stays a warning until that domain's
+ * offenders are fixed, so the gate can ratchet outward one domain at a time.
+ */
+export declare const ENFORCED_HYGIENE_DOMAINS: readonly ["tasks", "spaces", "projects"];
+/**
+ * The verb grammar `commands --audit` checks, stated once so a reader of the
+ * report sees the rule and not only the findings it produced.
+ */
+export declare const NAMING_GRAMMAR: readonly ["Verbs: list, show, create, update, delete, archive, unarchive, move. A reversible state flip is its own verb, never a flag on its inverse.", "Scope: a list verb takes its parent scope as an optional filter flag; a verb that cannot work without a scope says so in its description.", "Output: every command in tasks, spaces and projects takes --json and has a description (audit errors)."];

package/dist/lib/command-hygiene.js

@@ -33,6 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.NAMING_GRAMMAR = exports.ENFORCED_HYGIENE_DOMAINS = void 0;
 exports.auditCommands = auditCommands;
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
@@ -120,6 +121,32 @@ function auditCommands({ rootDir, manifest, }) {
                     });
                 }
             }
+            // Without a generated manifest (a source checkout, most CI jobs) the
+            // manifest rules below never run, so the P10 gate for tasks/spaces/projects
+            // would pass by not looking. Read the same two facts off the source.
+            if (!manifest && isEnforcedDomain(command)) {
+                // A spread of a shared flag set (`...paginatedExportFlags(...)`) may carry
+                // --json from another file; only the manifest can tell, so do not guess.
+                const spreadsSharedFlags = /\.\.\.[\w.]*Flags\b/.test(source);
+                if (!hasJson && !spreadsSharedFlags && isMachineRelevantCommand(command)) {
+                    issues.push({
+                        code: 'JSON_SUCCESS_OUTPUT_MISSING',
+                        severity: 'error',
+                        command,
+                        file: rel,
+                        message: 'Machine-relevant command has no --json success-output flag. Keep human-only commands intentional.',
+                    });
+                }
+                if (!/static (?:override )?description\s*=/.test(source)) {
+                    issues.push({
+                        code: 'COMMAND_DESCRIPTION_MISSING',
+                        severity: 'error',
+                        command,
+                        file: rel,
+                        message: 'Command is missing a description.',
+                    });
+                }
+            }
             if (hasFromJson && !hasJson) {
                 issues.push({
                     code: 'FROM_JSON_WITHOUT_JSON_OUTPUT',
@@ -153,7 +180,7 @@ function auditCommands({ rootDir, manifest, }) {
             if (!command?.description?.trim()) {
                 issues.push({
                     code: 'COMMAND_DESCRIPTION_MISSING',
-                    severity: 'warning',
+                    severity: isEnforcedDomain(id) ? 'error' : 'warning',
                     command: id,
                     message: 'Command is missing a description in the manifest.',
                 });
@@ -161,11 +188,22 @@ function auditCommands({ rootDir, manifest, }) {
             if (!hasJsonFlag(command?.flags) && isMachineRelevantCommand(id)) {
                 issues.push({
                     code: 'JSON_SUCCESS_OUTPUT_MISSING',
-                    severity: 'warning',
+                    severity: isEnforcedDomain(id) ? 'error' : 'warning',
                     command: id,
                     message: 'Machine-relevant command has no --json success-output flag. Keep human-only commands intentional.',
                 });
             }
+            // P8: a state flip is a verb (`archive` / `unarchive`), not a flag on its
+            // inverse. `spaces unarchive` follows the grammar; `tasks archive
+            // --unarchive` and `projects archive --unarchive` do not.
+            if (isEnforcedDomain(id) && hasFlag(command?.flags, 'unarchive')) {
+                issues.push({
+                    code: 'VERB_GRAMMAR_INVERSE_AS_FLAG',
+                    severity: 'warning',
+                    command: id,
+                    message: `Naming grammar: a state flip is its own verb (\`${id.replace(/:archive$/, ':unarchive').replace(/:/g, ' ')}\`), not --unarchive on the forward verb. Keep the flag as a deprecated alias when adding the verb.`,
+                });
+            }
         }
     }
     const errors = issues.filter((issue) => issue.severity === 'error').length;
@@ -190,6 +228,7 @@ function auditCommands({ rootDir, manifest, }) {
             domains: (0, usage_discovery_1.usageDomains)(manifestForCatalog).length,
             budgetErrors: usageBudgetIssues.length,
         },
+        namingGrammar: exports.NAMING_GRAMMAR,
         issues,
     };
 }
@@ -213,6 +252,27 @@ function commandIdFromRelativePath(relativePath) {
 function hasJsonFlag(flags) {
     return Boolean(flags && typeof flags === 'object' && 'json' in flags);
 }
+/**
+ * The domains an agent drives most. A missing description or `--json` output
+ * here is a build error (P10); elsewhere it stays a warning until that domain's
+ * offenders are fixed, so the gate can ratchet outward one domain at a time.
+ */
+exports.ENFORCED_HYGIENE_DOMAINS = ['tasks', 'spaces', 'projects'];
+function isEnforcedDomain(id) {
+    return exports.ENFORCED_HYGIENE_DOMAINS.some((domain) => id === domain || id.startsWith(`${domain}:`));
+}
+function hasFlag(flags, name) {
+    return Boolean(flags && typeof flags === 'object' && name in flags);
+}
+/**
+ * The verb grammar `commands --audit` checks, stated once so a reader of the
+ * report sees the rule and not only the findings it produced.
+ */
+exports.NAMING_GRAMMAR = [
+    'Verbs: list, show, create, update, delete, archive, unarchive, move. A reversible state flip is its own verb, never a flag on its inverse.',
+    'Scope: a list verb takes its parent scope as an optional filter flag; a verb that cannot work without a scope says so in its description.',
+    'Output: every command in tasks, spaces and projects takes --json and has a description (audit errors).',
+];
 function isMachineRelevantCommand(id) {
     return !(id === 'login' ||
         id === 'logout' ||

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

@@ -1,16 +1,10 @@
 import type { CommitmentDeliveryIntent, CommitmentExecutionReceipt, CommitmentExecutionReceiptQuarterlyMetricsResponse } 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;
 /**
  * `skrr commitments receipt-metrics <id>` — the closed-quarter rollup.

package/dist/lib/commitment-product.js

@@ -1,14 +1,10 @@
 "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.COMMITMENT_DELIVERY_CHOICES = void 0;
 exports.deliveryLabel = deliveryLabel;
 exports.deliveryInput = deliveryInput;
-exports.deliveryForProductMode = deliveryForProductMode;
 exports.renderExecutionReceipt = renderExecutionReceipt;
 exports.renderExecutionReceiptQuarterlyMetrics = renderExecutionReceiptQuarterlyMetrics;
-exports.COMMITMENT_PRODUCT_MODES = ['monitor', 'prepare', 'execute'];
 exports.COMMITMENT_DELIVERY_CHOICES = [
     'report-only',
     'local-patch',
@@ -16,20 +12,6 @@ exports.COMMITMENT_DELIVERY_CHOICES = [
     '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',
@@ -51,19 +33,8 @@ function deliveryInput(mode, options = {}) {
         ...(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)}`);
     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}` : ''}`);

package/dist/lib/commitments.d.ts

@@ -16,7 +16,7 @@
  * 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, COMMITMENT_AUTONOMY_MODES, COMMITMENT_EXECUTION_ISOLATION_MODES, COMMITMENT_STATUSES, COMMITMENT_KIND_VALUES } from '@skrr-ai/data-provider';
+import { COMMITMENT_WATCHED_SOURCES, COMMITMENT_TEMPLATE_IDS, COMMITMENT_CADENCE_MODES, COMMITMENT_CADENCE_TIME_PATTERN, COMMITMENT_CADENCE_MAX_TIMES, COMMITMENT_EXECUTION_ISOLATION_MODES, COMMITMENT_STATUSES, COMMITMENT_KIND_VALUES } from '@skrr-ai/data-provider';
 import type { CommitmentCheck, CommitmentChecksResponse, Commitment, CommitmentActionProposal, CommitmentListResponse, CommitmentPlanResponse, CommitmentStatusResponse, CommitmentWorkLink, CommitmentExecutionReceiptListResponse, CommitmentExecutionReceiptQuarterlyMetricsResponse, CommitmentCapabilitySource, CommitmentDeliveryPatchResponse, CommitmentDeliveryBundleResponse, CommitmentCyclesResponse, CommitmentExplanationResponse, CommitmentRunPermissions } 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, COMMITMENT_STATUSES, COMMITMENT_KIND_VALUES, };
@@ -24,19 +24,6 @@ export type { CommitmentCheck, CommitmentChecksResponse, Commitment, CommitmentA
 /** 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")[];
-/**
- * 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
@@ -212,8 +199,7 @@ export declare const commitmentPackApi: {
     plan: (body: Record<string, unknown>) => Promise<CommitmentPackPlanResponse>;
     bind: (body: Record<string, unknown>) => Promise<CommitmentPackBindResponse>;
     preflight: (id: string, nextRunCount?: number) => Promise<CommitmentPackPreflightResponse>;
-    shadow: (id: string) => Promise<CommitmentPackLifecycleResponse>;
-    promote: (id: string) => Promise<CommitmentPackLifecycleResponse>;
+    activate: (id: string) => Promise<CommitmentPackLifecycleResponse>;
 };
 export declare const commitmentApi: {
     /**
@@ -320,8 +306,6 @@ export declare const commitmentApi: {
     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, query?: {
         limit?: number;
@@ -445,6 +429,11 @@ export declare const commitmentApi: {
         status?: string;
         cursor?: string;
     }) => Promise<CommitmentListPage>;
+    evaluations: (id: string, query?: {
+        limit?: number;
+    }) => Promise<CommitmentListPage>;
+    createEvaluation: (id: string, body: Record<string, unknown>) => Promise<Record<string, unknown>>;
+    retryEvaluationLearning: (id: string, scheduleId: string) => Promise<Record<string, unknown>>;
     observations: (id: string, query?: {
         limit?: number;
         declaredOnly?: boolean;
@@ -457,7 +446,7 @@ export declare const commitmentApi: {
     /** Bounded, named corrections — never a free-form contract edit. */
     remediate: (id: string, body: Record<string, unknown>) => Promise<Record<string, unknown>>;
     /** Approve/reject an Agent-proposed cadence change the server parked. */
-    decideAutonomyRequest: (id: string, requestId: string, approved: boolean) => Promise<Record<string, unknown>>;
+    decideCadenceRequest: (id: string, requestId: string, approved: boolean) => Promise<Record<string, unknown>>;
     linkGoal: (id: string, goalId: string) => Promise<Record<string, unknown>>;
     unlinkGoal: (id: string, goalId: string) => Promise<Record<string, unknown>>;
 };
@@ -550,9 +539,6 @@ export interface CommitmentCostWindow {
 }
 /** Shape of `GET /:id/wake-capabilities`. */
 export interface CommitmentWakeCapabilities {
-    workPromotionModel?: 'monitor_prepare_execute_v1';
-    mode: string;
-    selectedCapabilityIds?: string[];
     eligibleCapabilities: Array<{
         id: string;
         kind?: string;
@@ -571,7 +557,7 @@ export declare const COMMITMENT_FEEDBACK_KINDS: readonly ["useful", "noisy", "wr
  * the "this commitment is misbehaving, calm it down" lever, and a free-form
  * contract edit would defeat the point of having one.
  */
-export declare const COMMITMENT_REMEDIATION_ACTIONS: readonly ["pause_commitment", "mute_user_nudges", "reduce_nudge_frequency", "tighten_policy", "mark_noop"];
+export declare const COMMITMENT_REMEDIATION_ACTIONS: readonly ["pause_commitment", "mute_user_nudges", "reduce_nudge_frequency", "mark_noop"];
 /** The only keys `createBodySchema` (a `z.strictObject`) accepts. */
 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"];
 /**
@@ -690,23 +676,6 @@ export declare function buildSuccessCriteria(labels: string[], opts?: {
 }): SuccessCriterionInput[];
 export declare function cadenceLabel(commitment: CommitmentView): string;
 export declare function renderCommitmentList(commitments: CommitmentView[], log: (line: string) => void): void;
-/**
- * The autonomy mode a check ACTUALLY ran at, read from its policy trace
- * (OSK-4881).
- *
- * 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.
- */
-export declare function effectiveAutonomyMode(check?: {
-    decision?: {
-        policyTrace?: Array<Record<string, unknown>>;
-    } | null;
-} | null): string | undefined;
 /**
  * A `commitment_standstill` policyTrace entry, extracted from the latest
  * check's decision. The arbiter appends it whenever a quiet posture is the
@@ -737,11 +706,6 @@ export declare function extractStandstillFromCheck(check?: {
  *
  * Exported for tests.
  */
-export declare function describeAutonomyLine(commitment: CommitmentView, latestCheck?: {
-    decision?: {
-        policyTrace?: Array<Record<string, unknown>>;
-    } | null;
-} | null): string;
 /**
  * One-line rendering of `commitment.executorBlocked` — the B4/A7 signal that
  * the executor's targets are all unusable: `{reason:'quota'|'offline'|'waiting_for_machine', until?,