@skrr-ai/cli 0.1.108 → 0.1.109

package/README.md

@@ -1780,8 +1780,18 @@ sky tasks retry-schedule <task-id> --at 2026-06-02T15:00:00Z
 # Pause / resume a recurring schedule without losing its definition
 sky tasks pause-schedule <task-id>
 sky tasks resume-schedule <task-id>
+
+# A finished occurrence whose next occurrence was never armed (`tasks show` says
+# "The next occurrence was not scheduled: ..."): continue the series from it.
+# `tasks schedule` refuses a finished Task; this is the way back. --cron fixes an
+# invalid pattern first.
+skrr tasks rearm-recurrence <finished-task-id>
+skrr tasks rearm-recurrence <finished-task-id> --cron "0 9 * * 1-5"
 ```
 
+A pattern is validated when it is written: `--cron nonsense` is refused with the
+expected format and an example, never stored and armed at some other time.
+
 Pass `--from-json schedule.json` to `schedule` for fields not exposed as
 typed flags (matches the `TaskScheduleParams` shape).
 

package/dist/base-command.d.ts

@@ -1,5 +1,7 @@
 import { Command, Flags, type Interfaces } from '@oclif/core';
 export { resolveProfileFromArgv } from './lib/keychain';
+import { dataService } from '@skrr-ai/data-provider';
+import { type WriteTarget } from './lib/write-target';
 import { type AssigneeResolution, type MemberKind, type SpaceMember } from './lib/assignee-resolver';
 import { type CliConfig } from './lib/config';
 import { type OutboxMethod } from './lib/outbox';
@@ -59,6 +61,24 @@ export declare abstract class BaseCommand extends Command {
      */
     log(message?: string, ...args: unknown[]): void;
     protected wantsRawJson(): boolean;
+    /**
+     * Print a command's `--json` RESULT: pretty JSON, with `ok` on an object so a
+     * script can test one field for success and failure alike (OSK-16425).
+     *
+     * A failure already prints `{ok:false, error}`; a success printed whatever the
+     * server sent, so `jq '{id, title}'` turned the failure into `{id:null,
+     * title:null}` — an empty success. `ok` is added HERE, by the command that
+     * knows its own outcome, and not in `log()`: `log` cannot see the exit status
+     * to come, and several commands print a document and then exit non-zero.
+     * Pass `{ ok: false }` for one of those; the command still owns its exit code.
+     *
+     * An array is printed as it is (it cannot carry a field), and an object that
+     * already has `ok` keeps its own. The exit status stays the test for a command
+     * that has not been moved here yet.
+     */
+    protected printJsonResult(value: unknown, options?: {
+        ok?: boolean;
+    }): void;
     protected cliConfig: CliConfig;
     /**
      * Resolved credential for this process. Populated in `init()` and
@@ -220,6 +240,17 @@ export declare abstract class BaseCommand extends Command {
      * friendly error on any API failure, so callers can `await` it directly.
      */
     protected resolveCurrentUserId(): Promise<string>;
+    /**
+     * The signed-in user, read ONCE per command run.
+     *
+     * `me`, the default-assignee policy and the write-target notice all need it,
+     * and a command that touches many nodes (`create-tree` with ninety-four)
+     * asked for it once per node. Who you are does not change during one command,
+     * so one read answers every caller — and a failed read is not remembered, so a
+     * transient error does not poison the rest of the run.
+     */
+    private currentUserRead?;
+    protected fetchCurrentUser(): Promise<Awaited<ReturnType<typeof dataService.getUser>>>;
     /**
      * Decide who owns a task this invocation is creating, when the caller did
      * not say.
@@ -249,6 +280,27 @@ export declare abstract class BaseCommand extends Command {
      * worse, resolve a typo to a stranger the caller never intended to name.
      */
     protected loadSpaceMembers(spaceId: string): Promise<SpaceMember[]>;
+    /** Lazily created: a command built without its constructor (specs do) must still work. */
+    private spaceMemberReads?;
+    /**
+     * Where a write from this invocation is about to land: the signed-in account,
+     * the server and the workspace. Best effort on the account (a failed read
+     * leaves it null and the line says so) — it is a statement, not a gate; the
+     * gate is `assertWriteTarget`.
+     */
+    protected describeWriteTarget(): Promise<WriteTarget>;
+    /**
+     * Say where a bulk write is about to land, and refuse if the caller said it
+     * should land somewhere else.
+     *
+     * The line goes to stderr and only when stderr is a person's terminal: an
+     * agent capturing `2>&1` gets no extra bytes (the update nudge taught that
+     * lesson), and gets the same facts in-band instead — the commands that call
+     * this put `target` in their `--json`. `--expect-target` is the control for a
+     * caller that cannot watch: it is checked HERE, before the first write, and a
+     * mismatch is a non-retryable usage error.
+     */
+    protected assertWriteTarget(expected?: readonly string[]): Promise<WriteTarget>;
     /**
      * Turn free-text assignee references ("frank", "frank@example.com", "me",
      * or a raw id) into ids, failing the command if ANY of them can't be pinned
@@ -316,6 +368,13 @@ export declare abstract class BaseCommand extends Command {
      * subject is folded into the message, so the human line and the `--json`
      * envelope carry the same identifying text.
      */
+    /**
+     * Request body paths this invocation built from its flags, each mapped to the flag that wrote
+     * it. Set by a command before it sends a body it assembled from flags, and left unset when the
+     * person supplied the body themselves; `handleApiError` uses it to name the flag instead of a
+     * path the person never typed. See `lib/request-field-flags.ts`.
+     */
+    protected requestFieldFlags?: Readonly<Record<string, string>>;
     protected handleApiError(err: unknown, { subject }?: {
         subject?: string;
     }): never;

package/dist/base-command.js

@@ -22,7 +22,9 @@ const node_fs_1 = require("node:fs");
 const core_1 = require("@oclif/core");
 Object.defineProperty(exports, "Flags", { enumerable: true, get: function () { return core_1.Flags; } });
 const option_hint_1 = require("./lib/option-hint");
+const request_field_flags_1 = require("./lib/request-field-flags");
 const json_output_1 = require("./lib/json-output");
+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");
@@ -36,6 +38,7 @@ const data_provider_1 = require("@skrr-ai/data-provider");
 const auth_core_1 = require("@skrr-ai/auth-core");
 const auth_failure_1 = require("./lib/auth-failure");
 const list_output_1 = require("./lib/list-output");
+const write_target_1 = require("./lib/write-target");
 const assignee_resolver_1 = require("./lib/assignee-resolver");
 const task_ref_resolver_1 = require("./lib/task-ref-resolver");
 const space_resolver_1 = require("./lib/space-resolver");
@@ -176,6 +179,24 @@ class BaseCommand extends core_1.Command {
     wantsRawJson() {
         return this.argv.includes('--raw') || process.env.OVERSKY_CLI_RAW === '1';
     }
+    /**
+     * Print a command's `--json` RESULT: pretty JSON, with `ok` on an object so a
+     * script can test one field for success and failure alike (OSK-16425).
+     *
+     * A failure already prints `{ok:false, error}`; a success printed whatever the
+     * server sent, so `jq '{id, title}'` turned the failure into `{id:null,
+     * title:null}` — an empty success. `ok` is added HERE, by the command that
+     * knows its own outcome, and not in `log()`: `log` cannot see the exit status
+     * to come, and several commands print a document and then exit non-zero.
+     * Pass `{ ok: false }` for one of those; the command still owns its exit code.
+     *
+     * An array is printed as it is (it cannot carry a field), and an object that
+     * already has `ok` keeps its own. The exit status stays the test for a command
+     * that has not been moved here yet.
+     */
+    printJsonResult(value, options = {}) {
+        this.log(JSON.stringify((0, json_output_1.withOk)(value, options.ok ?? true), null, 2));
+    }
     cliConfig;
     /**
      * Resolved credential for this process. Populated in `init()` and
@@ -928,7 +949,7 @@ class BaseCommand extends core_1.Command {
     async resolveCurrentUserId() {
         let user;
         try {
-            user = await data_provider_1.dataService.getUser();
+            user = await this.fetchCurrentUser();
         }
         catch (err) {
             this.handleApiError(err);
@@ -941,6 +962,25 @@ class BaseCommand extends core_1.Command {
         }
         return user.id;
     }
+    /**
+     * The signed-in user, read ONCE per command run.
+     *
+     * `me`, the default-assignee policy and the write-target notice all need it,
+     * and a command that touches many nodes (`create-tree` with ninety-four)
+     * asked for it once per node. Who you are does not change during one command,
+     * so one read answers every caller — and a failed read is not remembered, so a
+     * transient error does not poison the rest of the run.
+     */
+    currentUserRead;
+    fetchCurrentUser() {
+        if (!this.currentUserRead) {
+            this.currentUserRead = data_provider_1.dataService.getUser().catch((err) => {
+                this.currentUserRead = undefined;
+                throw err;
+            });
+        }
+        return this.currentUserRead;
+    }
     /**
      * Decide who owns a task this invocation is creating, when the caller did
      * not say.
@@ -979,6 +1019,12 @@ class BaseCommand extends core_1.Command {
      * worse, resolve a typo to a stranger the caller never intended to name.
      */
     async loadSpaceMembers(spaceId) {
+        // A space's roster does not change during one command; a tree of ninety-four
+        // nodes that name people read it ninety-four times.
+        const reads = (this.spaceMemberReads ??= new Map());
+        const cached = reads.get(spaceId);
+        if (cached)
+            return cached;
         let response;
         try {
             response = await data_provider_1.dataService.getResourcePermissions(data_provider_1.ResourceType.SPACE, spaceId);
@@ -987,7 +1033,67 @@ class BaseCommand extends core_1.Command {
             this.handleApiError(err);
         }
         const principals = (response.principals ?? []);
-        return (0, assignee_resolver_1.membersFromPrincipals)(principals);
+        const members = (0, assignee_resolver_1.membersFromPrincipals)(principals);
+        reads.set(spaceId, Promise.resolve(members));
+        return members;
+    }
+    /** Lazily created: a command built without its constructor (specs do) must still work. */
+    spaceMemberReads;
+    /**
+     * Where a write from this invocation is about to land: the signed-in account,
+     * the server and the workspace. Best effort on the account (a failed read
+     * leaves it null and the line says so) — it is a statement, not a gate; the
+     * gate is `assertWriteTarget`.
+     */
+    async describeWriteTarget() {
+        let user;
+        try {
+            user = await this.fetchCurrentUser();
+        }
+        catch {
+            user = undefined;
+        }
+        const workspace = process.env.OVERSKY_SESSION_WORKSPACE_ID?.trim() ||
+            process.env.OVERSKY_WORKSPACE_ID?.trim() ||
+            null;
+        return {
+            server: this.cliConfig?.baseURL ?? '',
+            account: user?.email ?? null,
+            accountId: user?.id ?? null,
+            workspace,
+        };
+    }
+    /**
+     * Say where a bulk write is about to land, and refuse if the caller said it
+     * should land somewhere else.
+     *
+     * The line goes to stderr and only when stderr is a person's terminal: an
+     * agent capturing `2>&1` gets no extra bytes (the update nudge taught that
+     * lesson), and gets the same facts in-band instead — the commands that call
+     * this put `target` in their `--json`. `--expect-target` is the control for a
+     * caller that cannot watch: it is checked HERE, before the first write, and a
+     * mismatch is a non-retryable usage error.
+     */
+    async assertWriteTarget(expected) {
+        const target = await this.describeWriteTarget();
+        const unmet = (0, write_target_1.firstUnmetExpectation)(target, expected);
+        if (unmet !== undefined) {
+            this.failWithCliError({
+                message: `Refusing to write: this command would write to ${(0, write_target_1.formatWriteTarget)(target)}, ` +
+                    `which does not match --expect-target ${unmet}. Nothing was created.`,
+                code: 'WRITE_TARGET_MISMATCH',
+                exit: 2,
+                retryable: false,
+                details: {
+                    suggestion: `Sign in to the intended account or server (\`${this.config.bin} login\`, \`${this.config.bin} whoami\`), or correct --expect-target.`,
+                    context: { target, expected: [...(expected ?? [])] },
+                },
+            });
+        }
+        if (process.stderr.isTTY) {
+            process.stderr.write(`Writing to ${(0, write_target_1.formatWriteTarget)(target)}\n`);
+        }
+        return target;
     }
     /**
      * Turn free-text assignee references ("frank", "frank@example.com", "me",
@@ -1170,6 +1276,13 @@ class BaseCommand extends core_1.Command {
      * subject is folded into the message, so the human line and the `--json`
      * envelope carry the same identifying text.
      */
+    /**
+     * Request body paths this invocation built from its flags, each mapped to the flag that wrote
+     * it. Set by a command before it sends a body it assembled from flags, and left unset when the
+     * person supplied the body themselves; `handleApiError` uses it to name the flag instead of a
+     * path the person never typed. See `lib/request-field-flags.ts`.
+     */
+    requestFieldFlags;
     handleApiError(err, { subject } = {}) {
         // An error this command already raised for the user is not an API failure
         // to translate. `this.error()` throws a CLIError carrying `oclif.exit`, and
@@ -1194,7 +1307,8 @@ class BaseCommand extends core_1.Command {
             this.lastRetryAfterMs = e.retryAfterMs;
             const body = parseErrorBody(e.body);
             const bodyCode = stringProp(body, 'code') || stringProp(body, 'errorType');
-            const bodyMessage = stringProp(body, 'message') || stringProp(body, 'error');
+            // A body path the person never typed is read back as the flag that wrote it (OSK-15313).
+            const bodyMessage = (0, request_field_flags_1.translateRequestFieldPaths)(stringProp(body, 'message') || stringProp(body, 'error'), this.requestFieldFlags);
             // `requireAuth()` catches this before requests for normal commands, but
             // keep the API-error check too: a handful of commands make a direct
             // request and a supplied `--token` can bypass their normal preflight.
@@ -1817,10 +1931,7 @@ class BaseCommand extends core_1.Command {
             process.stderr.write(`${line}\n`);
     }
     wantsJsonOutput() {
-        return (this.argv.includes('--json') ||
-            this.argv.includes('--ndjson') ||
-            process.env.SKY_JSON === '1' ||
-            process.env.OVERSKY_CLI_JSON === '1');
+        return (0, json_mode_1.wantsJsonFromArgv)(this.argv);
     }
 }
 exports.BaseCommand = BaseCommand;

package/dist/commands/agents/update.d.ts

@@ -1,3 +1,4 @@
+import { type AgentWriteReceipt } from '@skrr-ai/data-provider';
 import { BaseCommand } from '../../base-command';
 export default class AgentsUpdate extends BaseCommand {
     static description: string;
@@ -72,9 +73,22 @@ export default class AgentsUpdate extends BaseCommand {
  *   through `--from-json` was reported as "not an agent field" after the server
  *   had cleared it on purpose (OSK-12167).
  *
+ * All of that is the fallback for a server that predates `writeReceipt`. When
+ * the response carries a receipt, the server's own account of each key is used
+ * instead and nothing is inferred from the response's shape (OSK-15070).
+ *
  * Exported for tests.
  */
 export declare function agentUpdateWarnings(payload: Record<string, unknown>, updated: unknown): string[];
+/**
+ * Warnings from the server's `writeReceipt` (OSK-15070). The receipt names
+ * every key the write saw as applied (and through which control: the legacy
+ * `isAlwaysOn` goes to the Always-On control and is applied, not "not kept") or
+ * ignored with a reason. A sent key it does not mention never reached the write.
+ *
+ * Exported for tests.
+ */
+export declare function writeReceiptWarnings(payload: Record<string, unknown>, receipt: AgentWriteReceipt): string[];
 /**
  * The per-Agent mutation fence's "another request holds this right now"
  * refusals. `updateAgent` takes a short lease on the Agent before it writes, so

package/dist/commands/agents/update.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AGENT_FENCE_RETRY_CODES = void 0;
 exports.agentUpdateWarnings = agentUpdateWarnings;
+exports.writeReceiptWarnings = writeReceiptWarnings;
 exports.retryOnceOnAgentFence = retryOnceOnAgentFence;
 exports.defaultPermissionModePatch = defaultPermissionModePatch;
 exports.defaultPermissionModeNote = defaultPermissionModeNote;
@@ -184,7 +185,9 @@ class AgentsUpdate extends base_command_1.BaseCommand {
             this.error(err.message, { exit: 1 });
         }
         if (Object.keys(payload).length === 0) {
-            this.error('Nothing to update. Pass at least one flag (e.g. --name) or --from-json.', { exit: 1 });
+            this.error('Nothing to update. Pass at least one flag (e.g. --name) or --from-json.', {
+                exit: 1,
+            });
         }
         let updated;
         try {
@@ -240,9 +243,18 @@ exports.default = AgentsUpdate;
  *   through `--from-json` was reported as "not an agent field" after the server
  *   had cleared it on purpose (OSK-12167).
  *
+ * All of that is the fallback for a server that predates `writeReceipt`. When
+ * the response carries a receipt, the server's own account of each key is used
+ * instead and nothing is inferred from the response's shape (OSK-15070).
+ *
  * Exported for tests.
  */
 function agentUpdateWarnings(payload, updated) {
+    // A server that reports what it did with each key is the authority; the
+    // shape comparison below is only for a server older than the receipt.
+    const receipt = (0, data_provider_1.readAgentWriteReceipt)(updated);
+    if (receipt)
+        return writeReceiptWarnings(payload, receipt);
     const isRecord = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
     const controlReply = isRecord(updated) &&
         typeof updated.agentId === 'string' &&
@@ -273,6 +285,33 @@ function agentUpdateWarnings(payload, updated) {
         ...(unapplied.length > 0 ? [(0, create_1.unappliedPayloadKeysWarning)(unapplied)] : []),
     ];
 }
+/**
+ * Warnings from the server's `writeReceipt` (OSK-15070). The receipt names
+ * every key the write saw as applied (and through which control: the legacy
+ * `isAlwaysOn` goes to the Always-On control and is applied, not "not kept") or
+ * ignored with a reason. A sent key it does not mention never reached the write.
+ *
+ * Exported for tests.
+ */
+function writeReceiptWarnings(payload, receipt) {
+    const explained = receipt.ignored
+        .filter((entry) => entry.reason !== 'not_an_agent_field')
+        .map((entry) => `${entry.field}: ${entry.detail || 'ignored by the server'}`);
+    const notFields = receipt.ignored
+        .filter((entry) => entry.reason === 'not_an_agent_field')
+        .map((entry) => entry.field);
+    const unreported = (0, data_provider_1.unreportedAgentWriteFields)(payload, receipt);
+    const warnings = [...explained];
+    if (notFields.length > 0)
+        warnings.push((0, create_1.unappliedPayloadKeysWarning)(notFields));
+    if (unreported.length > 0) {
+        const one = unreported.length === 1;
+        warnings.push(`The server did not receive ${unreported.join(', ')}: a request filter removed ` +
+            `${one ? 'it' : 'them'} before the write, so nothing was changed for ${one ? 'it' : 'them'}. ` +
+            '`skrr agents show <id> --json` shows what the agent stores.');
+    }
+    return warnings;
+}
 /**
  * The per-Agent mutation fence's "another request holds this right now"
  * refusals. `updateAgent` takes a short lease on the Agent before it writes, so

package/dist/commands/commitments/accounting.js

@@ -4,6 +4,7 @@ exports.formatAccountingReadout = formatAccountingReadout;
 const core_1 = require("@oclif/core");
 const base_command_1 = require("../../base-command");
 const commitments_1 = require("../../lib/commitments");
+const cost_1 = require("./cost");
 /**
  * `skrr commitments accounting <id>` — the allowance-accounting SHADOW readout.
  *
@@ -92,14 +93,18 @@ function formatAccountingReadout(readout) {
     // 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',
+        reported: "every run's cost is known",
         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)`);
+        ` (${Number(readout.costReportedRunCount || 0)} of ${Number(readout.costRunCount || 0)} runs priced` +
+        `, ${Number(readout.costNoSpendRunCount || 0)} refused before starting)`);
+    const noSpendNote = (0, cost_1.noSpendInferenceNote)(Number(readout.costNoSpendRunCount || 0), Number(readout.costNoSpendInferredRunCount || 0));
+    if (noSpendNote)
+        lines.push(noSpendNote);
     const multiplier = readout.recommendedAttemptMultiplier;
     lines.push('');
     lines.push(`Attempt multiplier: ${multiplier == null ? 'not derivable yet' : multiplier}` +

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

@@ -60,3 +60,14 @@ export default class CommitmentsCost extends BaseCommand {
  * formed a belief by the time they reach the caveat.
  */
 export declare function formatCostWindow(data: CommitmentCostWindow): string[];
+/**
+ * The line that says when "cost nothing" rests on inference (OSK-15500).
+ *
+ * A Run refused before any model turn records that fact when it is refused.
+ * Runs written before the fact was recorded are judged by the platform's legacy
+ * inference (admission-denied status, a pre-start refusal code, cancelled before
+ * any claim). Both are counted as $0 by the live budget, the spend ledger and
+ * this read alike — but a reader must be able to tell a recorded fact from an
+ * inferred one, so an inferred share is always printed, never folded in.
+ */
+export declare function noSpendInferenceNote(noSpend: number, inferred: number): string | null;

package/dist/commands/commitments/cost.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveCostWindow = resolveCostWindow;
 exports.formatCostWindow = formatCostWindow;
+exports.noSpendInferenceNote = noSpendInferenceNote;
 const core_1 = require("@oclif/core");
 const base_command_1 = require("../../base-command");
 const commitments_1 = require("../../lib/commitments");
@@ -113,18 +114,40 @@ function formatCostWindow(data) {
     const micros = Number(data.costUsdMicros || 0);
     const runs = Number(data.runCount || 0);
     const unattributed = Number(data.unavailableRunCount || 0);
+    const noSpend = Number(data.noSpendRunCount || 0);
     const status = data.costStatus ?? 'not_applicable';
     const caveat = {
-        reported: 'every run in the window reported a cost',
+        reported: "every run's cost in the window is known",
         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 [
+    const lines = [
         `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)`,
+        `Runs:        ${runs} (${Number(data.reportedRunCount || 0)} with cost, ` +
+            `${noSpend} refused before starting, ${unattributed} without)`,
     ];
+    const note = noSpendInferenceNote(noSpend, Number(data.noSpendInferredRunCount || 0));
+    if (note)
+        lines.push(note);
+    return lines;
+}
+/**
+ * The line that says when "cost nothing" rests on inference (OSK-15500).
+ *
+ * A Run refused before any model turn records that fact when it is refused.
+ * Runs written before the fact was recorded are judged by the platform's legacy
+ * inference (admission-denied status, a pre-start refusal code, cancelled before
+ * any claim). Both are counted as $0 by the live budget, the spend ledger and
+ * this read alike — but a reader must be able to tell a recorded fact from an
+ * inferred one, so an inferred share is always printed, never folded in.
+ */
+function noSpendInferenceNote(noSpend, inferred) {
+    if (!(inferred > 0))
+        return null;
+    return (`Note:        ${inferred} of the ${noSpend} run(s) refused before starting are counted ` +
+        'as $0 by inference (recorded before refusals were stored), not from a recorded refusal');
 }

package/dist/commands/commitments/create.js

@@ -156,7 +156,8 @@ function createCadenceFromFlags({ eventDriven, cadence: cadenceInput, cadenceMod
  * For a natural-language draft instead of flags, use `skrr commitments plan`.
  */
 class CommitmentsCreate extends base_command_1.BaseCommand {
-    static description = 'Create a commitment (a durable agent contract)';
+    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 "Hiring loop" --outcome "Every candidate hears back in 48h" --watch tasks --watch email --cadence 12h',

package/dist/commands/commitments/operating-review.d.ts

@@ -1,5 +1,7 @@
+import type { CommitmentLoopStatus } from '@skrr-ai/data-provider';
 import { BaseCommand } from '../../base-command';
 type SystemCommitmentRow = {
+    id?: string;
     systemRole?: string;
     status?: string;
     lastCheckedAt?: string;
@@ -13,6 +15,19 @@ type SystemCommitmentRow = {
  * (OSK-15438): an Agent that cannot run cannot have asked.
  */
 export declare function noQuestionsSentence(alwaysOn: boolean, roles: SystemCommitmentRow[]): string;
+/**
+ * What the roster said about this Agent's loops, or why it could not be read. The review's own rows
+ * carry only the stored lifecycle status; whether a loop is armed, when it next wakes, why it last
+ * stopped and whether it can read its sources come from the roster (OSK-15438, OSK-15412).
+ */
+export type OperatingReviewLoops = {
+    rows: Map<string, CommitmentLoopStatus>;
+    truncated: boolean;
+} | {
+    error: string;
+};
+/** The review as text. Pure, so the whole output can be pinned. */
+export declare function formatOperatingReview(review: Record<string, unknown>, loops: OperatingReviewLoops): string[];
 export default class CommitmentsOperatingReview extends BaseCommand {
     static description: string;
     static args: {