@skrr-ai/cli 0.1.47 → 0.1.49

package/dist/commands/tasks/list.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.emptyTasksMessage = emptyTasksMessage;
+exports.nextActionText = nextActionText;
+exports.taskRef = taskRef;
 exports.buildListParams = buildListParams;
 const core_1 = require("@oclif/core");
 const data_provider_1 = require("@skrr-ai/data-provider");
@@ -22,6 +24,7 @@ const FILTER_FLAGS = new Set([
     'parent',
     'status',
     'status-type',
+    'open',
     'execution-state',
     'actionable-by',
     'actionable-for-agent',
@@ -77,7 +80,7 @@ function emptyTasksMessage(flags, bin = 'skrr') {
         lines.push(`  → Create your first one: \`${bin} tasks create --title "..." --space <space-id>\``);
         lines.push(`  → List spaces to find one: \`${bin} spaces list\``);
     }
-    else if (flags.status === 'in_progress' && !flags['execution-state']) {
+    else if (statusList(flags).includes('in_progress') && !flags['execution-state']) {
         // `--status in_progress` filters the board column only. A run that was
         // reaped/reset (e.g. a stuck-task timeout) is moved OFF `in_progress` but
         // keeps its execution markers, so it hides here. Point the operator at
@@ -87,9 +90,7 @@ function emptyTasksMessage(flags, bin = 'skrr') {
         lines.push('      no longer has that status. Try `--execution-state active` (running now) or');
         lines.push(`      \`--execution-state recovered\` (reaped, startable), or \`${bin} tasks active\`.`);
     }
-    else if (typeof flags.status === 'string' &&
-        flags.status.length > 0 &&
-        !flags['execution-state']) {
+    else if (statusList(flags).length > 0 && !flags['execution-state']) {
         // A filter that matches nothing and a board that IS empty print the same
         // thing, and the caller cannot tell which they are looking at. Observed:
         // `--status todo` on a board whose open column is `backlog` said `No tasks.`
@@ -106,16 +107,54 @@ function emptyTasksMessage(flags, bin = 'skrr') {
         // string the branch above deliberately produces for that combination. The
         // same ambiguity exists there, but overturning a pinned decision is not
         // this change's business.
+        const wanted = statusList(flags);
         lines.push('');
-        lines.push(`Note: nothing matched \`--status ${flags.status}\`. A status is a workflow-state id the`);
-        lines.push('      space owns, so a board need not use this one at all.');
+        lines.push(`Note: nothing matched \`--status ${wanted.join(' --status ')}\`. A status is a`);
+        lines.push('      workflow-state id the space owns, so a board need not use this one at all.');
         lines.push('  → See what this scope actually holds: the same command without `--status`.');
-        if (!data_provider_1.TASK_STATUSES.includes(flags.status)) {
+        if (wanted.some((s) => !data_provider_1.TASK_STATUSES.includes(s))) {
             lines.push(`      (built-in ids: ${data_provider_1.TASK_STATUSES.join(', ')})`);
         }
     }
     return lines.join('\n');
 }
+/**
+ * `--status` is repeatable, so the flag value is a list; callers that predate
+ * that and tests that pass a bare string both normalize through here.
+ */
+function statusList(flags) {
+    const value = flags.status;
+    if (Array.isArray(value))
+        return value.filter((s) => typeof s === 'string');
+    return typeof value === 'string' && value.length > 0 ? [value] : [];
+}
+/** Same normalization for the repeatable `--status-type`. */
+function statusTypeList(flags) {
+    const value = flags['status-type'];
+    if (Array.isArray(value))
+        return value.filter((s) => typeof s === 'string');
+    return typeof value === 'string' && value.length > 0 ? [value] : [];
+}
+/**
+ * The NEXT column's text, computed once for the table and the `--json`
+ * `nextAction` alias. `reason` is the sentence the server wrote for a person;
+ * `reasonCode` is the enum it wrote for a machine — printing the code rendered
+ * every stage of every lifecycle as `human:lifecycle_stage` while the sentence
+ * naming the stage sat unread in the same payload.
+ */
+function nextActionText(t) {
+    const actionability = t.actionability;
+    return actionability
+        ? `${String(actionability.nextActor ?? '-')}: ${String(actionability.reason || actionability.reasonCode || actionability.state || '-')}`
+        : String(t.executionMode ?? '-');
+}
+/**
+ * The REF column's value, aliased to `ref` under `--json` because `identifier`
+ * is the one name an agent scanning 43 keys does not guess (OSK-10692).
+ */
+function taskRef(t) {
+    return String(t.identifier ?? (t.taskNumber ? `#${t.taskNumber}` : '-'));
+}
 /**
  * The task-list request bag is shared with import/export so every CLI list
  * surface serializes the same server-side filters. Keep user-id resolution in
@@ -129,8 +168,25 @@ function buildListParams(flags, assigneeUserId) {
         projectId: flag('project'),
         cycleId: flag('cycle'),
         parentId: flag('parent'),
-        ...(flag('status') ? { status: flag('status') } : {}),
-        ...(flag('status-type') ? { statusType: flag('status-type') } : {}),
+        // Scalar for a single value, `$in` array once the caller ORs — keeps the
+        // wire shape identical to the pre-multiple flag for the common case.
+        ...(statusList(flags).length === 1
+            ? { status: statusList(flags)[0] }
+            : statusList(flags).length > 1
+                ? { status: statusList(flags) }
+                : {}),
+        // `--open` sends the DECLARED band rather than a string the CLI invented:
+        // TASK_WORKFLOW_TYPE_BANDS.open is the same list `--overdue` already
+        // filters by server-side, so the two cannot drift apart. The endpoint
+        // types statusType as `string | string[]` and the model does `$in`, so
+        // nothing below the CLI had to change.
+        ...(flag('open')
+            ? { statusType: [...data_provider_1.TASK_WORKFLOW_TYPE_BANDS.open] }
+            : statusTypeList(flags).length === 1
+                ? { statusType: statusTypeList(flags)[0] }
+                : statusTypeList(flags).length > 1
+                    ? { statusType: statusTypeList(flags) }
+                    : {}),
         ...(flag('execution-state')
             ? { executionState: flag('execution-state') }
             : {}),
@@ -206,6 +262,8 @@ class TasksList extends base_command_1.BaseCommand {
         '<%= config.bin %> tasks list --include-snoozed',
         '<%= config.bin %> tasks list --actionable-by agent --actionable-for-agent <agent-id>',
         '<%= config.bin %> tasks list --needs-me',
+        '<%= config.bin %> tasks list --open',
+        '<%= config.bin %> tasks list --status-type blocked --status-type review',
         '<%= config.bin %> tasks list --dri me',
         '<%= config.bin %> tasks list --view <task-view-id>',
         '<%= config.bin %> tasks list --calendar 2026-08-01..2026-08-31 --json',
@@ -219,9 +277,17 @@ class TasksList extends base_command_1.BaseCommand {
             description: 'Filter by planning cycle ID, or "current" / "next" (requires --space)',
         }),
         parent: core_1.Flags.string({ description: 'Filter by parent task ID' }),
-        status: core_1.Flags.string({ description: 'Filter by task status' }),
+        // Repeatable: each occurrence ORs into one `$in` clause server-side, so
+        // "backlog or in review" is one call, not one call per band (OSK-10693).
+        status: core_1.Flags.string({ description: 'Filter by task status (repeatable, OR)', multiple: true }),
+        open: core_1.Flags.boolean({
+            description: 'Everything still open — the declared open band (backlog, unstarted, started, review, ' +
+                'triage, failed, blocked). One call instead of one per band, and it survives a Space ' +
+                'adding its own workflow state names.',
+            exclusive: ['status-type', 'status'],
+        }),
         'status-type': core_1.Flags.string({
-            description: 'Filter by fixed workflow TYPE (independent of Space state names)',
+            description: 'Filter by fixed workflow TYPE, independent of Space state names (repeatable, OR)',
             options: [
                 'backlog',
                 'unstarted',
@@ -234,6 +300,7 @@ class TasksList extends base_command_1.BaseCommand {
                 'blocked',
                 'hidden',
             ],
+            multiple: true,
         }),
         'execution-state': core_1.Flags.string({
             description: 'Filter by execution state, not board status: "active" (running now — in_progress OR checked out OR live session) or "recovered" (startable again after a reaped/failed run). Surfaces reaped runs that --status in_progress hides.',
@@ -257,7 +324,7 @@ class TasksList extends base_command_1.BaseCommand {
         'due-before': core_1.Flags.string({ description: 'Only tasks due before an ISO timestamp or "now"' }),
         'due-after': core_1.Flags.string({ description: 'Only tasks due after an ISO timestamp or "now"' }),
         overdue: core_1.Flags.boolean({
-            description: 'Alias for --due-before now --status-type open; uses the shared legacy open-status band until configurable workflow states land',
+            description: 'Alias for --due-before now --open; uses the shared legacy open-status band until configurable workflow states land',
         }),
         'blocked-by': core_1.Flags.string({ description: 'Only tasks blocked by this task ID' }),
         blocks: core_1.Flags.string({ description: 'Only tasks that block this task ID' }),
@@ -382,7 +449,9 @@ class TasksList extends base_command_1.BaseCommand {
                     ...calendarRange,
                     ...(flags.space ? { spaceId: flags.space } : {}),
                     ...(flags.project ? { projectId: flags.project } : {}),
-                    ...(flags.status ? { status: flags.status } : {}),
+                    ...(statusList(flags).length > 0
+                        ? { status: statusList(flags) }
+                        : {}),
                 })
                 : await data_provider_1.dataService.listTasks(buildListParams(flags, assigneeUserId));
         }
@@ -390,7 +459,22 @@ class TasksList extends base_command_1.BaseCommand {
             this.handleApiError(err);
         }
         if (flags.json) {
-            this.log(JSON.stringify((0, web_url_1.withDataUrls)(this.cliConfig.baseURL, response, web_url_1.taskUrlFrom), null, 2));
+            // The table renders REF and NEXT, but the raw payload names them
+            // `identifier` and `actionability` — under `--json` an agent scanning 43
+            // keys could not find either (OSK-10692). Alias them to the names the
+            // table prints so the machine view answers the same questions.
+            const list = response;
+            const enriched = list && Array.isArray(list.data)
+                ? {
+                    ...list,
+                    data: list.data.map((t) => ({
+                        ...t,
+                        ref: taskRef(t),
+                        nextAction: nextActionText(t),
+                    })),
+                }
+                : response;
+            this.log(JSON.stringify((0, web_url_1.withDataUrls)(this.cliConfig.baseURL, enriched, web_url_1.taskUrlFrom), null, 2));
             return;
         }
         if (calendarRange) {
@@ -427,23 +511,15 @@ class TasksList extends base_command_1.BaseCommand {
             const agents = Array.isArray(t.assigneeAgentIds) ? t.assigneeAgentIds.length : 0;
             const users = Array.isArray(t.assigneeUserIds) ? t.assigneeUserIds.length : 0;
             const assignees = agents + users > 0 ? `${agents}a/${users}u` : '-';
-            const actionability = t.actionability;
             return {
                 id: String(t.id ?? t._id ?? '-'),
-                ident: String(t.identifier ?? (t.taskNumber ? `#${t.taskNumber}` : '-')),
+                ident: taskRef(t),
                 title: String(t.title ?? '-'),
                 status: String(t.status ?? '-'),
                 priority: String(t.priority ?? '-'),
                 estimate: t.estimate === null || t.estimate === undefined ? '-' : String(t.estimate),
                 assignees,
-                // `reason` is the sentence the server wrote for a person; `reasonCode`
-                // is the enum it wrote for a machine. Printing the code rendered every
-                // stage of every lifecycle as `human:lifecycle_stage` — six different
-                // waits, one string — while the sentence naming the stage sat unread in
-                // the same payload.
-                next: actionability
-                    ? `${String(actionability.nextActor ?? '-')}: ${String(actionability.reason || actionability.reasonCode || actionability.state || '-')}`
-                    : String(t.executionMode ?? '-'),
+                next: nextActionText(t),
                 match: String(t._matchField ?? '-'),
             };
         });

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

@@ -27,6 +27,29 @@ export declare function taskPointerLines(t: Record<string, unknown>, ref: string
  * newest `blocker` Update and hands its payload here.
  */
 export declare function blockerDetailLines(detail: Record<string, unknown> | undefined): string[];
+/**
+ * The answer this command leads with: is it done?
+ *
+ * Everything below it in `tasks show` is still there — Status, Resolution,
+ * Result, Review, the Expectation counts. This does not replace them; it
+ * answers, in one sentence, the question a reader had to assemble from eleven
+ * concepts before. The projection is computed on the SERVER
+ * (`deriveTaskCompletion`), so this function renders and never decides: if the
+ * CLI derived it here, the board and a phone would each derive their own and
+ * the three would disagree about one Task.
+ *
+ * A read that FAILED prints its own line rather than nothing, because silence
+ * here is indistinguishable from "we had no concerns" — which is the exact
+ * collapse this whole projection exists to undo.
+ *
+ * Pure and exported so the wording is testable without an oclif runtime.
+ */
+export declare function completionLines(projection: {
+    sentence?: unknown;
+    alsoOutstanding?: unknown;
+} | null | undefined, { read }?: {
+    read?: boolean;
+}): string[];
 export declare function labelsLine(labelIds?: string[], nameById?: Map<string, string>): string;
 /**
  * The `Executor:` value — who does this task, and whether anyone said so.

package/dist/commands/tasks/show.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.taskPointerLines = taskPointerLines;
 exports.blockerDetailLines = blockerDetailLines;
+exports.completionLines = completionLines;
 exports.labelsLine = labelsLine;
 exports.taskExecutorLabel = taskExecutorLabel;
 exports.taskFailureLines = taskFailureLines;
@@ -76,6 +77,35 @@ function blockerDetailLines(detail) {
     }
     return lines;
 }
+/**
+ * The answer this command leads with: is it done?
+ *
+ * Everything below it in `tasks show` is still there — Status, Resolution,
+ * Result, Review, the Expectation counts. This does not replace them; it
+ * answers, in one sentence, the question a reader had to assemble from eleven
+ * concepts before. The projection is computed on the SERVER
+ * (`deriveTaskCompletion`), so this function renders and never decides: if the
+ * CLI derived it here, the board and a phone would each derive their own and
+ * the three would disagree about one Task.
+ *
+ * A read that FAILED prints its own line rather than nothing, because silence
+ * here is indistinguishable from "we had no concerns" — which is the exact
+ * collapse this whole projection exists to undo.
+ *
+ * Pure and exported so the wording is testable without an oclif runtime.
+ */
+function completionLines(projection, { read = true } = {}) {
+    if (!read) {
+        return ['Done?        could not be worked out just now — that check did not answer.'];
+    }
+    const sentence = typeof projection?.sentence === 'string' ? projection.sentence.trim() : '';
+    if (!sentence)
+        return [];
+    const also = Array.isArray(projection?.alsoOutstanding)
+        ? projection.alsoOutstanding.filter((row) => typeof row === 'string' && row.trim().length > 0)
+        : [];
+    return [`Done?        ${sentence}`, ...also.map((row) => `             also: ${row.trim()}`)];
+}
 function labelsLine(labelIds, nameById) {
     const ids = (labelIds ?? []).filter((id) => typeof id === 'string' && id.length > 0);
     if (ids.length === 0)
@@ -254,10 +284,30 @@ class TasksShow extends base_command_1.BaseCommand {
         }
         const t = task;
         const url = (0, web_url_1.taskUrlFrom)(this.cliConfig.baseURL, t);
+        /*
+         * The three-state answer, read from the server rather than worked out here.
+         *
+         * One extra request on a DETAIL view, for the line the whole command is
+         * read for. A failure is reported as a failure: `completionLines` prints
+         * that it could not be worked out, because a missing headline reads exactly
+         * like a clean one.
+         */
+        let completion = null;
+        let completionRead = true;
+        try {
+            const response = await data_provider_1.dataService.getTaskCompletion(String(t.id ?? taskId));
+            completion = (response?.completion ?? null);
+            completionRead = Boolean(completion);
+        }
+        catch {
+            completionRead = false;
+        }
         if (flags.json) {
-            this.log(JSON.stringify({ ...t, url }, null, 2));
+            this.log(JSON.stringify({ ...t, url, completion }, null, 2));
             return;
         }
+        for (const line of completionLines(completion, { read: completionRead }))
+            this.log(line);
         const agents = Array.isArray(t.assigneeAgentIds) ? t.assigneeAgentIds : [];
         const users = Array.isArray(t.assigneeUserIds) ? t.assigneeUserIds : [];
         this.log(`ID:          ${t.id ?? t._id ?? '-'}`);

package/dist/commands/wiki/rm.d.ts

@@ -1,13 +1,34 @@
 import { BaseCommand } from '../../base-command';
+/**
+ * What to say when a page path does not resolve.
+ *
+ * A path is a SLUG, and renaming a page deliberately does not move it — that
+ * is what keeps a stored `skrr wiki` address working. The consequence is that
+ * a caller who types the page's TITLE is always wrong, and every page created
+ * in the web UI is `untitled`, `untitled-2`, … The old message named the
+ * failure and stopped, which leaves the one question the caller now has
+ * unanswered: where are the real paths? (OSK-10694)
+ *
+ * Exported so the wording is testable without driving the command.
+ */
+export declare function missingPagePathError({ path, spaceId, binName, }: {
+    path: string;
+    spaceId: string;
+    binName: string;
+}): {
+    message: string;
+    code: string;
+};
 export default class WikiRm extends BaseCommand {
     static description: string;
     static examples: string[];
     static args: {
         space: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
-        path: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+        path: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
     };
     static flags: {
         json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'page-id': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         force: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         purge: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
     };

package/dist/commands/wiki/rm.js

@@ -1,11 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.missingPagePathError = missingPagePathError;
 const core_1 = require("@oclif/core");
 const data_provider_1 = require("@skrr-ai/data-provider");
 const base_command_1 = require("../../base-command");
 const http_error_1 = require("../../lib/http-error");
 const prompt_1 = require("../../lib/prompt");
 const wiki_1 = require("../../lib/wiki");
+/**
+ * What to say when a page path does not resolve.
+ *
+ * A path is a SLUG, and renaming a page deliberately does not move it — that
+ * is what keeps a stored `skrr wiki` address working. The consequence is that
+ * a caller who types the page's TITLE is always wrong, and every page created
+ * in the web UI is `untitled`, `untitled-2`, … The old message named the
+ * failure and stopped, which leaves the one question the caller now has
+ * unanswered: where are the real paths? (OSK-10694)
+ *
+ * Exported so the wording is testable without driving the command.
+ */
+function missingPagePathError({ path, spaceId, binName, }) {
+    return {
+        message: `No page at path '${path}'. Paths are slugs and do not follow a page's title, ` +
+            `so list them with \`${binName} wiki ls ${spaceId}\` (or \`wiki tree\`), ` +
+            `or address the page directly with --page-id.`,
+        code: 'NOT_FOUND',
+    };
+}
 class WikiRm extends base_command_1.BaseCommand {
     // "recoverable" promised something no command can deliver: the row is
     // archived rather than destroyed, but nothing in `skrr wiki` — or in the model
@@ -19,10 +40,17 @@ class WikiRm extends base_command_1.BaseCommand {
     ];
     static args = {
         space: core_1.Args.string({ description: 'Space ID', required: true, ignoreStdin: true }),
-        path: core_1.Args.string({ description: 'Page path', required: true, ignoreStdin: true }),
+        path: core_1.Args.string({ description: 'Page path', required: false, ignoreStdin: true }),
     };
     static flags = {
         json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+        // `wiki cat` has had this since it shipped; the two commands that MUTATE a
+        // page did not, which is backwards. Every create and every rm hands the
+        // caller a page id — rm's own success line tells you to read the archived
+        // page back with `wiki cat --page-id` — so an agent holding an id could
+        // read the page and not remove it without first translating the id into a
+        // slug through `wiki tree` (OSK-10694).
+        'page-id': core_1.Flags.string({ description: 'Address the page by id instead of path' }),
         // `--yes` is the CLI-wide name for this (62 of 64 destructive commands use
         // it) and is what the non-TTY guard tells a script to pass. `--force`/`-f`
         // predates that convention here and stays for back-compat.
@@ -47,16 +75,37 @@ class WikiRm extends base_command_1.BaseCommand {
     async run() {
         this.requireAuth();
         const { args, flags } = await this.parse(WikiRm);
+        if (!args.path && !flags['page-id']) {
+            this.failWithCliError({
+                message: 'Provide a page path or --page-id.',
+                code: 'WIKI_PATH_REQUIRED',
+                exit: 1,
+                retryable: false,
+            });
+        }
         let page;
         try {
-            page = await data_provider_1.dataService.getSpaceWikiPageByPath(args.space, args.path);
+            page = flags['page-id']
+                ? await data_provider_1.dataService.getSpaceWikiPage(args.space, flags['page-id'])
+                : await data_provider_1.dataService.getSpaceWikiPageByPath(args.space, args.path);
         }
         catch (err) {
             // `rm` addresses pages. Pointing a folder path at it used to report the
             // bare "No page at path 'X'", which reads as "nothing is there" when in
             // fact a folder is — send the caller to the verb that removes one.
-            if ((0, http_error_1.isHttpNotFound)(err)) {
+            if ((0, http_error_1.isHttpNotFound)(err) && args.path) {
                 const folderId = await (0, wiki_1.resolveWikiFolderId)(args.space, args.path, data_provider_1.dataService.listSpaceWikiDirectory, http_error_1.isHttpNotFound).catch(() => null);
+                if (!folderId) {
+                    this.failWithCliError({
+                        ...missingPagePathError({
+                            path: args.path,
+                            spaceId: args.space,
+                            binName: this.config.bin,
+                        }),
+                        exit: 1,
+                        retryable: false,
+                    });
+                }
                 if (folderId) {
                     this.failWithCliError({
                         message: `'${args.path}' is a folder, not a page. Remove it with \`${this.config.bin} wiki rmdir ${args.space} ${args.path}\`.`,

package/dist/lib/agentic-stream.js

@@ -662,8 +662,16 @@ class AgenticStreamClient {
                 this.finish('failed', event);
         });
         socket.on('permission:request', (event) => {
-            if (match(event))
-                void this.handlePermission(event);
+            if (!match(event))
+                return;
+            // One ask, one answer (OSK-11796). The same `permission:request` can
+            // arrive twice — a `session:join` replay overlapping the live emit, or
+            // fan-out through a second room — and each copy used to emit its own
+            // `permission.requested` AND send its own approve/deny, so a duplicate
+            // delivery produced a duplicate prompt and a racing second decision.
+            if (!this.firstTimeSeen('permission', event.toolUseId))
+                return;
+            void this.handlePermission(event);
         });
         socket.on('question:ask', (event) => {
             if (match(event))

package/dist/lib/balance.d.ts

@@ -1,4 +1,4 @@
-import type { TSubscription, TSkyCodeUsageEvents, TSkyCodeUsageSnapshot } from '@skrr-ai/data-provider';
+import type { TSubscription, TSkyCodeUsageBreakdown, TSkyCodeUsageEvents, TSkyCodeUsageSnapshot } from '@skrr-ai/data-provider';
 /**
  * balance.ts — request client for `/api/balance`.
  *
@@ -91,6 +91,11 @@ export declare function getSkyCodeUsageEvents(workspaceId: string | undefined, p
     cursor?: string;
     limit?: number;
 }): Promise<TSkyCodeUsageEvents>;
+export declare function getSkyCodeUsageBreakdown(workspaceId: string | undefined, params?: {
+    from?: string;
+    to?: string;
+    productFamily?: string;
+}): Promise<TSkyCodeUsageBreakdown>;
 /** Recent token transactions, newest first. Cursor is an ISO createdAt. */
 export declare function getBalanceHistory(limit: number, cursor?: string): Promise<BalanceHistory>;
 /**

package/dist/lib/balance.js

@@ -6,6 +6,7 @@ exports.getSkyCodeUsage = getSkyCodeUsage;
 exports.getSkyCodeSubscription = getSkyCodeSubscription;
 exports.setSkyCodeOverageConsent = setSkyCodeOverageConsent;
 exports.getSkyCodeUsageEvents = getSkyCodeUsageEvents;
+exports.getSkyCodeUsageBreakdown = getSkyCodeUsageBreakdown;
 exports.getBalanceHistory = getBalanceHistory;
 exports.formatCredits = formatCredits;
 exports.getWorkspaceBalance = getWorkspaceBalance;
@@ -57,6 +58,20 @@ async function getSkyCodeUsageEvents(workspaceId, params = {}) {
     const suffix = query.toString();
     return (0, api_fetch_1.apiFetch)(suffix ? `${base}?${suffix}` : base);
 }
+async function getSkyCodeUsageBreakdown(workspaceId, params = {}) {
+    const query = new URLSearchParams();
+    if (params.from)
+        query.set('from', params.from);
+    if (params.to)
+        query.set('to', params.to);
+    if (params.productFamily)
+        query.set('productFamily', params.productFamily);
+    const base = workspaceId
+        ? `/api/balance/usage/sky-code/workspace/${encodeURIComponent(workspaceId)}/breakdown`
+        : '/api/balance/usage/sky-code/breakdown';
+    const suffix = query.toString();
+    return (0, api_fetch_1.apiFetch)(suffix ? `${base}?${suffix}` : base);
+}
 /** Recent token transactions, newest first. Cursor is an ISO createdAt. */
 async function getBalanceHistory(limit, cursor) {
     const query = new URLSearchParams({ limit: String(limit) });

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

@@ -0,0 +1,48 @@
+/**
+ * The shape every commerce and governed-store write shares.
+ *
+ * These endpoints validate rich bodies with their own zod schemas, and the CLI
+ * deliberately does not restate those shapes as flags. Two reasons, and the
+ * second is the one that bites:
+ *
+ * 1. A vocabulary declared twice drifts. The server owns what a contract, an
+ *    offer version or a budget policy looks like; a flag table here would be a
+ *    second declaration that silently falls behind the API that rejects it.
+ * 2. These are financial writes. A flag table invites a half-specified body
+ *    assembled from defaults; a file you wrote and can diff is a document you
+ *    reviewed. `-` reads stdin, so a pipeline still works.
+ *
+ * What the CLI DOES own is refusing to send nothing: a mutation whose body is
+ * required will not be fired with `{}` just because a path was omitted.
+ */
+export declare const jsonBodyFlags: {
+    file: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+};
+export interface JsonBodyOwner {
+    error(message: string, options?: {
+        exit?: number;
+    }): never | void;
+}
+/**
+ * Read `--file`, refusing an empty body when the endpoint requires one.
+ *
+ * `required: false` is for the verbs whose body is genuinely optional — an
+ * offer `publish` carries nothing but its id — where `{}` is the honest
+ * request rather than a missing argument.
+ */
+export declare function jsonBodyFrom(command: JsonBodyOwner, file: string | undefined, { required }?: {
+    required?: boolean;
+}): Promise<Record<string, unknown>>;
+/**
+ * Print a result.
+ *
+ * Deliberately JSON-by-default for these surfaces rather than a summary line.
+ * A contract, a budget evaluation or an entitlement explanation is a DOCUMENT
+ * whose fields an operator is about to reason about; summarising it would be
+ * choosing for them which parts of a financial record matter, and every field
+ * this CLI hides is one they would have to open a browser to see.
+ */
+export declare function printResult(command: {
+    log(message: string): void;
+}, result: unknown, humanSummary?: string[]): void;

package/dist/lib/commerce-command.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jsonBodyFlags = void 0;
+exports.jsonBodyFrom = jsonBodyFrom;
+exports.printResult = printResult;
+const core_1 = require("@oclif/core");
+const prompt_1 = require("./prompt");
+/**
+ * The shape every commerce and governed-store write shares.
+ *
+ * These endpoints validate rich bodies with their own zod schemas, and the CLI
+ * deliberately does not restate those shapes as flags. Two reasons, and the
+ * second is the one that bites:
+ *
+ * 1. A vocabulary declared twice drifts. The server owns what a contract, an
+ *    offer version or a budget policy looks like; a flag table here would be a
+ *    second declaration that silently falls behind the API that rejects it.
+ * 2. These are financial writes. A flag table invites a half-specified body
+ *    assembled from defaults; a file you wrote and can diff is a document you
+ *    reviewed. `-` reads stdin, so a pipeline still works.
+ *
+ * What the CLI DOES own is refusing to send nothing: a mutation whose body is
+ * required will not be fired with `{}` just because a path was omitted.
+ */
+exports.jsonBodyFlags = {
+    file: core_1.Flags.string({
+        description: 'Path to the JSON body, or - to read stdin',
+    }),
+    json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+};
+/**
+ * Read `--file`, refusing an empty body when the endpoint requires one.
+ *
+ * `required: false` is for the verbs whose body is genuinely optional — an
+ * offer `publish` carries nothing but its id — where `{}` is the honest
+ * request rather than a missing argument.
+ */
+async function jsonBodyFrom(command, file, { required = true } = {}) {
+    if (!file) {
+        if (!required)
+            return {};
+        command.error('This write needs a body: pass --file <path> (or --file - to read stdin). The body is ' +
+            'validated by the server, which owns its shape — see the command help for what it expects.', { exit: 2 });
+        return {};
+    }
+    try {
+        return await (0, prompt_1.readJsonBody)(file);
+    }
+    catch (error) {
+        command.error(error instanceof Error ? error.message : String(error), { exit: 1 });
+        return {};
+    }
+}
+/**
+ * Print a result.
+ *
+ * Deliberately JSON-by-default for these surfaces rather than a summary line.
+ * A contract, a budget evaluation or an entitlement explanation is a DOCUMENT
+ * whose fields an operator is about to reason about; summarising it would be
+ * choosing for them which parts of a financial record matter, and every field
+ * this CLI hides is one they would have to open a browser to see.
+ */
+function printResult(command, result, humanSummary) {
+    if (humanSummary?.length) {
+        for (const line of humanSummary)
+            command.log(line);
+        return;
+    }
+    command.log(JSON.stringify(result, null, 2));
+}