@skrr-ai/cli 0.1.116 → 0.1.117

package/dist/base-command.d.ts

@@ -477,6 +477,12 @@ export interface ParsedGlobals {
     workspace?: string;
 }
 export declare function parseGlobalFlags(argv: readonly string[]): ParsedGlobals;
+/**
+ * The typed refusal code an API error body carries, wherever this codebase has
+ * put it: canonical `code` (or `errorType`) first, then the legacy
+ * code-spelled-in-`error` shape.
+ */
+export declare function refusalCodeOf(body: Record<string, unknown> | null | undefined): string | undefined;
 /**
  * The typed `code` and message an API refusal carried, read the way
  * `handleApiError` reads them, for a command that answers one code itself
@@ -621,6 +627,21 @@ export declare function errorBodyMessage(body: unknown): string | undefined;
  * from there, so no caller reads two places. A lifted `details.message` cannot replace it.
  */
 export declare function envelopeDetails(body: Record<string, unknown> | null | undefined): unknown;
+type UnsupportedFlagRemedyTarget = {
+    command: string;
+    flags: readonly string[];
+};
+type UnsupportedFlagRemedy = {
+    fix: string;
+    targets: readonly UnsupportedFlagRemedyTarget[];
+};
+/**
+ * Specific corrections for habitual flags that look plausible but do not belong
+ * to the command that received them. Keep the replacement command and every
+ * flag it names explicit: the spec checks this table against the shipped
+ * manifest, so a useful refusal cannot slowly point at a removed form.
+ */
+export declare const UNSUPPORTED_FLAG_REMEDIES: Readonly<Record<string, Readonly<Record<string, UnsupportedFlagRemedy>>>>;
 /**
  * The hint for a `Nonexistent flags:` refusal, or null. Two cases:
  *  - a flag retired from THIS command, which this command does not define again: where it went;

package/dist/base-command.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Flags = exports.BaseCommand = exports.resolveProfileFromArgv = void 0;
+exports.Flags = exports.UNSUPPORTED_FLAG_REMEDIES = exports.BaseCommand = exports.resolveProfileFromArgv = void 0;
 exports.assigneePayloadNeedsResolution = assigneePayloadNeedsResolution;
 exports.parseGlobalFlags = parseGlobalFlags;
+exports.refusalCodeOf = refusalCodeOf;
 exports.apiRefusal = apiRefusal;
 exports.withSubject = withSubject;
 exports.describeHarnessUnavailable = describeHarnessUnavailable;
@@ -31,6 +32,7 @@ const json_mode_1 = require("./lib/json-mode");
 const failed_lookup_1 = require("./lib/failed-lookup");
 const internal_id_1 = require("./lib/internal-id");
 const http_error_1 = require("./lib/http-error");
+const guide_pointer_1 = require("./lib/guide-pointer");
 // Re-exported from its home in `lib/keychain`, beside the other profile
 // functions. It lived here while `init()` was its only caller; a lib module
 // needing it would otherwise have to import the command base class, and with
@@ -1279,6 +1281,10 @@ class BaseCommand extends core_1.Command {
         if (retiredHint) {
             err.message = `${err.message}\n\n${retiredHint}`;
         }
+        const unsupportedFlagHint = unsupportedFlagRemedyForMessage(err.message || '', this.id);
+        if (unsupportedFlagHint && !err.message.includes(unsupportedFlagHint.fix)) {
+            err.message = `${err.message}\n\n${unsupportedFlagHint.fix}`;
+        }
         // Sibling domains spell one lifecycle differently (`in_progress` for a
         // space, `active` for a goal), and oclif's enum refusal named neither the
         // difference nor the value to use (OSK-9735).
@@ -1296,13 +1302,19 @@ class BaseCommand extends core_1.Command {
         const httpBody = (0, http_error_1.httpBodyOf)(err);
         const httpStatus = (0, http_error_1.httpStatusOf)(err);
         if (httpBody && httpStatus !== undefined && httpStatus >= 400) {
-            const bodyCode = stringProp(httpBody, 'code') || stringProp(httpBody, 'errorType');
+            const bodyCode = refusalCodeOf(httpBody);
             const bodyMessage = stringProp(httpBody, 'message') || stringProp(httpBody, 'error');
             err.code ??= bodyCode || `HTTP_${httpStatus}`;
             if (bodyMessage && !err.message.includes(bodyMessage)) {
                 err.message = `${bodyMessage} — ${err.message}`;
             }
         }
+        // A refusal a guide section explains points the reader at it (OSK-17977):
+        // text gets a `Guide:` line as the message's last line, --json a `guide`
+        // field. Resolved offline from the bundled registry — never a request on
+        // an already-failing path — and absent for a code nothing explains.
+        const code = err.code ?? parseCliErrorCode(err);
+        const guide = (0, guide_pointer_1.agentGuidePointerFor)(code);
         if (this.wantsJsonOutput()) {
             const exit = err.exitCode ?? err.oclif?.exit ?? 1;
             process.exitCode = exit;
@@ -1310,17 +1322,23 @@ class BaseCommand extends core_1.Command {
             this.log(JSON.stringify(this.jsonOperationError({
                 ok: false,
                 error: {
-                    code: err.code ?? parseCliErrorCode(err),
+                    code,
                     message: err.message || String(err),
                     retryable: err.retryable ?? false,
                     command: this.id ?? null,
                     server: this.cliConfig?.baseURL ?? null,
                     ...parseErrorRemedy(err, this.id, this.config?.bin),
+                    ...(guide ? { guide } : {}),
                     ...(details ? { details } : {}),
                 },
             }), null, 2));
             return;
         }
+        if (guide) {
+            const line = (0, guide_pointer_1.agentGuidePointerLine)(guide);
+            if (!err.message.includes(line))
+                err.message = `${err.message}\n\n${line}`;
+        }
         return super.catch(err);
     }
     error(input, options = {}) {
@@ -1390,7 +1408,7 @@ class BaseCommand extends core_1.Command {
             this.lastApiRequestId = e.requestId;
             this.lastRetryAfterMs = e.retryAfterMs;
             const body = parseErrorBody(e.body);
-            const bodyCode = stringProp(body, 'code') || stringProp(body, 'errorType');
+            const bodyCode = refusalCodeOf(body);
             // A body path the person never typed is read back as the flag that wrote it (OSK-15313).
             // The server answers every error with `message` (OSK-16986); `errorBodyMessage` keeps the
             // older `error` string and the nested `/v1` shape as fallbacks for a server without it.
@@ -1987,6 +2005,9 @@ class BaseCommand extends core_1.Command {
     /** E6: the server's `Retry-After` for the refused call, when it was a 429. */
     lastRetryAfterMs;
     writeJsonCliError({ message, code, status, exit, retryable, details, requestId, }) {
+        // The guide section that explains this code, when one does — the `guide`
+        // half of the `Guide:` line the text path appends.
+        const guide = (0, guide_pointer_1.agentGuidePointerFor)(code);
         this.log(JSON.stringify(this.jsonOperationError({
             ok: false,
             error: {
@@ -1996,6 +2017,7 @@ class BaseCommand extends core_1.Command {
                 retryable,
                 command: this.id ?? null,
                 server: this.cliConfig?.baseURL ?? null,
+                ...(guide ? { guide } : {}),
                 // The id the server logged this refusal against. Without it, a
                 // refused call can only be matched to a log line by guessing from
                 // timestamps — which, with several clients on one account,
@@ -2105,6 +2127,27 @@ function stringProp(obj, key) {
     const value = obj?.[key];
     return typeof value === 'string' && value.trim() ? value.trim() : undefined;
 }
+/**
+ * Lower_snake is how the scoped-Memory REST surface (and older routes like it)
+ * spelled a refusal code in `error`, where the canonical envelope expects human
+ * text (OSK-18250). A released server still answers that way, so a code-shaped
+ * `error` is read as the code — reported in the upper-case spelling the code
+ * vocabulary and `parseMemoryApiError` already use. Anything else in `error`
+ * (a sentence, a bare word) is text and stays out of `code`.
+ */
+const LEGACY_ERROR_FIELD_CODE = /^[a-z][a-z0-9]*(?:_[a-z0-9]+)+$/;
+/**
+ * The typed refusal code an API error body carries, wherever this codebase has
+ * put it: canonical `code` (or `errorType`) first, then the legacy
+ * code-spelled-in-`error` shape.
+ */
+function refusalCodeOf(body) {
+    const direct = stringProp(body ?? null, 'code') || stringProp(body ?? null, 'errorType');
+    if (direct)
+        return direct;
+    const legacy = stringProp(body ?? null, 'error');
+    return legacy && LEGACY_ERROR_FIELD_CODE.test(legacy) ? legacy.toUpperCase() : undefined;
+}
 /**
  * The typed `code` and message an API refusal carried, read the way
  * `handleApiError` reads them, for a command that answers one code itself
@@ -2115,7 +2158,7 @@ function apiRefusal(err) {
         return {};
     const body = parseErrorBody(err.body);
     return {
-        code: stringProp(body, 'code') || stringProp(body, 'errorType'),
+        code: refusalCodeOf(body),
         message: errorBodyMessage(body),
         ...(body ? { body } : {}),
     };
@@ -2432,7 +2475,7 @@ function describeDaemonScopedCredential(bin, scope = 'daemon', source) {
 function isTypedServerRefusal(body) {
     if (!body || typeof body !== 'object')
         return false;
-    const code = stringProp(body, 'code') || stringProp(body, 'errorType');
+    const code = refusalCodeOf(body);
     if (!code)
         return false;
     return (typeof body.cause === 'string' || typeof body.remedy === 'string' || body.retryable === false);
@@ -2455,7 +2498,7 @@ function isTypedServerRefusal(body) {
 function isApplicationCodedUnavailable(status, body) {
     if (status !== 502 && status !== 503 && status !== 504)
         return false;
-    return Boolean(stringProp(body, 'code') || stringProp(body, 'errorType'));
+    return Boolean(refusalCodeOf(body));
 }
 /**
  * The sentence `redactServerErrorResponses` substitutes for a 5xx message in
@@ -2470,7 +2513,7 @@ function isRetryableFailure(status, body) {
     const declared = body?.retryable;
     if (typeof declared === 'boolean')
         return declared;
-    const code = stringProp(body, 'code') || stringProp(body, 'errorType');
+    const code = refusalCodeOf(body);
     if (code && TERMINAL_ERROR_CODES.has(code))
         return false;
     return status === 408 || status === 425 || status === 429 || !!(status && status >= 500);
@@ -2600,6 +2643,41 @@ function envelopeDetails(body) {
  * "--outcome is now --summary" (OSK-16494). A rename is a fact about one command.
  */
 const RETIRED_FLAG_COMMANDS = new Set(['tasks:complete', 'tasks:result:submit']);
+/**
+ * Specific corrections for habitual flags that look plausible but do not belong
+ * to the command that received them. Keep the replacement command and every
+ * flag it names explicit: the spec checks this table against the shipped
+ * manifest, so a useful refusal cannot slowly point at a removed form.
+ */
+exports.UNSUPPORTED_FLAG_REMEDIES = {
+    'spaces:create': {
+        agent: {
+            fix: 'A Space is created for the authenticated caller. Add an Agent after creation with ' +
+                '`skrr spaces members add <space-id> --agent <agent-id>`.',
+            targets: [{ command: 'spaces:members:add', flags: ['agent'] }],
+        },
+    },
+    'tasks:create': {
+        agent: {
+            fix: 'Assign the Task with `--assignee-agent <agent-id>`; `--agent` does not set Task assignees.',
+            targets: [{ command: 'tasks:create', flags: ['assignee-agent'] }],
+        },
+    },
+    'followups:checkin': {
+        check: {
+            fix: 'A check-in is only a timed return. To check a condition, use ' +
+                '`skrr followups watch --check <check> --success <condition> --abort <condition> --wait <kind>`.',
+            targets: [{ command: 'followups:watch', flags: ['check', 'success', 'abort', 'wait'] }],
+        },
+    },
+};
+function unsupportedFlagRemedy(commandId, flag) {
+    return commandId ? exports.UNSUPPORTED_FLAG_REMEDIES[commandId]?.[flag] : undefined;
+}
+function unsupportedFlagRemedyForMessage(message, commandId) {
+    const match = /Nonexistent flag[s]?:?\s*(-{1,2}[\w-]+)/i.exec(message);
+    return match ? unsupportedFlagRemedy(commandId, match[1].replace(/^-+/, '')) : undefined;
+}
 /**
  * The hint for a `Nonexistent flags:` refusal, or null. Two cases:
  *  - a flag retired from THIS command, which this command does not define again: where it went;
@@ -2651,6 +2729,15 @@ function parseErrorRemedy(err, commandId, bin = 'skrr') {
         };
     }
     const nonexistent = /Nonexistent flag[s]?:?\s*(-{1,2}[\w-]+)(?:[ =]([^\s,][^,\n]*))?/i.exec(message);
+    const unsupportedFlagHint = nonexistent
+        ? unsupportedFlagRemedy(commandId, nonexistent[1].replace(/^-+/, ''))
+        : undefined;
+    if (unsupportedFlagHint) {
+        return {
+            flag: nonexistent[1].replace(/^-+/, ''),
+            fix: unsupportedFlagHint.fix,
+        };
+    }
     if (nonexistent?.[2]) {
         // `"--outcome failed"` arrived as ONE argument: the flag may well exist, so
         // "remove it" would be wrong advice. Same case retiredFlagHint explains in text.

package/dist/commands/actions/install.d.ts

@@ -8,6 +8,7 @@ export default class ActionsInstall extends BaseCommand {
     static flags: {
         agent: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
         json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;
 }

package/dist/commands/actions/install.js

@@ -3,11 +3,13 @@ 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");
+const prompt_1 = require("../../lib/prompt");
 const agent_actions_1 = require("../../lib/agent-actions");
 class ActionsInstall extends base_command_1.BaseCommand {
-    static description = 'Install an action listing into an agent';
+    static description = 'Install an action listing into an agent. A paid listing shows its price and asks you to confirm first.';
     static examples = [
         '<%= config.bin %> actions install <listing-id> --agent <agent-id>',
+        '<%= config.bin %> actions install <listing-id> --agent <agent-id> --yes',
         '<%= config.bin %> actions install <listing-id> --agent <agent-id> --json',
     ];
     static args = {
@@ -16,15 +18,58 @@ class ActionsInstall extends base_command_1.BaseCommand {
     static flags = {
         agent: core_1.Flags.string({ description: 'Target agent ID', required: true }),
         json: core_1.Flags.boolean({ description: 'Output install response as JSON' }),
+        yes: core_1.Flags.boolean({
+            char: 'y',
+            description: 'Confirm a paid install without prompting. The price is still printed.',
+        }),
     };
     async run() {
         this.requireAuth();
         const { args, flags } = await this.parse(ActionsInstall);
+        // What installing would charge NOW, read before the install sends it.
+        // A paid listing shows its price and asks first; the install then pins
+        // what was shown, so a listing whose price moved in between is refused
+        // rather than charged (OSK-18042 — same convention as `store install`,
+        // OSK-12240).
+        let listing;
+        try {
+            listing = await data_provider_1.dataService.getActionListing(args.id);
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+        let charge = Number(listing.price) || 0;
+        if (charge > 0 && String(listing.author) === (await this.resolveCurrentUserId())) {
+            // Installing a listing you published is never charged — pin what the
+            // server would actually charge, not the sticker price.
+            charge = 0;
+        }
+        if (charge > 0) {
+            const name = listing.displayName || listing.name || args.id;
+            // Printed before any prompt and even with --yes, so a scripted purchase
+            // still leaves the price it agreed to in its own output.
+            this.logToStderr(`${name} is a paid action.`);
+            this.logToStderr(`  Price: ${(0, data_provider_1.formatStoreAcquisitionPrice)(charge)} USD`);
+            if (listing.offerVersionId) {
+                this.logToStderr(`  Offer: ${listing.offerVersionId}`);
+            }
+            const confirmed = await (0, prompt_1.confirmDestructive)(`Buy ${name} for ${(0, data_provider_1.formatStoreAcquisitionPrice)(charge)}?`, flags.yes).catch((err) => this.error(err.message, { exit: err.exit ?? 1 }));
+            if (!confirmed) {
+                this.log('Cancelled. Nothing was bought.');
+                return;
+            }
+        }
         let response;
         try {
             response = await data_provider_1.dataService.installActionListing({
                 listingId: args.id,
                 targetAgentId: flags.agent,
+                // Pin what the person was shown: the charge always, the offer when
+                // there is one to charge under.
+                expectedPrice: charge,
+                ...(charge > 0 && listing.offerVersionId
+                    ? { expectedOfferVersionId: listing.offerVersionId }
+                    : {}),
             });
         }
         catch (err) {

package/dist/commands/commitments/create.d.ts

@@ -1,4 +1,5 @@
 import { BaseCommand } from '../../base-command';
+import { type AgentGuidePointer } from '../../lib/guide-pointer';
 /**
  * True only when the authored create body can materialize at least one event
  * binding. A polling-only source must not make `--event-driven` look successful
@@ -26,13 +27,30 @@ export declare function createCadenceFromFlags({ eventDriven, cadence: cadenceIn
  * be said out loud at the CLI boundary; otherwise a successful create response
  * reads like the requested autonomy is live when something else is running.
  */
+/**
+ * A refused `--activate` leaves a draft, and the draft's id is the answer the
+ * caller needs — so the refusal is reported on the result, never thrown over
+ * it. `{code, reason, fix}` mirrors the MCP surface's refusal; `guide` points
+ * at the section that explains the code when one does (resolved offline).
+ */
+export declare function commitmentActivationRefusal(err: unknown, { id, bin }: {
+    id: string;
+    bin: string;
+}): {
+    code: string;
+    reason: string;
+    fix: string;
+    guide?: AgentGuidePointer;
+};
 /**
  * `skrr commitments create` — author a durable commitment contract.
  *
  * A Commitment is a standing commitment ("hold this outcome true"), watched on a
  * cadence by its own control loop — not a task. Create it `draft` first and
- * activate once the contract reads right; an `active` commitment with a non-manual
- * cadence starts spending compute on every check.
+ * activate once the contract reads right — or pass `--activate` to turn it on
+ * in the same call (the same resume + Preflight boundary `commitments resume`
+ * runs; a refusal keeps the draft and says why). An `active` commitment with a
+ * non-manual cadence starts spending compute on every check.
  *
  * For a natural-language draft instead of flags, use `skrr commitments plan`.
  */
@@ -51,6 +69,7 @@ export default class CommitmentsCreate extends BaseCommand {
         'agent-directive-file': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         goal: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         status: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        activate: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         deadline: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         criterion: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
         evaluator: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;

package/dist/commands/commitments/create.js

@@ -3,9 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.hasEventCapableWatchedSource = hasEventCapableWatchedSource;
 exports.assertEventDrivenWatchedSource = assertEventDrivenWatchedSource;
 exports.createCadenceFromFlags = createCadenceFromFlags;
+exports.commitmentActivationRefusal = commitmentActivationRefusal;
 const data_provider_1 = require("@skrr-ai/data-provider");
 const core_1 = require("@oclif/core");
 const base_command_1 = require("../../base-command");
+const guide_pointer_1 = require("../../lib/guide-pointer");
 const web_url_1 = require("../../lib/web-url");
 const prompt_1 = require("../../lib/prompt");
 const triggers_1 = require("../../lib/triggers");
@@ -145,13 +147,37 @@ function createCadenceFromFlags({ eventDriven, cadence: cadenceInput, cadenceMod
  * be said out loud at the CLI boundary; otherwise a successful create response
  * reads like the requested autonomy is live when something else is running.
  */
+/**
+ * A refused `--activate` leaves a draft, and the draft's id is the answer the
+ * caller needs — so the refusal is reported on the result, never thrown over
+ * it. `{code, reason, fix}` mirrors the MCP surface's refusal; `guide` points
+ * at the section that explains the code when one does (resolved offline).
+ */
+function commitmentActivationRefusal(err, { id, bin }) {
+    const refusal = (0, base_command_1.apiRefusal)(err);
+    const errorField = refusal.body?.error;
+    const code = refusal.code ||
+        (typeof errorField === 'string' && /^[A-Za-z][A-Za-z0-9_]*$/.test(errorField)
+            ? errorField
+            : undefined) ||
+        'COMMITMENT_ACTIVATION_REFUSED';
+    const guide = (0, guide_pointer_1.agentGuidePointerFor)(code);
+    return {
+        code,
+        reason: refusal.message || (err instanceof Error ? err.message : 'Activation was refused.'),
+        fix: (0, data_provider_1.describeCommitmentActivationFix)(code === 'COMMITMENT_ACTIVATION_REFUSED' ? undefined : code, { turnOn: `run \`${bin} commitments resume ${id}\`` }),
+        ...(guide ? { guide } : {}),
+    };
+}
 /**
  * `skrr commitments create` — author a durable commitment contract.
  *
  * A Commitment is a standing commitment ("hold this outcome true"), watched on a
  * cadence by its own control loop — not a task. Create it `draft` first and
- * activate once the contract reads right; an `active` commitment with a non-manual
- * cadence starts spending compute on every check.
+ * activate once the contract reads right — or pass `--activate` to turn it on
+ * in the same call (the same resume + Preflight boundary `commitments resume`
+ * runs; a refusal keeps the draft and says why). An `active` commitment with a
+ * non-manual cadence starts spending compute on every check.
  *
  * For a natural-language draft instead of flags, use `skrr commitments plan`.
  */
@@ -159,7 +185,7 @@ class CommitmentsCreate extends base_command_1.BaseCommand {
     static description = 'Create a commitment (a durable agent contract). Its cadence is manual, an interval or daily clock times; ' +
         'it has no weekday, holiday, business-day or trading-calendar fields';
     static examples = [
-        '<%= config.bin %> commitments create --agent <agent-id> --title "Ship v2" --outcome "v2 is live for all users" --cadence 6h',
+        '<%= config.bin %> commitments create --agent <agent-id> --title "Ship v2" --outcome "v2 is live for all users" --cadence 6h --activate',
         '<%= config.bin %> commitments create --agent <agent-id> --title "Hiring loop" --outcome "Every candidate hears back in 48h" --watch tasks --watch email --cadence 12h',
         '<%= config.bin %> commitments create --agent <agent-id> --title "SLA" --outcome "p95 under 200ms" --criterion "p95 latency confirmed" --evaluator metric --measure <measure-id>',
         '<%= config.bin %> commitments create --agent <agent-id> --title "AWS cost watch" --outcome "Cost regressions are investigated" --agent-directive-file ./aws-cost-policy.md',
@@ -218,6 +244,11 @@ JSON
             description: 'Create as a draft (default); activate later with commitments resume',
             options: ['draft'],
         }),
+        activate: core_1.Flags.boolean({
+            description: 'Turn the commitment on right after creating it — the same resume + Preflight boundary ' +
+                "as `commitments resume`. A refused activation keeps the draft and reports the refusal's " +
+                'code, reason and fix.',
+        }),
         deadline: core_1.Flags.string({ description: 'ISO-8601 deadline for an `achieve` commitment' }),
         criterion: core_1.Flags.string({
             description: 'Success criterion label (repeatable). Evaluated manually unless --evaluator/--measure is set.',
@@ -457,17 +488,56 @@ JSON
         catch (err) {
             this.handleApiError(err);
         }
+        // `--activate` is the same resume + Preflight boundary `commitments
+        // resume` runs, composed onto the create so the caller gets one answer.
+        // A refusal is reported on the result — never thrown over the draft's id.
+        let activation = null;
+        if (flags.activate) {
+            try {
+                commitment = await commitments_1.commitmentApi.resume(String(commitment.id));
+                activation = { activated: true };
+            }
+            catch (err) {
+                activation = {
+                    activated: false,
+                    refusal: commitmentActivationRefusal(err, {
+                        id: String(commitment.id),
+                        bin: this.config.bin,
+                    }),
+                };
+                // Report the row as it now is: a failed materialization rolls the
+                // activation back to paused, and printing the create-time snapshot
+                // would claim "draft" of a paused Commitment.
+                try {
+                    const live = await commitments_1.commitmentApi.get(String(commitment.id));
+                    if (live?.commitment)
+                        commitment = live.commitment;
+                }
+                catch {
+                    /* the refusal is the news; the create-time row is the fallback */
+                }
+            }
+        }
         const warnings = (0, commitments_1.commitmentWriteWarnings)(commitment, { payload });
         if (flags.json) {
             this.log(JSON.stringify((0, web_url_1.withCommitmentUrl)(this.cliConfig.baseURL, {
                 ...commitment,
+                ...(activation ?? {}),
                 ...(warnings.length ? { warnings } : {}),
             }), null, 2));
             return;
         }
-        this.log('Created commitment:');
+        this.log(activation?.activated ? 'Created and activated commitment:' : 'Created commitment:');
         (0, commitments_1.renderCommitmentSummary)(commitment, (line) => this.log(line));
         (0, commitments_1.renderCommitmentWriteWarnings)(warnings, (line) => this.warn(line));
+        if (activation && !activation.activated) {
+            const { refusal } = activation;
+            this.warn(`Activation refused (${refusal.code}): ${refusal.reason}`);
+            if (refusal.fix)
+                this.warn(`Fix: ${refusal.fix}`);
+            if (refusal.guide)
+                this.warn(`Guide: ${refusal.guide.command}`);
+        }
     }
 }
 exports.default = CommitmentsCreate;

package/dist/commands/convos/recovery.js

@@ -7,7 +7,11 @@ class ConvosRecovery extends base_command_1.BaseCommand {
     static description = 'Inspect interrupted native work, continue once, or dismiss its recovery offer';
     static args = {
         id: core_1.Args.string({ description: 'Conversation ID', required: true, ignoreStdin: true }),
-        action: core_1.Args.string({ options: ['list', 'continue', 'dismiss'], default: 'list' }),
+        action: core_1.Args.string({
+            options: ['list', 'continue', 'dismiss'],
+            default: 'list',
+            ignoreStdin: true,
+        }),
     };
     static flags = {
         json: core_1.Flags.boolean({ description: 'Output JSON' }),
@@ -27,11 +31,15 @@ class ConvosRecovery extends base_command_1.BaseCommand {
         try {
             const path = `/api/convos/${encodeURIComponent(args.id)}/recovery`;
             if (args.action === 'continue') {
-                result = await (0, api_fetch_1.apiFetch)('/api/agentic/chat', { method: 'POST',
-                    body: { conversationId: args.id, recoveryOfferId: flags.offer } });
+                result = await (0, api_fetch_1.apiFetch)('/api/agentic/chat', {
+                    method: 'POST',
+                    body: { conversationId: args.id, recoveryOfferId: flags.offer },
+                });
             }
             else if (args.action === 'dismiss') {
-                result = await (0, api_fetch_1.apiFetch)(`${path}/${encodeURIComponent(flags.offer)}/dismiss`, { method: 'POST' });
+                result = await (0, api_fetch_1.apiFetch)(`${path}/${encodeURIComponent(flags.offer)}/dismiss`, {
+                    method: 'POST',
+                });
             }
             else {
                 result = await (0, api_fetch_1.apiFetch)(path);

package/dist/commands/followups/plans/list.js

@@ -34,7 +34,7 @@ class LookbackPlansList extends base_command_1.BaseCommand {
                 return;
             }
             if (!result.plans.length) {
-                this.log('No lookback plans.');
+                this.log((0, lookbackPlans_1.lookbackPlansEmptyMessage)(result.scope));
                 return;
             }
             for (const plan of result.plans)

package/dist/commands/guide.d.ts

@@ -0,0 +1,21 @@
+import { Command } from '@oclif/core';
+export default class Guide extends Command {
+    static baseFlags: {
+        bare: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        token: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        workspace: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        profile: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        raw: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    static description: string;
+    static args: {
+        id: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+        section: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        offline: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/commands/guide.js

@@ -0,0 +1,46 @@
+"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");
+const agent_guides_1 = require("../lib/agent-guides");
+// Documentation stays available when a daemon-issued Agent credential is
+// unavailable. Do not run BaseCommand's mandatory credential initialization.
+class Guide extends core_1.Command {
+    static baseFlags = base_command_1.BaseCommand.baseFlags;
+    static description = 'Read Skrr operation guides on demand';
+    static args = {
+        id: core_1.Args.string({ description: 'Guide id', ignoreStdin: true }),
+        section: core_1.Args.string({ description: 'Section id', ignoreStdin: true }),
+    };
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output the guide and source provenance as JSON' }),
+        offline: core_1.Flags.boolean({
+            description: 'Read the bundled release guides without checking credentials or the server',
+        }),
+    };
+    static examples = [
+        '<%= config.bin %> guide',
+        '<%= config.bin %> guide tasks',
+        '<%= config.bin %> guide tasks updates --offline',
+    ];
+    async run() {
+        const { args, flags } = await this.parse(Guide);
+        const request = {
+            ...(args.id ? { id: args.id } : {}),
+            ...(args.section ? { section: args.section } : {}),
+        };
+        const read = await (0, agent_guides_1.readAgentGuide)(request, flags);
+        if (!read.found)
+            return (0, agent_guides_1.writeAgentGuideMiss)(this, read.miss, flags.json);
+        if (flags.json) {
+            process.stdout.write((0, agent_guides_1.agentGuideJson)(read));
+            return;
+        }
+        const notice = (0, agent_guides_1.agentGuideFallbackNotice)(read);
+        if (notice)
+            process.stderr.write(`${notice}\n`);
+        process.stdout.write((0, data_provider_1.renderAgentGuideText)(read.response));
+    }
+}
+exports.default = Guide;