@skrr-ai/cli 0.1.47 → 0.1.48

package/dist/commands/commerce/trials/start.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../../../base-command");
+const commerce_1 = require("../../../lib/commerce");
+const commerce_command_1 = require("../../../lib/commerce-command");
+/**
+ * `skrr commerce trials start` — enrol in a trial.
+ *
+ * Enrols YOU. The server takes the subject from the credential and there is no
+ * flag for it, so this command cannot start a trial on somebody else's
+ * account — which is the only property here worth protecting.
+ *
+ * `--file` carries the optional conversion consent, a structured object with
+ * its own id and timestamp. Consent is exactly the kind of thing that must not
+ * be assembled from loose flags: it is a record of what somebody agreed to.
+ */
+class CommerceTrialsStart extends base_command_1.BaseCommand {
+    static description = 'Start a trial of an offer version, for the account you are signed in as.';
+    static examples = [
+        '<%= config.bin %> commerce trials start --offer-version <id>',
+        '<%= config.bin %> commerce trials start --offer-version <id> --file ./consent.json',
+    ];
+    static flags = {
+        'offer-version': core_1.Flags.string({
+            description: 'Offer version to trial',
+            required: true,
+        }),
+        'payment-method-evidence': core_1.Flags.string({
+            description: 'Payment method evidence id, when the offer requires one',
+        }),
+        file: core_1.Flags.string({
+            description: 'JSON with optional `conversionConsent`, or - for stdin',
+        }),
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { flags } = await this.parse(CommerceTrialsStart);
+        const extra = await (0, commerce_command_1.jsonBodyFrom)(this, flags.file, { required: false });
+        let result;
+        try {
+            result = await (0, commerce_1.startCommerceTrial)({
+                ...extra,
+                offerVersionId: flags['offer-version'],
+                ...(flags['payment-method-evidence']
+                    ? { paymentMethodEvidenceId: flags['payment-method-evidence'] }
+                    : {}),
+            });
+        }
+        catch (error) {
+            this.handleApiError(error);
+            return;
+        }
+        this.log(JSON.stringify(result, null, 2));
+    }
+}
+exports.default = CommerceTrialsStart;

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

@@ -0,0 +1,39 @@
+import { BaseCommand } from '../../base-command';
+import { type CommitmentAccountingReadout } from '../../lib/commitments';
+/**
+ * `skrr commitments accounting <id>` — the allowance-accounting SHADOW readout.
+ *
+ * Allowance accounting replaces "count the attempts" with "count what the
+ * attempts advanced", and it may only be activated once there is enough CLOSED
+ * evidence to derive the attempt multiplier. Until then the requested mode is
+ * held at `shadow` and nothing says so anywhere an operator can read — the
+ * workspace looks configured, and the behaviour is unchanged.
+ *
+ * This is that read: what the shadow window observed, what multiplier it
+ * derives, and — the field that matters — whether it can activate yet and what
+ * is blocking it.
+ *
+ * WORKSPACE-scoped despite taking a commitment id: the readout aggregates every
+ * closed daily metric in the commitment's workspace. `commitments cost` is the
+ * per-commitment spend question.
+ */
+export default class CommitmentsAccounting extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}
+/**
+ * Pure renderer for the accounting readout.
+ *
+ * `requestedMode` and `canActivate` are printed together because the gap
+ * between them IS the finding: a workspace that asked for `on` and reads
+ * `canActivate: false` is running on the old attempt accounting and has no
+ * other surface that says so.
+ */
+export declare function formatAccountingReadout(readout: CommitmentAccountingReadout): string[];

package/dist/commands/commitments/accounting.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatAccountingReadout = formatAccountingReadout;
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../../base-command");
+const commitments_1 = require("../../lib/commitments");
+/**
+ * `skrr commitments accounting <id>` — the allowance-accounting SHADOW readout.
+ *
+ * Allowance accounting replaces "count the attempts" with "count what the
+ * attempts advanced", and it may only be activated once there is enough CLOSED
+ * evidence to derive the attempt multiplier. Until then the requested mode is
+ * held at `shadow` and nothing says so anywhere an operator can read — the
+ * workspace looks configured, and the behaviour is unchanged.
+ *
+ * This is that read: what the shadow window observed, what multiplier it
+ * derives, and — the field that matters — whether it can activate yet and what
+ * is blocking it.
+ *
+ * WORKSPACE-scoped despite taking a commitment id: the readout aggregates every
+ * closed daily metric in the commitment's workspace. `commitments cost` is the
+ * per-commitment spend question.
+ */
+class CommitmentsAccounting extends base_command_1.BaseCommand {
+    static description = "Show the workspace's allowance-accounting shadow readout and whether it can activate";
+    static examples = [
+        '<%= config.bin %> commitments accounting obj_abc123',
+        '<%= config.bin %> commitments accounting obj_abc123 --json',
+    ];
+    static args = {
+        id: core_1.Args.string({ description: 'Commitment ID', required: true, ignoreStdin: true }),
+    };
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output the complete readout as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(CommitmentsAccounting);
+        let readout;
+        try {
+            readout = await commitments_1.commitmentApi.accountingReadout(args.id);
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+        if (flags.json) {
+            this.log(JSON.stringify(readout, null, 2));
+            return;
+        }
+        for (const line of formatAccountingReadout(readout))
+            this.log(line);
+    }
+}
+exports.default = CommitmentsAccounting;
+/**
+ * Pure renderer for the accounting readout.
+ *
+ * `requestedMode` and `canActivate` are printed together because the gap
+ * between them IS the finding: a workspace that asked for `on` and reads
+ * `canActivate: false` is running on the old attempt accounting and has no
+ * other surface that says so.
+ */
+function formatAccountingReadout(readout) {
+    const requested = readout.requestedMode ?? 'off';
+    const canActivate = readout.canActivate === true;
+    const lines = [
+        'Allowance accounting (workspace shadow readout)',
+        '',
+        `Requested mode:  ${requested}`,
+        `Can activate:    ${canActivate ? 'yes' : 'no'}`,
+    ];
+    if (!canActivate && readout.activationBlocker) {
+        lines.push(`Blocked by:      ${readout.activationBlocker}`);
+    }
+    if (requested === 'on' && !canActivate) {
+        // Say the consequence, not just the state. "Held at shadow" is the fact an
+        // operator needs; "canActivate: false" is the fact the server reports.
+        lines.push('Effective mode:  shadow — the requested mode is withheld until evidence closes.');
+    }
+    lines.push('');
+    lines.push(`Window:          ${Number(readout.evidenceDays || 0)} of ${Number(readout.windowDays || 0)} closed day(s)`);
+    lines.push(`Source:          ${readout.source ?? '-'}`);
+    lines.push('');
+    lines.push(`Attempts:        ${Number(readout.attempts || 0)}`);
+    // These two count different units — `advancements` is advancing CHECKS while
+    // `netAdvancements` is advancement KIND ENTRIES (one check can mint several).
+    // Rendered as "4 vs 5" without the labels, they read as a contradiction.
+    lines.push(`Advancing checks: ${Number(readout.advancements || 0)}`);
+    lines.push(`  advancement kinds, net of self-minted: ${Number(readout.netAdvancements || 0)}`);
+    lines.push(`Divergence:      ${Number(readout.allowanceAttemptDivergence || 0)}`);
+    // Same attribution caveat as `commitments cost`: a bare dollar figure lets
+    // a priced window and an unpriced one read alike (OSK-10940).
+    const costStatus = readout.costStatus ?? 'not_applicable';
+    const costCaveat = {
+        reported: 'every run reported a cost',
+        partial: 'some runs reported no cost — the total is a FLOOR',
+        unavailable: 'no run reported a cost — the total is meaningless',
+        not_applicable: 'no closed runs in the window',
+    };
+    lines.push(`Window cost:     $${(Number(readout.costUsdMicros || 0) / 1_000_000).toFixed(4)}` +
+        ` — ${costStatus}: ${costCaveat[costStatus] ?? 'unrecognized cost status'}` +
+        ` (${Number(readout.costReportedRunCount || 0)} of ${Number(readout.costRunCount || 0)} runs priced)`);
+    const multiplier = readout.recommendedAttemptMultiplier;
+    lines.push('');
+    lines.push(`Attempt multiplier: ${multiplier == null ? 'not derivable yet' : multiplier}` +
+        (readout.multiplierDerivation ? ` — ${readout.multiplierDerivation}` : ''));
+    const none = readout.noneByReason ?? {};
+    const reasons = Object.entries(none);
+    if (reasons.length > 0) {
+        lines.push('');
+        lines.push('Checks that advanced nothing, by reason:');
+        for (const [reason, count] of reasons)
+            lines.push(`  ${reason}: ${Number(count || 0)}`);
+    }
+    return lines;
+}

package/dist/commands/commitments/action-history.d.ts

@@ -16,6 +16,7 @@ export default class CommitmentsActionHistory extends BaseCommand {
     static flags: {
         json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         limit: import("@oclif/core/lib/interfaces").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        cursor: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
     };
     run(): Promise<void>;
 }

package/dist/commands/commitments/action-history.js

@@ -23,18 +23,25 @@ class CommitmentsActionHistory extends base_command_1.BaseCommand {
     static flags = {
         json: core_1.Flags.boolean({ description: 'Output as JSON' }),
         limit: core_1.Flags.integer({ description: 'Max rows', min: 1, max: 200 }),
+        cursor: core_1.Flags.string({
+            description: 'Continue from the next_cursor emitted by a previous page',
+        }),
     };
     async run() {
         this.requireAuth();
         const { args, flags } = await this.parse(CommitmentsActionHistory);
         let response;
         try {
-            response = await commitments_1.commitmentApi.actionHistory(args.commitmentId, flags.limit);
+            response = await commitments_1.commitmentApi.actionHistory(args.commitmentId, {
+                limit: flags.limit,
+                cursor: flags.cursor,
+            });
         }
         catch (err) {
             this.handleApiError(err);
         }
         this.log(JSON.stringify(response, null, 2));
+        (0, commitments_1.renderListPageHint)(response, (line) => this.log(line));
     }
 }
 exports.default = CommitmentsActionHistory;

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

@@ -7,6 +7,7 @@ export default class CommitmentsCase extends BaseCommand {
     };
     static flags: {
         json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        entries: import("@oclif/core/lib/interfaces").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
     };
     run(): Promise<void>;
 }

package/dist/commands/commitments/case.js

@@ -9,10 +9,17 @@ class CommitmentsCase extends base_command_1.BaseCommand {
         commitmentId: core_1.Args.string({ ignoreStdin: true, description: 'Commitment ID', required: true }),
         caseId: core_1.Args.string({ ignoreStdin: true, description: 'Case ID', required: true }),
     };
-    static flags = { json: core_1.Flags.boolean({ description: 'Output as JSON' }) };
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output the full case document as JSON' }),
+        entries: core_1.Flags.integer({
+            description: 'Latest facts and receipts to show (the full document is --json)',
+            min: 1,
+            max: 100,
+        }),
+    };
     async run() {
         this.requireAuth();
-        const { args } = await this.parse(CommitmentsCase);
+        const { args, flags } = await this.parse(CommitmentsCase);
         let result;
         try {
             result = await commitments_1.commitmentApi.caseDetail(args.commitmentId, args.caseId);
@@ -20,7 +27,16 @@ class CommitmentsCase extends base_command_1.BaseCommand {
         catch (error) {
             this.handleApiError(error);
         }
-        this.log(JSON.stringify(result, null, 2));
+        if (flags.json) {
+            this.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        // A case document has no size bound — 93k lines was observed — so the
+        // human view is a digest with the most recent entries, and --json stays
+        // the opt-in for the full document (OSK-10952).
+        (0, commitments_1.renderCommitmentCaseDetail)(result, (line) => this.log(line), {
+            maxEntries: flags.entries ?? 10,
+        });
     }
 }
 exports.default = CommitmentsCase;

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

@@ -8,6 +8,7 @@ export default class CommitmentsCases extends BaseCommand {
         json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         limit: import("@oclif/core/lib/interfaces").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         status: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        cursor: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
     };
     run(): Promise<void>;
 }

package/dist/commands/commitments/cases.js

@@ -12,6 +12,9 @@ class CommitmentsCases extends base_command_1.BaseCommand {
         json: core_1.Flags.boolean({ description: 'Output as JSON' }),
         limit: core_1.Flags.integer({ description: 'Cases to return (1..200)', min: 1, max: 200 }),
         status: core_1.Flags.string({ description: 'Case lifecycle status to include' }),
+        cursor: core_1.Flags.string({
+            description: 'Continue from the next_cursor emitted by a previous page',
+        }),
     };
     async run() {
         this.requireAuth();
@@ -21,12 +24,19 @@ class CommitmentsCases extends base_command_1.BaseCommand {
             result = await commitments_1.commitmentApi.cases(args.commitmentId, {
                 limit: flags.limit,
                 status: flags.status,
+                cursor: flags.cursor,
             });
         }
         catch (error) {
             this.handleApiError(error);
         }
-        this.log(JSON.stringify(result, null, 2));
+        if (flags.json) {
+            this.log(JSON.stringify(result, null, 2));
+        }
+        else {
+            (0, commitments_1.renderCommitmentCases)(result, (line) => this.log(line));
+        }
+        (0, commitments_1.renderListPageHint)(result, (line) => this.log(line));
     }
 }
 exports.default = CommitmentsCases;

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

@@ -16,6 +16,7 @@ export default class CommitmentsChecks extends BaseCommand {
     static flags: {
         json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         limit: import("@oclif/core/lib/interfaces").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        cursor: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
     };
     run(): Promise<void>;
 }

package/dist/commands/commitments/checks.js

@@ -23,13 +23,16 @@ class CommitmentsChecks extends base_command_1.BaseCommand {
     static flags = {
         json: core_1.Flags.boolean({ description: 'Output as JSON' }),
         limit: core_1.Flags.integer({ description: 'Max checks to return (1..100)', min: 1, max: 100 }),
+        cursor: core_1.Flags.string({
+            description: 'Continue from the next_cursor emitted by a previous page',
+        }),
     };
     async run() {
         this.requireAuth();
         const { args, flags } = await this.parse(CommitmentsChecks);
         let response;
         try {
-            response = await commitments_1.commitmentApi.checks(args.id, flags.limit);
+            response = await commitments_1.commitmentApi.checks(args.id, { limit: flags.limit, cursor: flags.cursor });
         }
         catch (err) {
             this.handleApiError(err);
@@ -39,6 +42,7 @@ class CommitmentsChecks extends base_command_1.BaseCommand {
             return;
         }
         (0, commitments_1.renderCheckList)(response.data ?? [], (line) => this.log(line));
+        (0, commitments_1.renderListPageHint)(response, (line) => this.log(line));
     }
 }
 exports.default = CommitmentsChecks;

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

@@ -0,0 +1,62 @@
+import { BaseCommand } from '../../base-command';
+import { type CommitmentCostWindow } from '../../lib/commitments';
+/**
+ * Resolve a cost window to UTC day boundaries.
+ *
+ * `CommitmentPeriodClose.readCostWindow` REFUSES a window that is not exactly
+ * on UTC day starts (`RangeError: cost windows must use UTC day boundaries`),
+ * because the closed daily metrics it sums are bucketed that way — a window
+ * that started mid-day would silently include or exclude a whole bucket. So the
+ * CLI snaps to the boundary itself rather than forwarding a wall-clock time and
+ * letting the operator meet a 500 they cannot act on.
+ *
+ * Snapping is a real change to what was asked for, so it is deliberately
+ * TRUNCATION in both directions — `--to 2026-09-19T18:00Z` reports through the
+ * start of the 19th, not the end of it. The command prints the window it
+ * actually used for that reason.
+ *
+ * The default window ends at TODAY's UTC day start, not now: today's metrics
+ * are not closed yet, so including the partial day would report a cost that
+ * changes when you re-run the same command.
+ */
+export declare function resolveCostWindow(input?: {
+    from?: string;
+    to?: string;
+}, now?: Date): {
+    from: string;
+    to: string;
+};
+/**
+ * `skrr commitments cost <id>` — closed-period spend for one commitment.
+ *
+ * Money on this path has no other bound the operator can read: a Commitment's
+ * agent turns are `AgentOutcome` rows carrying no cost fields, so
+ * `spendLimitDailyUsd` cannot see them and `maxRunsPerDay` IS the spend control
+ * (see `autonomyEnvelope.maxRunsPerDay` in the API's own schema note). This is
+ * the read that says what those runs actually cost.
+ *
+ * `metrics` shows the daily rows; this sums the closed ones over a window and,
+ * critically, reports how much of the window was ATTRIBUTABLE.
+ */
+export default class CommitmentsCost extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        from: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        to: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}
+/**
+ * Pure renderer for the cost window.
+ *
+ * `costStatus` is printed BEFORE the dollar figure, on purpose. `partial` and
+ * `unavailable` mean some runs reported no cost attribution at all, so the
+ * total understates the spend; a reader who sees the number first has already
+ * formed a belief by the time they reach the caveat.
+ */
+export declare function formatCostWindow(data: CommitmentCostWindow): string[];

package/dist/commands/commitments/cost.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveCostWindow = resolveCostWindow;
+exports.formatCostWindow = formatCostWindow;
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../../base-command");
+const commitments_1 = require("../../lib/commitments");
+const DAY_MS = 24 * 60 * 60 * 1000;
+const DEFAULT_WINDOW_DAYS = 7;
+/**
+ * Resolve a cost window to UTC day boundaries.
+ *
+ * `CommitmentPeriodClose.readCostWindow` REFUSES a window that is not exactly
+ * on UTC day starts (`RangeError: cost windows must use UTC day boundaries`),
+ * because the closed daily metrics it sums are bucketed that way — a window
+ * that started mid-day would silently include or exclude a whole bucket. So the
+ * CLI snaps to the boundary itself rather than forwarding a wall-clock time and
+ * letting the operator meet a 500 they cannot act on.
+ *
+ * Snapping is a real change to what was asked for, so it is deliberately
+ * TRUNCATION in both directions — `--to 2026-09-19T18:00Z` reports through the
+ * start of the 19th, not the end of it. The command prints the window it
+ * actually used for that reason.
+ *
+ * The default window ends at TODAY's UTC day start, not now: today's metrics
+ * are not closed yet, so including the partial day would report a cost that
+ * changes when you re-run the same command.
+ */
+function resolveCostWindow(input = {}, now = new Date()) {
+    const dayStart = (date) => new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate()));
+    const parse = (value, flag) => {
+        const parsed = new Date(value);
+        if (Number.isNaN(parsed.getTime())) {
+            throw new Error(`${flag} is not a date: ${value}`);
+        }
+        return parsed;
+    };
+    const to = input.to ? dayStart(parse(input.to, '--to')) : dayStart(now);
+    const from = input.from
+        ? dayStart(parse(input.from, '--from'))
+        : new Date(to.getTime() - DEFAULT_WINDOW_DAYS * DAY_MS);
+    if (to.getTime() <= from.getTime()) {
+        throw new Error('--to must be a later UTC day than --from.');
+    }
+    return { from: from.toISOString(), to: to.toISOString() };
+}
+/**
+ * `skrr commitments cost <id>` — closed-period spend for one commitment.
+ *
+ * Money on this path has no other bound the operator can read: a Commitment's
+ * agent turns are `AgentOutcome` rows carrying no cost fields, so
+ * `spendLimitDailyUsd` cannot see them and `maxRunsPerDay` IS the spend control
+ * (see `autonomyEnvelope.maxRunsPerDay` in the API's own schema note). This is
+ * the read that says what those runs actually cost.
+ *
+ * `metrics` shows the daily rows; this sums the closed ones over a window and,
+ * critically, reports how much of the window was ATTRIBUTABLE.
+ */
+class CommitmentsCost extends base_command_1.BaseCommand {
+    static description = "Sum a commitment's closed-period run cost over a UTC day window";
+    static examples = [
+        '<%= config.bin %> commitments cost obj_abc123',
+        '<%= config.bin %> commitments cost obj_abc123 --from 2026-09-01 --to 2026-09-15',
+        '<%= config.bin %> commitments cost obj_abc123 --json',
+    ];
+    static args = {
+        id: core_1.Args.string({ description: 'Commitment ID', required: true, ignoreStdin: true }),
+    };
+    static flags = {
+        from: core_1.Flags.string({
+            description: `Window start, truncated to its UTC day (default: ${DEFAULT_WINDOW_DAYS} days before --to)`,
+        }),
+        to: core_1.Flags.string({
+            description: "Window end, truncated to its UTC day (default: today's UTC day start)",
+        }),
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(CommitmentsCost);
+        let window;
+        try {
+            window = resolveCostWindow({ from: flags.from, to: flags.to });
+        }
+        catch (err) {
+            this.error(err.message, { exit: 1 });
+        }
+        let data;
+        try {
+            data = await commitments_1.commitmentApi.cost(args.id, window);
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+        if (flags.json) {
+            this.log(JSON.stringify(data, null, 2));
+            return;
+        }
+        for (const line of formatCostWindow(data))
+            this.log(line);
+    }
+}
+exports.default = CommitmentsCost;
+/**
+ * Pure renderer for the cost window.
+ *
+ * `costStatus` is printed BEFORE the dollar figure, on purpose. `partial` and
+ * `unavailable` mean some runs reported no cost attribution at all, so the
+ * total understates the spend; a reader who sees the number first has already
+ * formed a belief by the time they reach the caveat.
+ */
+function formatCostWindow(data) {
+    const micros = Number(data.costUsdMicros || 0);
+    const runs = Number(data.runCount || 0);
+    const unattributed = Number(data.unavailableRunCount || 0);
+    const status = data.costStatus ?? 'not_applicable';
+    const caveat = {
+        reported: 'every run in the window reported a cost',
+        partial: 'some runs reported no cost — the total below is a FLOOR',
+        unavailable: 'no run in the window reported a cost — the total below is meaningless',
+        not_applicable: 'no closed runs in the window',
+    };
+    return [
+        `Cost for ${data.commitmentId ?? '-'}`,
+        `Window:      ${data.from ?? '-'} → ${data.to ?? '-'} (${Number(data.dayCount || 0)} closed day(s))`,
+        `Attribution: ${status} — ${caveat[status] ?? 'unrecognized cost status'}`,
+        `Cost:        $${(micros / 1_000_000).toFixed(4)}`,
+        `Runs:        ${runs} (${Number(data.reportedRunCount || 0)} with cost, ${unattributed} without)`,
+    ];
+}

package/dist/commands/commitments/create.js

@@ -197,7 +197,7 @@ class CommitmentsCreate extends base_command_1.BaseCommand {
         agent: core_1.Flags.string({ description: 'Agent that owns and watches this commitment (required)' }),
         kind: core_1.Flags.string({
             description: 'Lifecycle kind: achieve is terminal-capable; maintain is perpetual',
-            options: ['achieve', 'maintain'],
+            options: [...commitments_1.COMMITMENT_KIND_VALUES],
         }),
         title: core_1.Flags.string({ description: 'Short commitment title (required)' }),
         outcome: core_1.Flags.string({

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

@@ -22,6 +22,7 @@ export default class CommitmentsDelete extends BaseCommand {
         json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         reason: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         yes: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'stop-open-work': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;
 }