@skrr-ai/cli 0.1.60 → 0.1.62

package/dist/commands/subscriptions/subscribe.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");
 class SubscriptionsSubscribe extends base_command_1.BaseCommand {
-    static description = 'Subscribe to a published service — installs your own managed instance and opens the obligation it is delivered through';
+    static description = 'Subscribe to a published Service — pays its first period from your balance, installs your own managed instance, and opens the obligation it is delivered through. Shows the price and asks you to confirm first.';
     static examples = [
         '<%= config.bin %> subscriptions subscribe agent_abc123',
-        '<%= config.bin %> subscriptions subscribe agent_abc123 --billing-mode per-user',
+        '<%= config.bin %> subscriptions subscribe agent_abc123 --space space_xyz --yes --json',
+        '<%= config.bin %> subscriptions subscribe agent_abc123 --grant cegrant_abc',
         '<%= config.bin %> subscriptions subscribe agent_abc123 --space space_xyz --json',
     ];
     static args = {
@@ -19,24 +21,75 @@ class SubscriptionsSubscribe extends base_command_1.BaseCommand {
     };
     static flags = {
         json: core_1.Flags.boolean({ description: 'Output as JSON' }),
-        'billing-mode': core_1.Flags.string({
-            description: 'Who pays for the inference this service consumes',
-            options: ['owner', 'per-user', 'shared'],
-        }),
-        'expires-at': core_1.Flags.string({ description: 'Paid-through date (ISO 8601)' }),
+        // No --billing-mode and no --expires-at: who pays for the compute is
+        // declared by the Service's offer, and the term and price are resolved
+        // server-side — a caller-sent one is refused (C11, OSK-12276).
         space: core_1.Flags.string({ description: 'Space the service should work in' }),
+        grant: core_1.Flags.string({
+            description: 'Activate a period that was already paid (its grant id) instead of buying one. Nothing is charged.',
+        }),
+        trial: core_1.Flags.boolean({
+            description: 'Start the card-free trial instead of buying: 7 days, nothing charged, does not renew (OSK-12281).',
+        }),
+        yes: core_1.Flags.boolean({
+            char: 'y',
+            description: 'Confirm the purchase without prompting. The price and refund terms are still printed.',
+        }),
     };
     async run() {
         this.requireAuth();
         const { args, flags } = await this.parse(SubscriptionsSubscribe);
+        if (flags.trial) {
+            return this.startTrial(args.agentId, flags);
+        }
+        let pin;
+        if (!flags.grant) {
+            // What subscribing would charge NOW, resolved by the server the way the
+            // purchase resolves it. The purchase then pins what was shown, so a
+            // Service whose price moved in between is refused rather than charged.
+            let quote;
+            try {
+                quote = await data_provider_1.dataService.getStoreAgentServiceOffer(args.agentId);
+            }
+            catch (err) {
+                this.handleApiError(err);
+            }
+            if (!quote) {
+                this.error('Could not read the price of this Service, so nothing was bought.', {
+                    exit: 1,
+                });
+            }
+            const name = quote.listingName || args.agentId;
+            const version = quote.versionLabel ? ` v${quote.versionLabel}` : '';
+            const price = (0, data_provider_1.formatStoreServicePrice)(quote.price, quote.interval);
+            // Printed before any prompt and even with --yes, so a scripted purchase
+            // still leaves the terms it agreed to in its own output.
+            this.logToStderr(`${name}${version} is a Service.`);
+            this.logToStderr(`  Price:        ${price} (${quote.currency})`);
+            this.logToStderr(`  Billing:      charged from your balance now, then every ${quote.interval} until you cancel`);
+            this.logToStderr(`  Refunds:      ${(0, data_provider_1.describeStoreAcquisitionRefundTerms)(quote.refundTerms)}`);
+            this.logToStderr(`  Buyer terms:  ${quote.buyerTerms
+                ? `${quote.buyerTerms.termsVersion} — ${quote.buyerTerms.artifactUri}`
+                : 'not configured'}`);
+            this.logToStderr(`  Offer:        ${quote.offerVersionId}`);
+            if (!quote.purchasable) {
+                this.error('Service subscriptions are not open for purchase yet. Nothing was bought.', {
+                    exit: 1,
+                });
+            }
+            const confirmed = await (0, prompt_1.confirmDestructive)(`Subscribe to ${name} for ${price} and accept the buyer terms?`, flags.yes).catch((err) => this.error(err.message, { exit: err.exit ?? 1 }));
+            if (!confirmed) {
+                this.log('Cancelled. Nothing was bought.');
+                return;
+            }
+            pin = { expectedOfferVersionId: quote.offerVersionId, expectedPrice: quote.price };
+        }
         let response;
         try {
             response = await data_provider_1.dataService.subscribeToStoreAgent(args.agentId, {
-                ...(flags['billing-mode']
-                    ? { billingMode: flags['billing-mode'] }
-                    : {}),
-                ...(flags['expires-at'] ? { expiresAt: flags['expires-at'] } : {}),
                 ...(flags.space ? { spaceId: flags.space } : {}),
+                ...(flags.grant ? { grantId: flags.grant } : {}),
+                ...(pin ?? {}),
             });
         }
         catch (err) {
@@ -48,7 +101,10 @@ class SubscriptionsSubscribe extends base_command_1.BaseCommand {
         }
         this.log(`Subscribed. Entitlement ${response?.entitlementId}`);
         this.log(`Your instance: ${response?.instanceAgentId ?? '-'}`);
-        this.log(`Compute paid by: ${response?.billingMode}`);
+        if (response?.expiresAt) {
+            this.log(`Paid through: ${response.expiresAt}`);
+        }
+        this.log(`Compute paid by: ${(0, data_provider_1.describeStoreComputePayer)(response?.computePayer)}`);
         if (response?.commitmentId) {
             // The commitment is the thing you can hold the service to — surface it,
             // because "is it working" is answered there and nowhere else.
@@ -59,5 +115,78 @@ class SubscriptionsSubscribe extends base_command_1.BaseCommand {
             this.log('Note: the subscription is live but its obligation has not been created yet. It is resumable and refundable; retry to finish opening it.');
         }
     }
+    /**
+     * The card-free trial path (OSK-12281). The trial's own terms — days, the
+     * platform compute budget — come from the quote's `trial` block the server
+     * computed for this caller, so what is printed is what the write will do.
+     */
+    async startTrial(agentId, flags) {
+        let quote;
+        try {
+            quote = await data_provider_1.dataService.getStoreAgentServiceOffer(agentId);
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+        const trial = quote?.trial;
+        if (!quote || !trial) {
+            this.error('This Service does not offer a trial, or yours cannot be read. Nothing happened.', {
+                exit: 1,
+            });
+        }
+        const name = quote.listingName || agentId;
+        if (trial.state === 'active_trial') {
+            this.logToStderr(`Your trial of ${name} is already running — it ends ${trial.endsAt}.`);
+        }
+        else if (trial.requiresPaymentMethod) {
+            this.error('This Service\u2019s trial requires a payment method — the card-free trial cannot start it.', {
+                exit: 1,
+            });
+        }
+        else if (trial.state !== 'eligible') {
+            const TRIAL_BLOCKED_REASONS = {
+                already_used: 'you already used your trial for this product family',
+                subscribed: 'you already subscribe to this Service',
+                purchased: 'you already bought this Service',
+                copy_owned: 'you already own a copy of this agent in this workspace',
+            };
+            const why = TRIAL_BLOCKED_REASONS[trial.state] ||
+                'the server did not name a reason this trial is closed to you';
+            this.error(`This trial cannot be started: ${why}.`, { exit: 1 });
+        }
+        // Printed before any prompt and even with --yes: the terms it agreed to.
+        this.logToStderr(`${name} offers a ${trial.durationDays}-day free trial.`);
+        this.logToStderr('  Card:        not required — nothing is charged');
+        this.logToStderr('  Renewal:     none — it stops working when the trial ends');
+        this.logToStderr(`  Compute:     covered by the platform${trial.computeBudgetMicros
+            ? `, up to ${(0, data_provider_1.formatStoreAcquisitionPrice)(trial.computeBudgetMicros)}`
+            : ''}`);
+        this.logToStderr('  Limit:       one trial per product family');
+        const confirmed = await (0, prompt_1.confirmDestructive)(`Start the ${trial.durationDays}-day free trial of ${name}?`, flags.yes ?? false).catch((err) => this.error(err.message, { exit: err.exit ?? 1 }));
+        if (!confirmed) {
+            this.log('Cancelled. Nothing was started.');
+            return;
+        }
+        let response;
+        try {
+            response = await data_provider_1.dataService.startStoreAgentServiceTrial(agentId, {
+                ...(flags.space ? { spaceId: flags.space } : {}),
+                expectedOfferVersionId: quote.offerVersionId,
+            });
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+        if (flags.json) {
+            this.log(JSON.stringify(response, null, 2));
+            return;
+        }
+        this.log(`Trial started. Entitlement ${response?.entitlementId}`);
+        this.log(`Your instance: ${response?.instanceAgentId ?? '-'}`);
+        if (response?.expiresAt) {
+            this.log(`Trial ends: ${response.expiresAt} (it does not renew)`);
+        }
+        this.log(`Compute paid by: ${(0, data_provider_1.describeStoreComputePayer)(response?.computePayer)}`);
+    }
 }
 exports.default = SubscriptionsSubscribe;

package/dist/commands/tasks/comments/list.js

@@ -4,6 +4,7 @@ const core_1 = require("@oclif/core");
 const data_provider_1 = require("@skrr-ai/data-provider");
 const base_command_1 = require("../../../base-command");
 const format_1 = require("../../../lib/format");
+const principal_display_1 = require("../../../lib/principal-display");
 const task_resolver_1 = require("../../../lib/task-resolver");
 class TasksCommentsList extends base_command_1.BaseCommand {
     static description = 'List comments on a task';
@@ -67,9 +68,16 @@ class TasksCommentsList extends base_command_1.BaseCommand {
             this.log('No comments.');
             return;
         }
+        // The AUTHOR column is for "who" — resolve ids to names where the task's
+        // space roster (or the caller's own record) can see them; ids that cannot
+        // resolve print unchanged.
+        const principalNames = await (0, principal_display_1.resolvePrincipalNames)(items.map((c) => c.authorAgentId ?? c.authorUserId ?? c.author));
         const rows = items.map((c) => ({
             time: (0, format_1.localTime)(c.createdAt),
-            author: String(c.authorAgentId ?? c.authorUserId ?? c.author ?? '-'),
+            // The server enriches authors directly (_authorUserName/_authorAgentName);
+            // the roster lookup is the fallback for a deployment that predates it.
+            author: String(c._authorUserName ?? c._authorAgentName ?? '') ||
+                (0, principal_display_1.displayPrincipal)(c.authorAgentId ?? c.authorUserId ?? c.author, principalNames),
             body: (0, format_1.truncate)(String(c.body ?? c.content ?? '-'), 60),
             id: String(c.id ?? c._id ?? '-'),
         }));

package/dist/commands/tasks/labels/attach.js

@@ -60,6 +60,18 @@ class TasksLabelsAttach extends base_command_1.BaseCommand {
                 this.error(err.message, { exit: 1 });
             this.handleApiError(err);
         }
+        // Output names labels, not ids — the reader wants "what", not "which uuid".
+        // resolveLabelRefs already fetched the vocabulary; fetching again here costs
+        // one request and keeps the failure mode (unreadable vocabulary → ids) safe.
+        let nameById;
+        try {
+            const vocabulary = await (0, label_ref_1.collectLabelVocabulary)({ applicableTo: 'task' });
+            nameById = new Map(vocabulary.map((row) => [row.id, row.name]));
+        }
+        catch {
+            nameById = undefined;
+        }
+        const nameFor = (id) => nameById?.get(id) ?? id;
         let current;
         try {
             current = await data_provider_1.dataService.getTask(args.id, { enrich: false });
@@ -72,7 +84,8 @@ class TasksLabelsAttach extends base_command_1.BaseCommand {
         // genuinely-new ids in the order they were passed.
         const merged = Array.from(new Set([...existing, ...incoming]));
         if (merged.length === existing.length) {
-            this.log(`No change — labels already attached: ${incoming.join(', ')}`);
+            const names = incoming.map((id) => nameFor(id));
+            this.log(`No change — labels already attached: ${names.join(', ')}`);
             if (flags.json)
                 this.log(JSON.stringify(current, null, 2));
             return;
@@ -93,7 +106,7 @@ class TasksLabelsAttach extends base_command_1.BaseCommand {
         }
         const t = updated;
         const ref = t.identifier ?? (t.taskNumber ? `#${t.taskNumber}` : '');
-        this.log(`Attached ${merged.length - existing.length} label(s) to task ${t.id ?? args.id}${ref ? ` (${ref})` : ''} — now: ${merged.join(', ')}`);
+        this.log(`Attached ${merged.length - existing.length} label(s) to task ${t.id ?? args.id}${ref ? ` (${ref})` : ''} — now: ${merged.map(nameFor).join(', ')}`);
     }
 }
 exports.default = TasksLabelsAttach;

package/dist/commands/tasks/show.js

@@ -16,6 +16,7 @@ const task_resolver_1 = require("../../lib/task-resolver");
 const web_url_1 = require("../../lib/web-url");
 const html_text_1 = require("../../lib/html-text");
 const label_ref_1 = require("../../lib/label-ref");
+const principal_display_1 = require("../../lib/principal-display");
 const format_1 = require("../../lib/format");
 /**
  * Where to look next — as COMMANDS, not as facts about the task.
@@ -472,10 +473,21 @@ class TasksShow extends base_command_1.BaseCommand {
             }
         }
         this.log(`Labels:      ${labelsLine(labelIds, labelNames)}`);
-        this.log(`Author:      ${t.author ?? '-'}`);
+        // Principals print as names, not ObjectIds — same rule as labels above: a
+        // roster that cannot be read prints ids rather than failing the command.
+        const principalIds = [
+            t.author,
+            t.dri?.resolved?.id,
+            ...(Array.isArray(t.assigneeAgentIds) ? t.assigneeAgentIds : []),
+            ...(Array.isArray(t.assigneeUserIds) ? t.assigneeUserIds : []),
+        ];
+        const principalNames = await (0, principal_display_1.resolvePrincipalNames)(principalIds, {
+            spaceId: t.spaceId ?? null,
+        });
+        this.log(`Author:      ${t.authorDisplayName || (0, principal_display_1.displayPrincipal)(t.author, principalNames)}`);
         const dri = t.dri;
         if (dri?.resolved) {
-            this.log(`DRI:         ${String(dri.resolved.kind ?? '-')} ${String(dri.resolved.id ?? '-')} (${String(dri.source ?? '-')})`);
+            this.log(`DRI:         ${String(dri.resolved.kind ?? '-')} ${(0, principal_display_1.displayPrincipal)(dri.resolved.id, principalNames)} (${String(dri.source ?? '-')})`);
         }
         else {
             this.log('DRI:         -');
@@ -484,7 +496,9 @@ class TasksShow extends base_command_1.BaseCommand {
         // live. It was only reachable via `--json | jq .conversationId`, so the
         // transcript was effectively undiscoverable from the human view.
         this.log(`Convo:       ${t.conversationId ?? '-'}`);
-        this.log(`Assignees:   ${agents.length} agent(s), ${users.length} user(s)${agents.length + users.length > 0 ? ` — ${[...agents, ...users].join(', ')}` : ''}`);
+        this.log(`Assignees:   ${agents.length} agent(s), ${users.length} user(s)${agents.length + users.length > 0
+            ? ` — ${[...agents, ...users].map((id) => (0, principal_display_1.displayPrincipal)(id, principalNames)).join(', ')}`
+            : ''}`);
         const actionability = t.actionability;
         if (actionability) {
             this.log(`Next action: ${actionability.nextActor ?? '-'} · ${actionability.state ?? '-'} · ${actionability.reasonCode ?? '-'}`);

package/dist/commands/tasks/update.js

@@ -277,9 +277,12 @@ class TasksUpdate extends base_command_1.BaseCommand {
             body.expectations !== undefined ||
             flags.description !== undefined ||
             body.description !== undefined;
+        // Hoisted so the post-write notice can still say how much the edit cost
+        // when `--yes` skipped the prompt — the revocation happens either way.
+        let settledSpecAssessments = 0;
+        let acceptanceUnreadable = false;
         if (changesSpec) {
             let settled = [];
-            let unreadable = false;
             try {
                 const acceptance = await data_provider_1.dataService.getTaskAcceptance(taskIdentity.id);
                 settled = acceptance.expectations.filter((e) => e.assessmentId);
@@ -287,11 +290,12 @@ class TasksUpdate extends base_command_1.BaseCommand {
             catch {
                 // An unreadable acceptance is not a reason to refuse the edit. Warn
                 // without a number rather than inventing one or blocking the write.
-                unreadable = true;
+                acceptanceUnreadable = true;
             }
-            if ((unreadable || settled.length > 0) && !flags.yes) {
+            settledSpecAssessments = settled.length;
+            if ((acceptanceUnreadable || settled.length > 0) && !flags.yes) {
                 const noun = settled.length === 1 ? 'assessment' : 'assessments';
-                const count = unreadable ? 'Any existing' : `${settled.length} existing`;
+                const count = acceptanceUnreadable ? 'Any existing' : `${settled.length} existing`;
                 const field = expectationsPatch !== undefined || body.expectations !== undefined
                     ? 'Changing Expectations'
                     : 'Changing the description';
@@ -478,6 +482,13 @@ class TasksUpdate extends base_command_1.BaseCommand {
         const t = updated;
         const ref = t.identifier ?? (t.taskNumber ? `#${t.taskNumber}` : '');
         this.log(`Updated task ${t.id ?? t._id ?? taskIdentity.id}${ref ? ` (${ref})` : ''} — ${t.title ?? '(no title)'}`);
+        // `--yes` asserts the revocation; it does not erase that it happened.
+        // Report the cost after the write too, or the evidence is silently gone.
+        if (changesSpec && flags.yes && (settledSpecAssessments > 0 || acceptanceUnreadable)) {
+            this.log(`Specification advanced — ${settledSpecAssessments > 0
+                ? `${settledSpecAssessments} recorded assessment(s) no longer count`
+                : 'any recorded assessments no longer count'} and must be recorded again.`);
+        }
     }
 }
 exports.default = TasksUpdate;

package/dist/commands/tasks/updates/add.js

@@ -179,7 +179,11 @@ class TasksUpdatesAdd extends base_command_1.BaseCommand {
         }
         if (flags.json)
             return this.log(JSON.stringify(result, null, 2));
-        this.log(`Recorded ${flags.type} Update on ${task.id}${result?.resumePoint ? ' with a Resume Point' : ''}.`);
+        // A replayed idempotency key answers the SAME stored record — say so,
+        // otherwise a retried write reads as a second write.
+        this.log(result?.idempotent
+            ? `Update already recorded on ${task.id} (idempotent replay — no new write).`
+            : `Recorded ${flags.type} Update on ${task.id}${result?.resumePoint ? ' with a Resume Point' : ''}.`);
     }
 }
 exports.default = TasksUpdatesAdd;

package/dist/lib/agent-config.js

@@ -77,6 +77,7 @@ function mergeAgentConfigFlags(body, flags) {
         'model-parameters': 'model_parameters',
         'agent-ids': 'agent_ids',
         'network-agent-ids': 'network_agent_ids',
+        'network-shell-write-agent-ids': 'network_shell_write_agent_ids',
         'agent-actions': 'agentActions',
         skills: 'skills',
         'tool-policy': 'toolPolicy',

package/dist/lib/agent-evals.d.ts

@@ -0,0 +1,71 @@
+/**
+ * `skrr agents eval` — the pure half (OSK-12303): reading a case file, choosing
+ * the release, and rendering what the platform reports back.
+ *
+ * The CLI never grades anything. It uploads the cases once, then asks the API
+ * to run each planned trial; the API executes, grades and prices every trial
+ * itself, so nothing printed here is a number the CLI computed from its own
+ * observations.
+ */
+import type { AgentRelease, AgentReleaseEval, GetAgentReleaseEvalOptions, ReleaseEvalBaselineKind, ReleaseEvalCase, ReleaseEvalTrial, ReleaseEvalTrialPlanEntry, RunAgentReleaseEvalTrialResponse } from '@skrr-ai/data-provider';
+/** CLI spelling → API spelling. */
+export declare const EVAL_BASELINE_FLAG_VALUES: Record<string, ReleaseEvalBaselineKind>;
+/**
+ * Read `--cases`: a JSON file (a list, `{cases: [...]}`, or one case) or a
+ * directory of such files, read in name order — so the repo's golden set
+ * directory is a valid argument as-is.
+ */
+export declare function readEvalCases(casesPath: string): ReleaseEvalCase[];
+/**
+ * `--release`: an id, a version label (`1.2` or `v1.2`), or omitted for the
+ * newest release. Releases arrive newest first.
+ */
+export declare function pickRelease(releases: AgentRelease[], wanted?: string): AgentRelease | undefined;
+/** The planned trials that have no graded result yet, in run order. */
+export declare function pendingTrials(evaluation: AgentReleaseEval): ReleaseEvalTrialPlanEntry[];
+export declare function describeTrialLine(evaluation: AgentReleaseEval, trial: ReleaseEvalTrial, position: number, total: number, replayed?: boolean): string;
+export declare function describeEvalHeader(evaluation: AgentReleaseEval): string[];
+/** The comparison, the per-case table, and the provenance lines. */
+export declare function describeEvalReport(evaluation: AgentReleaseEval): string[];
+/**
+ * The two calls one trial needs. Injected so the loop is testable without a
+ * server: `start` is `dataService.runAgentReleaseEvalTrial`, `observe` is
+ * `dataService.getAgentReleaseEval` with `{ trial, waitMs }`.
+ */
+export type EvalTrialClient = {
+    start: (entry: ReleaseEvalTrialPlanEntry) => Promise<RunAgentReleaseEvalTrialResponse>;
+    observe: (options: GetAgentReleaseEvalOptions) => Promise<AgentReleaseEval>;
+    sleep?: (ms: number) => Promise<void>;
+    now?: () => number;
+};
+export type EvalTrialOutcome = {
+    trial: ReleaseEvalTrial;
+    evaluation: AgentReleaseEval;
+    replayed: boolean;
+};
+/** A trial that ended without a result; `message` is the server's reason. */
+export declare class EvalTrialFailedError extends Error {
+    readonly key: string;
+    constructor(key: string, message: string);
+}
+/** How long one trial is observed before the CLI gives up and says how to resume. */
+export declare const EVAL_TRIAL_OBSERVE_LIMIT_MS: number;
+/**
+ * Whether a failed START may still have started the trial, or found it
+ * running: an edge timeout or dropped connection (the request may have landed),
+ * or the server saying another run holds it. Either way the answer is to
+ * observe the trial, not to give up — or to start a second run.
+ */
+export declare function isTrialStillRunningError(error: unknown): boolean;
+/**
+ * Run ONE planned trial to a graded result: start it, then observe it with
+ * bounded reads until it is graded. No request waits on the run itself.
+ *
+ * - A trial already graded comes back at once (`replayed`).
+ * - A start that fails in a way that may have started it (an edge 504, a
+ *   dropped connection) or that finds it running elsewhere is observed.
+ * - A run that errors is recorded by the server; that reason is thrown as an
+ *   `EvalTrialFailedError`, and a re-run is the caller's choice (`--resume`).
+ * - A claim whose run is gone (`stale`) is started again, which retakes it.
+ */
+export declare function runEvalTrial(client: EvalTrialClient, entry: ReleaseEvalTrialPlanEntry): Promise<EvalTrialOutcome>;