@skrr-ai/cli 0.1.38 → 0.1.40

package/dist/lib/dedicated-machines.js

@@ -5,6 +5,8 @@ exports.describeDedicatedImageStanding = describeDedicatedImageStanding;
 exports.dedicatedRuntimeCreateInput = dedicatedRuntimeCreateInput;
 exports.isDedicatedRepositoryRef = isDedicatedRepositoryRef;
 exports.createDedicatedRuntime = createDedicatedRuntime;
+exports.getDedicatedOperatorPriceBook = getDedicatedOperatorPriceBook;
+exports.dedicatedOperatorPriceBookLines = dedicatedOperatorPriceBookLines;
 exports.listDedicatedRuntimes = listDedicatedRuntimes;
 exports.getDedicatedRuntime = getDedicatedRuntime;
 exports.performDedicatedLeaseAction = performDedicatedLeaseAction;
@@ -157,6 +159,59 @@ async function createDedicatedRuntime(input) {
     const { requestId, workspaceId, ...body } = input;
     return (0, api_fetch_1.apiFetch)(withDedicatedScope('/api/machines/dedicated', { workspaceId }), { method: 'POST', body, headers: { 'Idempotency-Key': requestId } });
 }
+/**
+ * The Dedicated Runtime price book as an operator reads it: which version and
+ * which pricing policy, and each tier's rate, cost and margin. The customer
+ * catalog carries none of the policy or cost facts, and the admin plane that
+ * also serves this is not deployed in production (OSK-9562).
+ */
+async function getDedicatedOperatorPriceBook() {
+    return (0, api_fetch_1.apiFetch)('/api/machines/dedicated/price-book');
+}
+function formatBps(bps) {
+    return bps === null ? 'unknown' : `${(bps / 100).toFixed(1)}%`;
+}
+function formatRateCents(cents) {
+    return cents === null ? 'none' : `$${(cents / 100).toFixed(2)}/hr`;
+}
+/** Human lines for `machines dedicated price-book`. Pure, so it can be pinned. */
+function dedicatedOperatorPriceBookLines(read) {
+    const book = read.priceBook;
+    const lines = [
+        `Dedicated Runtime price book — ${book.approved ? 'approved' : 'NOT approved'}${book.required ? '' : ' (not required here)'}`,
+        `  version       ${book.version ?? 'not recorded'}`,
+        `  policy        ${book.pricingPolicyRef ?? 'not recorded'}`,
+        `  target margin ${formatBps(book.targetGrossMarginBps)}`,
+    ];
+    if (!book.approved && book.missingReason)
+        lines.push(`  why           ${book.missingReason}`);
+    if (read.availability === 'disabled' && read.disabledReason) {
+        lines.push(`  product       disabled: ${read.disabledReason}`);
+    }
+    if (read.configError)
+        lines.push(`  config        unreadable: ${read.configError}`);
+    lines.push('', 'Offered tiers');
+    if (book.presetChecks.length === 0)
+        lines.push('  none');
+    for (const check of book.presetChecks) {
+        const verdict = !check.priced
+            ? 'UNPRICED'
+            : !check.providerCostRecorded
+                ? 'UNCOSTED'
+                : check.marginTargetMet
+                    ? 'meets target'
+                    : 'BELOW TARGET';
+        lines.push(`  ${check.sizePreset.padEnd(12)} rate ${formatRateCents(check.customerRateCentsPerHour)} · cost ${formatRateCents(check.providerCostCentsPerHour)} · margin ${formatBps(check.grossMarginBps)} · ${verdict}`);
+    }
+    const withheld = read.sizeAvailability.filter((entry) => !entry.offered);
+    if (withheld.length > 0) {
+        lines.push('', 'Withheld tiers');
+        for (const entry of withheld) {
+            lines.push(`  ${entry.id.padEnd(12)} ${entry.withheldReason ?? 'no reason recorded'}`);
+        }
+    }
+    return lines;
+}
 async function listDedicatedRuntimes(options = {}) {
     const query = new URLSearchParams();
     if (options.limit)
@@ -411,10 +466,25 @@ function dedicatedSpendSummary(lease) {
         parts.push(`projected ${formatUsdCents(projected)}`);
     }
     if (billing.spendingLimitExceeded) {
-        parts.push('OVER CAP — compute is stopped, files are kept');
+        parts.push(`OVER CAP — ${overCapComputeClause(lease.state)}, files are kept`);
     }
     return parts.join(' · ');
 }
+/**
+ * What the cap has done to compute, in the tense the lease is actually in.
+ *
+ * This always said "compute is stopped", including for a machine that was still
+ * `requested` — which, over its cap, never provisions and cannot have its cap
+ * raised until it settles (OSK-9836). The reconciler stops compute for exactly
+ * `stopping`, `stopped` and `archived`; anything else is only on its way there.
+ */
+function overCapComputeClause(state) {
+    if (state === 'stopped' || state === 'archived')
+        return 'compute is stopped';
+    if (state === 'stopping')
+        return 'compute is stopping';
+    return 'compute will be stopped';
+}
 /**
  * The human rendering of `machines dedicated show`, as lines.
  *
@@ -1064,9 +1134,9 @@ function dedicatedRuntimeApiErrorDetails(err) {
  * say nothing to the person running it (OSK-8768); `--json` keeps them in
  * `error.details.reasons`.
  */
-function describeRefusalReasons(err) {
+function describeRefusalReasons(err, context = {}) {
     const details = dedicatedRuntimeApiErrorDetails(err);
-    const spend = describeSpendingCapRefusal(err.body, details);
+    const spend = describeSpendingCapRefusal(err.body, details, context);
     if (spend)
         return spend;
     const sentences = (0, harnesses_1.describeHealthReasonSentences)(details?.reasons, details?.state);
@@ -1078,7 +1148,7 @@ function describeRefusalReasons(err) {
  * the cap. Without them "would exceed the monthly cap" left a user guessing by
  * how much, and which cap (OSK-9552).
  */
-function describeSpendingCapRefusal(body, details) {
+function describeSpendingCapRefusal(body, details, context = {}) {
     let code;
     try {
         code = JSON.parse(body || '{}').code;
@@ -1102,9 +1172,25 @@ function describeSpendingCapRefusal(body, details) {
     ].filter(Boolean);
     if (parts.length === 0)
         return '';
-    return ` ${parts.join('; ')}. Raise the cap with \`machines dedicated spending-limit <lease-id> --cents <n>\`.`;
+    return ` ${parts.join('; ')}. ${raiseCapHint(context)}`;
+}
+/**
+ * How to get past a cap refusal, for the command that was refused. A create or
+ * a restore makes a NEW machine and takes its cap as a flag; only an existing
+ * machine has a lease id to raise. Every refusal used to say
+ * `machines dedicated spending-limit <lease-id>`, which a user refused on create
+ * had no lease id to run (OSK-9552).
+ */
+function raiseCapHint(context) {
+    const bin = context.bin || 'skrr';
+    const creates = context.command === 'machines:dedicated:create' ||
+        context.command === 'machines:dedicated:restore';
+    if (creates) {
+        return 'Pass a higher --spending-limit-cents: the cap is compared with the whole month, not with this machine alone.';
+    }
+    return `Raise the cap with \`${bin} machines dedicated spending-limit ${context.leaseId || '<lease-id>'} --cents <n>\`.`;
 }
-function formatDedicatedRuntimeApiError(err) {
+function formatDedicatedRuntimeApiError(err, context = {}) {
     if (!(err instanceof api_fetch_1.ApiFetchError) || !err.body) {
         return null;
     }
@@ -1132,7 +1218,7 @@ function formatDedicatedRuntimeApiError(err) {
         // Machine noun even though the caller named a Dedicated Runtime. Do not
         // repeat that contradictory product name while a mixed deployment rolls.
         const sentence = (parsed.message || parsed.error || parsed.code)?.replace(/(?:skrr )?Hosted Machine/g, 'Dedicated Runtime');
-        return sentence ? `${sentence}${describeRefusalReasons(err)}` : null;
+        return sentence ? `${sentence}${describeRefusalReasons(err, context)}` : null;
     }
     catch {
         return err.body.trim() || null;

package/dist/lib/dedicated-wait.js

@@ -17,8 +17,21 @@ function backupIsNewer(current, previous) {
     const b = Date.parse(previous);
     return Number.isFinite(a) && Number.isFinite(b) ? a > b : current !== previous;
 }
+/**
+ * `recovering` is also the state an image move replaces the machine through, on
+ * purpose. Reading every `recovering` as a failed action being retried told an
+ * owner watching an ordinary `update-image --wait` that destroy was available
+ * "if it never settles".
+ */
+const PLANNED_REPLACEMENT_PROGRESS = {
+    dedicated_runtime_image_update: 'replacing the machine',
+    dedicated_runtime_image_update_rolling_back: 'replacing the machine again',
+};
 function progressOf(lease) {
     const state = (0, dedicated_machines_1.dedicatedLeaseState)(lease);
+    const planned = lease.stateReason ? PLANNED_REPLACEMENT_PROGRESS[lease.stateReason] : undefined;
+    if (state === 'recovering' && planned)
+        return planned;
     if (state === 'recovering') {
         // `recovering` is where a failed provision or action lands, retried with
         // backoff. It can settle — or never, which is why destroy is allowed from it.

package/dist/lib/followups.d.ts

@@ -34,6 +34,8 @@ export interface FollowUpRow {
     terminal?: string | null;
     terminalAt?: string | null;
     terminalReason?: string | null;
+    /** Who settled it: `trigger_fire` for the runtime, otherwise the actor. */
+    terminalBy?: string | null;
     escalatedInitiativeId?: string | null;
     capsule?: unknown;
     nextRunAt?: string | null;
@@ -62,6 +64,12 @@ export interface FollowUpObservability {
             terminal: Record<string, number>;
             escalationRate: number | null;
             fires: number;
+            /** USD from the fires' UsageLog rows; null when the ledger could not be read. */
+            spend?: {
+                today: number;
+                total: number;
+                currency: string;
+            } | null;
             budget: {
                 pool: string | null;
                 used: number;

package/dist/lib/label-ref.d.ts

@@ -59,12 +59,19 @@ export declare function closestNames(typed: string, names: string[], limit?: num
 export interface LabelVocabularyContext {
     /** Narrow to labels attachable to this entity type. Omit for all of them. */
     applicableTo?: LabelApplicable;
-    /** Narrows to the workspace scope; `--workspace` / OVERSKY_WORKSPACE_ID. */
+    /**
+     * Narrows to this workspace scope. When omitted the AMBIENT workspace is
+     * resolved (`--workspace` / OVERSKY_WORKSPACE_ID / the server's default
+     * workspace): a session that never selected a workspace still writes to
+     * one, and a vocabulary that cannot see it refuses names that exist.
+     */
     workspaceId?: string;
     /** Archived labels are excluded unless asked for. */
     includeArchived?: boolean;
     /** Injected in tests. */
     getLabels?: typeof dataService.getLabels;
+    /** Injected in tests; defaults to `workspaces.ambientWorkspaceId`. */
+    resolveWorkspaceId?: () => Promise<string | undefined>;
 }
 export interface LabelRefContext extends LabelVocabularyContext {
     /** Which entity the resolved labels will be attached to. */

package/dist/lib/label-ref.js

@@ -39,6 +39,7 @@ exports.closestNames = closestNames;
 exports.collectLabelVocabulary = collectLabelVocabulary;
 exports.resolveLabelRefs = resolveLabelRefs;
 const data_provider_1 = require("@skrr-ai/data-provider");
+const workspaces_1 = require("./workspaces");
 /** A canonical v4 uuid, which is what every label id is. */
 const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 function looksLikeLabelId(ref) {
@@ -89,9 +90,18 @@ function closestNames(typed, names, limit = 3) {
  */
 async function collectLabelVocabulary(context) {
     const getLabels = context.getLabels ?? data_provider_1.dataService.getLabels;
+    let workspaceId = context.workspaceId;
+    if (!workspaceId) {
+        try {
+            workspaceId = await (context.resolveWorkspaceId ?? workspaces_1.ambientWorkspaceId)();
+        }
+        catch {
+            workspaceId = undefined;
+        }
+    }
     const requests = [{ scope: 'user' }];
-    if (context.workspaceId)
-        requests.push({ scope: 'workspace', scopeId: context.workspaceId });
+    if (workspaceId)
+        requests.push({ scope: 'workspace', scopeId: workspaceId });
     const settled = await Promise.allSettled(requests.map((request) => getLabels({
         ...request,
         ...(context.applicableTo ? { applicableTo: context.applicableTo } : {}),

package/dist/lib/option-hint.d.ts

@@ -0,0 +1,15 @@
+/**
+ * A "did you mean" for oclif's enum refusal (OSK-9735).
+ *
+ * Tasks, spaces, goals and key results each spell one lifecycle their own way —
+ * "under way" is `in_progress` for a space and `active` for a goal; "finished"
+ * is `done`, `completed` or `achieved` — and oclif's
+ * `Expected --status=in_progress to be one of: …` was the only place a user
+ * learned that. This names the value the command uses for the word that was
+ * typed, and otherwise the nearest spelling.
+ *
+ * It suggests and never substitutes. Some of the differences are deliberate (a
+ * key result's status is a health reading, not a lifecycle), so writing a mapped
+ * value would record a status nobody chose.
+ */
+export declare function invalidOptionHint(message: string): string | null;

package/dist/lib/option-hint.js

@@ -0,0 +1,75 @@
+"use strict";
+/**
+ * A "did you mean" for oclif's enum refusal (OSK-9735).
+ *
+ * Tasks, spaces, goals and key results each spell one lifecycle their own way —
+ * "under way" is `in_progress` for a space and `active` for a goal; "finished"
+ * is `done`, `completed` or `achieved` — and oclif's
+ * `Expected --status=in_progress to be one of: …` was the only place a user
+ * learned that. This names the value the command uses for the word that was
+ * typed, and otherwise the nearest spelling.
+ *
+ * It suggests and never substitutes. Some of the differences are deliberate (a
+ * key result's status is a health reading, not a lifecycle), so writing a mapped
+ * value would record a status nobody chose.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.invalidOptionHint = invalidOptionHint;
+/**
+ * Spellings of one concept across the CLI's vocabularies. A value is suggested
+ * only when it shares a group with what was typed.
+ */
+const CONCEPT_GROUPS = [
+    new Set(['in_progress', 'inprogress', 'active', 'started', 'ongoing', 'running', 'doing']),
+    new Set(['done', 'completed', 'complete', 'achieved', 'finished', 'closed', 'resolved']),
+    new Set(['cancelled', 'canceled', 'abandoned']),
+    new Set(['in_review', 'inreview', 'review', 'reviewing']),
+    new Set(['planned', 'todo', 'to_do', 'not_started']),
+];
+const REFUSAL = /Expected (--[\w-]+)=(.+?) to be one of: ([^\n]+)/;
+const normalize = (value) => value
+    .trim()
+    .toLowerCase()
+    .replace(/[\s-]+/g, '_');
+function editDistance(a, b) {
+    const row = Array.from({ length: b.length + 1 }, (_, i) => i);
+    for (let i = 1; i <= a.length; i += 1) {
+        let diagonal = row[0];
+        row[0] = i;
+        for (let j = 1; j <= b.length; j += 1) {
+            const above = row[j];
+            row[j] = Math.min(row[j] + 1, row[j - 1] + 1, diagonal + (a[i - 1] === b[j - 1] ? 0 : 1));
+            diagonal = above;
+        }
+    }
+    return row[b.length];
+}
+function invalidOptionHint(message) {
+    const match = REFUSAL.exec(message || '');
+    if (!match)
+        return null;
+    const [, flag, input, list] = match;
+    const options = list
+        .split(',')
+        .map((option) => option.trim())
+        .filter(Boolean);
+    const typed = normalize(input);
+    const exact = options.find((option) => normalize(option) === typed);
+    if (exact)
+        return `  Did you mean ${flag} ${exact}?`;
+    const group = CONCEPT_GROUPS.find((concept) => concept.has(typed));
+    const synonym = group && options.find((option) => group.has(normalize(option)));
+    if (synonym) {
+        return `  Did you mean ${flag} ${synonym}? Here "${input}" is spelled "${synonym}".`;
+    }
+    let nearest = null;
+    for (const option of options) {
+        const distance = editDistance(typed, normalize(option));
+        if (!nearest || distance < nearest.distance)
+            nearest = { option, distance };
+    }
+    if (nearest && nearest.distance <= Math.max(2, Math.floor(typed.length / 4))) {
+        return `  Did you mean ${flag} ${nearest.option}?`;
+    }
+    return null;
+}

package/dist/lib/workspaces.d.ts

@@ -56,6 +56,9 @@ export interface WorkspaceListing {
  */
 export declare function describeUnselectedWorkspace(listing: WorkspaceListing): string;
 export declare function listWorkspaces(): Promise<WorkspaceRow[]>;
+export declare function ambientWorkspaceId(env?: NodeJS.ProcessEnv): Promise<string | undefined>;
+/** Test seam — a memoized network result must not leak between specs. */
+export declare function clearAmbientWorkspaceCache(): void;
 /** `listWorkspaces`, keeping the envelope's caller-level fields. */
 export declare function listWorkspaceListing(): Promise<WorkspaceListing>;
 export declare function getWorkspace(workspaceId: string): Promise<WorkspaceRow>;

package/dist/lib/workspaces.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.describeUnselectedWorkspace = describeUnselectedWorkspace;
 exports.listWorkspaces = listWorkspaces;
+exports.ambientWorkspaceId = ambientWorkspaceId;
+exports.clearAmbientWorkspaceCache = clearAmbientWorkspaceCache;
 exports.listWorkspaceListing = listWorkspaceListing;
 exports.getWorkspace = getWorkspace;
 exports.matchWorkspace = matchWorkspace;
@@ -60,6 +62,42 @@ function describeUnselectedWorkspace(listing) {
 async function listWorkspaces() {
     return (await listWorkspaceListing()).rows;
 }
+/**
+ * The workspace a bare session actually writes to, for callers merging the
+ * caller's vocabulary or defaults across scopes.
+ *
+ * `OVERSKY_WORKSPACE_ID` is only populated when a workspace was SELECTED —
+ * `workspaces use`, `--workspace`, or a daemon session handoff. An account
+ * that never selected one still has a server-side `defaultWorkspaceId`, and
+ * every unscoped write lands there; a caller that only read the variable
+ * would reason about a smaller world than the one the server writes into
+ * (observed: `labels list` reported a user-only vocabulary while three
+ * workspace-scoped labels existed and were attachable).
+ *
+ * The listing fetch is memoized and fail-open: this runs to give a better
+ * answer, and must never become the error — an unreachable server returns
+ * `undefined`, which is the same world the caller saw before this existed.
+ */
+let memoizedDefaultWorkspaceId;
+async function ambientWorkspaceId(env = process.env) {
+    const explicit = env.OVERSKY_WORKSPACE_ID?.trim();
+    if (explicit)
+        return explicit;
+    if (memoizedDefaultWorkspaceId !== undefined) {
+        return memoizedDefaultWorkspaceId ?? undefined;
+    }
+    try {
+        memoizedDefaultWorkspaceId = (await listWorkspaceListing()).defaultWorkspaceId ?? null;
+    }
+    catch {
+        memoizedDefaultWorkspaceId = null;
+    }
+    return memoizedDefaultWorkspaceId ?? undefined;
+}
+/** Test seam — a memoized network result must not leak between specs. */
+function clearAmbientWorkspaceCache() {
+    memoizedDefaultWorkspaceId = undefined;
+}
 /** `listWorkspaces`, keeping the envelope's caller-level fields. */
 async function listWorkspaceListing() {
     const rows = [];